anyclaude-sdk 0.5.0 → 0.6.1

package/dist/anthropic-endpoint.d.ts

@@ -0,0 +1,97 @@
+import type { ChatMsg, LLMClient, StreamResult, ToolDef } from './types/index.js';
+export interface AnthropicTextBlock {
+    type: 'text';
+    text: string;
+}
+export interface AnthropicImageBlock {
+    type: 'image';
+    source: {
+        type: 'base64';
+        media_type: string;
+        data: string;
+    } | {
+        type: 'url';
+        url: string;
+    };
+}
+export interface AnthropicToolUseBlock {
+    type: 'tool_use';
+    id: string;
+    name: string;
+    input: Record<string, unknown>;
+}
+export interface AnthropicToolResultBlock {
+    type: 'tool_result';
+    tool_use_id: string;
+    content: string | Array<{
+        type: string;
+        text?: string;
+        [k: string]: unknown;
+    }>;
+    is_error?: boolean;
+}
+export type AnthropicContentBlock = AnthropicTextBlock | AnthropicImageBlock | AnthropicToolUseBlock | AnthropicToolResultBlock | {
+    type: string;
+    [k: string]: unknown;
+};
+export interface AnthropicMessage {
+    role: 'user' | 'assistant';
+    content: string | AnthropicContentBlock[];
+}
+export interface AnthropicMessagesRequest {
+    model: string;
+    max_tokens?: number;
+    system?: string | Array<{
+        type: 'text';
+        text: string;
+        [k: string]: unknown;
+    }>;
+    messages: AnthropicMessage[];
+    tools?: Array<{
+        name: string;
+        description?: string;
+        input_schema: Record<string, unknown>;
+    }>;
+    tool_choice?: {
+        type: 'auto' | 'any' | 'tool' | 'none';
+        name?: string;
+    };
+    temperature?: number;
+    stream?: boolean;
+    [k: string]: unknown;
+}
+/** The neutral request the SDK's LLMClient consumes. */
+export interface ChatRequest {
+    messages: ChatMsg[];
+    tools: ToolDef[];
+    model: string;
+    maxTokens?: number;
+    temperature?: number;
+    stream: boolean;
+}
+/** Convert Anthropic `tools` into the SDK's OpenAI-shape `ToolDef[]`. */
+export declare function anthropicToolsToDefs(tools: AnthropicMessagesRequest['tools']): ToolDef[];
+/**
+ * Convert an Anthropic Messages request into the neutral `ChatRequest` the SDK
+ * consumes. Anthropic packs `tool_result` blocks inside user messages; we split
+ * them into separate `tool` ChatMsgs (OpenAI shape). `tool_use` blocks on an
+ * assistant message become `tool_calls`.
+ */
+export declare function anthropicToChat(body: AnthropicMessagesRequest): ChatRequest;
+/** Build a non-streaming Anthropic Messages response object from a StreamResult. */
+export declare function streamResultToAnthropicMessage(result: StreamResult, opts: {
+    model: string;
+    id?: string;
+}): Record<string, unknown>;
+/**
+ * Run a turn through `llm` and yield the Anthropic Messages **SSE** event
+ * sequence as strings (message_start -> content_block_* -> message_delta ->
+ * message_stop). Text streams live; tool calls (native or dialect-recovered)
+ * are emitted as `tool_use` blocks with a single `input_json_delta`. Pipe the
+ * yielded strings straight to an HTTP response body.
+ */
+export declare function anthropicSSE(llm: LLMClient, req: ChatRequest, opts?: {
+    model: string;
+    signal?: AbortSignal;
+    id?: string;
+}): AsyncGenerator<string>;

package/dist/anthropic-endpoint.js

@@ -0,0 +1,271 @@
+import { uuid } from './util/ids.js';
+// ---------------------------------------------------------------------------
+// Request: Anthropic Messages -> ChatMsg[] + ToolDef[]
+// ---------------------------------------------------------------------------
+/** Convert Anthropic `tools` into the SDK's OpenAI-shape `ToolDef[]`. */
+export function anthropicToolsToDefs(tools) {
+    if (!tools?.length)
+        return [];
+    return tools.map((t) => ({
+        type: 'function',
+        function: {
+            name: t.name,
+            description: t.description ?? '',
+            parameters: t.input_schema ?? {
+                type: 'object',
+                properties: {},
+            },
+        },
+    }));
+}
+function systemToText(system) {
+    if (!system)
+        return '';
+    if (typeof system === 'string')
+        return system;
+    return system.map((b) => b.text ?? '').join('\n');
+}
+function anthropicImageToBlock(b) {
+    if (b.source.type === 'base64') {
+        return { type: 'image', source: { type: 'base64', media_type: b.source.media_type, data: b.source.data } };
+    }
+    // URL images — pass through as a text marker; most OpenAI-compatible chat
+    // endpoints want a data URL, which we don't have here.
+    return null;
+}
+function resultBlockToText(content) {
+    if (typeof content === 'string')
+        return content;
+    return content
+        .map((c) => (c.type === 'text' ? (c.text ?? '') : JSON.stringify(c)))
+        .filter(Boolean)
+        .join('\n');
+}
+/**
+ * Convert an Anthropic Messages request into the neutral `ChatRequest` the SDK
+ * consumes. Anthropic packs `tool_result` blocks inside user messages; we split
+ * them into separate `tool` ChatMsgs (OpenAI shape). `tool_use` blocks on an
+ * assistant message become `tool_calls`.
+ */
+export function anthropicToChat(body) {
+    const messages = [];
+    const system = systemToText(body.system);
+    if (system)
+        messages.push({ role: 'system', content: system });
+    for (const msg of body.messages) {
+        if (typeof msg.content === 'string') {
+            messages.push({ role: msg.role, content: msg.content });
+            continue;
+        }
+        if (msg.role === 'assistant') {
+            const textParts = [];
+            const toolCalls = [];
+            for (const b of msg.content) {
+                if (b.type === 'text')
+                    textParts.push(b.text);
+                else if (b.type === 'tool_use') {
+                    const tu = b;
+                    toolCalls.push({
+                        id: tu.id,
+                        type: 'function',
+                        function: { name: tu.name, arguments: JSON.stringify(tu.input ?? {}) },
+                    });
+                }
+            }
+            messages.push({
+                role: 'assistant',
+                content: textParts.join('\n'),
+                tool_calls: toolCalls.length ? toolCalls : undefined,
+            });
+            continue;
+        }
+        // user: tool_result blocks become separate `tool` msgs; remaining
+        // text/image content becomes a user msg (after the tool results).
+        const userBlocks = [];
+        for (const b of msg.content) {
+            if (b.type === 'tool_result') {
+                const tr = b;
+                messages.push({
+                    role: 'tool',
+                    tool_call_id: tr.tool_use_id,
+                    content: resultBlockToText(tr.content),
+                });
+            }
+            else if (b.type === 'text') {
+                userBlocks.push({ type: 'text', text: b.text });
+            }
+            else if (b.type === 'image') {
+                const img = anthropicImageToBlock(b);
+                if (img)
+                    userBlocks.push(img);
+            }
+        }
+        if (userBlocks.length) {
+            const onlyText = userBlocks.length === 1 && userBlocks[0].type === 'text';
+            messages.push({
+                role: 'user',
+                content: onlyText ? userBlocks[0].text : userBlocks,
+            });
+        }
+    }
+    return {
+        messages,
+        tools: anthropicToolsToDefs(body.tools),
+        model: body.model,
+        maxTokens: body.max_tokens,
+        temperature: body.temperature,
+        stream: !!body.stream,
+    };
+}
+// ---------------------------------------------------------------------------
+// Response: StreamResult -> Anthropic Message (non-streaming)
+// ---------------------------------------------------------------------------
+function mapStopReason(reason, hasTools) {
+    if (hasTools)
+        return 'tool_use';
+    switch (reason) {
+        case 'max_tokens':
+            return 'max_tokens';
+        case 'tool_use':
+            return 'tool_use';
+        default:
+            return 'end_turn';
+    }
+}
+function safeJson(s) {
+    try {
+        const v = JSON.parse(s || '{}');
+        return v && typeof v === 'object' ? v : {};
+    }
+    catch {
+        return {};
+    }
+}
+/** Build a non-streaming Anthropic Messages response object from a StreamResult. */
+export function streamResultToAnthropicMessage(result, opts) {
+    const content = [];
+    if (result.text)
+        content.push({ type: 'text', text: result.text });
+    for (const tc of result.toolCalls) {
+        content.push({ type: 'tool_use', id: tc.id, name: tc.function.name, input: safeJson(tc.function.arguments) });
+    }
+    return {
+        id: opts.id ?? 'msg_' + uuid().replace(/-/g, '').slice(0, 24),
+        type: 'message',
+        role: 'assistant',
+        model: opts.model,
+        content,
+        stop_reason: mapStopReason(result.stopReason ?? null, result.toolCalls.length > 0),
+        stop_sequence: null,
+        usage: {
+            input_tokens: result.usage?.input_tokens ?? 0,
+            output_tokens: result.usage?.output_tokens ?? 0,
+            cache_read_input_tokens: result.usage?.cache_read_input_tokens ?? 0,
+        },
+    };
+}
+// ---------------------------------------------------------------------------
+// Response: run the LLM and emit the Anthropic SSE event sequence.
+// ---------------------------------------------------------------------------
+function sse(event, data) {
+    return `event: ${event}\ndata: ${JSON.stringify(data)}\n\n`;
+}
+/**
+ * Run a turn through `llm` and yield the Anthropic Messages **SSE** event
+ * sequence as strings (message_start -> content_block_* -> message_delta ->
+ * message_stop). Text streams live; tool calls (native or dialect-recovered)
+ * are emitted as `tool_use` blocks with a single `input_json_delta`. Pipe the
+ * yielded strings straight to an HTTP response body.
+ */
+export async function* anthropicSSE(llm, req, opts = { model: '' }) {
+    const model = opts.model || req.model;
+    const msgId = opts.id ?? 'msg_' + uuid().replace(/-/g, '').slice(0, 24);
+    yield sse('message_start', {
+        type: 'message_start',
+        message: {
+            id: msgId,
+            type: 'message',
+            role: 'assistant',
+            model,
+            content: [],
+            stop_reason: null,
+            stop_sequence: null,
+            usage: { input_tokens: 0, output_tokens: 0 },
+        },
+    });
+    // Live text streaming with a push queue; suppress tokens once inline
+    // tool-call markup begins (the dialect parser recovers the call from the
+    // final result instead — we don't want raw <tool_call> markup as text).
+    const queue = [];
+    let resolveNext = null;
+    let streamedText = '';
+    let inToolMarkup = false;
+    let textOpen = false;
+    let nextIndex = 0;
+    let textIndex = 0;
+    const push = (s) => {
+        queue.push(s);
+        resolveNext?.();
+        resolveNext = null;
+    };
+    const sp = llm.streamChat(req.messages, {
+        model,
+        tools: req.tools.length ? req.tools : undefined,
+        signal: opts.signal,
+        onToken: (delta) => {
+            streamedText += delta;
+            if (!inToolMarkup && /<tool_call|<function\s*=/.test(streamedText))
+                inToolMarkup = true;
+            if (inToolMarkup)
+                return;
+            if (!textOpen) {
+                textOpen = true;
+                textIndex = nextIndex++;
+                push(sse('content_block_start', { type: 'content_block_start', index: textIndex, content_block: { type: 'text', text: '' } }));
+            }
+            push(sse('content_block_delta', { type: 'content_block_delta', index: textIndex, delta: { type: 'text_delta', text: delta } }));
+        },
+    });
+    let result;
+    let done = false;
+    sp.then((r) => {
+        result = r;
+    }, () => { }).finally(() => {
+        done = true;
+        resolveNext?.();
+        resolveNext = null;
+    });
+    // Drain text deltas as they arrive.
+    while (!done || queue.length) {
+        if (queue.length) {
+            yield queue.shift();
+            continue;
+        }
+        await new Promise((res) => (resolveNext = res));
+    }
+    result = await sp.catch(() => undefined);
+    if (textOpen) {
+        yield sse('content_block_stop', { type: 'content_block_stop', index: textIndex });
+    }
+    const toolCalls = result?.toolCalls ?? [];
+    for (const tc of toolCalls) {
+        const idx = nextIndex++;
+        yield sse('content_block_start', {
+            type: 'content_block_start',
+            index: idx,
+            content_block: { type: 'tool_use', id: tc.id, name: tc.function.name, input: {} },
+        });
+        yield sse('content_block_delta', {
+            type: 'content_block_delta',
+            index: idx,
+            delta: { type: 'input_json_delta', partial_json: tc.function.arguments || '{}' },
+        });
+        yield sse('content_block_stop', { type: 'content_block_stop', index: idx });
+    }
+    yield sse('message_delta', {
+        type: 'message_delta',
+        delta: { stop_reason: mapStopReason(result?.stopReason ?? null, toolCalls.length > 0), stop_sequence: null },
+        usage: { output_tokens: result?.usage?.output_tokens ?? 0 },
+    });
+    yield sse('message_stop', { type: 'message_stop' });
+}

package/dist/queue.d.ts

@@ -1,6 +1,8 @@
 import type { ContentBlockParam } from './types/index.js';
 export type QueuedContent = string | ContentBlockParam[];
 export interface QueuedMessage {
+    /** Stable id for this queued item — use it to `remove()` a single message. */
+    id: string;
     content: QueuedContent;
     /** Epoch ms when enqueued. */
     at: number;
@@ -8,10 +10,19 @@ export interface QueuedMessage {
 export declare class MessageQueue {
     private items;
     private listeners;
-    /** Enqueue a user message to be delivered at the next turn boundary. */
-    push(content: QueuedContent): void;
+    /**
+     * Enqueue a user message to be delivered at the next turn boundary.
+     * Returns the item's stable `id` (pass it to `remove()` to cancel just this one).
+     */
+    push(content: QueuedContent): string;
     /** Remove and return the oldest queued message (FIFO), or undefined if empty. */
     shift(): QueuedMessage | undefined;
+    /**
+     * Remove a single pending message by its `id` (e.g. a per-pill ✕ in the UI).
+     * Returns true if an item was removed. No-op if the id isn't pending — already
+     * drained (shifted) items can't be cancelled.
+     */
+    remove(id: string): boolean;
     peek(): QueuedMessage | undefined;
     get size(): number;
     /** Snapshot of pending messages (does not drain). */

package/dist/queue.js

@@ -1,12 +1,18 @@
+import { uuid } from './util/ids.js';
 export class MessageQueue {
     constructor() {
         this.items = [];
         this.listeners = new Set();
     }
-    /** Enqueue a user message to be delivered at the next turn boundary. */
+    /**
+     * Enqueue a user message to be delivered at the next turn boundary.
+     * Returns the item's stable `id` (pass it to `remove()` to cancel just this one).
+     */
     push(content) {
-        this.items.push({ content, at: Date.now() });
+        const id = uuid();
+        this.items.push({ id, content, at: Date.now() });
         this.emit();
+        return id;
     }
     /** Remove and return the oldest queued message (FIFO), or undefined if empty. */
     shift() {
@@ -15,6 +21,19 @@ export class MessageQueue {
             this.emit();
         return m;
     }
+    /**
+     * Remove a single pending message by its `id` (e.g. a per-pill ✕ in the UI).
+     * Returns true if an item was removed. No-op if the id isn't pending — already
+     * drained (shifted) items can't be cancelled.
+     */
+    remove(id) {
+        const i = this.items.findIndex((m) => m.id === id);
+        if (i < 0)
+            return false;
+        this.items.splice(i, 1);
+        this.emit();
+        return true;
+    }
     peek() {
         return this.items[0];
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "anyclaude-sdk",
-  "version": "0.5.0",
+  "version": "0.6.1",
   "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",
@@ -67,6 +67,10 @@
     "./loop": {
       "types": "./dist/loop.d.ts",
       "import": "./dist/loop.js"
+    },
+    "./anthropic-endpoint": {
+      "types": "./dist/anthropic-endpoint.d.ts",
+      "import": "./dist/anthropic-endpoint.js"
     }
   },
   "sideEffects": false,