recker 1.0.4 → 1.0.6

package/dist/ai/providers/anthropic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"anthropic.d.ts","sourceRoot":"","sources":["../../../src/ai/providers/anthropic.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EACV,WAAW,EACX,WAAW,EACX,UAAU,EACV,QAAQ,EACR,WAAW,EACX,YAAY,EACZ,aAAa,EACb,cAAc,EAIf,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACL,cAAc,EACd,sBAAsB,EAMvB,MAAM,WAAW,CAAC;AAKnB,MAAM,WAAW,eAAgB,SAAQ,cAAc;IAErD,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAKD,UAAU,gBAAgB;IACxB,IAAI,EAAE,MAAM,GAAG,WAAW,CAAC;IAC3B,OAAO,EAAE,MAAM,GAAG,oBAAoB,EAAE,CAAC;CAC1C;AAED,KAAK,oBAAoB,GACrB;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAC9B;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE;QAAE,IAAI,EAAE,QAAQ,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAA;CAAE,GAC/E;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,GAC9D;IAAE,IAAI,EAAE,aAAa,CAAC;IAAC,WAAW,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC;AAclE,UAAU,mBAAmB;IAC3B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,SAAS,CAAC;IAChB,IAAI,EAAE,WAAW,CAAC;IAClB,OAAO,EAAE,oBAAoB,EAAE,CAAC;IAChC,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,UAAU,GAAG,YAAY,GAAG,eAAe,GAAG,UAAU,CAAC;IACtE,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,KAAK,EAAE;QACL,YAAY,EAAE,MAAM,CAAC;QACrB,aAAa,EAAE,MAAM,CAAC;KACvB,CAAC;CACH;AAkBD,qBAAa,iBAAkB,SAAQ,cAAc;IACnD,OAAO,CAAC,eAAe,CAAkB;gBAE7B,MAAM,GAAE,eAAoB;IAKxC,SAAS,CAAC,YAAY,IAAI,MAAM,GAAG,SAAS;IAI5C,SAAS,CAAC,UAAU,IAAI,MAAM;IAI9B,SAAS,CAAC,YAAY,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAShD,SAAS,CAAC,iBAAiB,CAAC,QAAQ,EAAE,WAAW,EAAE,GAAG,gBAAgB,EAAE;IA0BxE,OAAO,CAAC,gBAAgB;IAuDxB,OAAO,CAAC,cAAc;IAStB,OAAO,CAAC,eAAe;IAYjB,IAAI,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,UAAU,CAAC;IAa/C,MAAM,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,QAAQ,CAAC;IAY/C,KAAK,CAAC,QAAQ,EAAE,YAAY,GAAG,OAAO,CAAC,aAAa,CAAC;IAW3D,OAAO,CAAC,aAAa;YAmCP,WAAW;YAsBX,WAAW;IA8BzB,SAAS,CAAC,aAAa,CAAC,IAAI,EAAE,mBAAmB,EAAE,OAAO,EAAE,sBAAsB,GAAG,UAAU;IAiD/F,SAAS,CAAC,gBAAgB,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,sBAAsB,GAAG,WAAW,GAAG,IAAI;YAKjF,oBAAoB;CAyHpC"}

package/dist/ai/providers/anthropic.js

@@ -0,0 +1,367 @@
+import { BaseAIProvider, AIError, RateLimitError, ContextLengthError, OverloadedError, AuthenticationError, } from './base.js';
+export class AnthropicProvider extends BaseAIProvider {
+    anthropicConfig;
+    constructor(config = {}) {
+        super({ ...config, name: 'anthropic' });
+        this.anthropicConfig = config;
+    }
+    getEnvApiKey() {
+        return process.env.ANTHROPIC_API_KEY;
+    }
+    getBaseUrl() {
+        return this.config.baseUrl || 'https://api.anthropic.com/v1';
+    }
+    buildHeaders() {
+        return {
+            'Content-Type': 'application/json',
+            'x-api-key': this.getApiKey(),
+            'anthropic-version': this.anthropicConfig.version || '2025-01-01',
+            ...this.config.headers,
+        };
+    }
+    transformMessages(messages) {
+        const filtered = messages.filter((m) => m.role !== 'system');
+        return filtered.map((msg) => {
+            if (msg.role === 'tool') {
+                return {
+                    role: 'user',
+                    content: [
+                        {
+                            type: 'tool_result',
+                            tool_use_id: msg.tool_call_id || '',
+                            content: typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content),
+                        },
+                    ],
+                };
+            }
+            return {
+                role: msg.role === 'user' ? 'user' : 'assistant',
+                content: this.transformContent(msg),
+            };
+        });
+    }
+    transformContent(msg) {
+        if (typeof msg.content === 'string') {
+            if (msg.tool_calls?.length) {
+                const parts = [{ type: 'text', text: msg.content }];
+                for (const tc of msg.tool_calls) {
+                    parts.push({
+                        type: 'tool_use',
+                        id: tc.id,
+                        name: tc.function.name,
+                        input: JSON.parse(tc.function.arguments || '{}'),
+                    });
+                }
+                return parts;
+            }
+            return msg.content;
+        }
+        if (!msg.content)
+            return '';
+        return msg.content.map((part) => {
+            if (part.type === 'text') {
+                return { type: 'text', text: part.text };
+            }
+            if (part.type === 'image_url') {
+                const match = part.image_url.url.match(/^data:([^;]+);base64,(.+)$/);
+                if (match) {
+                    return {
+                        type: 'image',
+                        source: {
+                            type: 'base64',
+                            media_type: match[1],
+                            data: match[2],
+                        },
+                    };
+                }
+                return { type: 'text', text: `[Image: ${part.image_url.url}]` };
+            }
+            if (part.type === 'image') {
+                return {
+                    type: 'image',
+                    source: {
+                        type: 'base64',
+                        media_type: part.mediaType,
+                        data: Buffer.from(part.data).toString('base64'),
+                    },
+                };
+            }
+            return { type: 'text', text: '' };
+        });
+    }
+    transformTools(tools) {
+        if (!tools)
+            return undefined;
+        return tools.map((tool) => ({
+            name: tool.function.name,
+            description: tool.function.description,
+            input_schema: tool.function.parameters || { type: 'object', properties: {} },
+        }));
+    }
+    getSystemPrompt(options) {
+        const systemMessage = options.messages.find((m) => m.role === 'system');
+        if (options.systemPrompt)
+            return options.systemPrompt;
+        if (systemMessage) {
+            return typeof systemMessage.content === 'string'
+                ? systemMessage.content
+                : systemMessage.content?.map((p) => (p.type === 'text' ? p.text : '')).join('');
+        }
+        return undefined;
+    }
+    async chat(options) {
+        const context = {
+            startTime: performance.now(),
+            tokenCount: 0,
+        };
+        const body = this.buildChatBody(options, false);
+        const response = await this.makeRequest('/messages', body, options.signal);
+        const data = await response.json();
+        return this.parseResponse(data, context);
+    }
+    async stream(options) {
+        const context = {
+            startTime: performance.now(),
+            tokenCount: 0,
+        };
+        const body = this.buildChatBody(options, true);
+        const response = await this.makeRequest('/messages', body, options.signal);
+        return this.parseAnthropicStream(response, context);
+    }
+    async embed(_options) {
+        throw new AIError('Anthropic does not support embeddings. Use a different provider.', 'anthropic', 'not_supported', 400, false);
+    }
+    buildChatBody(options, stream) {
+        const body = {
+            model: options.model || this.config.defaultModel || 'claude-sonnet-4-20250514',
+            messages: this.transformMessages(options.messages),
+            max_tokens: options.maxTokens || 4096,
+        };
+        const systemPrompt = this.getSystemPrompt(options);
+        if (systemPrompt)
+            body.system = systemPrompt;
+        if (options.temperature !== undefined)
+            body.temperature = options.temperature;
+        if (options.topP !== undefined)
+            body.top_p = options.topP;
+        if (options.stop)
+            body.stop_sequences = options.stop;
+        if (options.tools)
+            body.tools = this.transformTools(options.tools);
+        if (options.toolChoice) {
+            if (options.toolChoice === 'auto') {
+                body.tool_choice = { type: 'auto' };
+            }
+            else if (options.toolChoice === 'none') {
+            }
+            else if (options.toolChoice === 'required') {
+                body.tool_choice = { type: 'any' };
+            }
+            else if (typeof options.toolChoice === 'object') {
+                body.tool_choice = {
+                    type: 'tool',
+                    name: options.toolChoice.function.name,
+                };
+            }
+        }
+        if (stream)
+            body.stream = true;
+        return body;
+    }
+    async makeRequest(endpoint, body, signal) {
+        const url = `${this.getBaseUrl()}${endpoint}`;
+        const headers = this.buildHeaders();
+        const response = await fetch(url, {
+            method: 'POST',
+            headers,
+            body: JSON.stringify(body),
+            signal,
+        });
+        if (!response.ok) {
+            await this.handleError(response);
+        }
+        return response;
+    }
+    async handleError(response) {
+        let errorData = {};
+        try {
+            errorData = await response.json();
+        }
+        catch {
+        }
+        const message = errorData.error?.message || response.statusText;
+        const errorType = errorData.error?.type;
+        switch (response.status) {
+            case 401:
+                throw new AuthenticationError('anthropic');
+            case 429:
+                const retryAfter = parseInt(response.headers.get('retry-after') || '0', 10);
+                throw new RateLimitError('anthropic', retryAfter || undefined);
+            case 400:
+                if (errorType === 'invalid_request_error' && message.includes('context')) {
+                    throw new ContextLengthError('anthropic');
+                }
+                break;
+            case 503:
+            case 529:
+                throw new OverloadedError('anthropic');
+        }
+        throw new AIError(message, 'anthropic', errorType, response.status, response.status >= 500);
+    }
+    parseResponse(data, context) {
+        let content = '';
+        const toolCalls = [];
+        for (const block of data.content) {
+            if (block.type === 'text') {
+                content += block.text;
+            }
+            else if (block.type === 'tool_use') {
+                toolCalls.push({
+                    id: block.id,
+                    type: 'function',
+                    function: {
+                        name: block.name,
+                        arguments: JSON.stringify(block.input),
+                    },
+                });
+            }
+        }
+        const usage = {
+            inputTokens: data.usage.input_tokens,
+            outputTokens: data.usage.output_tokens,
+            totalTokens: data.usage.input_tokens + data.usage.output_tokens,
+        };
+        context.tokenCount = usage.outputTokens;
+        const finishReasonMap = {
+            end_turn: 'stop',
+            max_tokens: 'length',
+            stop_sequence: 'stop',
+            tool_use: 'tool_calls',
+        };
+        return {
+            content,
+            usage,
+            latency: this.calculateLatency(context),
+            model: data.model,
+            provider: 'anthropic',
+            cached: false,
+            finishReason: finishReasonMap[data.stop_reason] || 'stop',
+            toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
+            raw: data,
+        };
+    }
+    parseStreamEvent(_chunk, _context) {
+        return null;
+    }
+    async *parseAnthropicStream(response, context) {
+        const reader = response.body?.getReader();
+        if (!reader) {
+            throw new Error('Response body is not readable');
+        }
+        const decoder = new TextDecoder();
+        let buffer = '';
+        let currentToolCallId = '';
+        let currentToolCallName = '';
+        let currentToolCallArgs = '';
+        try {
+            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) {
+                    const trimmed = line.trim();
+                    if (!trimmed || !trimmed.startsWith('data: '))
+                        continue;
+                    const jsonStr = trimmed.slice(6);
+                    if (jsonStr === '[DONE]')
+                        continue;
+                    try {
+                        const event = JSON.parse(jsonStr);
+                        switch (event.type) {
+                            case 'content_block_start':
+                                if (event.content_block.type === 'tool_use') {
+                                    currentToolCallId = event.content_block.id;
+                                    currentToolCallName = event.content_block.name;
+                                    currentToolCallArgs = '';
+                                }
+                                break;
+                            case 'content_block_delta':
+                                if (event.delta.type === 'text_delta' && event.delta.text) {
+                                    if (!context.firstTokenTime) {
+                                        context.firstTokenTime = performance.now();
+                                    }
+                                    context.tokenCount++;
+                                    yield { type: 'text', content: event.delta.text };
+                                }
+                                else if (event.delta.type === 'input_json_delta' && event.delta.partial_json) {
+                                    currentToolCallArgs += event.delta.partial_json;
+                                    yield {
+                                        type: 'tool_call_delta',
+                                        index: event.index,
+                                        delta: { arguments: event.delta.partial_json },
+                                    };
+                                }
+                                break;
+                            case 'content_block_stop':
+                                if (currentToolCallId) {
+                                    yield {
+                                        type: 'tool_call',
+                                        toolCall: {
+                                            id: currentToolCallId,
+                                            type: 'function',
+                                            function: {
+                                                name: currentToolCallName,
+                                                arguments: currentToolCallArgs,
+                                            },
+                                        },
+                                    };
+                                    currentToolCallId = '';
+                                    currentToolCallName = '';
+                                    currentToolCallArgs = '';
+                                }
+                                break;
+                            case 'message_delta':
+                                if (event.usage) {
+                                    yield {
+                                        type: 'usage',
+                                        usage: {
+                                            inputTokens: 0,
+                                            outputTokens: event.usage.output_tokens,
+                                            totalTokens: event.usage.output_tokens,
+                                        },
+                                    };
+                                }
+                                if (event.delta.stop_reason) {
+                                    const finishReasonMap = {
+                                        end_turn: 'stop',
+                                        max_tokens: 'length',
+                                        stop_sequence: 'stop',
+                                        tool_use: 'tool_calls',
+                                    };
+                                    yield {
+                                        type: 'done',
+                                        finishReason: finishReasonMap[event.delta.stop_reason] || 'stop',
+                                    };
+                                }
+                                break;
+                            case 'error':
+                                yield {
+                                    type: 'error',
+                                    error: new AIError(event.error.message, 'anthropic', event.error.type),
+                                };
+                                break;
+                        }
+                    }
+                    catch {
+                    }
+                }
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+    }
+}

package/dist/ai/providers/base.d.ts

@@ -0,0 +1,49 @@
+import type { AIProvider, ChatOptions, ChatMessage, AIResponse, AIStream, StreamEvent, EmbedOptions, EmbedResponse, ProviderConfig, TokenUsage, AILatency, ToolCall } from '../../types/ai.js';
+export interface ProviderRequestContext {
+    startTime: number;
+    firstTokenTime?: number;
+    tokenCount: number;
+}
+export interface BaseProviderConfig extends ProviderConfig {
+    name: AIProvider;
+}
+export declare abstract class BaseAIProvider {
+    protected config: BaseProviderConfig;
+    constructor(config: BaseProviderConfig);
+    get name(): AIProvider;
+    abstract chat(options: ChatOptions): Promise<AIResponse>;
+    abstract stream(options: ChatOptions): Promise<AIStream>;
+    abstract embed(options: EmbedOptions): Promise<EmbedResponse>;
+    protected getApiKey(): string;
+    protected abstract getEnvApiKey(): string | undefined;
+    protected abstract getBaseUrl(): string;
+    protected buildHeaders(): Record<string, string>;
+    protected abstract transformMessages(messages: ChatMessage[]): unknown[];
+    protected abstract parseResponse(response: unknown, context: ProviderRequestContext): AIResponse;
+    protected abstract parseStreamEvent(chunk: string, context: ProviderRequestContext): StreamEvent | null;
+    protected calculateLatency(context: ProviderRequestContext): AILatency;
+    protected emptyUsage(): TokenUsage;
+    protected parseSSEStream(response: Response, context: ProviderRequestContext): AIStream;
+    protected parseToolCalls(rawToolCalls: unknown[]): ToolCall[];
+}
+export declare class AIError extends Error {
+    readonly provider: AIProvider;
+    readonly code?: string | undefined;
+    readonly status?: number | undefined;
+    readonly retryable: boolean;
+    constructor(message: string, provider: AIProvider, code?: string | undefined, status?: number | undefined, retryable?: boolean);
+}
+export declare class RateLimitError extends AIError {
+    readonly retryAfter?: number | undefined;
+    constructor(provider: AIProvider, retryAfter?: number | undefined);
+}
+export declare class ContextLengthError extends AIError {
+    constructor(provider: AIProvider);
+}
+export declare class OverloadedError extends AIError {
+    constructor(provider: AIProvider);
+}
+export declare class AuthenticationError extends AIError {
+    constructor(provider: AIProvider);
+}
+//# sourceMappingURL=base.d.ts.map

package/dist/ai/providers/base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../../src/ai/providers/base.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EACV,UAAU,EACV,WAAW,EACX,WAAW,EACX,UAAU,EACV,QAAQ,EACR,WAAW,EACX,YAAY,EACZ,aAAa,EACb,cAAc,EACd,UAAU,EACV,SAAS,EACT,QAAQ,EACT,MAAM,mBAAmB,CAAC;AAK3B,MAAM,WAAW,sBAAsB;IACrC,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,UAAU,EAAE,MAAM,CAAC;CACpB;AAKD,MAAM,WAAW,kBAAmB,SAAQ,cAAc;IAExD,IAAI,EAAE,UAAU,CAAC;CAClB;AAKD,8BAAsB,cAAc;IAClC,SAAS,CAAC,MAAM,EAAE,kBAAkB,CAAC;gBAEzB,MAAM,EAAE,kBAAkB;IAOtC,IAAI,IAAI,IAAI,UAAU,CAErB;IAKD,QAAQ,CAAC,IAAI,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,UAAU,CAAC;IAKxD,QAAQ,CAAC,MAAM,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,QAAQ,CAAC;IAKxD,QAAQ,CAAC,KAAK,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,aAAa,CAAC;IAK7D,SAAS,CAAC,SAAS,IAAI,MAAM;IAW7B,SAAS,CAAC,QAAQ,CAAC,YAAY,IAAI,MAAM,GAAG,SAAS;IAKrD,SAAS,CAAC,QAAQ,CAAC,UAAU,IAAI,MAAM;IAKvC,SAAS,CAAC,YAAY,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAUhD,SAAS,CAAC,QAAQ,CAAC,iBAAiB,CAAC,QAAQ,EAAE,WAAW,EAAE,GAAG,OAAO,EAAE;IAKxE,SAAS,CAAC,QAAQ,CAAC,aAAa,CAAC,QAAQ,EAAE,OAAO,EAAE,OAAO,EAAE,sBAAsB,GAAG,UAAU;IAKhG,SAAS,CAAC,QAAQ,CAAC,gBAAgB,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,sBAAsB,GAAG,WAAW,GAAG,IAAI;IAKvG,SAAS,CAAC,gBAAgB,CAAC,OAAO,EAAE,sBAAsB,GAAG,SAAS;IAgBtE,SAAS,CAAC,UAAU,IAAI,UAAU;cAWjB,cAAc,CAC7B,QAAQ,EAAE,QAAQ,EAClB,OAAO,EAAE,sBAAsB,GAC9B,QAAQ;IA6DX,SAAS,CAAC,cAAc,CAAC,YAAY,EAAE,OAAO,EAAE,GAAG,QAAQ,EAAE;CAY9D;AAKD,qBAAa,OAAQ,SAAQ,KAAK;aAGd,QAAQ,EAAE,UAAU;aACpB,IAAI,CAAC,EAAE,MAAM;aACb,MAAM,CAAC,EAAE,MAAM;aACf,SAAS,EAAE,OAAO;gBAJlC,OAAO,EAAE,MAAM,EACC,QAAQ,EAAE,UAAU,EACpB,IAAI,CAAC,EAAE,MAAM,YAAA,EACb,MAAM,CAAC,EAAE,MAAM,YAAA,EACf,SAAS,GAAE,OAAe;CAK7C;AAED,qBAAa,cAAe,SAAQ,OAAO;aAGvB,UAAU,CAAC,EAAE,MAAM;gBADnC,QAAQ,EAAE,UAAU,EACJ,UAAU,CAAC,EAAE,MAAM,YAAA;CAKtC;AAED,qBAAa,kBAAmB,SAAQ,OAAO;gBACjC,QAAQ,EAAE,UAAU;CAIjC;AAED,qBAAa,eAAgB,SAAQ,OAAO;gBAC9B,QAAQ,EAAE,UAAU;CAIjC;AAED,qBAAa,mBAAoB,SAAQ,OAAO;gBAClC,QAAQ,EAAE,UAAU;CAIjC"}

package/dist/ai/providers/base.js

@@ -0,0 +1,145 @@
+export class BaseAIProvider {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    get name() {
+        return this.config.name;
+    }
+    getApiKey() {
+        const key = this.config.apiKey || this.getEnvApiKey();
+        if (!key) {
+            throw new Error(`API key not configured for provider: ${this.config.name}`);
+        }
+        return key;
+    }
+    buildHeaders() {
+        return {
+            'Content-Type': 'application/json',
+            ...this.config.headers,
+        };
+    }
+    calculateLatency(context) {
+        const now = performance.now();
+        const total = now - context.startTime;
+        const ttft = context.firstTokenTime
+            ? context.firstTokenTime - context.startTime
+            : total;
+        const tps = context.tokenCount > 0 && total > 0
+            ? (context.tokenCount / total) * 1000
+            : 0;
+        return { ttft, tps, total };
+    }
+    emptyUsage() {
+        return {
+            inputTokens: 0,
+            outputTokens: 0,
+            totalTokens: 0,
+        };
+    }
+    async *parseSSEStream(response, context) {
+        const reader = response.body?.getReader();
+        if (!reader) {
+            throw new Error('Response body is not readable');
+        }
+        const decoder = new TextDecoder();
+        let buffer = '';
+        try {
+            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) {
+                    const trimmed = line.trim();
+                    if (!trimmed || trimmed === 'data: [DONE]')
+                        continue;
+                    if (trimmed.startsWith('data: ')) {
+                        const data = trimmed.slice(6);
+                        try {
+                            const event = this.parseStreamEvent(data, context);
+                            if (event) {
+                                if (event.type === 'text' && !context.firstTokenTime) {
+                                    context.firstTokenTime = performance.now();
+                                }
+                                yield event;
+                            }
+                        }
+                        catch {
+                        }
+                    }
+                }
+            }
+            if (buffer.trim()) {
+                const trimmed = buffer.trim();
+                if (trimmed.startsWith('data: ') && trimmed !== 'data: [DONE]') {
+                    const data = trimmed.slice(6);
+                    try {
+                        const event = this.parseStreamEvent(data, context);
+                        if (event)
+                            yield event;
+                    }
+                    catch {
+                    }
+                }
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+    }
+    parseToolCalls(rawToolCalls) {
+        if (!Array.isArray(rawToolCalls))
+            return [];
+        return rawToolCalls.map((tc) => ({
+            id: tc.id || '',
+            type: 'function',
+            function: {
+                name: tc.function?.name || '',
+                arguments: tc.function?.arguments || '{}',
+            },
+        }));
+    }
+}
+export class AIError extends Error {
+    provider;
+    code;
+    status;
+    retryable;
+    constructor(message, provider, code, status, retryable = false) {
+        super(message);
+        this.provider = provider;
+        this.code = code;
+        this.status = status;
+        this.retryable = retryable;
+        this.name = 'AIError';
+    }
+}
+export class RateLimitError extends AIError {
+    retryAfter;
+    constructor(provider, retryAfter) {
+        super('Rate limit exceeded', provider, 'rate_limit', 429, true);
+        this.retryAfter = retryAfter;
+        this.name = 'RateLimitError';
+    }
+}
+export class ContextLengthError extends AIError {
+    constructor(provider) {
+        super('Context length exceeded', provider, 'context_length_exceeded', 400, true);
+        this.name = 'ContextLengthError';
+    }
+}
+export class OverloadedError extends AIError {
+    constructor(provider) {
+        super('Provider is overloaded', provider, 'overloaded', 503, true);
+        this.name = 'OverloadedError';
+    }
+}
+export class AuthenticationError extends AIError {
+    constructor(provider) {
+        super('Authentication failed', provider, 'authentication_error', 401, false);
+        this.name = 'AuthenticationError';
+    }
+}

package/dist/ai/providers/index.d.ts

@@ -0,0 +1,7 @@
+export { BaseAIProvider, AIError, RateLimitError, ContextLengthError, OverloadedError, AuthenticationError } from './base.js';
+export type { ProviderRequestContext, BaseProviderConfig } from './base.js';
+export { OpenAIProvider } from './openai.js';
+export type { OpenAIConfig } from './openai.js';
+export { AnthropicProvider } from './anthropic.js';
+export type { AnthropicConfig } from './anthropic.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/ai/providers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/ai/providers/index.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,cAAc,EAAE,OAAO,EAAE,cAAc,EAAE,kBAAkB,EAAE,eAAe,EAAE,mBAAmB,EAAE,MAAM,WAAW,CAAC;AAC9H,YAAY,EAAE,sBAAsB,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC;AAE5E,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAC7C,YAAY,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAEhD,OAAO,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACnD,YAAY,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/ai/providers/index.js

@@ -0,0 +1,3 @@
+export { BaseAIProvider, AIError, RateLimitError, ContextLengthError, OverloadedError, AuthenticationError } from './base.js';
+export { OpenAIProvider } from './openai.js';
+export { AnthropicProvider } from './anthropic.js';

package/dist/ai/providers/openai.d.ts

@@ -0,0 +1,65 @@
+import type { ChatOptions, ChatMessage, AIResponse, AIStream, StreamEvent, EmbedOptions, EmbedResponse, ProviderConfig } from '../../types/ai.js';
+import { BaseAIProvider, ProviderRequestContext } from './base.js';
+export interface OpenAIConfig extends ProviderConfig {
+    organization?: string;
+}
+interface OpenAIMessage {
+    role: 'system' | 'user' | 'assistant' | 'tool';
+    content: string | OpenAIContentPart[] | null;
+    name?: string;
+    tool_call_id?: string;
+    tool_calls?: OpenAIToolCall[];
+}
+interface OpenAIContentPart {
+    type: 'text' | 'image_url';
+    text?: string;
+    image_url?: {
+        url: string;
+        detail?: string;
+    };
+}
+interface OpenAIToolCall {
+    id: string;
+    type: 'function';
+    function: {
+        name: string;
+        arguments: string;
+    };
+}
+interface OpenAICompletion {
+    id: string;
+    object: string;
+    created: number;
+    model: string;
+    choices: Array<{
+        index: number;
+        message: OpenAIMessage;
+        finish_reason: 'stop' | 'length' | 'tool_calls' | 'content_filter';
+    }>;
+    usage?: {
+        prompt_tokens: number;
+        completion_tokens: number;
+        total_tokens: number;
+    };
+}
+export declare class OpenAIProvider extends BaseAIProvider {
+    private openaiConfig;
+    constructor(config?: OpenAIConfig);
+    protected getEnvApiKey(): string | undefined;
+    protected getBaseUrl(): string;
+    protected buildHeaders(): Record<string, string>;
+    protected transformMessages(messages: ChatMessage[]): OpenAIMessage[];
+    private transformContent;
+    private transformTools;
+    chat(options: ChatOptions): Promise<AIResponse>;
+    stream(options: ChatOptions): Promise<AIStream>;
+    embed(options: EmbedOptions): Promise<EmbedResponse>;
+    private prepareMessages;
+    private buildChatBody;
+    private makeRequest;
+    private handleError;
+    protected parseResponse(data: OpenAICompletion, context: ProviderRequestContext): AIResponse;
+    protected parseStreamEvent(chunk: string, context: ProviderRequestContext): StreamEvent | null;
+}
+export {};
+//# sourceMappingURL=openai.d.ts.map

package/dist/ai/providers/openai.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openai.d.ts","sourceRoot":"","sources":["../../../src/ai/providers/openai.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EACV,WAAW,EACX,WAAW,EACX,UAAU,EACV,QAAQ,EACR,WAAW,EACX,YAAY,EACZ,aAAa,EACb,cAAc,EAIf,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACL,cAAc,EACd,sBAAsB,EAMvB,MAAM,WAAW,CAAC;AAKnB,MAAM,WAAW,YAAa,SAAQ,cAAc;IAElD,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAKD,UAAU,aAAa;IACrB,IAAI,EAAE,QAAQ,GAAG,MAAM,GAAG,WAAW,GAAG,MAAM,CAAC;IAC/C,OAAO,EAAE,MAAM,GAAG,iBAAiB,EAAE,GAAG,IAAI,CAAC;IAC7C,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,UAAU,CAAC,EAAE,cAAc,EAAE,CAAC;CAC/B;AAED,UAAU,iBAAiB;IACzB,IAAI,EAAE,MAAM,GAAG,WAAW,CAAC;IAC3B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CAC9C;AAED,UAAU,cAAc;IACtB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,UAAU,CAAC;IACjB,QAAQ,EAAE;QACR,IAAI,EAAE,MAAM,CAAC;QACb,SAAS,EAAE,MAAM,CAAC;KACnB,CAAC;CACH;AAKD,UAAU,gBAAgB;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,KAAK,CAAC;QACb,KAAK,EAAE,MAAM,CAAC;QACd,OAAO,EAAE,aAAa,CAAC;QACvB,aAAa,EAAE,MAAM,GAAG,QAAQ,GAAG,YAAY,GAAG,gBAAgB,CAAC;KACpE,CAAC,CAAC;IACH,KAAK,CAAC,EAAE;QACN,aAAa,EAAE,MAAM,CAAC;QACtB,iBAAiB,EAAE,MAAM,CAAC;QAC1B,YAAY,EAAE,MAAM,CAAC;KACtB,CAAC;CACH;AAsDD,qBAAa,cAAe,SAAQ,cAAc;IAChD,OAAO,CAAC,YAAY,CAAe;gBAEvB,MAAM,GAAE,YAAiB;IAKrC,SAAS,CAAC,YAAY,IAAI,MAAM,GAAG,SAAS;IAI5C,SAAS,CAAC,UAAU,IAAI,MAAM;IAI9B,SAAS,CAAC,YAAY,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAchD,SAAS,CAAC,iBAAiB,CAAC,QAAQ,EAAE,WAAW,EAAE,GAAG,aAAa,EAAE;IAerE,OAAO,CAAC,gBAAgB;IA+BxB,OAAO,CAAC,cAAc;IAQhB,IAAI,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,UAAU,CAAC;IAe/C,MAAM,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,QAAQ,CAAC;IAc/C,KAAK,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,aAAa,CAAC;IA+B1D,OAAO,CAAC,eAAe;IAcvB,OAAO,CAAC,aAAa;YAqCP,WAAW;YAsBX,WAAW;IA8BzB,SAAS,CAAC,aAAa,CAAC,IAAI,EAAE,gBAAgB,EAAE,OAAO,EAAE,sBAAsB,GAAG,UAAU;IA8B5F,SAAS,CAAC,gBAAgB,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,sBAAsB,GAAG,WAAW,GAAG,IAAI;CA2E/F"}