recker 1.0.43 → 1.0.44

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

@@ -0,0 +1,298 @@
+import { BaseAIProvider, AIError, RateLimitError, ContextLengthError, OverloadedError, AuthenticationError, } from './base.js';
+export class OpenAIProvider extends BaseAIProvider {
+    openaiConfig;
+    constructor(config = {}) {
+        super({ ...config, name: 'openai' });
+        this.openaiConfig = config;
+    }
+    getEnvApiKey() {
+        return process.env.OPENAI_API_KEY;
+    }
+    getBaseUrl() {
+        return this.config.baseUrl || 'https://api.openai.com/v1';
+    }
+    buildHeaders() {
+        const headers = {
+            'Content-Type': 'application/json',
+            'Authorization': `Bearer ${this.getApiKey()}`,
+            ...this.config.headers,
+        };
+        if (this.openaiConfig.organization) {
+            headers['OpenAI-Organization'] = this.openaiConfig.organization;
+        }
+        return headers;
+    }
+    transformMessages(messages) {
+        return messages.map((msg) => {
+            const openaiMsg = {
+                role: msg.role,
+                content: this.transformContent(msg.content),
+            };
+            if (msg.name)
+                openaiMsg.name = msg.name;
+            if (msg.tool_call_id)
+                openaiMsg.tool_call_id = msg.tool_call_id;
+            if (msg.tool_calls)
+                openaiMsg.tool_calls = msg.tool_calls;
+            return openaiMsg;
+        });
+    }
+    transformContent(content) {
+        if (typeof content === 'string')
+            return content;
+        if (!content)
+            return null;
+        return content.map((part) => {
+            if (part.type === 'text') {
+                return { type: 'text', text: part.text };
+            }
+            if (part.type === 'image_url') {
+                return {
+                    type: 'image_url',
+                    image_url: {
+                        url: part.image_url.url,
+                        detail: part.image_url.detail,
+                    },
+                };
+            }
+            if (part.type === 'image') {
+                const base64 = Buffer.from(part.data).toString('base64');
+                return {
+                    type: 'image_url',
+                    image_url: {
+                        url: `data:${part.mediaType};base64,${base64}`,
+                    },
+                };
+            }
+            return { type: 'text', text: '' };
+        });
+    }
+    transformTools(tools) {
+        if (!tools)
+            return undefined;
+        return tools.map((tool) => ({
+            type: tool.type,
+            function: tool.function,
+        }));
+    }
+    async chat(options) {
+        const context = {
+            startTime: performance.now(),
+            tokenCount: 0,
+        };
+        const messages = this.prepareMessages(options);
+        const body = this.buildChatBody(options, messages, false);
+        const response = await this.makeRequest('/chat/completions', body, options.signal);
+        const data = await response.json();
+        return this.parseResponse(data, context);
+    }
+    async stream(options) {
+        const context = {
+            startTime: performance.now(),
+            tokenCount: 0,
+        };
+        const messages = this.prepareMessages(options);
+        const body = this.buildChatBody(options, messages, true);
+        const response = await this.makeRequest('/chat/completions', body, options.signal);
+        return this.parseSSEStream(response, context);
+    }
+    async embed(options) {
+        const startTime = performance.now();
+        const body = {
+            model: options.model || this.config.defaultModel || 'text-embedding-3-large',
+            input: options.input,
+            ...(options.dimensions && { dimensions: options.dimensions }),
+        };
+        const response = await this.makeRequest('/embeddings', body, options.signal);
+        const data = await response.json();
+        const latency = {
+            ttft: performance.now() - startTime,
+            tps: 0,
+            total: performance.now() - startTime,
+        };
+        return {
+            embeddings: data.data.map((d) => d.embedding),
+            usage: {
+                inputTokens: data.usage.prompt_tokens,
+                outputTokens: 0,
+                totalTokens: data.usage.total_tokens,
+            },
+            model: data.model,
+            provider: 'openai',
+            latency,
+        };
+    }
+    prepareMessages(options) {
+        const messages = [...options.messages];
+        if (options.systemPrompt) {
+            messages.unshift({
+                role: 'system',
+                content: options.systemPrompt,
+            });
+        }
+        return messages;
+    }
+    buildChatBody(options, messages, stream) {
+        const body = {
+            model: options.model || this.config.defaultModel || 'gpt-5.1',
+            messages: this.transformMessages(messages),
+            stream,
+        };
+        if (options.temperature !== undefined)
+            body.temperature = options.temperature;
+        if (options.topP !== undefined)
+            body.top_p = options.topP;
+        if (options.maxTokens !== undefined)
+            body.max_tokens = options.maxTokens;
+        if (options.stop)
+            body.stop = options.stop;
+        if (options.tools)
+            body.tools = this.transformTools(options.tools);
+        if (options.toolChoice)
+            body.tool_choice = options.toolChoice;
+        if (options.responseFormat) {
+            if (options.responseFormat.type === 'json_object') {
+                body.response_format = { type: 'json_object' };
+            }
+            else if (options.responseFormat.type === 'json_schema') {
+                body.response_format = {
+                    type: 'json_schema',
+                    json_schema: options.responseFormat.schema,
+                };
+            }
+        }
+        if (stream) {
+            body.stream_options = { include_usage: 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 code = errorData.error?.code || errorData.error?.type;
+        switch (response.status) {
+            case 401:
+                throw new AuthenticationError('openai');
+            case 429:
+                const retryAfter = parseInt(response.headers.get('retry-after') || '0', 10);
+                throw new RateLimitError('openai', retryAfter || undefined);
+            case 400:
+                if (code === 'context_length_exceeded' || message.includes('maximum context length')) {
+                    throw new ContextLengthError('openai');
+                }
+                break;
+            case 503:
+            case 529:
+                throw new OverloadedError('openai');
+        }
+        throw new AIError(message, 'openai', code, response.status, response.status >= 500);
+    }
+    parseResponse(data, context) {
+        const choice = data.choices[0];
+        const message = choice?.message;
+        const content = typeof message?.content === 'string' ? message.content : '';
+        const toolCalls = message?.tool_calls ? this.parseToolCalls(message.tool_calls) : undefined;
+        const usage = data.usage
+            ? {
+                inputTokens: data.usage.prompt_tokens,
+                outputTokens: data.usage.completion_tokens,
+                totalTokens: data.usage.total_tokens,
+            }
+            : this.emptyUsage();
+        context.tokenCount = usage.outputTokens;
+        return {
+            content,
+            usage,
+            latency: this.calculateLatency(context),
+            model: data.model,
+            provider: 'openai',
+            cached: false,
+            finishReason: choice?.finish_reason,
+            toolCalls,
+            raw: data,
+        };
+    }
+    parseStreamEvent(chunk, context) {
+        const data = JSON.parse(chunk);
+        const choice = data.choices?.[0];
+        if (!choice) {
+            if (data.usage) {
+                return {
+                    type: 'usage',
+                    usage: {
+                        inputTokens: data.usage.prompt_tokens,
+                        outputTokens: data.usage.completion_tokens,
+                        totalTokens: data.usage.total_tokens,
+                    },
+                };
+            }
+            return null;
+        }
+        const delta = choice.delta;
+        if (delta.content) {
+            context.tokenCount++;
+            return {
+                type: 'text',
+                content: delta.content,
+            };
+        }
+        if (delta.tool_calls?.length) {
+            const tc = delta.tool_calls[0];
+            if (tc.id) {
+                return {
+                    type: 'tool_call',
+                    toolCall: {
+                        id: tc.id,
+                        type: 'function',
+                        function: {
+                            name: tc.function?.name || '',
+                            arguments: tc.function?.arguments || '',
+                        },
+                    },
+                };
+            }
+            else if (tc.function?.arguments) {
+                return {
+                    type: 'tool_call_delta',
+                    index: tc.index,
+                    delta: {
+                        arguments: tc.function.arguments,
+                    },
+                };
+            }
+        }
+        if (choice.finish_reason) {
+            return {
+                type: 'done',
+                finishReason: choice.finish_reason,
+                usage: data.usage
+                    ? {
+                        inputTokens: data.usage.prompt_tokens,
+                        outputTokens: data.usage.completion_tokens,
+                        totalTokens: data.usage.total_tokens,
+                    }
+                    : undefined,
+            };
+        }
+        return null;
+    }
+}

package/dist/browser/ai/rate-limiter.d.ts

@@ -0,0 +1,43 @@
+import type { TokenRateLimitConfig, ChatOptions } from '../types/ai.js';
+export declare class TokenRateLimiter {
+    private config;
+    private state;
+    private queue;
+    private processing;
+    private nextId;
+    constructor(config?: TokenRateLimitConfig);
+    execute<T>(fn: () => Promise<T>, options?: {
+        estimatedTokens?: number;
+        priority?: 'high' | 'normal' | 'low';
+    }): Promise<T>;
+    executeChat<T>(options: ChatOptions, fn: () => Promise<T>): Promise<T>;
+    recordUsage(actualTokens: number, estimatedTokens: number): void;
+    getUsage(): {
+        tokensUsed: number;
+        tokensRemaining: number;
+        requestsUsed: number;
+        requestsRemaining: number;
+        resetIn: number;
+        queueLength: number;
+    };
+    clearQueue(): void;
+    reset(): void;
+    private canExecute;
+    private executeNow;
+    private enqueue;
+    private processQueue;
+    private maybeResetWindow;
+    private getResetTime;
+    private getRetryAfter;
+    private sleep;
+}
+export declare class RateLimitExceededError extends Error {
+    readonly retryAfter: number;
+    constructor(retryAfter: number);
+}
+export declare const PROVIDER_RATE_LIMITS: Record<string, Partial<TokenRateLimitConfig>>;
+export declare function createRateLimiter(providerTier?: string, overrides?: Partial<TokenRateLimitConfig>): TokenRateLimiter;
+export declare const tokenEstimators: {
+    estimateMessage(content: string): number;
+    estimateChatTokens(options: ChatOptions): number;
+};

package/dist/browser/ai/rate-limiter.js

@@ -0,0 +1,215 @@
+import { QueueCancelledError } from '../core/errors.js';
+const DEFAULT_LIMITS = {
+    tokensPerMinute: 90000,
+    requestsPerMinute: 500,
+    strategy: 'queue',
+    priority: () => 'normal',
+};
+const TOKEN_ESTIMATORS = {
+    estimateMessage(content) {
+        if (!content)
+            return 0;
+        return Math.ceil(content.length / 4);
+    },
+    estimateChatTokens(options) {
+        let tokens = 0;
+        for (const msg of options.messages) {
+            if (typeof msg.content === 'string') {
+                tokens += this.estimateMessage(msg.content);
+            }
+            else if (Array.isArray(msg.content)) {
+                for (const part of msg.content) {
+                    if (part.type === 'text') {
+                        tokens += this.estimateMessage(part.text);
+                    }
+                    else if (part.type === 'image' || part.type === 'image_url') {
+                        tokens += 1000;
+                    }
+                }
+            }
+        }
+        if (options.systemPrompt) {
+            tokens += this.estimateMessage(options.systemPrompt);
+        }
+        tokens += options.maxTokens || 1000;
+        if (options.tools?.length) {
+            tokens += options.tools.length * 100;
+        }
+        return tokens;
+    },
+};
+export class TokenRateLimiter {
+    config;
+    state;
+    queue = [];
+    processing = false;
+    nextId = 0;
+    constructor(config = {}) {
+        this.config = { ...DEFAULT_LIMITS, ...config };
+        this.state = {
+            tokenCount: 0,
+            requestCount: 0,
+            windowStart: Date.now(),
+        };
+    }
+    async execute(fn, options) {
+        const estimatedTokens = options?.estimatedTokens || 1000;
+        const priority = options?.priority || 'normal';
+        if (this.canExecute(estimatedTokens)) {
+            return this.executeNow(fn, estimatedTokens);
+        }
+        switch (this.config.strategy) {
+            case 'throw':
+                throw new RateLimitExceededError(this.getRetryAfter());
+            case 'retry-after':
+                const retryAfter = this.getRetryAfter();
+                await this.sleep(retryAfter);
+                return this.execute(fn, options);
+            case 'queue':
+            default:
+                return this.enqueue(fn, estimatedTokens, priority);
+        }
+    }
+    async executeChat(options, fn) {
+        const estimatedTokens = TOKEN_ESTIMATORS.estimateChatTokens(options);
+        const priority = this.config.priority(options);
+        return this.execute(fn, { estimatedTokens, priority });
+    }
+    recordUsage(actualTokens, estimatedTokens) {
+        const diff = actualTokens - estimatedTokens;
+        this.state.tokenCount += diff;
+        if (this.state.tokenCount < 0) {
+            this.state.tokenCount = 0;
+        }
+    }
+    getUsage() {
+        this.maybeResetWindow();
+        return {
+            tokensUsed: this.state.tokenCount,
+            tokensRemaining: Math.max(0, this.config.tokensPerMinute - this.state.tokenCount),
+            requestsUsed: this.state.requestCount,
+            requestsRemaining: Math.max(0, this.config.requestsPerMinute - this.state.requestCount),
+            resetIn: this.getResetTime(),
+            queueLength: this.queue.length,
+        };
+    }
+    clearQueue() {
+        for (const req of this.queue) {
+            req.reject(new QueueCancelledError('Queue cleared', {
+                queueName: 'ai-rate-limiter',
+            }));
+        }
+        this.queue = [];
+    }
+    reset() {
+        this.state = {
+            tokenCount: 0,
+            requestCount: 0,
+            windowStart: Date.now(),
+        };
+        this.clearQueue();
+    }
+    canExecute(estimatedTokens) {
+        this.maybeResetWindow();
+        const hasTokenBudget = this.state.tokenCount + estimatedTokens <= this.config.tokensPerMinute;
+        const hasRequestBudget = this.state.requestCount + 1 <= this.config.requestsPerMinute;
+        return hasTokenBudget && hasRequestBudget;
+    }
+    async executeNow(fn, estimatedTokens) {
+        this.state.tokenCount += estimatedTokens;
+        this.state.requestCount++;
+        return fn();
+    }
+    enqueue(fn, estimatedTokens, priority) {
+        return new Promise((resolve, reject) => {
+            const request = {
+                id: `req-${this.nextId++}`,
+                priority,
+                estimatedTokens,
+                execute: fn,
+                resolve,
+                reject,
+                enqueueTime: Date.now(),
+            };
+            let insertIndex = this.queue.length;
+            const priorityOrder = { high: 0, normal: 1, low: 2 };
+            for (let i = 0; i < this.queue.length; i++) {
+                if (priorityOrder[priority] < priorityOrder[this.queue[i].priority]) {
+                    insertIndex = i;
+                    break;
+                }
+            }
+            this.queue.splice(insertIndex, 0, request);
+            this.processQueue();
+        });
+    }
+    async processQueue() {
+        if (this.processing)
+            return;
+        this.processing = true;
+        try {
+            while (this.queue.length > 0) {
+                const next = this.queue[0];
+                while (!this.canExecute(next.estimatedTokens)) {
+                    const waitTime = this.getRetryAfter();
+                    await this.sleep(Math.min(waitTime, 1000));
+                    this.maybeResetWindow();
+                }
+                this.queue.shift();
+                try {
+                    const result = await this.executeNow(next.execute, next.estimatedTokens);
+                    next.resolve(result);
+                }
+                catch (error) {
+                    next.reject(error);
+                }
+            }
+        }
+        finally {
+            this.processing = false;
+        }
+    }
+    maybeResetWindow() {
+        const now = Date.now();
+        const windowDuration = 60000;
+        if (now - this.state.windowStart >= windowDuration) {
+            this.state.tokenCount = 0;
+            this.state.requestCount = 0;
+            this.state.windowStart = now;
+        }
+    }
+    getResetTime() {
+        const windowDuration = 60000;
+        return Math.max(0, windowDuration - (Date.now() - this.state.windowStart));
+    }
+    getRetryAfter() {
+        return this.getResetTime();
+    }
+    sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+}
+export class RateLimitExceededError extends Error {
+    retryAfter;
+    constructor(retryAfter) {
+        super(`Rate limit exceeded. Retry after ${retryAfter}ms`);
+        this.retryAfter = retryAfter;
+        this.name = 'RateLimitExceededError';
+    }
+}
+export const PROVIDER_RATE_LIMITS = {
+    'openai-tier1': { tokensPerMinute: 200000, requestsPerMinute: 500 },
+    'openai-tier2': { tokensPerMinute: 450000, requestsPerMinute: 5000 },
+    'openai-tier3': { tokensPerMinute: 600000, requestsPerMinute: 5000 },
+    'openai-tier4': { tokensPerMinute: 800000, requestsPerMinute: 10000 },
+    'openai-tier5': { tokensPerMinute: 10000000, requestsPerMinute: 10000 },
+    'anthropic-tier1': { tokensPerMinute: 80000, requestsPerMinute: 50 },
+    'anthropic-tier2': { tokensPerMinute: 160000, requestsPerMinute: 1000 },
+    'anthropic-tier3': { tokensPerMinute: 400000, requestsPerMinute: 2000 },
+    'anthropic-tier4': { tokensPerMinute: 800000, requestsPerMinute: 4000 },
+};
+export function createRateLimiter(providerTier, overrides) {
+    const baseConfig = providerTier ? PROVIDER_RATE_LIMITS[providerTier] || {} : {};
+    return new TokenRateLimiter({ ...baseConfig, ...overrides });
+}
+export const tokenEstimators = TOKEN_ESTIMATORS;

package/dist/browser/ai/vector/index.d.ts

@@ -0,0 +1,2 @@
+export * from './similarity.js';
+export * from './store.js';

package/dist/browser/ai/vector/index.js

@@ -0,0 +1,2 @@
+export * from './similarity.js';
+export * from './store.js';

package/dist/browser/ai/vector/similarity.d.ts

@@ -0,0 +1,2 @@
+export declare function cosineSimilarity(a: number[], b: number[]): number;
+export declare function euclideanDistance(a: number[], b: number[]): number;

package/dist/browser/ai/vector/similarity.js

@@ -0,0 +1,27 @@
+export function cosineSimilarity(a, b) {
+    if (a.length !== b.length) {
+        throw new Error(`Vector dimension mismatch: ${a.length} vs ${b.length}`);
+    }
+    let dot = 0;
+    let normA = 0;
+    let normB = 0;
+    for (let i = 0; i < a.length; i++) {
+        dot += a[i] * b[i];
+        normA += a[i] * a[i];
+        normB += b[i] * b[i];
+    }
+    if (normA === 0 || normB === 0)
+        return 0;
+    return dot / (Math.sqrt(normA) * Math.sqrt(normB));
+}
+export function euclideanDistance(a, b) {
+    if (a.length !== b.length) {
+        throw new Error(`Vector dimension mismatch: ${a.length} vs ${b.length}`);
+    }
+    let sum = 0;
+    for (let i = 0; i < a.length; i++) {
+        const diff = a[i] - b[i];
+        sum += diff * diff;
+    }
+    return Math.sqrt(sum);
+}

package/dist/browser/ai/vector/store.d.ts

@@ -0,0 +1,27 @@
+import type { AIClient } from '../../types/ai.js';
+export interface VectorDocument {
+    id: string;
+    content: string;
+    embedding?: number[];
+    metadata?: Record<string, unknown>;
+}
+export interface SearchResult extends VectorDocument {
+    score: number;
+}
+export interface VectorStoreOptions {
+    client?: AIClient;
+    model?: string;
+}
+export declare class MemoryVectorStore {
+    private documents;
+    private client?;
+    private model?;
+    constructor(options?: VectorStoreOptions);
+    add(docs: Array<Partial<VectorDocument> & {
+        content: string;
+    }>): Promise<void>;
+    search(query: string, limit?: number, threshold?: number): Promise<SearchResult[]>;
+    delete(id: string): boolean;
+    clear(): void;
+    get count(): number;
+}