AI Agents

npm install @superdoc-dev/sdk openai

import { createSuperDocClient, createAgentToolkit } from '@superdoc-dev/sdk';
import OpenAI from 'openai';

const client = createSuperDocClient();
await client.connect();
const doc = await client.open({ doc: './contract.docx' });

// One call — tools, system prompt, and dispatch, guaranteed coherent.
const { tools, systemPrompt, dispatch } = await createAgentToolkit({
  provider: 'openai',
  preset: 'core',
});
const openai = new OpenAI();

const messages: OpenAI.Chat.Completions.ChatCompletionMessageParam[] = [
  { role: 'system', content: systemPrompt },
  { role: 'user', content: 'Find the termination clause and rewrite it to allow 30-day notice. Use tracked changes.' },
];

while (true) {
  const response = await openai.chat.completions.create({
    model: 'gpt-5.4',
    messages,
    tools,
  });

  const message = response.choices[0].message;
  messages.push(message);

  if (!message.tool_calls?.length) break;

  for (const call of message.tool_calls) {
    const result = await dispatch(doc, call.function.name, JSON.parse(call.function.arguments));
    messages.push({
      role: 'tool',
      tool_call_id: call.id,
      content: JSON.stringify(result),
    });
  }
}

await doc.save({ inPlace: true });
await doc.close();
await client.dispose();

import { createAgentToolkit } from '@superdoc-dev/sdk';

const { tools, systemPrompt, dispatch, meta } = await createAgentToolkit({
  provider: 'openai',
  preset: 'core',
  excludeActions: ['delete_table'],   // applied to tools, prompt, AND dispatch
});

// in the loop:
const receipt = await dispatch(doc, call.function.name, JSON.parse(call.function.arguments));

import { chooseTools } from '@superdoc-dev/sdk';

const { tools, meta } = await chooseTools({
  provider: 'openai',   // 'openai' | 'anthropic' | 'vercel' | 'generic'
  preset: 'core',       // omit for the default 'legacy' surface
});

// meta = { preset: 'core', provider: 'openai', toolCount: 2, cacheStrategy: 'disabled' }
// cacheStrategy: 'disabled' | 'explicit' | 'automatic' | 'unsupported' —
// this call returns 'disabled'; anthropic with cache: true returns 'explicit'.

import { dispatchSuperDocTool } from '@superdoc-dev/sdk';

const result = await dispatchSuperDocTool(doc, toolName, args, { preset: 'core' });

import { getSystemPrompt } from '@superdoc-dev/sdk';

const legacyPrompt = await getSystemPrompt();        // legacy surface
const corePrompt = await getSystemPrompt('core');    // action surface

const { tools } = await chooseTools({ provider: 'openai', preset: 'core' });
// [{ type: 'function', function: { name, description, parameters } }]

import Anthropic from '@anthropic-ai/sdk';
import { chooseTools, getSystemPromptForProvider, dispatchSuperDocTool } from '@superdoc-dev/sdk';

const anthropic = new Anthropic();
// cache: true on both halves of the static prefix — the tool array and the
// system prompt — so Anthropic caches them across turns (see Token budget).
const { tools } = await chooseTools({ provider: 'anthropic', preset: 'core', cache: true });
const sys = await getSystemPromptForProvider({ provider: 'anthropic', preset: 'core', cache: true });

const messages: Anthropic.MessageParam[] = [
  { role: 'user', content: 'Rewrite the termination clause for 30-day notice, tracked.' },
];

while (true) {
  const response = await anthropic.messages.create({
    model: 'claude-sonnet-5',
    max_tokens: 4096,
    system: sys.content, // text blocks carrying cache_control markers
    tools,
    messages,
  });
  messages.push({ role: 'assistant', content: response.content });

  const toolUses = response.content.filter((block) => block.type === 'tool_use');
  if (toolUses.length === 0) break;

  const results = [];
  for (const use of toolUses) {
    const result = await dispatchSuperDocTool(doc, use.name, use.input, { preset: 'core' });
    results.push({ type: 'tool_result', tool_use_id: use.id, content: JSON.stringify(result) });
  }
  messages.push({ role: 'user', content: results });
}