anyclaude-sdk 0.7.3 → 0.8.0

package/dist/agent.d.ts

@@ -26,6 +26,11 @@ export interface AgentOptions {
     allowedTools?: string[];
     /** Denylist of tool names, applied after allowedTools. */
     disallowedTools?: string[];
+    /** Tool names to DEFER out of the per-turn payload — still discoverable via
+     *  `tool_search` and executable, but their schema isn't sent (saving tokens)
+     *  until the model searches and the loop arms them. For large pools of
+     *  rarely-used integration tools. (Per-tool `defer: true` works too.) */
+    deferredTools?: string[];
     maxTurns?: number;
     /** Wall-clock budget (ms). At a turn boundary past this, the loop pauses: it
      *  persists to sessionStore and emits a `paused` system message instead of

package/dist/agent.js

@@ -25,6 +25,7 @@ import { DEFAULT_MAX_RESULT_CHARS, maybePersistLargeResult } from './persist.js'
 import { computeCostUSD, contextWindowFor } from './util/pricing.js';
 import { estimateTokens, summarizeHistory } from './compact.js';
 import { validateToolArguments } from './llm/repair.js';
+import { parseToolCalls } from './llm/dialects.js';
 import { uuid } from './util/ids.js';
 /** Wrap a single text prompt into the async-iterable form runAgent expects. */
 async function* singleUserPrompt(text) {
@@ -262,8 +263,25 @@ export async function* runAgent(options) {
     for (const t of tools)
         if (!t.run)
             clientTools.add(t.def.function.name);
-    const defs = toolDefs(tools);
+    const defs = toolDefs(tools); // FULL set — for the search index, suppression, and call recovery
     const byName = toolByName(tools);
+    // Deferred tools: kept OUT of the per-turn payload (token savings) but still
+    // discoverable via tool_search and executable. `tool_search` surfaces them and
+    // arms them (adds their schema to subsequent turns). tool_search itself is
+    // never deferred, or discovery breaks.
+    const deferredSet = new Set([...(options.deferredTools ?? []), ...tools.filter((t) => t.defer).map((t) => t.def.function.name)].filter((n) => n !== 'tool_search'));
+    const armed = new Set();
+    const sentDefs = () => deferredSet.size
+        ? toolDefs(tools.filter((t) => !deferredSet.has(t.def.function.name) || armed.has(t.def.function.name)))
+        : defs;
+    // Stop streaming visible deltas once tool-call / reasoning markup begins (native
+    // dialects, <thinking>, or named-tag tools like <finish>); final text is cleaned.
+    const streamSuppressRe = (() => {
+        const esc = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        const names = defs.map((d) => d.function.name).filter(Boolean).map(esc);
+        const named = names.length ? `|<(?:${names.join('|')})[\\s/>]` : '';
+        return new RegExp(`<tool_call|<function\\s*=|<thinking${named}`, 'i');
+    })();
     let system = options.systemPrompt != null ? options.systemPrompt : defaultSystemPrompt(cwd);
     if (teamEnabled)
         system += '\n\n' + coordinatorPrompt();
@@ -293,6 +311,13 @@ export async function* runAgent(options) {
         memory,
         skills,
         planMode,
+        armTools: deferredSet.size
+            ? (names) => {
+                for (const n of names)
+                    if (deferredSet.has(n))
+                        armed.add(n);
+            }
+            : undefined,
     };
     const skillCommands = skillsToCommands(skills);
     const allCommands = [...(options.commands ?? []), ...skillCommands];
@@ -403,7 +428,7 @@ export async function* runAgent(options) {
         subtype: 'init',
         apiKeySource: 'none',
         cwd,
-        tools: defs.map((d) => d.function.name),
+        tools: sentDefs().map((d) => d.function.name),
         mcp_servers: mcpStatuses,
         model: model ?? 'unknown',
         permissionMode,
@@ -632,14 +657,14 @@ export async function* runAgent(options) {
                     let inToolMarkup = false;
                     const sp = llm.streamChat(history, {
                         model,
-                        tools: defs,
+                        tools: sentDefs(),
                         signal,
                         onToken: (delta) => {
                             streamedText += delta;
                             // Stop streaming once inline tool-call markup begins; it would
                             // otherwise flood the UI with raw XML / file contents. The cleaned
                             // text arrives with the final assistant message.
-                            if (!inToolMarkup && /<tool_call|<function\s*=/.test(streamedText)) {
+                            if (!inToolMarkup && streamSuppressRe.test(streamedText)) {
                                 inToolMarkup = true;
                             }
                             if (inToolMarkup)
@@ -664,7 +689,7 @@ export async function* runAgent(options) {
                 else {
                     result = await llm.streamChat(history, {
                         model,
-                        tools: defs,
+                        tools: sentDefs(),
                         signal,
                         onToken: (delta) => {
                             streamedText += delta;
@@ -680,8 +705,17 @@ export async function* runAgent(options) {
                 break;
             }
             apiMs += Date.now() - apiStart;
-            const text = result.text || streamedText;
-            const calls = result.toolCalls.length ? result.toolCalls : captured;
+            let text = result.text || streamedText;
+            let calls = result.toolCalls.length ? result.toolCalls : captured;
+            // Loop-level safety net: recover inline tool calls (native dialects +
+            // named-tag tools like <finish>) a custom LLMClient left as text, and scrub
+            // leaked tool/reasoning markup so raw tags never reach the user.
+            if (!calls.length) {
+                const recovered = parseToolCalls(text, { toolNames: defs.map((d) => d.function.name) });
+                if (recovered.calls.length)
+                    calls = recovered.calls;
+                text = recovered.cleanedText;
+            }
             lastText = text || lastText;
             resultModel = result.model || resultModel;
             addUsageInto(usageTotal, result.usage);

package/dist/llm/dialects.d.ts

@@ -16,6 +16,21 @@ export interface ToolDialect {
 export declare const xmlFunctionDialect: ToolDialect;
 export declare const hermesDialect: ToolDialect;
 export declare const jsonFenceDialect: ToolDialect;
+/**
+ * Named-tag tool calls (the Cline/Roo/Aider convention): a tool invoked as
+ * `<tool_name><param>value</param></tool_name>` (or `<tool_name/>`). Scoped to
+ * the KNOWN tool names so ordinary markup the model writes isn't misread. This
+ * is what leaks as raw `<finish>…</finish>` text when a model emulates a custom
+ * tool format and the SDK doesn't recognize it.
+ */
+export declare function parseNamedTagToolCalls(text: string, toolNames: string[], idBase?: number): ParsedToolCalls;
+/**
+ * Remove leaked reasoning / tool-wrapper markup from user-visible text:
+ * `<thinking>…</thinking>` blocks and orphan `<tool_call>` / `<function…>` /
+ * `<parameter…>` tags that a model emitted as prose. Conservative — only these
+ * well-known control tags, which essentially never appear in legitimate output.
+ */
+export declare function stripControlTags(text: string): string;
 /** All built-in dialects, keyed by name. */
 export declare const dialects: Record<string, ToolDialect>;
 /** Default attempt order — xml-function first preserves original behavior. */
@@ -27,6 +42,7 @@ export declare const DEFAULT_DIALECTS: string[];
 export declare function parseToolCalls(text: string, opts?: {
     dialects?: string[];
     idBase?: number;
+    toolNames?: string[];
 }): ParsedToolCalls;
 /** True if ANY of the given dialects (default: all) detects tool-call markup. */
 export declare function hasToolCalls(text: string, order?: string[]): boolean;

package/dist/llm/dialects.js

@@ -117,6 +117,69 @@ export const jsonFenceDialect = {
         return { calls, cleanedText };
     },
 };
+function escapeRe(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+/** Extract params from a tool-tag body: both `<parameter=key>v</parameter>` and direct `<key>v</key>` children. */
+function parseTagParams(body) {
+    const args = {};
+    const pRe = /<parameter\s*=\s*([^>\s]+)\s*>([\s\S]*?)(?:<\/parameter>|<parameter\s*=|$)/gi;
+    let m;
+    while ((m = pRe.exec(body)) !== null)
+        args[m[1].trim()] = trimEdges(m[2]);
+    const tRe = /<([a-zA-Z_][\w-]*)\s*>([\s\S]*?)<\/\1>/g;
+    while ((m = tRe.exec(body)) !== null) {
+        const k = m[1];
+        if (k === 'parameter' || k in args)
+            continue;
+        args[k] = trimEdges(m[2]);
+    }
+    return args;
+}
+/**
+ * Named-tag tool calls (the Cline/Roo/Aider convention): a tool invoked as
+ * `<tool_name><param>value</param></tool_name>` (or `<tool_name/>`). Scoped to
+ * the KNOWN tool names so ordinary markup the model writes isn't misread. This
+ * is what leaks as raw `<finish>…</finish>` text when a model emulates a custom
+ * tool format and the SDK doesn't recognize it.
+ */
+export function parseNamedTagToolCalls(text, toolNames, idBase = 0) {
+    if (!text || !toolNames?.length)
+        return { calls: [], cleanedText: text };
+    let best = { idx: -1, name: '', after: -1 };
+    for (const name of toolNames) {
+        const re = new RegExp('<' + escapeRe(name) + '(?:\\s[^>]*)?/?>', 'i');
+        const m = re.exec(text);
+        if (m && (best.idx < 0 || m.index < best.idx))
+            best = { idx: m.index, name, after: m.index + m[0].length };
+    }
+    if (best.idx < 0)
+        return { calls: [], cleanedText: text };
+    const closer = new RegExp('</' + escapeRe(best.name) + '>', 'i');
+    const rest = text.slice(best.after);
+    const cm = closer.exec(rest);
+    const body = cm ? rest.slice(0, cm.index) : rest;
+    const args = parseTagParams(body);
+    return {
+        calls: [{ id: `call_inline_${idBase}`, type: 'function', function: { name: best.name, arguments: JSON.stringify(args) } }],
+        cleanedText: text.slice(0, best.idx).trim(),
+    };
+}
+/**
+ * Remove leaked reasoning / tool-wrapper markup from user-visible text:
+ * `<thinking>…</thinking>` blocks and orphan `<tool_call>` / `<function…>` /
+ * `<parameter…>` tags that a model emitted as prose. Conservative — only these
+ * well-known control tags, which essentially never appear in legitimate output.
+ */
+export function stripControlTags(text) {
+    if (!text || text.indexOf('<') < 0)
+        return text;
+    return text
+        .replace(/<thinking\s*>[\s\S]*?<\/thinking\s*>/gi, '')
+        .replace(/<\/?(?:thinking|tool_call|function|parameter|antml:[a-z_]+)(?:\s[^>]*|=[^>]*)?\/?>/gi, '')
+        .replace(/[ \t]+(\r?\n)/g, '$1')
+        .trim();
+}
 /** All built-in dialects, keyed by name. */
 export const dialects = {
     'xml-function': xmlFunctionDialect,
@@ -139,9 +202,17 @@ export function parseToolCalls(text, opts = {}) {
             continue;
         const parsed = d.parse(text, opts.idBase ?? 0);
         if (parsed.calls.length)
-            return parsed;
+            return { calls: parsed.calls, cleanedText: stripControlTags(parsed.cleanedText) };
+    }
+    // Named-tag fallback (e.g. `<finish>…</finish>`) — scoped to known tool names.
+    if (opts.toolNames?.length) {
+        const named = parseNamedTagToolCalls(text, opts.toolNames, opts.idBase ?? 0);
+        if (named.calls.length)
+            return { calls: named.calls, cleanedText: stripControlTags(named.cleanedText) };
     }
-    return { calls: [], cleanedText: text };
+    // No tool call recognized — still scrub any leaked control/reasoning markup so
+    // raw tags never render to the user.
+    return { calls: [], cleanedText: stripControlTags(text) };
 }
 /** True if ANY of the given dialects (default: all) detects tool-call markup. */
 export function hasToolCalls(text, order = DEFAULT_DIALECTS) {

package/dist/llm/openai.js

@@ -113,11 +113,9 @@ export function createOpenAIClient(options = {}) {
             // visible text. (Empty `dialects` — e.g. for native GPT/Claude — skips this.)
             let finalText = text;
             if (!toolCalls.length && (!dialects || dialects.length)) {
-                const inline = parseToolCalls(text, { dialects });
-                if (inline.calls.length) {
-                    toolCalls.push(...inline.calls);
-                    finalText = inline.cleanedText;
-                }
+                const inline = parseToolCalls(text, { dialects, toolNames: opts.tools?.map((t) => t.function.name) });
+                toolCalls.push(...inline.calls);
+                finalText = inline.cleanedText; // also scrubs leaked control tags even when no call is found
             }
             if (toolCalls.length && opts.onTool)
                 opts.onTool(toolCalls);

package/dist/loop.js

@@ -1,6 +1,14 @@
 import { toolByName, toolDefs } from './tools/index.js';
 import { validateToolArguments } from './llm/repair.js';
+import { parseToolCalls } from './llm/dialects.js';
 import { uuid } from './util/ids.js';
+/** Regex that matches the onset of tool-call / reasoning markup in streamed text. */
+function buildSuppressRe(toolNames) {
+    const esc = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const names = toolNames.filter(Boolean).map(esc);
+    const named = names.length ? `|<(?:${names.join('|')})[\\s/>]` : '';
+    return new RegExp(`<tool_call|<function\\s*=|<thinking${named}`, 'i');
+}
 const emptyUsage = () => ({ input_tokens: 0, output_tokens: 0 });
 function addUsage(t, b) {
     if (!b)
@@ -85,6 +93,10 @@ export async function* runToolLoop(opts) {
     const emitPartial = !!opts.includePartialMessages;
     const byName = toolByName(tools);
     const defs = toolDefs(tools);
+    // Stop streaming visible deltas once tool-call / reasoning markup begins — the
+    // final cleaned text comes from the parsed result. Covers native dialects,
+    // <thinking>, and named-tag tools (e.g. <finish>) so they never flicker to the UI.
+    const suppressRe = buildSuppressRe(defs.map((d) => d.function.name));
     const startedAt = Date.now();
     let apiMs = 0;
     let turns = 0;
@@ -115,7 +127,7 @@ export async function* runToolLoop(opts) {
                     signal,
                     onToken: (delta) => {
                         streamedText += delta;
-                        if (!inToolMarkup && /<tool_call|<function\s*=/.test(streamedText))
+                        if (!inToolMarkup && suppressRe.test(streamedText))
                             inToolMarkup = true;
                         if (inToolMarkup)
                             return;
@@ -155,8 +167,17 @@ export async function* runToolLoop(opts) {
             break;
         }
         apiMs += Date.now() - apiStart;
-        const text = result.text || streamedText;
-        const calls = result.toolCalls.length ? result.toolCalls : captured;
+        let text = result.text || streamedText;
+        let calls = result.toolCalls.length ? result.toolCalls : captured;
+        // Loop-level safety net: recover tool calls a (possibly custom) LLMClient left
+        // as inline text — native dialects + named-tag tools — and scrub leaked
+        // tool/reasoning markup so it never renders. Runs for ANY client, not just ours.
+        if (!calls.length) {
+            const recovered = parseToolCalls(text, { toolNames: defs.map((d) => d.function.name) });
+            if (recovered.calls.length)
+                calls = recovered.calls;
+            text = recovered.cleanedText;
+        }
         lastText = text || lastText;
         resultModel = result.model || resultModel;
         addUsage(usageTotal, result.usage);

package/dist/query.d.ts

@@ -22,6 +22,9 @@ export interface QueryOptions {
     appendSystemPrompt?: string;
     allowedTools?: string[];
     disallowedTools?: string[];
+    /** Tool names to defer out of the per-turn payload — discoverable via `tool_search`
+     *  and armed on demand. Saves tokens on large tool pools (also per-tool `defer: true`). */
+    deferredTools?: string[];
     maxTurns?: number;
     /** Wall-clock budget (ms): pause at a turn boundary past this + emit `paused` (survivor). */
     maxDurationMs?: number;

package/dist/query.js

@@ -21,6 +21,7 @@ export function query(options) {
         appendSystemPrompt: options.appendSystemPrompt,
         allowedTools: options.allowedTools,
         disallowedTools: options.disallowedTools,
+        deferredTools: options.deferredTools,
         maxTurns: options.maxTurns,
         maxDurationMs: options.maxDurationMs,
         continueRun: options.continueRun,

package/dist/tools/define.d.ts

@@ -15,6 +15,9 @@ export interface DefineToolSpec {
     run?: (input: Record<string, unknown>, ctx: ToolContext) => Promise<ToolResult> | ToolResult;
     /** Optional: spill threshold for large outputs (see Tool.maxResultChars). */
     maxResultChars?: number;
+    /** Defer out of the per-turn payload — discoverable via `tool_search`, armed on
+     *  demand. For large pools of rarely-used tools (see Tool.defer). */
+    defer?: boolean;
 }
 /** Build a `Tool` from a friendly spec. */
 export declare function defineTool(spec: DefineToolSpec): Tool;

package/dist/tools/define.js

@@ -19,5 +19,7 @@ export function defineTool(spec) {
         tool.run = async (input, ctx) => spec.run(input, ctx);
     if (spec.maxResultChars !== undefined)
         tool.maxResultChars = spec.maxResultChars;
+    if (spec.defer)
+        tool.defer = true;
     return tool;
 }

package/dist/tools/tool_search.js

@@ -41,8 +41,11 @@ export const toolSearch = {
             .slice(0, limit);
         if (!scored.length)
             return { content: `No tools matched "${q}".` };
+        // Arm any deferred tools we surfaced so their full schema is sent next turn
+        // and the model can call them directly.
+        ctx.armTools?.(scored.map(({ t }) => t.name));
         return {
-            content: `Matching tools for "${q}":\n` +
+            content: `Matching tools for "${q}" (now available to call):\n` +
                 scored.map(({ t }) => `  ${t.name} — ${t.description.split('\n')[0]}`).join('\n'),
         };
     },

package/dist/tools/types.d.ts

@@ -72,6 +72,9 @@ export interface ToolContext {
     planMode?: {
         active: boolean;
     };
+    /** Arm deferred tools by name so their full schema is sent on subsequent turns.
+     *  Provided by the loop; `tool_search` calls it for the deferred tools it surfaces. */
+    armTools?: (names: string[]) => void;
 }
 /** Result returned by a tool run. */
 export interface ToolResult {
@@ -92,4 +95,12 @@ export interface Tool {
      * When omitted, the loop uses its global default threshold.
      */
     maxResultChars?: number;
+    /**
+     * DEFER this tool out of the per-turn payload sent to the LLM. It stays
+     * discoverable via `tool_search` and executable when called, but its schema
+     * isn't sent (saving tokens every turn) until `tool_search` surfaces it — at
+     * which point the loop "arms" it for subsequent turns. Use for large pools of
+     * rarely-used integration tools. (Also settable via `query({ deferredTools })`.)
+     */
+    defer?: boolean;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "anyclaude-sdk",
-  "version": "0.7.3",
+  "version": "0.8.0",
   "description": "Standalone, browser-compatible SDK providing Claude Code agent capabilities (tools, tool loop, multi-turn, MCP, sub-agents, sessions) against any OpenAI/Anthropic-compatible LLM endpoint. Runs in the browser (WebContainer), Node, and Bun — no backend required.",
   "type": "module",
   "main": "./dist/index.js",