anyclaude-sdk 0.4.5 → 0.4.7

package/dist/compact.d.ts

@@ -19,4 +19,19 @@ export declare function summarizeHistory(history: ChatMsg[], llm: SummarizerLLM,
     signal?: AbortSignal;
     focus?: string;
 }): Promise<ChatMsg[] | null>;
+/**
+ * Window-aware compaction: keep the most recent `keepRecent` messages VERBATIM
+ * and summarize only the older prefix into one summary message. Far less lossy
+ * than `summarizeHistory` (which collapses the entire transcript) — recent turns
+ * stay intact while old context is condensed. Returns a new history, or the
+ * original array unchanged if there isn't enough to compact.
+ *
+ *   if (estimateTokens(history) > limit) history = await compactWithWindow(history, llm, { keepRecent: 8 })
+ */
+export declare function compactWithWindow(history: ChatMsg[], llm: SummarizerLLM, opts?: {
+    keepRecent?: number;
+    model?: string;
+    signal?: AbortSignal;
+    focus?: string;
+}): Promise<ChatMsg[]>;
 export {};

package/dist/compact.js

@@ -65,3 +65,28 @@ export async function summarizeHistory(history, llm, opts = {}) {
         return null;
     return [history[0], { role: 'user', content: `Summary of the conversation so far:\n${summary}` }];
 }
+/**
+ * Window-aware compaction: keep the most recent `keepRecent` messages VERBATIM
+ * and summarize only the older prefix into one summary message. Far less lossy
+ * than `summarizeHistory` (which collapses the entire transcript) — recent turns
+ * stay intact while old context is condensed. Returns a new history, or the
+ * original array unchanged if there isn't enough to compact.
+ *
+ *   if (estimateTokens(history) > limit) history = await compactWithWindow(history, llm, { keepRecent: 8 })
+ */
+export async function compactWithWindow(history, llm, opts = {}) {
+    const keepRecent = Math.max(2, opts.keepRecent ?? 8);
+    if (history.length <= keepRecent + 2)
+        return history;
+    // Cut boundary for the verbatim window; don't start it on an orphan tool
+    // result (pull its preceding assistant turn into the window).
+    let cut = history.length - keepRecent;
+    while (cut > 1 && history[cut]?.role === 'tool')
+        cut--;
+    const older = history.slice(0, cut); // includes the system message at [0]
+    const recent = history.slice(cut);
+    const summarized = await summarizeHistory(older, llm, opts);
+    if (!summarized)
+        return history;
+    return [summarized[0], summarized[1], ...recent];
+}

package/dist/index.d.ts

@@ -24,4 +24,5 @@ export { enterPlanMode, exitPlanMode, PLAN_MODE_TOOLS } from './tools/plan_mode.
 export { uuid } from './util/ids.js';
 export * as paths from './util/paths.js';
 export { priceFor, computeCostUSD, contextWindowFor, type Pricing } from './util/pricing.js';
-export { estimateTokens, summarizeHistory } from './compact.js';
+export { estimateTokens, summarizeHistory, compactWithWindow } from './compact.js';
+export { runToolLoop, type RunToolLoopOptions } from './loop.js';

package/dist/index.js

@@ -26,5 +26,6 @@ export { enterPlanMode, exitPlanMode, PLAN_MODE_TOOLS } from './tools/plan_mode.
 export { uuid } from './util/ids.js';
 export * as paths from './util/paths.js';
 export { priceFor, computeCostUSD, contextWindowFor } from './util/pricing.js';
-export { estimateTokens, summarizeHistory } from './compact.js';
+export { estimateTokens, summarizeHistory, compactWithWindow } from './compact.js';
+export { runToolLoop } from './loop.js';
 // (createResponsesClient is exported via ./llm/index.js)

package/dist/llm/index.d.ts

@@ -1,3 +1,4 @@
 export * from './openai.js';
 export * from './anthropic.js';
 export * from './responses.js';
+export { hasInlineToolCalls, parseInlineToolCalls } from './inlineTools.js';

package/dist/llm/index.js

@@ -1,3 +1,6 @@
 export * from './openai.js';
 export * from './anthropic.js';
 export * from './responses.js';
+// Inline tool-call parsing — recover tool calls a model emitted as TEXT
+// (e.g. weak models that narrate tool calls instead of using native function calls).
+export { hasInlineToolCalls, parseInlineToolCalls } from './inlineTools.js';

package/dist/loop.d.ts

@@ -0,0 +1,29 @@
+import type { CanUseTool, ChatMsg, LLMClient, SDKMessage } from './types/index.js';
+import type { Tool, ToolContext } from './tools/types.js';
+export interface RunToolLoopOptions {
+    /** Conversation so far: `[systemMsg, ...]`. Mutated in place as the loop appends turns. */
+    history: ChatMsg[];
+    /** Tools the model may call (executed via `ctx`). */
+    tools: Tool[];
+    /** Any OpenAI/Anthropic-compatible client. */
+    llm: LLMClient;
+    model?: string;
+    /** Tool-execution context (fs / exec / cwd / readFiles / limits …). */
+    ctx: ToolContext;
+    /** Max LLM turns before stopping with `error_max_turns`. Default 50. */
+    maxTurns?: number;
+    signal?: AbortSignal;
+    /** Optional permission gate; a `deny` result turns into an error tool_result. */
+    canUseTool?: CanUseTool;
+    /** Emit `stream_event` text deltas as the assistant streams. */
+    includePartialMessages?: boolean;
+    /** Correlation id stamped on every emitted SDKMessage. */
+    sessionId?: string;
+}
+/**
+ * Run the bare tool loop, yielding SDKMessages until the model stops or maxTurns.
+ *
+ *   const ctx = { fs, exec, cwd: '/work', readFiles: new Set() } as ToolContext
+ *   for await (const m of runToolLoop({ history, tools, llm, model, ctx })) render(m)
+ */
+export declare function runToolLoop(opts: RunToolLoopOptions): AsyncGenerator<SDKMessage>;

package/dist/loop.js

@@ -0,0 +1,284 @@
+import { toolByName, toolDefs } from './tools/index.js';
+import { uuid } from './util/ids.js';
+const emptyUsage = () => ({ input_tokens: 0, output_tokens: 0 });
+function addUsage(t, b) {
+    if (!b)
+        return;
+    t.input_tokens += b.input_tokens || 0;
+    t.output_tokens += b.output_tokens || 0;
+    t.cache_read_input_tokens = (t.cache_read_input_tokens || 0) + (b.cache_read_input_tokens || 0);
+    t.cache_creation_input_tokens = (t.cache_creation_input_tokens || 0) + (b.cache_creation_input_tokens || 0);
+}
+function safeParse(json) {
+    if (!json || !json.trim())
+        return {};
+    try {
+        const v = JSON.parse(json);
+        return v && typeof v === 'object' ? v : { value: v };
+    }
+    catch {
+        return { _raw: json };
+    }
+}
+function toolUseBlocks(calls) {
+    return calls.map((c) => ({ type: 'tool_use', id: c.id, name: c.function.name, input: safeParse(c.function.arguments) }));
+}
+function resultToText(content) {
+    if (typeof content === 'string')
+        return content;
+    return content
+        .map((b) => (b.type === 'text' ? b.text : b.type === 'image' ? '[image]' : b.type === 'document' ? '[document]' : `[${b.type}]`))
+        .join('\n');
+}
+function toToolResultContent(content) {
+    if (typeof content === 'string')
+        return content;
+    return content.filter((b) => b.type === 'text' || b.type === 'image' || b.type === 'document');
+}
+function createPushQueue() {
+    const items = [];
+    let resolveNext = null;
+    let closed = false;
+    return {
+        push(v) {
+            if (resolveNext) {
+                resolveNext({ value: v, done: false });
+                resolveNext = null;
+            }
+            else
+                items.push(v);
+        },
+        close() {
+            closed = true;
+            if (resolveNext) {
+                resolveNext({ value: undefined, done: true });
+                resolveNext = null;
+            }
+        },
+        [Symbol.asyncIterator]() {
+            return {
+                next: () => {
+                    if (items.length)
+                        return Promise.resolve({ value: items.shift(), done: false });
+                    if (closed)
+                        return Promise.resolve({ value: undefined, done: true });
+                    return new Promise((res) => (resolveNext = res));
+                },
+            };
+        },
+    };
+}
+/**
+ * Run the bare tool loop, yielding SDKMessages until the model stops or maxTurns.
+ *
+ *   const ctx = { fs, exec, cwd: '/work', readFiles: new Set() } as ToolContext
+ *   for await (const m of runToolLoop({ history, tools, llm, model, ctx })) render(m)
+ */
+export async function* runToolLoop(opts) {
+    const { history, llm, model, ctx, signal, canUseTool } = opts;
+    const tools = opts.tools;
+    const maxTurns = opts.maxTurns ?? 50;
+    const sessionId = opts.sessionId ?? uuid();
+    const emitPartial = !!opts.includePartialMessages;
+    const byName = toolByName(tools);
+    const defs = toolDefs(tools);
+    const startedAt = Date.now();
+    let apiMs = 0;
+    let turns = 0;
+    let lastText = '';
+    let resultModel = model ?? 'unknown';
+    let hitMaxTurns = false;
+    let errored = null;
+    const usageTotal = emptyUsage();
+    while (true) {
+        if (signal?.aborted)
+            break;
+        if (turns >= maxTurns) {
+            hitMaxTurns = true;
+            break;
+        }
+        turns++;
+        let streamedText = '';
+        let captured = [];
+        const apiStart = Date.now();
+        let result;
+        try {
+            if (emitPartial) {
+                const q = createPushQueue();
+                let inToolMarkup = false;
+                const sp = llm.streamChat(history, {
+                    model,
+                    tools: defs,
+                    signal,
+                    onToken: (delta) => {
+                        streamedText += delta;
+                        if (!inToolMarkup && /<tool_call|<function\s*=/.test(streamedText))
+                            inToolMarkup = true;
+                        if (inToolMarkup)
+                            return;
+                        q.push({
+                            type: 'stream_event',
+                            event: { type: 'content_block_delta', index: 0, delta: { type: 'text_delta', text: delta } },
+                            parent_tool_use_id: null,
+                            uuid: uuid(),
+                            session_id: sessionId,
+                        });
+                    },
+                    onTool: (calls) => {
+                        captured = calls;
+                    },
+                });
+                sp.then(() => { }, () => { }).finally(() => q.close());
+                for await (const ev of q)
+                    yield ev;
+                result = await sp;
+            }
+            else {
+                result = await llm.streamChat(history, {
+                    model,
+                    tools: defs,
+                    signal,
+                    onToken: (delta) => {
+                        streamedText += delta;
+                    },
+                    onTool: (calls) => {
+                        captured = calls;
+                    },
+                });
+            }
+        }
+        catch (err) {
+            errored = err instanceof Error ? err.message : String(err);
+            break;
+        }
+        apiMs += Date.now() - apiStart;
+        const text = result.text || streamedText;
+        const calls = result.toolCalls.length ? result.toolCalls : captured;
+        lastText = text || lastText;
+        resultModel = result.model || resultModel;
+        addUsage(usageTotal, result.usage);
+        const stopReason = calls.length ? 'tool_use' : result.stopReason ?? 'end_turn';
+        const assistantContent = [];
+        if (text)
+            assistantContent.push({ type: 'text', text });
+        assistantContent.push(...toolUseBlocks(calls));
+        const apiAssistant = {
+            id: 'msg_' + uuid().replace(/-/g, '').slice(0, 24),
+            type: 'message',
+            role: 'assistant',
+            model: resultModel,
+            content: assistantContent,
+            stop_reason: stopReason,
+            stop_sequence: null,
+            usage: result.usage ?? emptyUsage(),
+        };
+        yield { type: 'assistant', message: apiAssistant, parent_tool_use_id: null, uuid: uuid(), session_id: sessionId };
+        history.push({ role: 'assistant', content: text, tool_calls: calls.length ? calls : undefined });
+        if (!calls.length)
+            break;
+        const toolResultBlocks = [];
+        const turnMedia = [];
+        for (const call of calls) {
+            if (signal?.aborted)
+                break;
+            const name = call.function.name;
+            let input = safeParse(call.function.arguments);
+            const tool = byName.get(name);
+            let content = '';
+            let isError = false;
+            if (!tool) {
+                content = `Error: unknown tool "${name}"`;
+                isError = true;
+            }
+            else {
+                const decision = canUseTool
+                    ? await canUseTool(name, input, { signal, toolUseId: call.id })
+                    : { behavior: 'allow' };
+                if (decision.behavior === 'deny') {
+                    content = `Permission denied: ${decision.message}`;
+                    isError = true;
+                }
+                else {
+                    if ('updatedInput' in decision && decision.updatedInput)
+                        input = decision.updatedInput;
+                    try {
+                        const r = await tool.run(input, ctx);
+                        content = r.content;
+                        isError = !!r.isError;
+                    }
+                    catch (err) {
+                        content = `Error executing ${name}: ${err instanceof Error ? err.message : String(err)}`;
+                        isError = true;
+                    }
+                }
+            }
+            const textOut = resultToText(content);
+            history.push({ role: 'tool', tool_call_id: call.id, content: textOut });
+            if (Array.isArray(content)) {
+                for (const b of content)
+                    if (b.type === 'image' || b.type === 'document')
+                        turnMedia.push(b);
+            }
+            toolResultBlocks.push({
+                type: 'tool_result',
+                tool_use_id: call.id,
+                content: typeof content === 'string' ? textOut : toToolResultContent(content),
+                is_error: isError || undefined,
+            });
+        }
+        if (turnMedia.length) {
+            history.push({
+                role: 'user',
+                content: [{ type: 'text', text: 'Attached file content from the tools above:' }, ...turnMedia],
+            });
+        }
+        if (toolResultBlocks.length) {
+            yield {
+                type: 'user',
+                message: { role: 'user', content: toolResultBlocks },
+                parent_tool_use_id: null,
+                isSynthetic: true,
+                timestamp: new Date().toISOString(),
+                uuid: uuid(),
+                session_id: sessionId,
+            };
+        }
+    }
+    const durationMs = Date.now() - startedAt;
+    if (errored || hitMaxTurns) {
+        yield {
+            type: 'result',
+            subtype: hitMaxTurns ? 'error_max_turns' : 'error_during_execution',
+            duration_ms: durationMs,
+            duration_api_ms: apiMs,
+            is_error: true,
+            num_turns: turns,
+            stop_reason: hitMaxTurns ? 'max_turns' : 'error',
+            total_cost_usd: 0,
+            usage: usageTotal,
+            modelUsage: {},
+            permission_denials: [],
+            errors: errored ? [errored] : [`Reached max turns (${maxTurns})`],
+            uuid: uuid(),
+            session_id: sessionId,
+        };
+    }
+    else {
+        yield {
+            type: 'result',
+            subtype: 'success',
+            duration_ms: durationMs,
+            duration_api_ms: apiMs,
+            is_error: false,
+            num_turns: turns,
+            result: lastText,
+            stop_reason: 'end_turn',
+            total_cost_usd: 0,
+            usage: usageTotal,
+            modelUsage: {},
+            permission_denials: [],
+            uuid: uuid(),
+            session_id: sessionId,
+        };
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "anyclaude-sdk",
-  "version": "0.4.5",
+  "version": "0.4.7",
   "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",
@@ -47,6 +47,26 @@
     "./compact": {
       "types": "./dist/compact.d.ts",
       "import": "./dist/compact.js"
+    },
+    "./permissions": {
+      "types": "./dist/permissions/index.d.ts",
+      "import": "./dist/permissions/index.js"
+    },
+    "./skills": {
+      "types": "./dist/skills/index.d.ts",
+      "import": "./dist/skills/index.js"
+    },
+    "./queue": {
+      "types": "./dist/queue.d.ts",
+      "import": "./dist/queue.js"
+    },
+    "./prompt": {
+      "types": "./dist/prompt.d.ts",
+      "import": "./dist/prompt.js"
+    },
+    "./loop": {
+      "types": "./dist/loop.d.ts",
+      "import": "./dist/loop.js"
     }
   },
   "sideEffects": false,