kode-sdk 2.7.0

package/dist/index.js

@@ -0,0 +1,147 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineTool = exports.globalToolRegistry = exports.ToolRegistry = exports.builtin = exports.SkillResource = exports.SkillActivate = exports.SkillList = exports.TodoWrite = exports.TodoRead = exports.createTaskRunTool = exports.BashKill = exports.BashLogs = exports.BashRun = exports.FsRm = exports.FsMultiEdit = exports.FsGrep = exports.FsGlob = exports.FsEdit = exports.FsWrite = exports.FsRead = exports.SandboxFactory = exports.AnthropicProvider = exports.LocalSandbox = exports.JSONStore = exports.ResumeError = exports.RedisCheckpointer = exports.FileCheckpointer = exports.MemoryCheckpointer = exports.PermissionModeRegistry = exports.permissionModes = exports.ToolRunner = exports.TodoManager = exports.MessageQueue = exports.PermissionManager = exports.BreakpointManager = exports.TimeBridge = exports.TodoService = exports.AgentTemplateRegistry = exports.estimateMessageTokens = exports.estimateTotalTokens = exports.AICompressionStrategy = exports.SimpleCompressionStrategy = exports.FilePool = exports.ContextManager = exports.HookManager = exports.EventBus = exports.Scheduler = exports.Room = exports.AgentPool = exports.Agent = void 0;
+exports.generateAgentId = exports.SkillsInjector = exports.SkillsManager = exports.SkillsLoader = exports.SkillsValidator = exports.SkillsParser = exports.extendSchema = exports.mergeSchemas = exports.SchemaBuilder = exports.patterns = exports.schema = exports.inferFromExample = exports.toolMethod = exports.ToolKit = exports.disconnectAllMCP = exports.disconnectMCP = exports.getMCPTools = exports.tools = exports.tool = exports.extractTools = exports.defineTools = void 0;
+// Core
+var agent_1 = require("./core/agent");
+Object.defineProperty(exports, "Agent", { enumerable: true, get: function () { return agent_1.Agent; } });
+var pool_1 = require("./core/pool");
+Object.defineProperty(exports, "AgentPool", { enumerable: true, get: function () { return pool_1.AgentPool; } });
+var room_1 = require("./core/room");
+Object.defineProperty(exports, "Room", { enumerable: true, get: function () { return room_1.Room; } });
+var scheduler_1 = require("./core/scheduler");
+Object.defineProperty(exports, "Scheduler", { enumerable: true, get: function () { return scheduler_1.Scheduler; } });
+var events_1 = require("./core/events");
+Object.defineProperty(exports, "EventBus", { enumerable: true, get: function () { return events_1.EventBus; } });
+var hooks_1 = require("./core/hooks");
+Object.defineProperty(exports, "HookManager", { enumerable: true, get: function () { return hooks_1.HookManager; } });
+var context_manager_1 = require("./core/context-manager");
+Object.defineProperty(exports, "ContextManager", { enumerable: true, get: function () { return context_manager_1.ContextManager; } });
+var file_pool_1 = require("./core/file-pool");
+Object.defineProperty(exports, "FilePool", { enumerable: true, get: function () { return file_pool_1.FilePool; } });
+// Compression Strategies
+var compression_1 = require("./core/compression");
+Object.defineProperty(exports, "SimpleCompressionStrategy", { enumerable: true, get: function () { return compression_1.SimpleCompressionStrategy; } });
+Object.defineProperty(exports, "AICompressionStrategy", { enumerable: true, get: function () { return compression_1.AICompressionStrategy; } });
+Object.defineProperty(exports, "estimateTotalTokens", { enumerable: true, get: function () { return compression_1.estimateTotalTokens; } });
+Object.defineProperty(exports, "estimateMessageTokens", { enumerable: true, get: function () { return compression_1.estimateMessageTokens; } });
+var template_1 = require("./core/template");
+Object.defineProperty(exports, "AgentTemplateRegistry", { enumerable: true, get: function () { return template_1.AgentTemplateRegistry; } });
+var todo_1 = require("./core/todo");
+Object.defineProperty(exports, "TodoService", { enumerable: true, get: function () { return todo_1.TodoService; } });
+var time_bridge_1 = require("./core/time-bridge");
+Object.defineProperty(exports, "TimeBridge", { enumerable: true, get: function () { return time_bridge_1.TimeBridge; } });
+var breakpoint_manager_1 = require("./core/agent/breakpoint-manager");
+Object.defineProperty(exports, "BreakpointManager", { enumerable: true, get: function () { return breakpoint_manager_1.BreakpointManager; } });
+var permission_manager_1 = require("./core/agent/permission-manager");
+Object.defineProperty(exports, "PermissionManager", { enumerable: true, get: function () { return permission_manager_1.PermissionManager; } });
+var message_queue_1 = require("./core/agent/message-queue");
+Object.defineProperty(exports, "MessageQueue", { enumerable: true, get: function () { return message_queue_1.MessageQueue; } });
+var todo_manager_1 = require("./core/agent/todo-manager");
+Object.defineProperty(exports, "TodoManager", { enumerable: true, get: function () { return todo_manager_1.TodoManager; } });
+var tool_runner_1 = require("./core/agent/tool-runner");
+Object.defineProperty(exports, "ToolRunner", { enumerable: true, get: function () { return tool_runner_1.ToolRunner; } });
+var permission_modes_1 = require("./core/permission-modes");
+Object.defineProperty(exports, "permissionModes", { enumerable: true, get: function () { return permission_modes_1.permissionModes; } });
+Object.defineProperty(exports, "PermissionModeRegistry", { enumerable: true, get: function () { return permission_modes_1.PermissionModeRegistry; } });
+var checkpointer_1 = require("./core/checkpointer");
+Object.defineProperty(exports, "MemoryCheckpointer", { enumerable: true, get: function () { return checkpointer_1.MemoryCheckpointer; } });
+var checkpointers_1 = require("./core/checkpointers");
+Object.defineProperty(exports, "FileCheckpointer", { enumerable: true, get: function () { return checkpointers_1.FileCheckpointer; } });
+Object.defineProperty(exports, "RedisCheckpointer", { enumerable: true, get: function () { return checkpointers_1.RedisCheckpointer; } });
+// Types
+__exportStar(require("./core/types"), exports);
+var errors_1 = require("./core/errors");
+Object.defineProperty(exports, "ResumeError", { enumerable: true, get: function () { return errors_1.ResumeError; } });
+// Infrastructure
+var store_1 = require("./infra/store");
+Object.defineProperty(exports, "JSONStore", { enumerable: true, get: function () { return store_1.JSONStore; } });
+var sandbox_1 = require("./infra/sandbox");
+Object.defineProperty(exports, "LocalSandbox", { enumerable: true, get: function () { return sandbox_1.LocalSandbox; } });
+var provider_1 = require("./infra/provider");
+Object.defineProperty(exports, "AnthropicProvider", { enumerable: true, get: function () { return provider_1.AnthropicProvider; } });
+var sandbox_factory_1 = require("./infra/sandbox-factory");
+Object.defineProperty(exports, "SandboxFactory", { enumerable: true, get: function () { return sandbox_factory_1.SandboxFactory; } });
+// Tools
+var fs_read_1 = require("./tools/fs_read");
+Object.defineProperty(exports, "FsRead", { enumerable: true, get: function () { return fs_read_1.FsRead; } });
+var fs_write_1 = require("./tools/fs_write");
+Object.defineProperty(exports, "FsWrite", { enumerable: true, get: function () { return fs_write_1.FsWrite; } });
+var fs_edit_1 = require("./tools/fs_edit");
+Object.defineProperty(exports, "FsEdit", { enumerable: true, get: function () { return fs_edit_1.FsEdit; } });
+var fs_glob_1 = require("./tools/fs_glob");
+Object.defineProperty(exports, "FsGlob", { enumerable: true, get: function () { return fs_glob_1.FsGlob; } });
+var fs_grep_1 = require("./tools/fs_grep");
+Object.defineProperty(exports, "FsGrep", { enumerable: true, get: function () { return fs_grep_1.FsGrep; } });
+var fs_multi_edit_1 = require("./tools/fs_multi_edit");
+Object.defineProperty(exports, "FsMultiEdit", { enumerable: true, get: function () { return fs_multi_edit_1.FsMultiEdit; } });
+var fs_rm_1 = require("./tools/fs_rm");
+Object.defineProperty(exports, "FsRm", { enumerable: true, get: function () { return fs_rm_1.FsRm; } });
+var bash_run_1 = require("./tools/bash_run");
+Object.defineProperty(exports, "BashRun", { enumerable: true, get: function () { return bash_run_1.BashRun; } });
+var bash_logs_1 = require("./tools/bash_logs");
+Object.defineProperty(exports, "BashLogs", { enumerable: true, get: function () { return bash_logs_1.BashLogs; } });
+var bash_kill_1 = require("./tools/bash_kill");
+Object.defineProperty(exports, "BashKill", { enumerable: true, get: function () { return bash_kill_1.BashKill; } });
+var task_run_1 = require("./tools/task_run");
+Object.defineProperty(exports, "createTaskRunTool", { enumerable: true, get: function () { return task_run_1.createTaskRunTool; } });
+var todo_read_1 = require("./tools/todo_read");
+Object.defineProperty(exports, "TodoRead", { enumerable: true, get: function () { return todo_read_1.TodoRead; } });
+var todo_write_1 = require("./tools/todo_write");
+Object.defineProperty(exports, "TodoWrite", { enumerable: true, get: function () { return todo_write_1.TodoWrite; } });
+var skill_list_1 = require("./tools/skill_list");
+Object.defineProperty(exports, "SkillList", { enumerable: true, get: function () { return skill_list_1.SkillList; } });
+var skill_activate_1 = require("./tools/skill_activate");
+Object.defineProperty(exports, "SkillActivate", { enumerable: true, get: function () { return skill_activate_1.SkillActivate; } });
+var skill_resource_1 = require("./tools/skill_resource");
+Object.defineProperty(exports, "SkillResource", { enumerable: true, get: function () { return skill_resource_1.SkillResource; } });
+var builtin_1 = require("./tools/builtin");
+Object.defineProperty(exports, "builtin", { enumerable: true, get: function () { return builtin_1.builtin; } });
+var registry_1 = require("./tools/registry");
+Object.defineProperty(exports, "ToolRegistry", { enumerable: true, get: function () { return registry_1.ToolRegistry; } });
+Object.defineProperty(exports, "globalToolRegistry", { enumerable: true, get: function () { return registry_1.globalToolRegistry; } });
+var define_1 = require("./tools/define");
+Object.defineProperty(exports, "defineTool", { enumerable: true, get: function () { return define_1.defineTool; } });
+Object.defineProperty(exports, "defineTools", { enumerable: true, get: function () { return define_1.defineTools; } });
+Object.defineProperty(exports, "extractTools", { enumerable: true, get: function () { return define_1.extractTools; } });
+var tool_1 = require("./tools/tool");
+Object.defineProperty(exports, "tool", { enumerable: true, get: function () { return tool_1.tool; } });
+Object.defineProperty(exports, "tools", { enumerable: true, get: function () { return tool_1.tools; } });
+var mcp_1 = require("./tools/mcp");
+Object.defineProperty(exports, "getMCPTools", { enumerable: true, get: function () { return mcp_1.getMCPTools; } });
+Object.defineProperty(exports, "disconnectMCP", { enumerable: true, get: function () { return mcp_1.disconnectMCP; } });
+Object.defineProperty(exports, "disconnectAllMCP", { enumerable: true, get: function () { return mcp_1.disconnectAllMCP; } });
+var toolkit_1 = require("./tools/toolkit");
+Object.defineProperty(exports, "ToolKit", { enumerable: true, get: function () { return toolkit_1.ToolKit; } });
+Object.defineProperty(exports, "toolMethod", { enumerable: true, get: function () { return toolkit_1.toolMethod; } });
+var type_inference_1 = require("./tools/type-inference");
+Object.defineProperty(exports, "inferFromExample", { enumerable: true, get: function () { return type_inference_1.inferFromExample; } });
+Object.defineProperty(exports, "schema", { enumerable: true, get: function () { return type_inference_1.schema; } });
+Object.defineProperty(exports, "patterns", { enumerable: true, get: function () { return type_inference_1.patterns; } });
+Object.defineProperty(exports, "SchemaBuilder", { enumerable: true, get: function () { return type_inference_1.SchemaBuilder; } });
+Object.defineProperty(exports, "mergeSchemas", { enumerable: true, get: function () { return type_inference_1.mergeSchemas; } });
+Object.defineProperty(exports, "extendSchema", { enumerable: true, get: function () { return type_inference_1.extendSchema; } });
+// Skills
+var skills_1 = require("./skills");
+Object.defineProperty(exports, "SkillsParser", { enumerable: true, get: function () { return skills_1.SkillsParser; } });
+Object.defineProperty(exports, "SkillsValidator", { enumerable: true, get: function () { return skills_1.SkillsValidator; } });
+Object.defineProperty(exports, "SkillsLoader", { enumerable: true, get: function () { return skills_1.SkillsLoader; } });
+Object.defineProperty(exports, "SkillsManager", { enumerable: true, get: function () { return skills_1.SkillsManager; } });
+Object.defineProperty(exports, "SkillsInjector", { enumerable: true, get: function () { return skills_1.SkillsInjector; } });
+// Utils
+var agent_id_1 = require("./utils/agent-id");
+Object.defineProperty(exports, "generateAgentId", { enumerable: true, get: function () { return agent_id_1.generateAgentId; } });

package/dist/infra/provider.d.ts

@@ -0,0 +1,144 @@
+import { Message, ContentBlock } from '../core/types';
+import { Configurable } from '../core/config';
+export interface AnthropicRetryConfig {
+    /**
+     * Total attempts including the initial request.
+     *
+     * - `1` means "no retries" (single attempt).
+     * - `3` means "initial try + up to 2 retries".
+     *
+     * Default: `6`.
+     */
+    maxAttempts?: number;
+    /**
+     * Base delay for exponential backoff in milliseconds.
+     *
+     * The actual delay grows exponentially with the attempt number:
+     * `delay = min(maxDelayMs, baseDelayMs * 2^(attemptIndex-1))`, then jitter is applied.
+     *
+     * Default: `500`.
+     */
+    baseDelayMs?: number;
+    /**
+     * Max delay cap for exponential backoff in milliseconds.
+     *
+     * Default: `20000`.
+     */
+    maxDelayMs?: number;
+    /**
+     * Jitter ratio applied to the computed backoff delay, in `[0, 1]`.
+     *
+     * Jitter reduces synchronized retry spikes ("thundering herd") by randomizing delay:
+     * `delay = delay * random(1-jitterRatio, 1+jitterRatio)`.
+     *
+     * Default: `0.2`.
+     */
+    jitterRatio?: number;
+}
+export interface AnthropicProviderOptions {
+    /**
+     * Retry/backoff strategy for transient failures (e.g. 429, 5xx).
+     *
+     * Note: this SDK intentionally does NOT read environment variables here.
+     * If you want env-driven configuration, read env in your application and pass it in.
+     */
+    retry?: AnthropicRetryConfig;
+}
+export interface ModelResponse {
+    role: 'assistant';
+    content: ContentBlock[];
+    usage?: {
+        input_tokens: number;
+        output_tokens: number;
+    };
+    stop_reason?: string;
+}
+export interface ModelStreamChunk {
+    type: 'content_block_start' | 'content_block_delta' | 'content_block_stop' | 'message_delta' | 'message_stop';
+    index?: number;
+    content_block?: ContentBlock;
+    delta?: {
+        type: 'text_delta' | 'input_json_delta';
+        text?: string;
+        partial_json?: string;
+    };
+    usage?: {
+        output_tokens: number;
+    };
+}
+export interface ModelConfig {
+    provider: 'anthropic' | string;
+    model: string;
+    baseUrl?: string;
+    apiKey?: string;
+    maxTokens?: number;
+    temperature?: number;
+    /**
+     * Optional provider-specific retry configuration.
+     * Only used by the built-in Anthropic provider.
+     *
+     * This is designed for application-layer injection (e.g. read env in your API server,
+     * then pass it to the model factory), so the SDK core stays environment-agnostic.
+     */
+    retry?: AnthropicRetryConfig;
+}
+export interface ModelProvider extends Configurable<ModelConfig> {
+    readonly model: string;
+    readonly maxWindowSize: number;
+    readonly maxOutputTokens: number;
+    readonly temperature: number;
+    complete(messages: Message[], opts?: {
+        tools?: any[];
+        maxTokens?: number;
+        temperature?: number;
+        system?: string;
+        stream?: boolean;
+    }): Promise<ModelResponse>;
+    stream(messages: Message[], opts?: {
+        tools?: any[];
+        maxTokens?: number;
+        temperature?: number;
+        system?: string;
+    }): AsyncIterable<ModelStreamChunk>;
+}
+export declare class AnthropicProvider implements ModelProvider {
+    private apiKey;
+    private baseUrl;
+    readonly maxWindowSize = 200000;
+    readonly maxOutputTokens = 8192;
+    readonly temperature = 0.7;
+    readonly model: string;
+    private readonly retryMaxAttempts;
+    private readonly retryBaseDelayMs;
+    private readonly retryMaxDelayMs;
+    private readonly retryJitterRatio;
+    constructor(apiKey: string, model?: string, baseUrl?: string, opts?: AnthropicProviderOptions);
+    private isRetryableStatus;
+    private computeBackoffMs;
+    /**
+     * Sends a Messages API request with automatic retries for transient failures.
+     *
+     * Rules:
+     * - Retries for HTTP 429/408/409 and 5xx.
+     * - Prefer server guidance via `Retry-After` header when present (seconds or HTTP-date).
+     * - Otherwise use exponential backoff with jitter.
+     * - Additionally, if the server rejects `max_tokens` as too large, retry once with 4096.
+     */
+    private fetchMessagesWithRetry;
+    complete(messages: Message[], opts?: {
+        tools?: any[];
+        maxTokens?: number;
+        temperature?: number;
+        system?: string;
+        stream?: boolean;
+    }): Promise<ModelResponse>;
+    stream(messages: Message[], opts?: {
+        tools?: any[];
+        maxTokens?: number;
+        temperature?: number;
+        system?: string;
+    }): AsyncIterable<ModelStreamChunk>;
+    private formatMessages;
+    private formatContent;
+    toConfig(): ModelConfig;
+}

package/dist/infra/provider.js

@@ -0,0 +1,294 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnthropicProvider = void 0;
+const unicode_1 = require("../utils/unicode");
+function sleep(ms) {
+    const delay = Number.isFinite(ms) ? Math.max(0, Math.floor(ms)) : 0;
+    if (delay <= 0)
+        return Promise.resolve();
+    return new Promise((resolve) => setTimeout(resolve, delay));
+}
+function parseRetryAfterMs(value) {
+    if (!value)
+        return null;
+    const raw = String(value).trim();
+    if (!raw)
+        return null;
+    // Retry-After can be either:
+    // - delay-seconds (integer/float)
+    // - HTTP-date
+    const asSeconds = Number(raw);
+    if (Number.isFinite(asSeconds) && asSeconds >= 0) {
+        return Math.max(0, Math.floor(asSeconds * 1000));
+    }
+    const asDateMs = Date.parse(raw);
+    if (Number.isFinite(asDateMs)) {
+        const delta = asDateMs - Date.now();
+        return Math.max(0, Math.floor(delta));
+    }
+    return null;
+}
+class AnthropicProvider {
+    constructor(apiKey, model = 'claude-3-5-sonnet-20241022', baseUrl = 'https://api.anthropic.com', opts) {
+        this.apiKey = apiKey;
+        this.baseUrl = baseUrl;
+        this.maxWindowSize = 200000;
+        // Modern Anthropic models often support >4k output tokens. Using 8k by default reduces
+        // truncated tool JSON (which can otherwise lead to invalid/empty tool inputs and stalled runs).
+        this.maxOutputTokens = 8192;
+        this.temperature = 0.7;
+        this.model = model;
+        const retry = opts?.retry;
+        const maxAttempts = typeof retry?.maxAttempts === 'number' ? retry.maxAttempts : Number.NaN;
+        const baseDelayMs = typeof retry?.baseDelayMs === 'number' ? retry.baseDelayMs : Number.NaN;
+        const maxDelayMs = typeof retry?.maxDelayMs === 'number' ? retry.maxDelayMs : Number.NaN;
+        const jitterRatio = typeof retry?.jitterRatio === 'number' ? retry.jitterRatio : Number.NaN;
+        // Defaults are intentionally conservative.
+        this.retryMaxAttempts = Number.isFinite(maxAttempts) && maxAttempts > 0 ? Math.floor(maxAttempts) : 6;
+        this.retryBaseDelayMs = Number.isFinite(baseDelayMs) && baseDelayMs >= 0 ? Math.floor(baseDelayMs) : 500;
+        this.retryMaxDelayMs = Number.isFinite(maxDelayMs) && maxDelayMs > 0 ? Math.floor(maxDelayMs) : 20000;
+        this.retryJitterRatio = Number.isFinite(jitterRatio) && jitterRatio >= 0 && jitterRatio <= 1 ? jitterRatio : 0.2;
+    }
+    isRetryableStatus(status) {
+        // 429 = rate limit. 408/409 occasionally show up in transient network/proxy scenarios.
+        // 5xx = upstream/server errors.
+        if (status === 429)
+            return true;
+        if (status === 408)
+            return true;
+        if (status === 409)
+            return true;
+        return status >= 500 && status <= 599;
+    }
+    computeBackoffMs(attemptIndex) {
+        // attemptIndex is 1-based.
+        const exp = Math.max(0, attemptIndex - 1);
+        const raw = this.retryBaseDelayMs * Math.pow(2, exp);
+        const capped = Math.min(this.retryMaxDelayMs, raw);
+        const jitter = this.retryJitterRatio;
+        if (jitter <= 0)
+            return Math.floor(capped);
+        const factor = 1 - jitter + Math.random() * (2 * jitter); // [1-j, 1+j]
+        return Math.max(0, Math.floor(capped * factor));
+    }
+    /**
+     * Sends a Messages API request with automatic retries for transient failures.
+     *
+     * Rules:
+     * - Retries for HTTP 429/408/409 and 5xx.
+     * - Prefer server guidance via `Retry-After` header when present (seconds or HTTP-date).
+     * - Otherwise use exponential backoff with jitter.
+     * - Additionally, if the server rejects `max_tokens` as too large, retry once with 4096.
+     */
+    async fetchMessagesWithRetry(body) {
+        const safeJson = (value) => JSON.stringify(value, (_key, v) => (typeof v === 'string' ? (0, unicode_1.stripInvalidSurrogates)(v) : v));
+        const doFetch = async () => fetch(`${this.baseUrl}/v1/messages`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'x-api-key': this.apiKey,
+                'anthropic-version': '2023-06-01',
+            },
+            body: safeJson(body),
+        });
+        let lastStatus;
+        let lastErrorText;
+        let lastErr;
+        for (let attempt = 1; attempt <= this.retryMaxAttempts; attempt++) {
+            let response;
+            try {
+                response = await doFetch();
+            }
+            catch (err) {
+                lastErr = err;
+                if (attempt >= this.retryMaxAttempts)
+                    break;
+                const delayMs = this.computeBackoffMs(attempt);
+                await sleep(delayMs);
+                continue;
+            }
+            if (response.ok)
+                return response;
+            lastStatus = response.status;
+            try {
+                lastErrorText = await response.text();
+            }
+            catch {
+                lastErrorText = '';
+            }
+            // Some model ids / gateways may reject larger max_tokens. Retry once with a smaller safe default.
+            if (body.max_tokens > 4096 && /max_tokens/i.test(lastErrorText || '')) {
+                body.max_tokens = 4096;
+                if (attempt >= this.retryMaxAttempts)
+                    break;
+                // Treat as immediate retry (no sleep) because this is a deterministic request-shape fix.
+                continue;
+            }
+            if (!this.isRetryableStatus(response.status) || attempt >= this.retryMaxAttempts) {
+                break;
+            }
+            const retryAfterMs = parseRetryAfterMs(response.headers.get('retry-after'));
+            const backoffMs = this.computeBackoffMs(attempt);
+            const delayMs = Math.max(0, retryAfterMs ?? 0, backoffMs);
+            await sleep(delayMs);
+        }
+        if (lastStatus !== undefined) {
+            throw new Error(`Anthropic API error after ${this.retryMaxAttempts} attempts: ${lastStatus} ${lastErrorText ?? ''}`);
+        }
+        throw new Error(`Anthropic API error after ${this.retryMaxAttempts} attempts: ${lastErr?.message || String(lastErr || 'Unknown error')}`);
+    }
+    async complete(messages, opts) {
+        const body = {
+            model: this.model,
+            messages: this.formatMessages(messages),
+            max_tokens: opts?.maxTokens || this.maxOutputTokens,
+        };
+        if (opts?.temperature !== undefined)
+            body.temperature = opts.temperature;
+        if (opts?.system)
+            body.system = opts.system;
+        if (opts?.tools && opts.tools.length > 0)
+            body.tools = opts.tools;
+        const response = await this.fetchMessagesWithRetry(body);
+        const data = (await response.json());
+        return {
+            role: 'assistant',
+            content: data.content,
+            usage: data.usage,
+            stop_reason: data.stop_reason,
+        };
+    }
+    async *stream(messages, opts) {
+        const body = {
+            model: this.model,
+            messages: this.formatMessages(messages),
+            max_tokens: opts?.maxTokens || this.maxOutputTokens,
+            stream: true,
+        };
+        if (opts?.temperature !== undefined)
+            body.temperature = opts.temperature;
+        if (opts?.system)
+            body.system = opts.system;
+        if (opts?.tools && opts.tools.length > 0)
+            body.tools = opts.tools;
+        const response = await this.fetchMessagesWithRetry(body);
+        const reader = response.body?.getReader();
+        if (!reader)
+            throw new Error('No response body');
+        const decoder = new TextDecoder();
+        let buffer = '';
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split('\n');
+            buffer = lines.pop() || '';
+            for (const line of lines) {
+                if (!line.trim() || !line.startsWith('data: '))
+                    continue;
+                const data = line.slice(6);
+                if (data === '[DONE]')
+                    continue;
+                try {
+                    const event = JSON.parse(data);
+                    if (event.type === 'content_block_start') {
+                        yield { type: 'content_block_start', index: event.index, content_block: event.content_block };
+                    }
+                    else if (event.type === 'content_block_delta') {
+                        yield { type: 'content_block_delta', index: event.index, delta: event.delta };
+                    }
+                    else if (event.type === 'content_block_stop') {
+                        yield { type: 'content_block_stop', index: event.index };
+                    }
+                    else if (event.type === 'message_delta') {
+                        yield { type: 'message_delta', delta: event.delta, usage: event.usage };
+                    }
+                    else if (event.type === 'message_stop') {
+                        yield { type: 'message_stop' };
+                    }
+                }
+                catch (e) {
+                    // Skip invalid JSON
+                }
+            }
+        }
+    }
+    formatMessages(messages) {
+        return messages.map((msg) => ({
+            role: msg.role === 'system' ? 'user' : msg.role,
+            content: this.formatContent(msg.content),
+        }));
+    }
+    formatContent(content) {
+        // Anthropic Messages API accepts message.content as either a string or an array of content blocks.
+        if (typeof content === 'string')
+            return content;
+        if (!Array.isArray(content)) {
+            return String(content ?? '');
+        }
+        return content.map((block) => {
+            if (!block || typeof block !== 'object') {
+                return { type: 'text', text: String(block ?? '') };
+            }
+            if (block.type === 'text') {
+                return { type: 'text', text: String(block.text ?? '') };
+            }
+            if (block.type === 'tool_use') {
+                return {
+                    type: 'tool_use',
+                    id: String(block.id ?? ''),
+                    name: String(block.name ?? ''),
+                    input: block.input ?? {},
+                };
+            }
+            if (block.type === 'tool_result') {
+                const raw = block.content;
+                let formatted = raw;
+                // Older Anthropic versions expect tool_result.content to be a string.
+                // We stringify structured payloads to keep compatibility.
+                if (typeof raw === 'string') {
+                    formatted = raw;
+                }
+                else if (Array.isArray(raw)) {
+                    formatted = raw;
+                }
+                else {
+                    try {
+                        formatted = JSON.stringify(raw ?? null);
+                    }
+                    catch {
+                        formatted = String(raw ?? '');
+                    }
+                }
+                const out = {
+                    type: 'tool_result',
+                    tool_use_id: String(block.tool_use_id ?? ''),
+                    content: formatted,
+                };
+                if (block.is_error !== undefined) {
+                    out.is_error = Boolean(block.is_error);
+                }
+                return out;
+            }
+            // Fallback for unknown blocks: serialize as text.
+            try {
+                return { type: 'text', text: JSON.stringify(block) };
+            }
+            catch {
+                return { type: 'text', text: String(block) };
+            }
+        });
+    }
+    toConfig() {
+        return {
+            provider: 'anthropic',
+            model: this.model,
+            baseUrl: this.baseUrl,
+            apiKey: this.apiKey,
+            maxTokens: this.maxOutputTokens,
+            temperature: this.temperature,
+        };
+    }
+}
+exports.AnthropicProvider = AnthropicProvider;

package/dist/infra/sandbox-factory.d.ts

@@ -0,0 +1,10 @@
+import { Sandbox, SandboxKind } from './sandbox';
+export type SandboxFactoryFn = (config: Record<string, any>) => Sandbox;
+export declare class SandboxFactory {
+    private factories;
+    constructor();
+    register(kind: SandboxKind, factory: SandboxFactoryFn): void;
+    create(config: {
+        kind: SandboxKind;
+    } & Record<string, any>): Sandbox;
+}

package/dist/infra/sandbox-factory.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SandboxFactory = void 0;
+const sandbox_1 = require("./sandbox");
+class SandboxFactory {
+    constructor() {
+        this.factories = new Map();
+        this.factories.set('local', (config) => new sandbox_1.LocalSandbox(config));
+    }
+    register(kind, factory) {
+        this.factories.set(kind, factory);
+    }
+    create(config) {
+        const factory = this.factories.get(config.kind);
+        if (!factory) {
+            throw new Error(`Sandbox factory not registered: ${config.kind}`);
+        }
+        return factory(config);
+    }
+}
+exports.SandboxFactory = SandboxFactory;