anyclaude-sdk 0.1.0

package/dist/llm/openai.js

@@ -0,0 +1,224 @@
+import { parseInlineToolCalls } from './inlineTools.js';
+/**
+ * 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 function createOpenAIClient(options = {}) {
+    const baseUrl = (options.baseUrl ?? 'https://api.openai.com/v1').replace(/\/$/, '');
+    const defaultModel = options.model ?? 'gpt-4o';
+    return {
+        async streamChat(messages, opts) {
+            const model = opts.model || defaultModel;
+            const body = {
+                model,
+                messages: messages.map(toOpenAIMessage),
+                stream: true,
+                stream_options: { include_usage: true },
+            };
+            if (options.temperature !== undefined)
+                body.temperature = options.temperature;
+            if (options.maxTokens !== undefined)
+                body.max_tokens = options.maxTokens;
+            // Reasoning models (e.g. xAI grok-4.x): 'none' → 0 reasoning tokens (cheaper/faster).
+            if (options.reasoningEffort)
+                body.reasoning_effort = options.reasoningEffort;
+            if (opts.tools?.length) {
+                body.tools = opts.tools;
+                body.tool_choice = 'auto';
+                if (options.parallelToolCalls !== undefined)
+                    body.parallel_tool_calls = options.parallelToolCalls;
+            }
+            const apiKey = typeof options.apiKey === 'function' ? options.apiKey() : options.apiKey;
+            const headers = {
+                'content-type': 'application/json',
+                ...options.headers,
+            };
+            if (apiKey)
+                headers.authorization = `Bearer ${apiKey}`;
+            const res = await fetch(`${baseUrl}/chat/completions`, {
+                method: 'POST',
+                signal: opts.signal,
+                headers,
+                body: JSON.stringify(body),
+            });
+            if (!res.ok || !res.body) {
+                const errText = await res.text().catch(() => res.statusText);
+                throw new Error(`LLM request failed (${res.status}): ${errText}`);
+            }
+            let text = '';
+            let usage;
+            let finishReason = null;
+            const toolAcc = new Map();
+            await consumeSSE(res.body, (data) => {
+                if (data === '[DONE]')
+                    return;
+                let chunk;
+                try {
+                    chunk = JSON.parse(data);
+                }
+                catch {
+                    return;
+                }
+                // The final usage chunk (stream_options.include_usage) has empty choices.
+                if (chunk.usage) {
+                    usage = {
+                        input_tokens: chunk.usage.prompt_tokens ?? 0,
+                        output_tokens: chunk.usage.completion_tokens ?? 0,
+                        cache_read_input_tokens: chunk.usage.prompt_tokens_details?.cached_tokens,
+                    };
+                }
+                const choice = chunk.choices?.[0];
+                if (choice?.finish_reason)
+                    finishReason = choice.finish_reason;
+                const delta = choice?.delta;
+                if (!delta)
+                    return;
+                if (typeof delta.content === 'string' && delta.content) {
+                    text += delta.content;
+                    opts.onToken(delta.content);
+                }
+                if (delta.tool_calls) {
+                    for (const tc of delta.tool_calls) {
+                        const idx = tc.index ?? 0;
+                        const cur = toolAcc.get(idx) ?? { id: '', name: '', args: '' };
+                        if (tc.id)
+                            cur.id = tc.id;
+                        if (tc.function?.name)
+                            cur.name = tc.function.name;
+                        if (tc.function?.arguments)
+                            cur.args += tc.function.arguments;
+                        toolAcc.set(idx, cur);
+                    }
+                }
+            });
+            const toolCalls = [...toolAcc.entries()]
+                .sort(([a], [b]) => a - b)
+                .map(([idx, t]) => ({
+                id: t.id || `call_${idx}`,
+                type: 'function',
+                function: { name: t.name, arguments: t.args || '{}' },
+            }));
+            // Fallback: some endpoints emit tool calls as inline text rather than
+            // native tool_calls. 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);
+            return { text: finalText, toolCalls, model, usage, stopReason: mapFinishReason(finishReason) };
+        },
+    };
+}
+/** Map OpenAI finish_reason to our StopReason vocabulary. */
+function mapFinishReason(reason) {
+    switch (reason) {
+        case 'stop':
+            return 'end_turn';
+        case 'length':
+            return 'max_tokens';
+        case 'tool_calls':
+        case 'function_call':
+            return 'tool_use';
+        default:
+            return reason ? 'end_turn' : null;
+    }
+}
+/** Convert our provider-neutral ChatMsg into an OpenAI chat message. */
+function toOpenAIMessage(msg) {
+    if (msg.role === 'tool') {
+        return {
+            role: 'tool',
+            tool_call_id: msg.tool_call_id,
+            content: typeof msg.content === 'string' ? msg.content : blocksToText(msg.content),
+        };
+    }
+    if (msg.role === 'assistant') {
+        const out = {
+            role: 'assistant',
+            content: typeof msg.content === 'string' ? msg.content : blocksToText(msg.content),
+        };
+        if (msg.tool_calls?.length)
+            out.tool_calls = msg.tool_calls;
+        return out;
+    }
+    // system / user
+    if (typeof msg.content === 'string') {
+        return { role: msg.role, content: msg.content };
+    }
+    return { role: msg.role, content: blocksToOpenAIContent(msg.content) };
+}
+function blocksToOpenAIContent(blocks) {
+    const parts = [];
+    for (const b of blocks) {
+        if (b.type === 'text')
+            parts.push({ type: 'text', text: b.text });
+        else if (b.type === 'image') {
+            parts.push({
+                type: 'image_url',
+                image_url: { url: `data:${b.source.media_type};base64,${b.source.data}` },
+            });
+        }
+        else if (b.type === 'document') {
+            // OpenAI chat completions has no portable inline-PDF part; some gateways
+            // accept a `file` part. Emit that when we have base64 PDF data, plus a
+            // text marker so non-supporting models still get a hint.
+            if (b.source.type === 'base64') {
+                parts.push({
+                    type: 'file',
+                    file: {
+                        filename: b.title ?? 'document.pdf',
+                        file_data: `data:application/pdf;base64,${b.source.data}`,
+                    },
+                });
+            }
+            else {
+                parts.push({ type: 'text', text: b.source.data });
+            }
+        }
+    }
+    return parts.length ? parts : '';
+}
+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');
+}
+/** Read an SSE response body, invoking `onData` for each `data:` payload. */
+export async function consumeSSE(body, onData) {
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+    try {
+        for (;;) {
+            const { value, done } = await reader.read();
+            if (done)
+                break;
+            buffer += decoder.decode(value, { stream: true });
+            let nl;
+            while ((nl = buffer.indexOf('\n')) !== -1) {
+                const line = buffer.slice(0, nl).trim();
+                buffer = buffer.slice(nl + 1);
+                if (line.startsWith('data:'))
+                    onData(line.slice(5).trim());
+            }
+        }
+    }
+    finally {
+        reader.releaseLock?.();
+    }
+}

package/dist/llm/responses.d.ts

@@ -0,0 +1,18 @@
+import type { LLMClient } from '../types/index.js';
+export interface ResponsesClientOptions {
+    apiKey?: string;
+    /** Base URL of the Responses-compatible API. Default: https://api.openai.com/v1 */
+    baseUrl?: string;
+    model?: string;
+    headers?: Record<string, string>;
+    temperature?: number;
+    /** Max output tokens (maps to `max_output_tokens`). */
+    maxTokens?: number;
+    /** Whether the server should persist state. Default false (we send full history). */
+    store?: boolean;
+}
+/**
+ * Creates an LLMClient backed by the OpenAI Responses API (or any
+ * Responses-compatible endpoint).
+ */
+export declare function createResponsesClient(options?: ResponsesClientOptions): LLMClient;

package/dist/llm/responses.js

@@ -0,0 +1,256 @@
+// OpenAI Responses API client (POST /v1/responses).
+//
+// The Responses API differs from Chat Completions:
+//   - System text goes in `instructions`; the conversation is an `input` array
+//     of typed items (messages, function_call, function_call_output).
+//   - Tools are flat: { type:'function', name, description, parameters }.
+//   - Streaming is a typed SSE event stream: response.output_text.delta,
+//     response.function_call_arguments.delta, response.output_item.added,
+//     response.completed, etc.
+//
+// We normalize all of that to our provider-neutral LLMClient interface.
+import { consumeSSE } from './openai.js';
+import { parseInlineToolCalls } from './inlineTools.js';
+/**
+ * Creates an LLMClient backed by the OpenAI Responses API (or any
+ * Responses-compatible endpoint).
+ */
+export function createResponsesClient(options = {}) {
+    const baseUrl = (options.baseUrl ?? 'https://api.openai.com/v1').replace(/\/$/, '');
+    const defaultModel = options.model ?? 'gpt-4o';
+    return {
+        async streamChat(messages, opts) {
+            const model = opts.model || defaultModel;
+            const { instructions, input } = toResponsesInput(messages);
+            const body = {
+                model,
+                input,
+                stream: true,
+                store: options.store ?? false,
+            };
+            if (instructions)
+                body.instructions = instructions;
+            if (options.temperature !== undefined)
+                body.temperature = options.temperature;
+            if (options.maxTokens !== undefined)
+                body.max_output_tokens = options.maxTokens;
+            if (opts.tools?.length) {
+                body.tools = opts.tools.map(toResponsesTool);
+                body.tool_choice = 'auto';
+            }
+            const res = await fetch(`${baseUrl}/responses`, {
+                method: 'POST',
+                signal: opts.signal,
+                headers: {
+                    'content-type': 'application/json',
+                    ...(options.apiKey ? { authorization: `Bearer ${options.apiKey}` } : {}),
+                    ...options.headers,
+                },
+                body: JSON.stringify(body),
+            });
+            if (!res.ok || !res.body) {
+                const errText = await res.text().catch(() => res.statusText);
+                throw new Error(`Responses request failed (${res.status}): ${errText}`);
+            }
+            let text = '';
+            let usage;
+            let status = null;
+            // Function calls stream as output items keyed by output_index.
+            const toolAcc = new Map();
+            await consumeSSE(res.body, (data) => {
+                if (data === '[DONE]')
+                    return;
+                let ev;
+                try {
+                    ev = JSON.parse(data);
+                }
+                catch {
+                    return;
+                }
+                switch (ev.type) {
+                    case 'response.output_text.delta': {
+                        if (typeof ev.delta === 'string' && ev.delta) {
+                            text += ev.delta;
+                            opts.onToken(ev.delta);
+                        }
+                        break;
+                    }
+                    case 'response.output_item.added': {
+                        const item = ev.item;
+                        if (item?.type === 'function_call') {
+                            toolAcc.set(ev.output_index ?? toolAcc.size, {
+                                callId: item.call_id ?? item.id ?? '',
+                                name: item.name ?? '',
+                                args: typeof item.arguments === 'string' ? item.arguments : '',
+                            });
+                        }
+                        break;
+                    }
+                    case 'response.function_call_arguments.delta': {
+                        const cur = toolAcc.get(ev.output_index ?? 0);
+                        if (cur && typeof ev.delta === 'string')
+                            cur.args += ev.delta;
+                        break;
+                    }
+                    case 'response.output_item.done': {
+                        // Finalize args/name/call_id from the completed item.
+                        const item = ev.item;
+                        if (item?.type === 'function_call') {
+                            const cur = toolAcc.get(ev.output_index ?? 0);
+                            if (cur) {
+                                if (item.call_id)
+                                    cur.callId = item.call_id;
+                                if (item.name)
+                                    cur.name = item.name;
+                                if (typeof item.arguments === 'string' && item.arguments)
+                                    cur.args = item.arguments;
+                            }
+                        }
+                        break;
+                    }
+                    case 'response.completed':
+                    case 'response.incomplete':
+                    case 'response.failed': {
+                        const r = ev.response;
+                        if (r?.usage) {
+                            usage = {
+                                input_tokens: r.usage.input_tokens ?? 0,
+                                output_tokens: r.usage.output_tokens ?? 0,
+                                cache_read_input_tokens: r.usage.input_tokens_details?.cached_tokens,
+                            };
+                        }
+                        status = r?.status ?? null;
+                        break;
+                    }
+                    default:
+                        break;
+                }
+            });
+            let toolCalls = [...toolAcc.entries()]
+                .sort(([a], [b]) => a - b)
+                .map(([idx, t]) => ({
+                id: t.callId || `call_${idx}`,
+                type: 'function',
+                function: { name: t.name, arguments: t.args || '{}' },
+            }));
+            let finalText = text;
+            if (!toolCalls.length) {
+                const inline = parseInlineToolCalls(text);
+                if (inline.calls.length) {
+                    toolCalls = inline.calls;
+                    finalText = inline.cleanedText;
+                }
+            }
+            if (toolCalls.length && opts.onTool)
+                opts.onTool(toolCalls);
+            const stopReason = toolCalls.length
+                ? 'tool_use'
+                : status === 'incomplete'
+                    ? 'max_tokens'
+                    : 'end_turn';
+            return { text: finalText, toolCalls, model, usage, stopReason };
+        },
+    };
+}
+/** Convert our ChatMsg[] into Responses `instructions` + `input` items. */
+function toResponsesInput(messages) {
+    const instructions = [];
+    const input = [];
+    for (const msg of messages) {
+        if (msg.role === 'system') {
+            instructions.push(typeof msg.content === 'string' ? msg.content : blocksToText(msg.content));
+            continue;
+        }
+        if (msg.role === 'tool') {
+            input.push({
+                type: 'function_call_output',
+                call_id: msg.tool_call_id,
+                output: typeof msg.content === 'string' ? msg.content : blocksToText(msg.content),
+            });
+            continue;
+        }
+        if (msg.role === 'assistant') {
+            const textContent = typeof msg.content === 'string' ? msg.content : blocksToText(msg.content);
+            if (textContent) {
+                input.push({
+                    role: 'assistant',
+                    content: [{ type: 'output_text', text: textContent }],
+                });
+            }
+            if (msg.tool_calls?.length) {
+                for (const tc of msg.tool_calls) {
+                    input.push({
+                        type: 'function_call',
+                        call_id: tc.id,
+                        name: tc.function.name,
+                        arguments: tc.function.arguments || '{}',
+                    });
+                }
+            }
+            continue;
+        }
+        // user
+        if (typeof msg.content === 'string') {
+            input.push({ role: 'user', content: [{ type: 'input_text', text: msg.content }] });
+        }
+        else {
+            input.push({ role: 'user', content: toInputParts(msg.content) });
+        }
+    }
+    return { instructions: instructions.join('\n\n'), input };
+}
+/** Map our content blocks to Responses input content parts. */
+function toInputParts(blocks) {
+    const parts = [];
+    for (const b of blocks) {
+        if (b.type === 'text') {
+            parts.push({ type: 'input_text', text: b.text });
+        }
+        else if (b.type === 'image') {
+            parts.push({
+                type: 'input_image',
+                image_url: `data:${b.source.media_type};base64,${b.source.data}`,
+            });
+        }
+        else if (b.type === 'document') {
+            if (b.source.type === 'base64') {
+                parts.push({
+                    type: 'input_file',
+                    filename: b.title ?? 'document.pdf',
+                    file_data: `data:application/pdf;base64,${b.source.data}`,
+                });
+            }
+            else {
+                parts.push({ type: 'input_text', text: b.source.data });
+            }
+        }
+        else if (b.type === 'tool_result') {
+            parts.push({
+                type: 'input_text',
+                text: typeof b.content === 'string' ? b.content : blocksToText(b.content),
+            });
+        }
+    }
+    return parts.length ? parts : [{ type: 'input_text', text: '' }];
+}
+/** Convert an OpenAI-shape ToolDef into a Responses (flat) tool definition. */
+function toResponsesTool(tool) {
+    return {
+        type: 'function',
+        name: tool.function.name,
+        description: tool.function.description,
+        parameters: 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');
+}

package/dist/mcp/client.d.ts

@@ -0,0 +1,20 @@
+import type { McpHttpServerConfig, McpSSEServerConfig, McpToolInfo, McpToolResult } from './types.js';
+import { type McpProxy } from './proxy.js';
+export declare class McpClient {
+    readonly name: string;
+    /** The actual URL we fetch (target, optionally rewritten through a proxy). */
+    private url;
+    private headers;
+    private sessionId;
+    private nextId;
+    private connected;
+    constructor(config: McpHttpServerConfig | McpSSEServerConfig, name: string, proxy?: McpProxy);
+    /** initialize handshake, then send the initialized notification. */
+    connect(signal?: AbortSignal): Promise<void>;
+    listTools(signal?: AbortSignal): Promise<McpToolInfo[]>;
+    callTool(name: string, args: Record<string, unknown>, signal?: AbortSignal): Promise<McpToolResult>;
+    private buildHeaders;
+    private request;
+    /** Fire-and-forget notification (no id, no response expected). */
+    private notify;
+}

package/dist/mcp/client.js

@@ -0,0 +1,156 @@
+// MCP client for remote servers over the Streamable HTTP transport.
+//
+// Implements the JSON-RPC handshake (initialize → notifications/initialized) and
+// the tools/list + tools/call methods. Browser-safe: uses only global fetch,
+// TextDecoder, and ReadableStream.
+//
+// Transport note: both 'http' and 'sse' configs are driven by POSTing JSON-RPC
+// to a single endpoint. A response may come back as a plain JSON body or as a
+// `text/event-stream` (SSE) — we handle both and match responses by request id.
+// Most MCP servers (including legacy "sse" servers) accept POSTed requests this
+// way; the dedicated GET event channel is not required for request/response.
+import { applyProxy } from './proxy.js';
+const PROTOCOL_VERSION = '2025-06-18';
+const FALLBACK_PROTOCOL_VERSION = '2024-11-05';
+const CLIENT_INFO = { name: 'browser-claude-sdk', version: '0.1.0' };
+export class McpClient {
+    constructor(config, name, proxy) {
+        this.sessionId = null;
+        this.nextId = 1;
+        this.connected = false;
+        this.name = name;
+        this.url = applyProxy(config.url, proxy);
+        this.headers = { ...(config.headers ?? {}) };
+    }
+    /** initialize handshake, then send the initialized notification. */
+    async connect(signal) {
+        if (this.connected)
+            return;
+        let initResult;
+        try {
+            initResult = await this.request('initialize', {
+                protocolVersion: PROTOCOL_VERSION,
+                capabilities: {},
+                clientInfo: CLIENT_INFO,
+            }, signal);
+        }
+        catch (err) {
+            // Retry once with the older protocol version for legacy servers.
+            initResult = await this.request('initialize', {
+                protocolVersion: FALLBACK_PROTOCOL_VERSION,
+                capabilities: {},
+                clientInfo: CLIENT_INFO,
+            }, signal);
+        }
+        if (initResult.error) {
+            throw new Error(`MCP initialize failed: ${initResult.error.message}`);
+        }
+        await this.notify('notifications/initialized');
+        this.connected = true;
+    }
+    async listTools(signal) {
+        const tools = [];
+        let cursor;
+        do {
+            const res = await this.request('tools/list', cursor ? { cursor } : {}, signal);
+            if (res.error)
+                throw new Error(`tools/list failed: ${res.error.message}`);
+            const result = (res.result ?? {});
+            if (Array.isArray(result.tools))
+                tools.push(...result.tools);
+            cursor = result.nextCursor;
+        } while (cursor);
+        return tools;
+    }
+    async callTool(name, args, signal) {
+        const res = await this.request('tools/call', { name, arguments: args ?? {} }, signal);
+        if (res.error)
+            throw new Error(`tools/call (${name}) failed: ${res.error.message}`);
+        const result = (res.result ?? { content: [] });
+        if (!Array.isArray(result.content))
+            result.content = [];
+        return result;
+    }
+    // ---- transport ----
+    buildHeaders() {
+        const h = {
+            'content-type': 'application/json',
+            accept: 'application/json, text/event-stream',
+            ...this.headers,
+        };
+        if (this.sessionId)
+            h['mcp-session-id'] = this.sessionId;
+        return h;
+    }
+    async request(method, params, signal) {
+        const id = this.nextId++;
+        const res = await fetch(this.url, {
+            method: 'POST',
+            signal,
+            headers: this.buildHeaders(),
+            body: JSON.stringify({ jsonrpc: '2.0', id, method, params }),
+        });
+        const sid = res.headers.get('mcp-session-id');
+        if (sid)
+            this.sessionId = sid;
+        if (!res.ok) {
+            const txt = await res.text().catch(() => res.statusText);
+            throw new Error(`MCP HTTP ${res.status} for ${method}: ${txt}`);
+        }
+        const contentType = res.headers.get('content-type') ?? '';
+        if (contentType.includes('text/event-stream') && res.body) {
+            return await readSSEForId(res.body, id);
+        }
+        // Plain JSON response.
+        return (await res.json());
+    }
+    /** Fire-and-forget notification (no id, no response expected). */
+    async notify(method, params) {
+        try {
+            await fetch(this.url, {
+                method: 'POST',
+                headers: this.buildHeaders(),
+                body: JSON.stringify({ jsonrpc: '2.0', method, params }),
+            });
+        }
+        catch {
+            // Notifications are best-effort.
+        }
+    }
+}
+/** Read an SSE body and resolve the first JSON-RPC message matching `id`. */
+async function readSSEForId(body, id) {
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+    try {
+        for (;;) {
+            const { value, done } = await reader.read();
+            if (done)
+                break;
+            buffer += decoder.decode(value, { stream: true });
+            let nl;
+            while ((nl = buffer.indexOf('\n')) !== -1) {
+                const line = buffer.slice(0, nl).trim();
+                buffer = buffer.slice(nl + 1);
+                if (!line.startsWith('data:'))
+                    continue;
+                const data = line.slice(5).trim();
+                if (!data || data === '[DONE]')
+                    continue;
+                try {
+                    const msg = JSON.parse(data);
+                    if (msg && msg.id === id)
+                        return msg;
+                }
+                catch {
+                    // partial/non-JSON keepalive; keep reading
+                }
+            }
+        }
+    }
+    finally {
+        reader.releaseLock?.();
+    }
+    throw new Error(`MCP SSE stream ended without a response for request ${id}`);
+}