recker 1.0.43 → 1.0.44

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

@@ -0,0 +1,305 @@
+import { BaseAIProvider, AIError, RateLimitError, OverloadedError, AuthenticationError, } from './base.js';
+export class GoogleProvider extends BaseAIProvider {
+    googleConfig;
+    constructor(config = {}) {
+        super({ ...config, name: 'google' });
+        this.googleConfig = config;
+    }
+    getEnvApiKey() {
+        return process.env.GOOGLE_API_KEY;
+    }
+    getBaseUrl() {
+        const version = this.googleConfig.apiVersion || 'v1beta';
+        return this.config.baseUrl || `https://generativelanguage.googleapis.com/${version}`;
+    }
+    buildHeaders() {
+        return {
+            'Content-Type': 'application/json',
+            ...this.config.headers,
+        };
+    }
+    transformMessages(messages) {
+        return messages
+            .filter((m) => m.role !== 'system')
+            .map((msg) => {
+            return {
+                role: msg.role === 'user' ? 'user' : 'model',
+                parts: this.transformContent(msg),
+            };
+        });
+    }
+    transformContent(msg) {
+        if (msg.role === 'tool') {
+            return [{
+                    functionResponse: {
+                        name: msg.name || 'unknown_tool',
+                        response: typeof msg.content === 'string' ? { content: msg.content } : { content: msg.content },
+                    },
+                }];
+        }
+        if (msg.tool_calls && msg.tool_calls.length > 0) {
+            const parts = [];
+            if (msg.content && typeof msg.content === 'string') {
+                parts.push({ text: msg.content });
+            }
+            msg.tool_calls.forEach((tc) => {
+                parts.push({
+                    functionCall: {
+                        name: tc.function.name,
+                        args: JSON.parse(tc.function.arguments || '{}'),
+                    },
+                });
+            });
+            return parts;
+        }
+        const content = msg.content;
+        if (typeof content === 'string') {
+            return [{ text: content }];
+        }
+        if (!content)
+            return [{ text: '' }];
+        return content.map((part) => {
+            if (part.type === 'text') {
+                return { text: part.text };
+            }
+            if (part.type === 'image_url') {
+                return { text: '[Image URL not supported directly in Gemini provider yet without base64]' };
+            }
+            if (part.type === 'image') {
+                const base64 = Buffer.from(part.data).toString('base64');
+                return {
+                    inlineData: {
+                        mimeType: part.mediaType,
+                        data: base64,
+                    },
+                };
+            }
+            return { text: '' };
+        });
+    }
+    transformTools(tools) {
+        if (!tools || tools.length === 0)
+            return undefined;
+        return [{
+                functionDeclarations: tools.map((t) => ({
+                    name: t.function.name,
+                    description: t.function.description,
+                    parameters: t.function.parameters,
+                })),
+            }];
+    }
+    async chat(options) {
+        const context = {
+            startTime: performance.now(),
+            tokenCount: 0,
+        };
+        const model = options.model || this.config.defaultModel || 'gemini-2.5-flash';
+        const body = this.buildChatBody(options);
+        const response = await this.makeRequest(`/models/${model}:generateContent`, body, options.signal);
+        const data = await response.json();
+        return this.parseResponse(data, context);
+    }
+    async stream(options) {
+        const context = {
+            startTime: performance.now(),
+            tokenCount: 0,
+        };
+        const model = options.model || this.config.defaultModel || 'gemini-2.5-flash';
+        const body = this.buildChatBody(options);
+        const response = await this.makeRequest(`/models/${model}:streamGenerateContent?alt=sse`, body, options.signal);
+        return this.parseSSEStream(response, context);
+    }
+    async embed(options) {
+        const startTime = performance.now();
+        const model = options.model || 'text-embedding-004';
+        const isBatch = Array.isArray(options.input);
+        const method = isBatch ? 'batchEmbedContents' : 'embedContent';
+        const inputs = isBatch ? options.input : [options.input];
+        const requests = inputs.map(text => ({
+            model: `models/${model}`,
+            content: { parts: [{ text }] }
+        }));
+        const body = isBatch ? { requests } : { ...requests[0] };
+        const response = await this.makeRequest(`/models/${model}:${method}`, body, options.signal);
+        const data = await response.json();
+        let embeddings = [];
+        if (isBatch) {
+            embeddings = data.embeddings.map((e) => e.values);
+        }
+        else {
+            embeddings = [data.embedding.values];
+        }
+        const totalTokens = 0;
+        const latency = {
+            ttft: performance.now() - startTime,
+            tps: 0,
+            total: performance.now() - startTime,
+        };
+        return {
+            embeddings,
+            usage: {
+                inputTokens: totalTokens,
+                outputTokens: 0,
+                totalTokens,
+            },
+            model,
+            provider: 'google',
+            latency,
+        };
+    }
+    buildChatBody(options) {
+        const messages = this.transformMessages(options.messages);
+        const systemMessage = options.messages.find(m => m.role === 'system');
+        let systemInstruction;
+        if (systemMessage) {
+            systemInstruction = {
+                parts: [{ text: typeof systemMessage.content === 'string' ? systemMessage.content : '' }]
+            };
+        }
+        else if (options.systemPrompt) {
+            systemInstruction = {
+                parts: [{ text: options.systemPrompt }]
+            };
+        }
+        const generationConfig = {};
+        if (options.temperature !== undefined)
+            generationConfig.temperature = options.temperature;
+        if (options.topP !== undefined)
+            generationConfig.topP = options.topP;
+        if (options.maxTokens !== undefined)
+            generationConfig.maxOutputTokens = options.maxTokens;
+        if (options.stop)
+            generationConfig.stopSequences = options.stop;
+        if (options.responseFormat?.type === 'json_object') {
+            generationConfig.responseMimeType = 'application/json';
+        }
+        const body = {
+            contents: messages,
+            generationConfig,
+            tools: this.transformTools(options.tools),
+        };
+        if (systemInstruction) {
+            body.systemInstruction = systemInstruction;
+        }
+        return body;
+    }
+    async makeRequest(endpoint, body, signal) {
+        const key = this.getApiKey();
+        const separator = endpoint.includes('?') ? '&' : '?';
+        const url = `${this.getBaseUrl()}${endpoint}${separator}key=${key}`;
+        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 status = errorData.error?.code || response.status;
+        switch (response.status) {
+            case 400:
+            case 401:
+                throw new AuthenticationError('google');
+            case 429:
+                throw new RateLimitError('google');
+            case 503:
+                throw new OverloadedError('google');
+        }
+        throw new AIError(message, 'google', String(status), response.status, response.status >= 500);
+    }
+    parseResponse(data, context) {
+        const candidate = data.candidates?.[0];
+        const parts = candidate?.content?.parts || [];
+        const content = parts
+            .filter(p => p.text)
+            .map(p => p.text)
+            .join('');
+        const toolCalls = parts
+            .filter(p => p.functionCall)
+            .map(p => ({
+            id: 'call_' + Math.random().toString(36).slice(2),
+            type: 'function',
+            function: {
+                name: p.functionCall.name,
+                arguments: JSON.stringify(p.functionCall.args),
+            }
+        }));
+        const usage = data.usageMetadata
+            ? {
+                inputTokens: data.usageMetadata.promptTokenCount,
+                outputTokens: data.usageMetadata.candidatesTokenCount,
+                totalTokens: data.usageMetadata.totalTokenCount,
+            }
+            : this.emptyUsage();
+        context.tokenCount = usage.outputTokens;
+        return {
+            content,
+            usage,
+            latency: this.calculateLatency(context),
+            model: 'gemini',
+            provider: 'google',
+            cached: false,
+            finishReason: candidate?.finishReason === 'STOP' ? 'stop' : 'length',
+            toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
+            raw: data,
+        };
+    }
+    parseStreamEvent(chunk, context) {
+        const data = JSON.parse(chunk);
+        const candidate = data.candidates?.[0];
+        if (!candidate)
+            return null;
+        if (data.usageMetadata) {
+            return {
+                type: 'usage',
+                usage: {
+                    inputTokens: data.usageMetadata.promptTokenCount,
+                    outputTokens: data.usageMetadata.candidatesTokenCount,
+                    totalTokens: data.usageMetadata.totalTokenCount,
+                }
+            };
+        }
+        const parts = candidate.content?.parts || [];
+        const textPart = parts.find(p => p.text);
+        if (textPart?.text) {
+            context.tokenCount++;
+            return {
+                type: 'text',
+                content: textPart.text,
+            };
+        }
+        const toolPart = parts.find(p => p.functionCall);
+        if (toolPart?.functionCall) {
+            return {
+                type: 'tool_call',
+                toolCall: {
+                    id: 'call_' + Math.random().toString(36).slice(2),
+                    type: 'function',
+                    function: {
+                        name: toolPart.functionCall.name,
+                        arguments: JSON.stringify(toolPart.functionCall.args),
+                    }
+                }
+            };
+        }
+        if (candidate.finishReason && candidate.finishReason !== 'STOP') {
+            return {
+                type: 'done',
+                finishReason: 'stop',
+            };
+        }
+        return null;
+    }
+}

package/dist/browser/ai/providers/ollama.d.ts

@@ -0,0 +1,44 @@
+import type { ChatOptions, ChatMessage, AIResponse, AIStream, StreamEvent, EmbedOptions, EmbedResponse, ProviderConfig } from '../../types/ai.js';
+import { BaseAIProvider, ProviderRequestContext } from './base.js';
+export interface OllamaConfig extends ProviderConfig {
+    keepAlive?: string;
+}
+interface OllamaMessage {
+    role: string;
+    content: string;
+    images?: string[];
+}
+interface OllamaResponse {
+    model: string;
+    created_at: string;
+    message: {
+        role: string;
+        content: string;
+        images?: string[] | null;
+    };
+    done: boolean;
+    total_duration?: number;
+    load_duration?: number;
+    prompt_eval_count?: number;
+    prompt_eval_duration?: number;
+    eval_count?: number;
+    eval_duration?: number;
+}
+export declare class OllamaProvider extends BaseAIProvider {
+    private ollamaConfig;
+    constructor(config?: OllamaConfig);
+    protected getEnvApiKey(): string | undefined;
+    protected getBaseUrl(): string;
+    protected buildHeaders(): Record<string, string>;
+    protected transformMessages(messages: ChatMessage[]): OllamaMessage[];
+    private extractContentAndImages;
+    chat(options: ChatOptions): Promise<AIResponse>;
+    stream(options: ChatOptions): Promise<AIStream>;
+    embed(options: EmbedOptions): Promise<EmbedResponse>;
+    private buildChatBody;
+    private makeRequest;
+    protected parseResponse(data: OllamaResponse, context: ProviderRequestContext): AIResponse;
+    protected parseStreamEvent(_chunk: string, _context: ProviderRequestContext): StreamEvent | null;
+    protected parseNDJSONStream(response: Response, context: ProviderRequestContext): AIStream;
+}
+export {};

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

@@ -0,0 +1,240 @@
+import { BaseAIProvider, AIError, RateLimitError, OverloadedError, } from './base.js';
+import { StreamError } from '../../core/errors.js';
+export class OllamaProvider extends BaseAIProvider {
+    ollamaConfig;
+    constructor(config = {}) {
+        super({ ...config, name: 'ollama' });
+        this.ollamaConfig = config;
+    }
+    getEnvApiKey() {
+        return undefined;
+    }
+    getBaseUrl() {
+        return this.config.baseUrl || 'http://127.0.0.1:11434/api';
+    }
+    buildHeaders() {
+        return {
+            'Content-Type': 'application/json',
+            ...this.config.headers,
+        };
+    }
+    transformMessages(messages) {
+        return messages.map((msg) => {
+            const { content, images } = this.extractContentAndImages(msg.content);
+            return {
+                role: msg.role,
+                content,
+                images: images.length > 0 ? images : undefined,
+            };
+        });
+    }
+    extractContentAndImages(content) {
+        if (typeof content === 'string') {
+            return { content, images: [] };
+        }
+        let text = '';
+        const images = [];
+        for (const part of content) {
+            if (part.type === 'text') {
+                text += part.text;
+            }
+            else if (part.type === 'image') {
+                images.push(Buffer.from(part.data).toString('base64'));
+            }
+            else if (part.type === 'image_url') {
+                if (part.image_url.url.startsWith('data:')) {
+                    const base64 = part.image_url.url.split(',')[1];
+                    if (base64)
+                        images.push(base64);
+                }
+            }
+        }
+        return { content: text, images };
+    }
+    async chat(options) {
+        const context = {
+            startTime: performance.now(),
+            tokenCount: 0,
+        };
+        const body = this.buildChatBody(options, false);
+        const response = await this.makeRequest('/chat', 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('/chat', body, options.signal);
+        return this.parseNDJSONStream(response, context);
+    }
+    async embed(options) {
+        const startTime = performance.now();
+        const body = {
+            model: options.model || this.config.defaultModel || 'nomic-embed-text',
+            input: options.input,
+        };
+        if (this.ollamaConfig.keepAlive) {
+            body.keep_alive = this.ollamaConfig.keepAlive;
+        }
+        const response = await this.makeRequest('/embed', body, options.signal);
+        const data = await response.json();
+        const latency = {
+            ttft: performance.now() - startTime,
+            tps: 0,
+            total: performance.now() - startTime,
+        };
+        const usage = {
+            inputTokens: data.prompt_eval_count || 0,
+            outputTokens: 0,
+            totalTokens: data.prompt_eval_count || 0,
+        };
+        return {
+            embeddings: data.embeddings,
+            usage,
+            model: data.model,
+            provider: 'ollama',
+            latency,
+        };
+    }
+    buildChatBody(options, stream) {
+        const body = {
+            model: options.model || this.config.defaultModel || 'llama3',
+            messages: this.transformMessages(options.messages),
+            stream,
+            options: {},
+        };
+        if (options.responseFormat?.type === 'json_object') {
+            body.format = 'json';
+        }
+        if (this.ollamaConfig.keepAlive) {
+            body.keep_alive = this.ollamaConfig.keepAlive;
+        }
+        if (options.temperature !== undefined)
+            body.options.temperature = options.temperature;
+        if (options.topP !== undefined)
+            body.options.top_p = options.topP;
+        if (options.maxTokens !== undefined)
+            body.options.num_predict = options.maxTokens;
+        if (options.stop)
+            body.options.stop = options.stop;
+        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) {
+            let errorMsg = response.statusText;
+            try {
+                const err = await response.json();
+                if (err.error)
+                    errorMsg = err.error;
+            }
+            catch { }
+            if (response.status === 429)
+                throw new RateLimitError('ollama');
+            if (response.status === 503)
+                throw new OverloadedError('ollama');
+            throw new AIError(errorMsg, 'ollama', String(response.status), response.status);
+        }
+        return response;
+    }
+    parseResponse(data, context) {
+        const usage = {
+            inputTokens: data.prompt_eval_count || 0,
+            outputTokens: data.eval_count || 0,
+            totalTokens: (data.prompt_eval_count || 0) + (data.eval_count || 0),
+        };
+        context.tokenCount = usage.outputTokens;
+        return {
+            content: data.message.content,
+            usage,
+            latency: this.calculateLatency(context),
+            model: data.model,
+            provider: 'ollama',
+            cached: false,
+            finishReason: data.done ? 'stop' : undefined,
+            raw: data,
+        };
+    }
+    parseStreamEvent(_chunk, _context) {
+        return null;
+    }
+    async *parseNDJSONStream(response, context) {
+        const reader = response.body?.getReader();
+        if (!reader)
+            throw new StreamError('Response body is not readable', { streamType: 'ndjson' });
+        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) {
+                    if (!line.trim())
+                        continue;
+                    try {
+                        const data = JSON.parse(line);
+                        if (data.message?.content) {
+                            if (!context.firstTokenTime)
+                                context.firstTokenTime = performance.now();
+                            context.tokenCount++;
+                            yield { type: 'text', content: data.message.content };
+                        }
+                        if (data.done) {
+                            const usage = {
+                                inputTokens: data.prompt_eval_count || 0,
+                                outputTokens: data.eval_count || 0,
+                                totalTokens: (data.prompt_eval_count || 0) + (data.eval_count || 0),
+                            };
+                            yield { type: 'done', finishReason: 'stop', usage };
+                        }
+                    }
+                    catch (e) {
+                    }
+                }
+            }
+            if (buffer.trim()) {
+                const lines = buffer.split('\n');
+                for (const line of lines) {
+                    if (!line.trim())
+                        continue;
+                    try {
+                        const data = JSON.parse(line);
+                        if (data.message?.content) {
+                            if (!context.firstTokenTime)
+                                context.firstTokenTime = performance.now();
+                            context.tokenCount++;
+                            yield { type: 'text', content: data.message.content };
+                        }
+                        if (data.done) {
+                            const usage = {
+                                inputTokens: data.prompt_eval_count || 0,
+                                outputTokens: data.eval_count || 0,
+                                totalTokens: (data.prompt_eval_count || 0) + (data.eval_count || 0),
+                            };
+                            yield { type: 'done', finishReason: 'stop', usage };
+                        }
+                    }
+                    catch (e) {
+                    }
+                }
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+    }
+}

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

@@ -0,0 +1,64 @@
+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 {};