@shareai-lab/kode-sdk 1.0.0-beta.9 → 2.7.0

package/dist/infra/provider.js

@@ -1,118 +1,67 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AnthropicProvider = void 0;
-class AnthropicProvider {
-    constructor(apiKey, model = 'claude-3-5-sonnet-20241022', baseUrl = 'https://api.anthropic.com') {
-        this.apiKey = apiKey;
-        this.model = model;
-        this.baseUrl = baseUrl;
-    }
-    async complete(messages, opts) {
-        const body = {
-            model: this.model,
-            messages: this.formatMessages(messages),
-            max_tokens: opts?.maxTokens || 4096,
-        };
-        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 fetch(`${this.baseUrl}/v1/messages`, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                'x-api-key': this.apiKey,
-                'anthropic-version': '2023-06-01',
-            },
-            body: JSON.stringify(body),
-        });
-        if (!response.ok) {
-            const error = await response.text();
-            throw new Error(`Anthropic API error: ${response.status} ${error}`);
-        }
-        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 || 4096,
-            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 fetch(`${this.baseUrl}/v1/messages`, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                'x-api-key': this.apiKey,
-                'anthropic-version': '2023-06-01',
-            },
-            body: JSON.stringify(body),
-        });
-        if (!response.ok) {
-            const error = await response.text();
-            throw new Error(`Anthropic API error: ${response.status} ${error}`);
-        }
-        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
-                }
-            }
-        }
+/**
+ * Provider Module
+ *
+ * Re-exports from the providers module for backward compatibility.
+ * The actual implementations are in src/infra/providers/.
+ *
+ * Usage:
+ * ```typescript
+ * import { AnthropicProvider, OpenAIProvider, GeminiProvider } from './infra/provider';
+ * // or
+ * import { AnthropicProvider } from './infra/providers';
+ * ```
+ */
+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]; } };
     }
-    formatMessages(messages) {
-        return messages.map((msg) => ({
-            role: msg.role === 'system' ? 'user' : msg.role,
-            content: msg.content,
-        }));
-    }
-}
-exports.AnthropicProvider = AnthropicProvider;
+    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.normalizeAnthropicDelta = exports.normalizeAnthropicContentBlock = exports.normalizeAnthropicContent = exports.mergeAnthropicBetaHeader = exports.hasAnthropicFileBlocks = exports.sanitizeGeminiSchema = exports.buildGeminiFilePart = exports.buildGeminiImagePart = exports.extractReasoningDetails = exports.splitThinkText = exports.normalizeThinkBlocks = exports.joinReasoningBlocks = exports.concatTextWithReasoning = exports.AUDIO_UNSUPPORTED_TEXT = exports.IMAGE_UNSUPPORTED_TEXT = exports.FILE_UNSUPPORTED_TEXT = exports.safeJsonStringify = exports.formatToolResult = exports.joinTextBlocks = exports.markTransportIfDegraded = exports.getMessageBlocks = exports.normalizeGeminiBaseUrl = exports.normalizeAnthropicBaseUrl = exports.normalizeOpenAIBaseUrl = exports.normalizeBaseUrl = exports.withProxy = exports.getProxyDispatcher = exports.resolveProxyUrl = exports.GeminiProvider = exports.OpenAIProvider = exports.AnthropicProvider = void 0;
+// Re-export provider implementations
+var providers_1 = require("./providers");
+Object.defineProperty(exports, "AnthropicProvider", { enumerable: true, get: function () { return providers_1.AnthropicProvider; } });
+Object.defineProperty(exports, "OpenAIProvider", { enumerable: true, get: function () { return providers_1.OpenAIProvider; } });
+Object.defineProperty(exports, "GeminiProvider", { enumerable: true, get: function () { return providers_1.GeminiProvider; } });
+// Re-export utilities for backward compatibility
+var providers_2 = require("./providers");
+Object.defineProperty(exports, "resolveProxyUrl", { enumerable: true, get: function () { return providers_2.resolveProxyUrl; } });
+Object.defineProperty(exports, "getProxyDispatcher", { enumerable: true, get: function () { return providers_2.getProxyDispatcher; } });
+Object.defineProperty(exports, "withProxy", { enumerable: true, get: function () { return providers_2.withProxy; } });
+Object.defineProperty(exports, "normalizeBaseUrl", { enumerable: true, get: function () { return providers_2.normalizeBaseUrl; } });
+Object.defineProperty(exports, "normalizeOpenAIBaseUrl", { enumerable: true, get: function () { return providers_2.normalizeOpenAIBaseUrl; } });
+Object.defineProperty(exports, "normalizeAnthropicBaseUrl", { enumerable: true, get: function () { return providers_2.normalizeAnthropicBaseUrl; } });
+Object.defineProperty(exports, "normalizeGeminiBaseUrl", { enumerable: true, get: function () { return providers_2.normalizeGeminiBaseUrl; } });
+Object.defineProperty(exports, "getMessageBlocks", { enumerable: true, get: function () { return providers_2.getMessageBlocks; } });
+Object.defineProperty(exports, "markTransportIfDegraded", { enumerable: true, get: function () { return providers_2.markTransportIfDegraded; } });
+Object.defineProperty(exports, "joinTextBlocks", { enumerable: true, get: function () { return providers_2.joinTextBlocks; } });
+Object.defineProperty(exports, "formatToolResult", { enumerable: true, get: function () { return providers_2.formatToolResult; } });
+Object.defineProperty(exports, "safeJsonStringify", { enumerable: true, get: function () { return providers_2.safeJsonStringify; } });
+Object.defineProperty(exports, "FILE_UNSUPPORTED_TEXT", { enumerable: true, get: function () { return providers_2.FILE_UNSUPPORTED_TEXT; } });
+Object.defineProperty(exports, "IMAGE_UNSUPPORTED_TEXT", { enumerable: true, get: function () { return providers_2.IMAGE_UNSUPPORTED_TEXT; } });
+Object.defineProperty(exports, "AUDIO_UNSUPPORTED_TEXT", { enumerable: true, get: function () { return providers_2.AUDIO_UNSUPPORTED_TEXT; } });
+Object.defineProperty(exports, "concatTextWithReasoning", { enumerable: true, get: function () { return providers_2.concatTextWithReasoning; } });
+Object.defineProperty(exports, "joinReasoningBlocks", { enumerable: true, get: function () { return providers_2.joinReasoningBlocks; } });
+Object.defineProperty(exports, "normalizeThinkBlocks", { enumerable: true, get: function () { return providers_2.normalizeThinkBlocks; } });
+Object.defineProperty(exports, "splitThinkText", { enumerable: true, get: function () { return providers_2.splitThinkText; } });
+Object.defineProperty(exports, "extractReasoningDetails", { enumerable: true, get: function () { return providers_2.extractReasoningDetails; } });
+Object.defineProperty(exports, "buildGeminiImagePart", { enumerable: true, get: function () { return providers_2.buildGeminiImagePart; } });
+Object.defineProperty(exports, "buildGeminiFilePart", { enumerable: true, get: function () { return providers_2.buildGeminiFilePart; } });
+Object.defineProperty(exports, "sanitizeGeminiSchema", { enumerable: true, get: function () { return providers_2.sanitizeGeminiSchema; } });
+Object.defineProperty(exports, "hasAnthropicFileBlocks", { enumerable: true, get: function () { return providers_2.hasAnthropicFileBlocks; } });
+Object.defineProperty(exports, "mergeAnthropicBetaHeader", { enumerable: true, get: function () { return providers_2.mergeAnthropicBetaHeader; } });
+Object.defineProperty(exports, "normalizeAnthropicContent", { enumerable: true, get: function () { return providers_2.normalizeAnthropicContent; } });
+Object.defineProperty(exports, "normalizeAnthropicContentBlock", { enumerable: true, get: function () { return providers_2.normalizeAnthropicContentBlock; } });
+Object.defineProperty(exports, "normalizeAnthropicDelta", { enumerable: true, get: function () { return providers_2.normalizeAnthropicDelta; } });
+// Re-export core module (errors, usage, retry, logging, fork)
+__exportStar(require("./providers/core"), exports);

package/dist/infra/providers/anthropic.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Anthropic Provider Adapter
+ *
+ * Converts internal Anthropic-style messages to Anthropic API format.
+ * Supports:
+ * - Extended thinking with interleaved-thinking-2025-05-14 beta
+ * - Files API with files-api-2025-04-14 beta
+ * - Streaming with SSE
+ * - Signature preservation for multi-turn conversations
+ */
+import { Message } from '../../core/types';
+import { ModelProvider, ModelResponse, ModelStreamChunk, ModelConfig, UploadFileInput, UploadFileResult, CompletionOptions, ReasoningTransport, ThinkingOptions } from './types';
+export interface AnthropicProviderOptions {
+    reasoningTransport?: ReasoningTransport;
+    extraHeaders?: Record<string, string>;
+    extraBody?: Record<string, any>;
+    providerOptions?: Record<string, any>;
+    multimodal?: ModelConfig['multimodal'];
+    thinking?: ThinkingOptions;
+}
+export declare class AnthropicProvider implements ModelProvider {
+    private apiKey;
+    readonly maxWindowSize = 200000;
+    readonly maxOutputTokens = 4096;
+    readonly temperature = 0.7;
+    readonly model: string;
+    private readonly baseUrl;
+    private readonly dispatcher?;
+    private readonly reasoningTransport;
+    private readonly extraHeaders?;
+    private readonly extraBody?;
+    private readonly providerOptions?;
+    private readonly multimodal?;
+    private readonly thinking?;
+    constructor(apiKey: string, model?: string, baseUrl?: string, proxyUrl?: string, options?: AnthropicProviderOptions);
+    complete(messages: Message[], opts?: CompletionOptions): Promise<ModelResponse>;
+    stream(messages: Message[], opts?: CompletionOptions): AsyncIterable<ModelStreamChunk>;
+    private formatMessages;
+    private buildThinkingConfig;
+    uploadFile(input: UploadFileInput): Promise<UploadFileResult | null>;
+    toConfig(): ModelConfig;
+}

package/dist/infra/providers/anthropic.js

@@ -0,0 +1,308 @@
+"use strict";
+/**
+ * Anthropic Provider Adapter
+ *
+ * Converts internal Anthropic-style messages to Anthropic API format.
+ * Supports:
+ * - Extended thinking with interleaved-thinking-2025-05-14 beta
+ * - Files API with files-api-2025-04-14 beta
+ * - Streaming with SSE
+ * - Signature preservation for multi-turn conversations
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnthropicProvider = void 0;
+const utils_1 = require("./utils");
+class AnthropicProvider {
+    constructor(apiKey, model = 'claude-3-5-sonnet-20241022', baseUrl = 'https://api.anthropic.com', proxyUrl, options) {
+        this.apiKey = apiKey;
+        this.maxWindowSize = 200000;
+        this.maxOutputTokens = 4096;
+        this.temperature = 0.7;
+        this.model = model;
+        this.baseUrl = (0, utils_1.normalizeAnthropicBaseUrl)(baseUrl);
+        this.dispatcher = (0, utils_1.getProxyDispatcher)(proxyUrl);
+        this.reasoningTransport = options?.reasoningTransport ?? 'provider';
+        this.extraHeaders = options?.extraHeaders;
+        this.extraBody = options?.extraBody;
+        this.providerOptions = options?.providerOptions;
+        this.multimodal = options?.multimodal;
+        this.thinking = options?.thinking;
+    }
+    async complete(messages, opts) {
+        const body = {
+            ...(this.extraBody || {}),
+            model: this.model,
+            messages: this.formatMessages(messages),
+            max_tokens: opts?.maxTokens || 4096,
+        };
+        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 thinkingConfig = opts?.thinking ?? this.thinking;
+        if (this.reasoningTransport === 'provider' && !body.thinking) {
+            body.thinking = this.buildThinkingConfig(thinkingConfig);
+        }
+        const betaEntries = [];
+        if (this.reasoningTransport === 'provider') {
+            betaEntries.push('interleaved-thinking-2025-05-14');
+        }
+        if ((0, utils_1.hasAnthropicFileBlocks)(messages)) {
+            betaEntries.push('files-api-2025-04-14');
+        }
+        const headers = {
+            'Content-Type': 'application/json',
+            'x-api-key': this.apiKey,
+            'anthropic-version': '2023-06-01',
+            ...(this.extraHeaders || {}),
+        };
+        const mergedBeta = (0, utils_1.mergeAnthropicBetaHeader)(headers['anthropic-beta'], betaEntries);
+        if (mergedBeta) {
+            headers['anthropic-beta'] = mergedBeta;
+        }
+        const response = await fetch(`${this.baseUrl}/v1/messages`, (0, utils_1.withProxy)({
+            method: 'POST',
+            headers,
+            body: JSON.stringify(body),
+        }, this.dispatcher));
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`Anthropic API error: ${response.status} ${error}`);
+        }
+        const data = await response.json();
+        const content = (0, utils_1.normalizeAnthropicContent)(data.content, this.reasoningTransport);
+        return {
+            role: 'assistant',
+            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 || 4096,
+            stream: true,
+            ...(this.extraBody || {}),
+        };
+        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 thinkingConfig = opts?.thinking ?? this.thinking;
+        if (this.reasoningTransport === 'provider' && !body.thinking) {
+            body.thinking = this.buildThinkingConfig(thinkingConfig);
+        }
+        const betaEntries = [];
+        if (this.reasoningTransport === 'provider') {
+            betaEntries.push('interleaved-thinking-2025-05-14');
+        }
+        if ((0, utils_1.hasAnthropicFileBlocks)(messages)) {
+            betaEntries.push('files-api-2025-04-14');
+        }
+        const headers = {
+            'Content-Type': 'application/json',
+            'x-api-key': this.apiKey,
+            'anthropic-version': '2023-06-01',
+            ...(this.extraHeaders || {}),
+        };
+        const mergedBeta = (0, utils_1.mergeAnthropicBetaHeader)(headers['anthropic-beta'], betaEntries);
+        if (mergedBeta) {
+            headers['anthropic-beta'] = mergedBeta;
+        }
+        const response = await fetch(`${this.baseUrl}/v1/messages`, (0, utils_1.withProxy)({
+            method: 'POST',
+            headers,
+            body: JSON.stringify(body),
+        }, this.dispatcher));
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`Anthropic API error: ${response.status} ${error}`);
+        }
+        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') {
+                        const block = (0, utils_1.normalizeAnthropicContentBlock)(event.content_block, this.reasoningTransport);
+                        if (!block) {
+                            continue;
+                        }
+                        yield { type: 'content_block_start', index: event.index, content_block: block };
+                    }
+                    else if (event.type === 'content_block_delta') {
+                        const delta = (0, utils_1.normalizeAnthropicDelta)(event.delta);
+                        yield { type: 'content_block_delta', index: event.index, 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 {
+                    // Skip invalid JSON
+                }
+            }
+        }
+    }
+    formatMessages(messages) {
+        return messages.map((msg) => {
+            const blocks = (0, utils_1.getMessageBlocks)(msg);
+            let degraded = false;
+            const content = blocks.map((block) => {
+                if (block.type === 'text') {
+                    return { type: 'text', text: block.text };
+                }
+                if (block.type === 'reasoning') {
+                    if (this.reasoningTransport === 'text') {
+                        return { type: 'text', text: `<think>${block.reasoning}</think>` };
+                    }
+                    const result = { type: 'thinking', thinking: block.reasoning };
+                    if (block.meta?.signature) {
+                        result.signature = block.meta.signature;
+                    }
+                    return result;
+                }
+                if (block.type === 'image') {
+                    if (block.base64 && block.mime_type) {
+                        return {
+                            type: 'image',
+                            source: {
+                                type: 'base64',
+                                media_type: block.mime_type,
+                                data: block.base64,
+                            },
+                        };
+                    }
+                    degraded = true;
+                    return { type: 'text', text: utils_1.IMAGE_UNSUPPORTED_TEXT };
+                }
+                if (block.type === 'audio') {
+                    degraded = true;
+                    return { type: 'text', text: utils_1.AUDIO_UNSUPPORTED_TEXT };
+                }
+                if (block.type === 'file') {
+                    if (block.file_id) {
+                        return {
+                            type: 'document',
+                            source: { type: 'file', file_id: block.file_id },
+                        };
+                    }
+                    degraded = true;
+                    return { type: 'text', text: utils_1.FILE_UNSUPPORTED_TEXT };
+                }
+                if (block.type === 'tool_use') {
+                    return {
+                        type: 'tool_use',
+                        id: block.id,
+                        name: block.name,
+                        input: block.input ?? {},
+                    };
+                }
+                if (block.type === 'tool_result') {
+                    return {
+                        type: 'tool_result',
+                        tool_use_id: block.tool_use_id,
+                        content: (0, utils_1.formatToolResult)(block.content),
+                        is_error: block.is_error,
+                    };
+                }
+                return block;
+            });
+            if (degraded) {
+                (0, utils_1.markTransportIfDegraded)(msg, blocks);
+            }
+            return {
+                role: msg.role === 'system' ? 'user' : msg.role,
+                content,
+            };
+        });
+    }
+    buildThinkingConfig(thinking) {
+        if (!thinking?.enabled && !thinking?.budgetTokens) {
+            return { type: 'enabled' };
+        }
+        const config = { type: 'enabled' };
+        if (thinking?.budgetTokens) {
+            config.budget_tokens = thinking.budgetTokens;
+        }
+        return config;
+    }
+    async uploadFile(input) {
+        if (input.kind !== 'file') {
+            return null;
+        }
+        const FormDataCtor = globalThis.FormData;
+        const BlobCtor = globalThis.Blob;
+        if (!FormDataCtor || !BlobCtor) {
+            return null;
+        }
+        const endpoint = `${(0, utils_1.normalizeAnthropicBaseUrl)(this.baseUrl)}/v1/files`;
+        const form = new FormDataCtor();
+        form.append('file', new BlobCtor([input.data], { type: input.mimeType }), input.filename || 'file.pdf');
+        form.append('purpose', 'document');
+        const response = await fetch(endpoint, (0, utils_1.withProxy)({
+            method: 'POST',
+            headers: {
+                'x-api-key': this.apiKey,
+                'anthropic-version': '2023-06-01',
+                'anthropic-beta': 'files-api-2025-04-14',
+                ...(this.extraHeaders || {}),
+            },
+            body: form,
+        }, this.dispatcher));
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`Anthropic file upload error: ${response.status} ${error}`);
+        }
+        const data = await response.json();
+        const fileId = data?.id ?? data?.file_id;
+        if (!fileId) {
+            return null;
+        }
+        return { fileId };
+    }
+    toConfig() {
+        return {
+            provider: 'anthropic',
+            model: this.model,
+            baseUrl: this.baseUrl,
+            apiKey: this.apiKey,
+            maxTokens: this.maxOutputTokens,
+            temperature: this.temperature,
+            reasoningTransport: this.reasoningTransport,
+            extraHeaders: this.extraHeaders,
+            extraBody: this.extraBody,
+            providerOptions: this.providerOptions,
+            multimodal: this.multimodal,
+            thinking: this.thinking,
+        };
+    }
+}
+exports.AnthropicProvider = AnthropicProvider;