anyclaude-sdk 0.1.0

package/dist/types/index.d.ts

@@ -0,0 +1,363 @@
+export type TextBlock = {
+    type: 'text';
+    text: string;
+};
+export type ThinkingBlock = {
+    type: 'thinking';
+    thinking: string;
+    signature?: string;
+};
+export type ToolUseBlock = {
+    type: 'tool_use';
+    id: string;
+    name: string;
+    input: Record<string, unknown>;
+};
+export type ImageBlock = {
+    type: 'image';
+    source: {
+        type: 'base64';
+        media_type: string;
+        data: string;
+    };
+};
+/** PDF / document block (Anthropic-native; matches @anthropic-ai/sdk DocumentBlockParam). */
+export type DocumentBlock = {
+    type: 'document';
+    source: {
+        type: 'base64';
+        media_type: 'application/pdf';
+        data: string;
+    } | {
+        type: 'text';
+        media_type: 'text/plain';
+        data: string;
+    };
+    title?: string;
+    context?: string;
+};
+export type ToolResultBlock = {
+    type: 'tool_result';
+    tool_use_id: string;
+    content: string | Array<TextBlock | ImageBlock | DocumentBlock>;
+    is_error?: boolean;
+};
+export type ContentBlockParam = TextBlock | ThinkingBlock | ToolUseBlock | ToolResultBlock | ImageBlock | DocumentBlock;
+export type StopReason = 'end_turn' | 'max_tokens' | 'stop_sequence' | 'tool_use' | 'pause_turn' | 'refusal' | null;
+/** Mirrors @anthropic-ai/sdk MessageParam for role: 'user'. */
+export type APIUserMessage = {
+    role: 'user';
+    content: string | ContentBlockParam[];
+};
+/** Mirrors @anthropic-ai/sdk Message (assistant turn). */
+export type APIAssistantMessage = {
+    id: string;
+    type: 'message';
+    role: 'assistant';
+    model: string;
+    content: ContentBlockParam[];
+    stop_reason: StopReason;
+    stop_sequence: string | null;
+    usage: Usage;
+};
+export type Usage = {
+    input_tokens: number;
+    output_tokens: number;
+    cache_read_input_tokens?: number;
+    cache_creation_input_tokens?: number;
+};
+export type ModelUsage = {
+    inputTokens: number;
+    outputTokens: number;
+    cacheReadInputTokens: number;
+    cacheCreationInputTokens: number;
+    webSearchRequests: number;
+    costUSD: number;
+    contextWindow: number;
+    maxOutputTokens: number;
+};
+export type ApiKeySource = 'user' | 'project' | 'org' | 'temporary' | 'oauth' | 'none';
+export type PermissionMode = 'default' | 'acceptEdits' | 'bypassPermissions' | 'plan' | 'dontAsk';
+export type SDKUserMessage = {
+    type: 'user';
+    message: APIUserMessage;
+    parent_tool_use_id: string | null;
+    /** ISO 8601 timestamp; optional to match the SDK (consumers fall back to receive time). */
+    timestamp?: string;
+    isSynthetic?: boolean;
+    uuid?: string;
+    session_id?: string;
+};
+export type SDKAssistantMessageError = 'authentication_failed' | 'billing_error' | 'rate_limit' | 'invalid_request' | 'server_error' | 'unknown' | 'max_output_tokens';
+export type SDKAssistantMessage = {
+    type: 'assistant';
+    message: APIAssistantMessage;
+    parent_tool_use_id: string | null;
+    error?: SDKAssistantMessageError;
+    uuid: string;
+    session_id: string;
+};
+/** A streaming delta event (mirrors SDKPartialAssistantMessage / 'stream_event'). */
+export type SDKPartialAssistantMessage = {
+    type: 'stream_event';
+    event: RawMessageStreamEvent;
+    parent_tool_use_id: string | null;
+    uuid: string;
+    session_id: string;
+};
+/** Minimal stream-event shape; matches the Anthropic streaming event tags we emit. */
+export type RawMessageStreamEvent = {
+    type: 'message_start';
+    message: Partial<APIAssistantMessage>;
+} | {
+    type: 'content_block_start';
+    index: number;
+    content_block: ContentBlockParam;
+} | {
+    type: 'content_block_delta';
+    index: number;
+    delta: {
+        type: 'text_delta';
+        text: string;
+    } | {
+        type: 'input_json_delta';
+        partial_json: string;
+    } | {
+        type: 'thinking_delta';
+        thinking: string;
+    };
+} | {
+    type: 'content_block_stop';
+    index: number;
+} | {
+    type: 'message_delta';
+    delta: {
+        stop_reason?: StopReason;
+    };
+    usage?: Partial<Usage>;
+} | {
+    type: 'message_stop';
+};
+export type SDKSystemMessage = {
+    type: 'system';
+    subtype: 'init';
+    apiKeySource: ApiKeySource;
+    cwd: string;
+    tools: string[];
+    mcp_servers: Array<{
+        name: string;
+        status: string;
+    }>;
+    model: string;
+    permissionMode: PermissionMode;
+    slash_commands: string[];
+    output_style: string;
+    skills: string[];
+    agents?: string[];
+    uuid: string;
+    session_id: string;
+};
+export type SDKCompactBoundaryMessage = {
+    type: 'system';
+    subtype: 'compact_boundary';
+    compact_metadata: {
+        trigger: 'manual' | 'auto';
+        pre_tokens: number;
+    };
+    uuid: string;
+    session_id: string;
+};
+/** Output of a local slash command (e.g. /help, /cost). */
+export type SDKLocalCommandOutputMessage = {
+    type: 'system';
+    subtype: 'local_command_output';
+    content: string;
+    uuid: string;
+    session_id: string;
+};
+export type SDKPermissionDenial = {
+    tool_name: string;
+    tool_use_id: string;
+    tool_input: Record<string, unknown>;
+};
+export type SDKResultMessage = {
+    type: 'result';
+    subtype: 'success';
+    duration_ms: number;
+    duration_api_ms: number;
+    is_error: boolean;
+    num_turns: number;
+    result: string;
+    stop_reason: string | null;
+    total_cost_usd: number;
+    usage: Usage;
+    modelUsage: Record<string, ModelUsage>;
+    permission_denials: SDKPermissionDenial[];
+    uuid: string;
+    session_id: string;
+} | {
+    type: 'result';
+    subtype: 'error_during_execution' | 'error_max_turns' | 'error_max_budget_usd';
+    duration_ms: number;
+    duration_api_ms: number;
+    is_error: boolean;
+    num_turns: number;
+    stop_reason: string | null;
+    total_cost_usd: number;
+    usage: Usage;
+    modelUsage: Record<string, ModelUsage>;
+    permission_denials: SDKPermissionDenial[];
+    errors: string[];
+    uuid: string;
+    session_id: string;
+};
+export type SDKMessage = SDKUserMessage | SDKAssistantMessage | SDKPartialAssistantMessage | SDKSystemMessage | SDKCompactBoundaryMessage | SDKLocalCommandOutputMessage | SDKResultMessage;
+/** A todo item managed by the todo_write tool. */
+export type TodoItem = {
+    content: string;
+    status: 'pending' | 'in_progress' | 'completed';
+    activeForm?: string;
+};
+/**
+ * Definition of a custom sub-agent invokable via the `task` tool (mirrors the
+ * official SDK's AgentDefinition subset).
+ */
+export type AgentDefinition = {
+    /** Natural-language description of when to use this agent. */
+    description: string;
+    /** The sub-agent's system prompt. */
+    prompt: string;
+    /** Allowed tool names. If omitted, inherits the parent's tools (minus `task`). */
+    tools?: string[];
+    /** Model override for this sub-agent. If omitted, inherits the parent model. */
+    model?: string;
+};
+/** Mutable per-session state shared with tools (todos, config, etc.). */
+export type AgentStore = {
+    todos: TodoItem[];
+    /** Free-form session config key/value store (used by the `config` tool). */
+    config?: Record<string, unknown>;
+};
+/** Result of a permission check — allow (optionally with modified input) or deny. */
+export type PermissionResult = {
+    behavior: 'allow';
+    updatedInput?: Record<string, unknown>;
+} | {
+    behavior: 'deny';
+    message: string;
+    interrupt?: boolean;
+};
+/**
+ * Permission gate invoked before each tool runs. Return allow/deny.
+ * Mirrors the official SDK's `canUseTool` option.
+ */
+export type CanUseTool = (toolName: string, input: Record<string, unknown>, options: {
+    signal?: AbortSignal;
+    toolUseId: string;
+}) => Promise<PermissionResult> | PermissionResult;
+/** Lifecycle hook events we surface (subset of the SDK's 27 hook events). */
+export type HookEvent = 'PreToolUse' | 'PostToolUse' | 'PostToolUseFailure' | 'PermissionRequest' | 'PermissionDenied' | 'FileChanged' | 'UserPromptSubmit' | 'Notification' | 'Stop' | 'SessionStart' | 'SessionEnd' | 'SubagentStart' | 'SubagentStop' | 'PreCompact' | 'PostCompact';
+export type PreToolUseHookInput = {
+    hook_event_name: 'PreToolUse';
+    tool_name: string;
+    tool_input: Record<string, unknown>;
+    tool_use_id: string;
+};
+export type PostToolUseHookInput = {
+    hook_event_name: 'PostToolUse';
+    tool_name: string;
+    tool_input: Record<string, unknown>;
+    tool_response: unknown;
+    tool_use_id: string;
+};
+/** Generic lifecycle hook input (session/subagent/compaction/prompt/permission/file events). */
+export type LifecycleHookInput = {
+    hook_event_name: 'UserPromptSubmit' | 'Notification' | 'Stop' | 'SessionStart' | 'SessionEnd' | 'SubagentStart' | 'SubagentStop' | 'PreCompact' | 'PostCompact' | 'PermissionRequest' | 'PermissionDenied' | 'PostToolUseFailure' | 'FileChanged';
+    [key: string]: unknown;
+};
+export type HookInput = PreToolUseHookInput | PostToolUseHookInput | LifecycleHookInput;
+/** A permission update a PermissionRequest hook may suggest. */
+export type PermissionUpdateSuggestion = {
+    type: 'addRules' | 'replaceRules' | 'removeRules';
+    behavior?: 'allow' | 'deny' | 'ask';
+    rules?: Array<{
+        toolName: string;
+        ruleContent?: string;
+    }>;
+};
+/**
+ * Hook callback output. `permissionDecision` on PreToolUse can short-circuit a
+ * tool ('deny'/'ask'→deny); `additionalContext` is appended to the tool result.
+ */
+export type HookOutput = {
+    decision?: 'approve' | 'block';
+    permissionDecision?: 'allow' | 'deny' | 'ask';
+    permissionDecisionReason?: string;
+    additionalContext?: string;
+    systemMessage?: string;
+    /** Permission rule updates suggested by a PermissionRequest hook. */
+    permissionUpdates?: PermissionUpdateSuggestion[];
+} | void;
+export type HookCallback = (input: HookInput, options: {
+    signal?: AbortSignal;
+}) => Promise<HookOutput> | HookOutput;
+export type ToolDef = {
+    type: 'function';
+    function: {
+        name: string;
+        description: string;
+        parameters: {
+            type: 'object';
+            properties: Record<string, unknown>;
+            required?: string[];
+        };
+    };
+};
+export type ToolCall = {
+    id: string;
+    type: 'function';
+    function: {
+        name: string;
+        arguments: string;
+    };
+};
+export interface FileSystem {
+    readFile(path: string): Promise<string | null>;
+    readBinary(path: string): Promise<Uint8Array | null>;
+    writeFile(path: string, contents: string): Promise<void>;
+    writeBinary(path: string, data: Uint8Array): Promise<void>;
+    deleteFile(path: string): Promise<void>;
+    readdir(path: string): Promise<Array<{
+        name: string;
+        isDir: boolean;
+    }> | null>;
+    mkdir(path: string): Promise<void>;
+}
+export interface CommandExecutor {
+    exec(command: string, timeoutMs?: number, env?: Record<string, string>): Promise<{
+        output: string;
+        exitCode: number;
+    }>;
+}
+export interface LLMClient {
+    streamChat(messages: ChatMsg[], opts: {
+        model?: string;
+        tools?: ToolDef[];
+        signal?: AbortSignal;
+        onToken: (delta: string) => void;
+        onTool?: (calls: ToolCall[]) => void;
+    }): Promise<StreamResult>;
+}
+export type ChatMsg = {
+    role: 'system' | 'user' | 'assistant' | 'tool';
+    content: string | ContentBlockParam[];
+    tool_calls?: ToolCall[];
+    tool_call_id?: string;
+};
+export type StreamResult = {
+    text: string;
+    toolCalls: ToolCall[];
+    model: string;
+    usage?: Usage;
+    stopReason?: StopReason;
+};

package/dist/types/index.js

@@ -0,0 +1,9 @@
+// Core types for browser-claude-sdk — a local, browser-compatible implementation
+// of Claude Code agent capabilities.
+//
+// The `SDK*` message family mirrors the official `@anthropic-ai/claude-agent-sdk`
+// message envelope (see Claude Code's sdk/coreSchemas.ts) so consumers written
+// against the real SDK can iterate our `query()` output unchanged. The
+// transport-layer interfaces (LLMClient / ChatMsg / ToolDef / ToolCall /
+// FileSystem / CommandExecutor) are our own OpenAI-compatible additions.
+export {};

package/dist/util/ids.d.ts

@@ -0,0 +1,3 @@
+export declare function uuid(): string;
+export declare function toolCallId(): string;
+export declare function now(): number;

package/dist/util/ids.js

@@ -0,0 +1,22 @@
+// Small id/uuid helpers, browser-safe with graceful fallback.
+function rand() {
+    // crypto.randomUUID is available in all modern browsers and Node 19+.
+    const c = globalThis.crypto;
+    if (c?.randomUUID)
+        return c.randomUUID();
+    // Fallback: not cryptographically strong, only used for correlation ids.
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (ch) => {
+        const r = (Math.random() * 16) | 0;
+        const v = ch === 'x' ? r : (r & 0x3) | 0x8;
+        return v.toString(16);
+    });
+}
+export function uuid() {
+    return rand();
+}
+export function toolCallId() {
+    return 'call_' + rand().replace(/-/g, '').slice(0, 24);
+}
+export function now() {
+    return Date.now();
+}

package/dist/util/paths.d.ts

@@ -0,0 +1,16 @@
+/** Collapse `.`/`..` segments and duplicate slashes. Preserves leading `/`. */
+export declare function normalizePath(p: string): string;
+/** Join segments with `/` and normalize. */
+export declare function joinPath(...parts: string[]): string;
+/** Resolve `p` against `cwd` when relative; normalize either way. */
+export declare function resolvePath(cwd: string, p: string): string;
+/** Directory portion of a path (like POSIX dirname). */
+export declare function dirname(p: string): string;
+/** Final path segment (like POSIX basename). */
+export declare function basename(p: string): string;
+/** Lowercased extension including the dot (e.g. ".ts"), or "" if none. */
+export declare function extname(p: string): string;
+/** Split an absolute/relative path into its non-empty segments. */
+export declare function segments(p: string): string[];
+/** Every ancestor directory of `p`, from `/` (or first segment) down to the parent. */
+export declare function ancestors(p: string): string[];

package/dist/util/paths.js

@@ -0,0 +1,72 @@
+// Shared POSIX-style path utilities (browser-safe, no node:path dependency).
+// Used by the persistent filesystems and sandbox adapters so path handling is
+// consistent across the SDK.
+/** Collapse `.`/`..` segments and duplicate slashes. Preserves leading `/`. */
+export function normalizePath(p) {
+    const isAbs = p.startsWith('/');
+    const out = [];
+    for (const seg of p.split('/')) {
+        if (seg === '' || seg === '.')
+            continue;
+        if (seg === '..') {
+            if (out.length && out[out.length - 1] !== '..')
+                out.pop();
+            else if (!isAbs)
+                out.push('..');
+        }
+        else {
+            out.push(seg);
+        }
+    }
+    return (isAbs ? '/' : '') + out.join('/');
+}
+/** Join segments with `/` and normalize. */
+export function joinPath(...parts) {
+    return normalizePath(parts.filter(Boolean).join('/'));
+}
+/** Resolve `p` against `cwd` when relative; normalize either way. */
+export function resolvePath(cwd, p) {
+    if (p.startsWith('/'))
+        return normalizePath(p);
+    return normalizePath(`${cwd}/${p}`);
+}
+/** Directory portion of a path (like POSIX dirname). */
+export function dirname(p) {
+    const n = normalizePath(p);
+    const i = n.lastIndexOf('/');
+    if (i < 0)
+        return '.';
+    if (i === 0)
+        return '/';
+    return n.slice(0, i);
+}
+/** Final path segment (like POSIX basename). */
+export function basename(p) {
+    const n = normalizePath(p);
+    const i = n.lastIndexOf('/');
+    return i < 0 ? n : n.slice(i + 1);
+}
+/** Lowercased extension including the dot (e.g. ".ts"), or "" if none. */
+export function extname(p) {
+    const base = basename(p);
+    const i = base.lastIndexOf('.');
+    return i > 0 ? base.slice(i).toLowerCase() : '';
+}
+/** Split an absolute/relative path into its non-empty segments. */
+export function segments(p) {
+    return normalizePath(p)
+        .split('/')
+        .filter((s) => s && s !== '.');
+}
+/** Every ancestor directory of `p`, from `/` (or first segment) down to the parent. */
+export function ancestors(p) {
+    const segs = segments(p);
+    const isAbs = normalizePath(p).startsWith('/');
+    const out = [];
+    let cur = isAbs ? '' : '';
+    for (let i = 0; i < segs.length - 1; i++) {
+        cur = cur + '/' + segs[i];
+        out.push(normalizePath((isAbs ? '' : '') + cur));
+    }
+    return isAbs ? out.map((a) => (a.startsWith('/') ? a : '/' + a)) : out;
+}

package/dist/util/pricing.d.ts

@@ -0,0 +1,15 @@
+import type { Usage } from '../types/index.js';
+export type Pricing = {
+    inputPerM: number;
+    outputPerM: number;
+    /** Cost of cache-read (cached input) tokens per 1M. Defaults to a fraction of input. */
+    cacheReadPerM?: number;
+    /** Cost of cache-write (cache creation) tokens per 1M. */
+    cacheWritePerM?: number;
+};
+/** Context window for a model id by longest-prefix match (0 if unknown). */
+export declare function contextWindowFor(model: string): number;
+/** Find pricing for a model id by longest-prefix match. */
+export declare function priceFor(model: string): Pricing | undefined;
+/** Estimate USD cost for a usage record under a model's pricing. 0 if unknown. */
+export declare function computeCostUSD(model: string, usage: Usage): number;

package/dist/util/pricing.js

@@ -0,0 +1,81 @@
+// Best-effort token pricing for cost accounting. USD per 1M tokens.
+// Matched by longest-prefix against the model id; unknown models cost 0 (and
+// callers can detect that via `priceFor` returning undefined).
+//
+// These are list prices and may drift — treat total_cost_usd as an estimate.
+// Keys are prefixes; the longest matching prefix wins.
+const TABLE = {
+    // Anthropic
+    'claude-opus-4': { inputPerM: 15, outputPerM: 75, cacheReadPerM: 1.5, cacheWritePerM: 18.75 },
+    'claude-sonnet-4': { inputPerM: 3, outputPerM: 15, cacheReadPerM: 0.3, cacheWritePerM: 3.75 },
+    'claude-haiku-4': { inputPerM: 1, outputPerM: 5, cacheReadPerM: 0.1, cacheWritePerM: 1.25 },
+    'claude-3-5-haiku': { inputPerM: 0.8, outputPerM: 4, cacheReadPerM: 0.08, cacheWritePerM: 1 },
+    'claude-3-5-sonnet': { inputPerM: 3, outputPerM: 15, cacheReadPerM: 0.3, cacheWritePerM: 3.75 },
+    'claude-3-opus': { inputPerM: 15, outputPerM: 75 },
+    // OpenAI
+    'gpt-4o-mini': { inputPerM: 0.15, outputPerM: 0.6, cacheReadPerM: 0.075 },
+    'gpt-4o': { inputPerM: 2.5, outputPerM: 10, cacheReadPerM: 1.25 },
+    'gpt-4.1-mini': { inputPerM: 0.4, outputPerM: 1.6 },
+    'gpt-4.1': { inputPerM: 2, outputPerM: 8 },
+    'o3-mini': { inputPerM: 1.1, outputPerM: 4.4 },
+    'o3': { inputPerM: 2, outputPerM: 8 },
+    'o1': { inputPerM: 15, outputPerM: 60 },
+    // xAI (Grok). Cached-input rate not published per-model → defaults apply.
+    'grok-build': { inputPerM: 1, outputPerM: 2, cacheReadPerM: 0.25 },
+    'grok-code': { inputPerM: 0.2, outputPerM: 1.5 },
+    'grok-4': { inputPerM: 3, outputPerM: 15 },
+    'grok-3-mini': { inputPerM: 0.3, outputPerM: 0.5 },
+    'grok-3': { inputPerM: 3, outputPerM: 15 },
+};
+// Context window (max input+output tokens) by model prefix. Best-effort.
+const CONTEXT_WINDOWS = {
+    'grok-build': 256_000,
+    'grok-code': 256_000,
+    'grok-4': 256_000,
+    'grok-3': 131_072,
+    'claude-sonnet-4': 200_000,
+    'claude-opus-4': 200_000,
+    'claude-haiku-4': 200_000,
+    'claude-3': 200_000,
+    'gpt-4o': 128_000,
+    'gpt-4.1': 1_047_576,
+    o3: 200_000,
+    o1: 200_000,
+};
+/** Context window for a model id by longest-prefix match (0 if unknown). */
+export function contextWindowFor(model) {
+    const id = model.toLowerCase();
+    let best;
+    for (const [key, v] of Object.entries(CONTEXT_WINDOWS)) {
+        if (id.includes(key) && (!best || key.length > best.key.length))
+            best = { key, v };
+    }
+    return best?.v ?? 0;
+}
+/** Find pricing for a model id by longest-prefix match. */
+export function priceFor(model) {
+    const id = model.toLowerCase();
+    let best;
+    for (const [key, p] of Object.entries(TABLE)) {
+        if (id.includes(key) && (!best || key.length > best.key.length))
+            best = { key, p };
+    }
+    return best?.p;
+}
+/** Estimate USD cost for a usage record under a model's pricing. 0 if unknown. */
+export function computeCostUSD(model, usage) {
+    const p = priceFor(model);
+    if (!p)
+        return 0;
+    const cacheRead = usage.cache_read_input_tokens ?? 0;
+    const cacheWrite = usage.cache_creation_input_tokens ?? 0;
+    // input_tokens from providers typically excludes cached/cache-creation; bill
+    // those at their own rates and the remainder at the input rate.
+    const plainInput = Math.max(0, usage.input_tokens - cacheRead - cacheWrite);
+    const cost = (plainInput * p.inputPerM +
+        usage.output_tokens * p.outputPerM +
+        cacheRead * (p.cacheReadPerM ?? p.inputPerM * 0.1) +
+        cacheWrite * (p.cacheWritePerM ?? p.inputPerM * 1.25)) /
+        1_000_000;
+    return cost;
+}

package/dist/workspace/index.d.ts

@@ -0,0 +1,2 @@
+export * from './webcontainer.js';
+export * from './memory.js';

package/dist/workspace/index.js

@@ -0,0 +1,2 @@
+export * from './webcontainer.js';
+export * from './memory.js';

package/dist/workspace/memory.d.ts

@@ -0,0 +1,28 @@
+import type { CommandExecutor, FileSystem } from '../types/index.js';
+/**
+ * A pure in-memory FileSystem. Useful for tests and environments without a
+ * WebContainer. Does not implement CommandExecutor — pair it with a custom
+ * executor or `NoopCommandExecutor` if bash is not needed.
+ */
+export declare class MemoryFileSystem implements FileSystem {
+    private files;
+    private dirs;
+    private norm;
+    readFile(path: string): Promise<string | null>;
+    readBinary(path: string): Promise<Uint8Array | null>;
+    writeFile(path: string, contents: string): Promise<void>;
+    writeBinary(path: string, data: Uint8Array): Promise<void>;
+    deleteFile(path: string): Promise<void>;
+    readdir(path: string): Promise<Array<{
+        name: string;
+        isDir: boolean;
+    }> | null>;
+    mkdir(path: string): Promise<void>;
+}
+/** A CommandExecutor that refuses to run anything — for FS-only workspaces. */
+export declare class NoopCommandExecutor implements CommandExecutor {
+    exec(): Promise<{
+        output: string;
+        exitCode: number;
+    }>;
+}