anyclaude-sdk 0.1.0

package/dist/fs/opfs.js

@@ -0,0 +1,112 @@
+// OpfsFileSystem — backed by the Origin Private File System (OPFS). Gives a
+// true hierarchical, persistent filesystem with native binary storage; best for
+// large files. Implements the SDK's FileSystem interface.
+//
+// OPFS has no metadata (mode/mtime) or symlinks — use DexieFileSystem when you
+// need those. Reads return null on NotFound rather than throwing.
+import { resolvePath, segments } from '../util/paths.js';
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+export class OpfsFileSystem {
+    constructor(options = {}) {
+        this.cwd = options.cwd ?? '/';
+    }
+    static isSupported() {
+        return typeof navigator !== 'undefined' && !!navigator.storage?.getDirectory;
+    }
+    async root() {
+        const nav = navigator;
+        return nav.storage.getDirectory();
+    }
+    /** Walk to the directory handle for `dirSegments`, optionally creating it. */
+    async dirHandle(dirSegments, create) {
+        let handle = await this.root();
+        for (const seg of dirSegments) {
+            try {
+                handle = await handle.getDirectoryHandle(seg, { create });
+            }
+            catch {
+                return null;
+            }
+        }
+        return handle;
+    }
+    split(path) {
+        const segs = segments(resolvePath(this.cwd, path));
+        if (segs.length === 0)
+            return { dir: [], name: null }; // root
+        return { dir: segs.slice(0, -1), name: segs[segs.length - 1] };
+    }
+    // ---- FileSystem interface ----
+    async readBinary(path) {
+        try {
+            const { dir, name } = this.split(path);
+            if (name == null)
+                return null;
+            const parent = await this.dirHandle(dir, false);
+            if (!parent)
+                return null;
+            const fh = await parent.getFileHandle(name, { create: false });
+            const file = await fh.getFile();
+            return new Uint8Array(await file.arrayBuffer());
+        }
+        catch {
+            return null;
+        }
+    }
+    async readFile(path) {
+        const bytes = await this.readBinary(path);
+        return bytes ? decoder.decode(bytes) : null;
+    }
+    async writeBinary(path, data) {
+        const { dir, name } = this.split(path);
+        if (name == null)
+            throw new Error('EISDIR: cannot write to root');
+        const parent = await this.dirHandle(dir, true);
+        if (!parent)
+            throw new Error(`ENOENT: cannot create '${path}'`);
+        const fh = await parent.getFileHandle(name, { create: true });
+        const w = await fh.createWritable();
+        await w.write(data);
+        await w.close();
+    }
+    async writeFile(path, contents) {
+        await this.writeBinary(path, encoder.encode(contents));
+    }
+    async deleteFile(path) {
+        const { dir, name } = this.split(path);
+        if (name == null)
+            return;
+        const parent = await this.dirHandle(dir, false);
+        if (!parent)
+            return;
+        try {
+            await parent.removeEntry(name, { recursive: true });
+        }
+        catch {
+            // already gone
+        }
+    }
+    async readdir(path) {
+        try {
+            const segs = segments(resolvePath(this.cwd, path));
+            const handle = await this.dirHandle(segs, false);
+            if (!handle)
+                return null;
+            const out = [];
+            for await (const [entryName, entry] of handle.entries()) {
+                out.push({ name: entryName, isDir: entry.kind === 'directory' });
+            }
+            return out;
+        }
+        catch {
+            return null;
+        }
+    }
+    async mkdir(path) {
+        const segs = segments(resolvePath(this.cwd, path));
+        const handle = await this.dirHandle(segs, true);
+        if (!handle)
+            throw new Error(`ENOENT: cannot create directory '${path}'`);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,26 @@
+export * from './types/index.js';
+export * from './query.js';
+export { runAgent, type Workspace, type AgentOptions } from './agent.js';
+export { defaultSystemPrompt } from './prompt.js';
+export { maybePersistLargeResult, DEFAULT_MAX_RESULT_CHARS, PREVIEW_CHARS, TOOL_RESULTS_DIR, } from './persist.js';
+export * from './workspace/index.js';
+export * from './sandbox/index.js';
+export * from './fs/index.js';
+export * from './llm/index.js';
+export * from './tools/index.js';
+export { task } from './tools/task.js';
+export * from './mcp/index.js';
+export * from './commands/index.js';
+export * from './background/index.js';
+export * from './queue.js';
+export * from './team/index.js';
+export * from './session/index.js';
+export * from './memory/index.js';
+export * from './permissions/index.js';
+export * from './settings/index.js';
+export * from './skills/index.js';
+export { enterPlanMode, exitPlanMode, PLAN_MODE_TOOLS } from './tools/plan_mode.js';
+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';

package/dist/index.js

@@ -0,0 +1,29 @@
+// browser-claude-sdk — Claude Code agent capabilities in the browser, against
+// any OpenAI/Anthropic-compatible LLM endpoint. No backend required.
+export * from './types/index.js';
+export * from './query.js';
+export { runAgent } from './agent.js';
+export { defaultSystemPrompt } from './prompt.js';
+export { maybePersistLargeResult, DEFAULT_MAX_RESULT_CHARS, PREVIEW_CHARS, TOOL_RESULTS_DIR, } from './persist.js';
+export * from './workspace/index.js';
+export * from './sandbox/index.js';
+export * from './fs/index.js';
+export * from './llm/index.js';
+export * from './tools/index.js';
+export { task } from './tools/task.js';
+export * from './mcp/index.js';
+export * from './commands/index.js';
+export * from './background/index.js';
+export * from './queue.js';
+export * from './team/index.js';
+export * from './session/index.js';
+export * from './memory/index.js';
+export * from './permissions/index.js';
+export * from './settings/index.js';
+export * from './skills/index.js';
+export { enterPlanMode, exitPlanMode, PLAN_MODE_TOOLS } from './tools/plan_mode.js';
+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';
+// (createResponsesClient is exported via ./llm/index.js)

package/dist/llm/anthropic.d.ts

@@ -0,0 +1,24 @@
+import type { LLMClient } from '../types/index.js';
+export interface AnthropicClientOptions {
+    apiKey?: string;
+    /** Base URL of the Anthropic-compatible API. Default: https://api.anthropic.com/v1 */
+    baseUrl?: string;
+    /** Default model id. Can be overridden per call via streamChat opts. */
+    model?: string;
+    /** Extra headers merged into every request. */
+    headers?: Record<string, string>;
+    /** anthropic-version header. Default: '2023-06-01'. */
+    anthropicVersion?: string;
+    /** Sampling temperature. */
+    temperature?: number;
+    /** Max output tokens (required by the API). Default: 4096. */
+    maxTokens?: number;
+}
+/**
+ * Creates an LLMClient backed by the Anthropic Messages API.
+ *
+ * Streams text deltas through `onToken` and surfaces tool calls (assembled
+ * from streamed `input_json_delta` events) via the returned StreamResult and
+ * the `onTool` hook.
+ */
+export declare function createAnthropicClient(options?: AnthropicClientOptions): LLMClient;

package/dist/llm/anthropic.js

@@ -0,0 +1,280 @@
+// Anthropic-compatible streaming chat client for browser-claude-sdk.
+// Talks to the Anthropic Messages API (or any compatible endpoint). Browser-
+// safe: relies only on the global `fetch`, `TextDecoder`, and `ReadableStream`.
+//
+// Reuses the SSE line reader from the OpenAI client. Anthropic emits both
+// `event:` and `data:` lines per event, but every `data:` payload carries its
+// own `type` field, so parsing the data JSON alone is sufficient.
+import { consumeSSE } from './openai.js';
+import { parseInlineToolCalls } from './inlineTools.js';
+/**
+ * Creates an LLMClient backed by the Anthropic Messages API.
+ *
+ * Streams text deltas through `onToken` and surfaces tool calls (assembled
+ * from streamed `input_json_delta` events) via the returned StreamResult and
+ * the `onTool` hook.
+ */
+export function createAnthropicClient(options = {}) {
+    const baseUrl = (options.baseUrl ?? 'https://api.anthropic.com/v1').replace(/\/$/, '');
+    const defaultModel = options.model ?? 'claude-sonnet-4-6';
+    const version = options.anthropicVersion ?? '2023-06-01';
+    return {
+        async streamChat(messages, opts) {
+            const model = opts.model || defaultModel;
+            const { system, messages: anthropicMessages } = toAnthropicMessages(messages);
+            const body = {
+                model,
+                max_tokens: options.maxTokens ?? 4096,
+                messages: anthropicMessages,
+                stream: true,
+            };
+            if (system)
+                body.system = system;
+            if (options.temperature !== undefined)
+                body.temperature = options.temperature;
+            if (opts.tools?.length)
+                body.tools = opts.tools.map(toAnthropicTool);
+            const res = await fetch(`${baseUrl}/messages`, {
+                method: 'POST',
+                signal: opts.signal,
+                headers: {
+                    'content-type': 'application/json',
+                    'anthropic-version': version,
+                    'anthropic-dangerous-direct-browser-access': 'true',
+                    ...(options.apiKey ? { 'x-api-key': options.apiKey } : {}),
+                    ...options.headers,
+                },
+                body: JSON.stringify(body),
+            });
+            if (!res.ok || !res.body) {
+                const errText = await res.text().catch(() => res.statusText);
+                throw new Error(`Anthropic request failed (${res.status}): ${errText}`);
+            }
+            let text = '';
+            let inputTokens = 0;
+            let outputTokens = 0;
+            let cacheRead;
+            let cacheCreation;
+            let stopReason = null;
+            // Tool uses arrive as a content_block_start (with id/name) followed by a
+            // sequence of input_json_delta partials. Accumulate by block index.
+            const toolAcc = new Map();
+            await consumeSSE(res.body, (data) => {
+                if (data === '[DONE]')
+                    return;
+                let event;
+                try {
+                    event = JSON.parse(data);
+                }
+                catch {
+                    return;
+                }
+                // Usage: input tokens arrive on message_start, output on message_delta.
+                if (event.type === 'message_start' && event.message?.usage) {
+                    inputTokens = event.message.usage.input_tokens ?? 0;
+                    cacheRead = event.message.usage.cache_read_input_tokens ?? cacheRead;
+                    cacheCreation = event.message.usage.cache_creation_input_tokens ?? cacheCreation;
+                }
+                if (event.type === 'message_delta') {
+                    if (event.usage?.output_tokens != null)
+                        outputTokens = event.usage.output_tokens;
+                    if (event.delta?.stop_reason)
+                        stopReason = mapStop(event.delta.stop_reason);
+                }
+                switch (event.type) {
+                    case 'content_block_start': {
+                        const block = event.content_block;
+                        if (block?.type === 'tool_use') {
+                            toolAcc.set(event.index ?? 0, {
+                                id: block.id ?? '',
+                                name: block.name ?? '',
+                                json: '',
+                            });
+                        }
+                        break;
+                    }
+                    case 'content_block_delta': {
+                        const delta = event.delta;
+                        if (delta?.type === 'text_delta' && delta.text) {
+                            text += delta.text;
+                            opts.onToken(delta.text);
+                        }
+                        else if (delta?.type === 'input_json_delta' && delta.partial_json) {
+                            const cur = toolAcc.get(event.index ?? 0);
+                            if (cur)
+                                cur.json += delta.partial_json;
+                        }
+                        break;
+                    }
+                    default:
+                        // message_start / message_delta / message_stop / content_block_stop
+                        // / ping — nothing to accumulate.
+                        break;
+                }
+            });
+            const toolCalls = [...toolAcc.entries()]
+                .sort(([a], [b]) => a - b)
+                .map(([idx, t]) => ({
+                id: t.id || `toolu_${idx}`,
+                type: 'function',
+                // `json` is already a JSON-encoded object string; default to "{}".
+                function: { name: t.name, arguments: t.json || '{}' },
+            }));
+            // Fallback: some relays/models emit tool calls as inline text rather than
+            // native tool_use blocks. Parse them out and clean the visible text.
+            let finalText = text;
+            if (!toolCalls.length) {
+                const inline = parseInlineToolCalls(text);
+                if (inline.calls.length) {
+                    toolCalls.push(...inline.calls);
+                    finalText = inline.cleanedText;
+                }
+            }
+            if (toolCalls.length && opts.onTool)
+                opts.onTool(toolCalls);
+            const usage = {
+                input_tokens: inputTokens,
+                output_tokens: outputTokens,
+                cache_read_input_tokens: cacheRead,
+                cache_creation_input_tokens: cacheCreation,
+            };
+            return { text: finalText, toolCalls, model, usage, stopReason };
+        },
+    };
+}
+/** Map Anthropic stop_reason to our StopReason vocabulary. */
+function mapStop(reason) {
+    switch (reason) {
+        case 'end_turn':
+        case 'max_tokens':
+        case 'stop_sequence':
+        case 'tool_use':
+        case 'pause_turn':
+        case 'refusal':
+            return reason;
+        default:
+            return 'end_turn';
+    }
+}
+/**
+ * Convert our provider-neutral ChatMsg[] into the Anthropic Messages format:
+ * leading system messages are hoisted into a top-level `system` string, and the
+ * remaining messages are mapped to user/assistant turns with content blocks.
+ */
+function toAnthropicMessages(messages) {
+    const systemParts = [];
+    const out = [];
+    for (const msg of messages) {
+        if (msg.role === 'system') {
+            systemParts.push(typeof msg.content === 'string' ? msg.content : blocksToText(msg.content));
+            continue;
+        }
+        if (msg.role === 'tool') {
+            // A tool result is delivered to Anthropic as a user message containing a
+            // tool_result block keyed by the originating tool_use id.
+            pushUserBlock(out, {
+                type: 'tool_result',
+                tool_use_id: msg.tool_call_id,
+                content: typeof msg.content === 'string' ? msg.content : blocksToText(msg.content),
+            });
+            continue;
+        }
+        if (msg.role === 'assistant') {
+            const blocks = [];
+            const textContent = typeof msg.content === 'string' ? msg.content : blocksToText(msg.content);
+            if (textContent)
+                blocks.push({ type: 'text', text: textContent });
+            if (msg.tool_calls?.length) {
+                for (const tc of msg.tool_calls) {
+                    blocks.push({
+                        type: 'tool_use',
+                        id: tc.id,
+                        name: tc.function.name,
+                        input: safeParseObject(tc.function.arguments),
+                    });
+                }
+            }
+            out.push({ role: 'assistant', content: blocks.length ? blocks : [{ type: 'text', text: '' }] });
+            continue;
+        }
+        // user
+        out.push({ role: 'user', content: contentToAnthropicBlocks(msg.content) });
+    }
+    return { system: systemParts.join('\n\n'), messages: out };
+}
+/** Append a single block to a user message, coalescing with a trailing user turn. */
+function pushUserBlock(out, block) {
+    const last = out[out.length - 1];
+    if (last && last.role === 'user') {
+        last.content.push(block);
+    }
+    else {
+        out.push({ role: 'user', content: [block] });
+    }
+}
+/** Map our content blocks to Anthropic content blocks. */
+function contentToAnthropicBlocks(content) {
+    if (typeof content === 'string')
+        return [{ type: 'text', text: content }];
+    const blocks = [];
+    for (const b of content) {
+        if (b.type === 'text') {
+            blocks.push({ type: 'text', text: b.text });
+        }
+        else if (b.type === 'image') {
+            blocks.push({
+                type: 'image',
+                source: { type: 'base64', media_type: b.source.media_type, data: b.source.data },
+            });
+        }
+        else if (b.type === 'document') {
+            blocks.push({
+                type: 'document',
+                source: b.source,
+                ...(b.title ? { title: b.title } : {}),
+                ...(b.context ? { context: b.context } : {}),
+            });
+        }
+        else if (b.type === 'tool_use') {
+            blocks.push({ type: 'tool_use', id: b.id, name: b.name, input: b.input });
+        }
+        else if (b.type === 'tool_result') {
+            blocks.push({
+                type: 'tool_result',
+                tool_use_id: b.tool_use_id,
+                content: typeof b.content === 'string' ? b.content : blocksToText(b.content),
+                ...(b.is_error ? { is_error: true } : {}),
+            });
+        }
+    }
+    return blocks.length ? blocks : [{ type: 'text', text: '' }];
+}
+/** Convert an OpenAI-shape ToolDef into an Anthropic tool definition. */
+function toAnthropicTool(tool) {
+    return {
+        name: tool.function.name,
+        description: tool.function.description,
+        input_schema: tool.function.parameters,
+    };
+}
+function blocksToText(blocks) {
+    return blocks
+        .map((b) => {
+        if (b.type === 'text')
+            return b.text;
+        if (b.type === 'tool_result')
+            return typeof b.content === 'string' ? b.content : blocksToText(b.content);
+        return '';
+    })
+        .filter(Boolean)
+        .join('\n');
+}
+function safeParseObject(json) {
+    try {
+        const parsed = JSON.parse(json);
+        return parsed && typeof parsed === 'object' ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}

package/dist/llm/index.d.ts

@@ -0,0 +1,3 @@
+export * from './openai.js';
+export * from './anthropic.js';
+export * from './responses.js';

package/dist/llm/index.js

@@ -0,0 +1,3 @@
+export * from './openai.js';
+export * from './anthropic.js';
+export * from './responses.js';

package/dist/llm/inlineTools.d.ts

@@ -0,0 +1,11 @@
+import type { ToolCall } from '../types/index.js';
+export declare function hasInlineToolCalls(text: string): boolean;
+/**
+ * Extract inline tool calls from assistant text. Returns the parsed calls and
+ * the text with the tool-call markup removed. If none are found, returns the
+ * original text and an empty array.
+ */
+export declare function parseInlineToolCalls(text: string): {
+    calls: ToolCall[];
+    cleanedText: string;
+};

package/dist/llm/inlineTools.js

@@ -0,0 +1,72 @@
+// Fallback parser for models/proxies that emit tool calls as inline TEXT
+// instead of native function-calling blocks. Several relays and open models use
+// an "XML" tool-call format like:
+//
+//   <tool_call>
+//   <function=write_file>
+//   <parameter=path>index.html</parameter>
+//   <parameter=content>
+//   <!DOCTYPE html> ...
+//   </parameter>
+//   </function>
+//   </tool_call>
+//
+// Parameters may or may not have closing </parameter> tags, and the wrapper
+// <tool_call> may be absent. This parser is tolerant of all those variants and
+// also strips the markup out of the user-visible text.
+const FUNCTION_MARKER = /<function\s*=/;
+export function hasInlineToolCalls(text) {
+    return FUNCTION_MARKER.test(text);
+}
+/**
+ * Extract inline tool calls from assistant text. Returns the parsed calls and
+ * the text with the tool-call markup removed. If none are found, returns the
+ * original text and an empty array.
+ */
+export function parseInlineToolCalls(text) {
+    if (!text || !FUNCTION_MARKER.test(text))
+        return { calls: [], cleanedText: text };
+    const calls = [];
+    const markerRe = /<function\s*=\s*([^>\s]+)\s*>/g;
+    const markers = [];
+    let m;
+    while ((m = markerRe.exec(text)) !== null) {
+        markers.push({ name: m[1], bodyStart: markerRe.lastIndex, markerStart: m.index });
+    }
+    for (let i = 0; i < markers.length; i++) {
+        const cur = markers[i];
+        const end = i + 1 < markers.length ? markers[i + 1].markerStart : text.length;
+        let body = text.slice(cur.bodyStart, end);
+        // Trim at the function/tool_call closers if present.
+        body = body.replace(/<\/function>[\s\S]*$/, '').replace(/<\/tool_call>[\s\S]*$/, '');
+        const args = {};
+        const parts = body.split(/<parameter\s*=/).slice(1);
+        for (const part of parts) {
+            const gt = part.indexOf('>');
+            if (gt < 0)
+                continue;
+            const key = part.slice(0, gt).trim();
+            let val = part.slice(gt + 1);
+            // Value ends at its own closer (or the function/tool_call closer, or the
+            // next parameter — already removed by the split).
+            val = val
+                .replace(/<\/parameter>[\s\S]*$/, '')
+                .replace(/<\/function>[\s\S]*$/, '')
+                .replace(/<\/tool_call>[\s\S]*$/, '');
+            args[key] = trimEdges(val);
+        }
+        calls.push({
+            id: `call_inline_${i}`,
+            type: 'function',
+            function: { name: cur.name.trim(), arguments: JSON.stringify(args) },
+        });
+    }
+    // Everything from the first tool-call/function marker onward is markup.
+    const cut = text.search(/<tool_call>|<function\s*=/);
+    const cleanedText = cut >= 0 ? text.slice(0, cut).trim() : text;
+    return { calls, cleanedText };
+}
+/** Strip a single leading newline and trailing whitespace from a param value. */
+function trimEdges(v) {
+    return v.replace(/^\r?\n/, '').replace(/\s+$/, '');
+}

package/dist/llm/openai.d.ts

@@ -0,0 +1,29 @@
+import type { LLMClient } from '../types/index.js';
+export interface OpenAIClientOptions {
+    /** API key, or a function returning one per request (for round-robin key pools). */
+    apiKey?: string | (() => string | undefined);
+    /** Base URL of the OpenAI-compatible API. Default: https://api.openai.com/v1 */
+    baseUrl?: string;
+    /** Default model id. Can be overridden per call via streamChat opts. */
+    model?: string;
+    /** Extra headers (e.g. for Groq, OpenRouter, Together). */
+    headers?: Record<string, string>;
+    /** Sampling temperature. */
+    temperature?: number;
+    /** Max output tokens. */
+    maxTokens?: number;
+    /** Reasoning effort ('none'|'low'|'high'…) → sets `reasoning_effort` (reasoning models). */
+    reasoningEffort?: string;
+    /** Allow the model to batch multiple tool calls → sets `parallel_tool_calls` (when tools present). */
+    parallelToolCalls?: boolean;
+}
+/**
+ * Creates an LLMClient backed by any OpenAI-compatible /chat/completions
+ * endpoint (OpenAI, Groq, Together, OpenRouter, local llama.cpp, etc.).
+ *
+ * Streams text deltas through `onToken` and surfaces tool calls (assembled
+ * from streamed deltas) via the returned StreamResult and the `onTool` hook.
+ */
+export declare function createOpenAIClient(options?: OpenAIClientOptions): LLMClient;
+/** Read an SSE response body, invoking `onData` for each `data:` payload. */
+export declare function consumeSSE(body: ReadableStream<Uint8Array>, onData: (data: string) => void): Promise<void>;