recker 1.0.43 → 1.0.44

package/dist/browser/ai/providers/anthropic.js

@@ -0,0 +1,370 @@
+import { BaseAIProvider, AIError, RateLimitError, ContextLengthError, OverloadedError, AuthenticationError, } from './base.js';
+import { StreamError } from '../../core/errors.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 StreamError('Response body is not readable', {
+                streamType: 'anthropic-sse',
+            });
+        }
+        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/browser/ai/providers/base.d.ts

@@ -0,0 +1,48 @@
+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);
+}

package/dist/browser/ai/providers/base.js

@@ -0,0 +1,150 @@
+import { ConfigurationError, StreamError } from '../../core/errors.js';
+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 ConfigurationError(`API key not configured for provider: ${this.config.name}`, {
+                configKey: `${this.config.name}.apiKey`,
+            });
+        }
+        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 StreamError('Response body is not readable', {
+                streamType: 'sse',
+            });
+        }
+        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/browser/ai/providers/google.d.ts

@@ -0,0 +1,59 @@
+import type { ChatOptions, ChatMessage, AIResponse, AIStream, StreamEvent, EmbedOptions, EmbedResponse, ProviderConfig } from '../../types/ai.js';
+import { BaseAIProvider, ProviderRequestContext } from './base.js';
+export interface GoogleConfig extends ProviderConfig {
+    apiVersion?: string;
+}
+interface GeminiContent {
+    role: 'user' | 'model';
+    parts: GeminiPart[];
+}
+interface GeminiPart {
+    text?: string;
+    inlineData?: {
+        mimeType: string;
+        data: string;
+    };
+    functionCall?: {
+        name: string;
+        args: Record<string, unknown>;
+    };
+    functionResponse?: {
+        name: string;
+        response: Record<string, unknown>;
+    };
+}
+interface GeminiResponse {
+    candidates?: Array<{
+        content: GeminiContent;
+        finishReason?: string;
+        citationMetadata?: unknown;
+        tokenCount?: number;
+    }>;
+    promptFeedback?: {
+        blockReason?: string;
+    };
+    usageMetadata?: {
+        promptTokenCount: number;
+        candidatesTokenCount: number;
+        totalTokenCount: number;
+    };
+}
+export declare class GoogleProvider extends BaseAIProvider {
+    private googleConfig;
+    constructor(config?: GoogleConfig);
+    protected getEnvApiKey(): string | undefined;
+    protected getBaseUrl(): string;
+    protected buildHeaders(): Record<string, string>;
+    protected transformMessages(messages: ChatMessage[]): GeminiContent[];
+    private transformContent;
+    private transformTools;
+    chat(options: ChatOptions): Promise<AIResponse>;
+    stream(options: ChatOptions): Promise<AIStream>;
+    embed(options: EmbedOptions): Promise<EmbedResponse>;
+    private buildChatBody;
+    private makeRequest;
+    private handleError;
+    protected parseResponse(data: GeminiResponse, context: ProviderRequestContext): AIResponse;
+    protected parseStreamEvent(chunk: string, context: ProviderRequestContext): StreamEvent | null;
+}
+export {};