anyclaude-sdk 0.7.2 → 0.7.4

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) {
@@ -264,6 +265,14 @@ export async function* runAgent(options) {
             clientTools.add(t.def.function.name);
     const defs = toolDefs(tools);
     const byName = toolByName(tools);
+    // 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();
@@ -639,7 +648,7 @@ export async function* runAgent(options) {
                             // 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)
@@ -680,8 +689,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.js

@@ -3,7 +3,7 @@
 // Returns an AsyncGenerator<SDKMessage>. Accepts either a single string prompt
 // or an async iterable of SDKUserMessage (for multi-turn / interactive use).
 import { runAgent } from './agent.js';
-import { track, telemetryEnabled } from './telemetry.js';
+import { track, telemetryEnabled, tokenBucket } from './telemetry.js';
 import { profileForModel } from './llm/profiles.js';
 export function query(options) {
     const prompt = typeof options.prompt === 'string'
@@ -59,17 +59,18 @@ export function query(options) {
         settings: options.settings,
         skills: options.skills,
     });
-    gen.interrupt = () => abortController.abort();
-    // Anonymous, aggregate adoption signal — one event per public run. Fire-and-forget,
-    // never blocks the generator, no-ops unless enabled + a collector is configured.
-    // Only booleans + a coarse model-family bucket leave the process (see telemetry.ts).
+    // Anonymous, aggregate adoption signal. Fire-and-forget, never blocks, no-ops
+    // unless enabled + a collector is configured. Only booleans + coarse buckets
+    // (model family, token-volume bucket) ever leave the process — see telemetry.ts.
     const telemetry = {
         disabled: options.disableTelemetry,
         ...options.telemetry,
     };
-    if (telemetryEnabled(telemetry)) {
+    const modelFamily = profileForModel(options.model).name;
+    const enabled = telemetryEnabled(telemetry);
+    if (enabled) {
         track('run', {
-            model_family: profileForModel(options.model).name,
+            model_family: modelFamily,
             client_workspace_tools: !!options.clientWorkspaceTools,
             client_tools: !!options.clientTools?.length,
             survivor: options.maxDurationMs != null,
@@ -83,7 +84,29 @@ export function query(options) {
             resumed: !!options.continueRun || !!options.resume,
         }, telemetry);
     }
-    return gen;
+    if (!enabled) {
+        gen.interrupt = () => abortController.abort();
+        return gen;
+    }
+    // Wrap to emit one `run_end` with a coarse token-volume bucket when the run
+    // finishes (tokens aren't known until the `result` message). Pass-through only.
+    const wrapped = (async function* () {
+        let totalTokens = 0;
+        try {
+            for await (const m of gen) {
+                if (m.type === 'result' && m.usage) {
+                    const u = m.usage;
+                    totalTokens = (u.input_tokens || 0) + (u.output_tokens || 0);
+                }
+                yield m;
+            }
+        }
+        finally {
+            track('run_end', { model_family: modelFamily, tokens_bucket: tokenBucket(totalTokens) }, telemetry);
+        }
+    })();
+    wrapped.interrupt = () => abortController.abort();
+    return wrapped;
 }
 /** Wrap a single text prompt into the async-iterable form runAgent expects. */
 export async function* singlePrompt(text) {

package/dist/telemetry.d.ts

@@ -6,6 +6,8 @@ export interface TelemetryOptions {
     /** Collector URL. Defaults to `ANYCLAUDE_TELEMETRY_URL` then the built-in default. */
     url?: string;
 }
+/** Coarse token-volume bucket — never an exact count, so a single run isn't fingerprintable. */
+export declare function tokenBucket(total: number): string;
 /** Resolve whether telemetry may run, honoring every documented opt-out. */
 export declare function telemetryEnabled(opts?: TelemetryOptions): boolean;
 /** Coarse runtime bucket — never anything machine-identifying. */

package/dist/telemetry.js

@@ -24,7 +24,21 @@ const DEFAULT_TELEMETRY_URL = 'https://anyclaude-telemetry.puter.work';
 // Only these prop keys are ever transmitted, and only with safe value types.
 // Booleans pass through; these specific string keys pass through as-is (they are
 // coarse buckets we set ourselves — never free-form / user data).
-const ALLOWED_STRING_KEYS = new Set(['model_family', 'event_detail']);
+const ALLOWED_STRING_KEYS = new Set(['model_family', 'event_detail', 'tokens_bucket']);
+/** Coarse token-volume bucket — never an exact count, so a single run isn't fingerprintable. */
+export function tokenBucket(total) {
+    if (!Number.isFinite(total) || total <= 0)
+        return '0';
+    if (total < 1_000)
+        return '<1k';
+    if (total < 10_000)
+        return '1k-10k';
+    if (total < 100_000)
+        return '10k-100k';
+    if (total < 1_000_000)
+        return '100k-1m';
+    return '1m+';
+}
 function readEnv(name) {
     const p = globalThis.process;
     return p?.env?.[name];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "anyclaude-sdk",
-  "version": "0.7.2",
+  "version": "0.7.4",
   "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",