codehere 0.2.2 → 0.3.0-rc.1

package/dist/infrastructure/providers/openai-provider.js

@@ -1,413 +0,0 @@
-/**
- * Provider Layer: OpenAIProvider
- * Implements IModelProvider for OpenAI API
- *
- * Phase 4C: OpenAI Provider Implementation
- *
- * Uses OpenAI REST API directly (no SDK dependency) to keep dependencies minimal.
- * Supports GPT-4, GPT-3.5, and text-embedding models.
- */
-import { config } from 'dotenv';
-import { join, dirname } from 'path';
-import { fileURLToPath } from 'url';
-import { encoding_for_model } from 'tiktoken';
-import { retryWithBackoff } from '../../error-handler.js';
-// Load .env (same pattern as CohereProvider)
-try {
-    const __filename = fileURLToPath(import.meta.url);
-    const __dirname = dirname(__filename);
-    const agentDir = join(__dirname, '../../../..');
-    config({ path: join(agentDir, '.env') });
-}
-catch { }
-config();
-// Token counting (using tiktoken - OpenAI's tokenizer)
-let tokenEncoder = null;
-function getTokenEncoder() {
-    if (!tokenEncoder) {
-        try {
-            tokenEncoder = encoding_for_model('gpt-3.5-turbo');
-        }
-        catch {
-            tokenEncoder = encoding_for_model('gpt-4');
-        }
-    }
-    return tokenEncoder;
-}
-function countTokens(text) {
-    try {
-        const encoder = getTokenEncoder();
-        return encoder.encode(text).length;
-    }
-    catch (error) {
-        console.warn('Warning: tiktoken failed, using character-based estimate (less accurate)');
-        return Math.ceil(text.length / 4);
-    }
-}
-/**
- * OpenAI Provider
- * Implements IModelProvider using OpenAI REST API
- */
-export class OpenAIProvider {
-    id = 'openai';
-    name = 'OpenAI';
-    capabilities = {
-        chat: true,
-        streaming: true,
-        embedding: true,
-        embeddingQuery: false, // OpenAI doesn't have separate query embeddings
-        rerank: false, // OpenAI doesn't have rerank API
-        toolCalling: true, // OpenAI supports function calling
-    };
-    apiKey;
-    baseUrl;
-    defaultChatModel;
-    defaultEmbedModel;
-    constructor(apiKey, baseUrl) {
-        const key = apiKey || process.env.CODEHERE_OPENAI_API_KEY || process.env.OPENAI_API_KEY;
-        if (!key) {
-            throw new Error('CODEHERE_OPENAI_API_KEY or OPENAI_API_KEY not found in environment');
-        }
-        this.apiKey = key;
-        this.baseUrl = baseUrl || process.env.OPENAI_BASE_URL || 'https://api.openai.com/v1';
-        this.defaultChatModel = process.env.CODEHERE_OPENAI_MODEL || 'gpt-4o-mini';
-        this.defaultEmbedModel = process.env.CODEHERE_OPENAI_EMBED_MODEL || 'text-embedding-3-small';
-    }
-    async getModels() {
-        // Return known OpenAI models (can be enhanced to fetch from API later)
-        return [
-            {
-                id: 'gpt-4o',
-                name: 'GPT-4o',
-                providerId: 'openai',
-                providerModelId: 'gpt-4o',
-                contextWindow: 128000,
-                capabilities: {
-                    chat: true,
-                    streaming: true,
-                    embedding: false,
-                    embeddingQuery: false,
-                    rerank: false,
-                    toolCalling: true,
-                },
-            },
-            {
-                id: 'gpt-4o-mini',
-                name: 'GPT-4o Mini',
-                providerId: 'openai',
-                providerModelId: 'gpt-4o-mini',
-                contextWindow: 128000,
-                capabilities: {
-                    chat: true,
-                    streaming: true,
-                    embedding: false,
-                    embeddingQuery: false,
-                    rerank: false,
-                    toolCalling: true,
-                },
-            },
-            {
-                id: 'gpt-4-turbo',
-                name: 'GPT-4 Turbo',
-                providerId: 'openai',
-                providerModelId: 'gpt-4-turbo',
-                contextWindow: 128000,
-                capabilities: {
-                    chat: true,
-                    streaming: true,
-                    embedding: false,
-                    embeddingQuery: false,
-                    rerank: false,
-                    toolCalling: true,
-                },
-            },
-            {
-                id: 'gpt-3.5-turbo',
-                name: 'GPT-3.5 Turbo',
-                providerId: 'openai',
-                providerModelId: 'gpt-3.5-turbo',
-                contextWindow: 16385,
-                capabilities: {
-                    chat: true,
-                    streaming: true,
-                    embedding: false,
-                    embeddingQuery: false,
-                    rerank: false,
-                    toolCalling: true,
-                },
-            },
-            {
-                id: 'text-embedding-3-small',
-                name: 'Text Embedding 3 Small',
-                providerId: 'openai',
-                providerModelId: 'text-embedding-3-small',
-                contextWindow: 8191,
-                capabilities: {
-                    chat: false,
-                    streaming: false,
-                    embedding: true,
-                    embeddingQuery: false,
-                    rerank: false,
-                    toolCalling: false,
-                },
-            },
-            {
-                id: 'text-embedding-3-large',
-                name: 'Text Embedding 3 Large',
-                providerId: 'openai',
-                providerModelId: 'text-embedding-3-large',
-                contextWindow: 8191,
-                capabilities: {
-                    chat: false,
-                    streaming: false,
-                    embedding: true,
-                    embeddingQuery: false,
-                    rerank: false,
-                    toolCalling: false,
-                },
-            },
-        ];
-    }
-    getDefaultModel() {
-        return this.defaultChatModel;
-    }
-    async chat(prompt, options) {
-        const model = options?.model || this.defaultChatModel;
-        return await retryWithBackoff(async () => {
-            const response = await fetch(`${this.baseUrl}/chat/completions`, {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                    'Authorization': `Bearer ${this.apiKey}`,
-                },
-                body: JSON.stringify({
-                    model,
-                    messages: [
-                        {
-                            role: 'user',
-                            content: prompt,
-                        },
-                    ],
-                    temperature: options?.temperature ?? 0.7,
-                    max_tokens: options?.maxTokens,
-                }),
-            });
-            if (!response.ok) {
-                const errorText = await response.text();
-                let errorMessage = `OpenAI API error: ${response.status} ${response.statusText}`;
-                try {
-                    const errorJson = JSON.parse(errorText);
-                    errorMessage = errorJson.error?.message || errorMessage;
-                }
-                catch {
-                    errorMessage = errorText || errorMessage;
-                }
-                throw new Error(errorMessage);
-            }
-            const data = await response.json();
-            const text = data.choices?.[0]?.message?.content || 'No response generated';
-            const usage = data.usage || {};
-            return {
-                text,
-                model: data.model || model,
-                usage: {
-                    inputTokens: usage.prompt_tokens || countTokens(prompt),
-                    outputTokens: usage.completion_tokens || countTokens(text),
-                },
-                finishReason: data.choices?.[0]?.finish_reason,
-            };
-        }, {
-            maxRetries: 5,
-            baseDelay: 2000,
-            maxDelay: 60000,
-            operationName: 'openai-provider-chat',
-        });
-    }
-    async chatStream(prompt, options, onEvent) {
-        const model = options?.model || this.defaultChatModel;
-        let fullText = '';
-        try {
-            if (onEvent) {
-                onEvent({ type: 'start' });
-            }
-            const response = await fetch(`${this.baseUrl}/chat/completions`, {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                    'Authorization': `Bearer ${this.apiKey}`,
-                },
-                body: JSON.stringify({
-                    model,
-                    messages: [
-                        {
-                            role: 'user',
-                            content: prompt,
-                        },
-                    ],
-                    temperature: options?.temperature ?? 0.7,
-                    max_tokens: options?.maxTokens,
-                    stream: true,
-                }),
-            });
-            if (!response.ok) {
-                const errorText = await response.text();
-                throw new Error(`OpenAI API error: ${response.status} ${errorText}`);
-            }
-            if (!response.body) {
-                throw new Error('No response body for streaming');
-            }
-            const reader = response.body.getReader();
-            const decoder = new TextDecoder();
-            while (true) {
-                const { done, value } = await reader.read();
-                if (done)
-                    break;
-                const chunk = decoder.decode(value, { stream: true });
-                const lines = chunk.split('\n').filter(line => line.trim() !== '');
-                for (const line of lines) {
-                    if (line.startsWith('data: ')) {
-                        const data = line.slice(6);
-                        if (data === '[DONE]') {
-                            if (onEvent) {
-                                onEvent({ type: 'complete', text: fullText });
-                            }
-                            break;
-                        }
-                        try {
-                            const json = JSON.parse(data);
-                            const delta = json.choices?.[0]?.delta?.content;
-                            if (delta) {
-                                fullText += delta;
-                                if (onEvent) {
-                                    onEvent({ type: 'delta', text: delta });
-                                }
-                            }
-                        }
-                        catch (e) {
-                            // Skip invalid JSON chunks
-                        }
-                    }
-                }
-            }
-            if (onEvent && !fullText) {
-                onEvent({ type: 'complete', text: fullText });
-            }
-            const inputTokens = countTokens(prompt);
-            const outputTokens = countTokens(fullText);
-            return {
-                text: fullText,
-                model: model || 'default',
-                usage: {
-                    inputTokens,
-                    outputTokens,
-                },
-            };
-        }
-        catch (error) {
-            if (onEvent) {
-                onEvent({
-                    type: 'error',
-                    error: error instanceof Error ? error : new Error(String(error)),
-                });
-            }
-            throw error;
-        }
-    }
-    async embed(text) {
-        const texts = Array.isArray(text) ? text : [text];
-        return await retryWithBackoff(async () => {
-            const response = await fetch(`${this.baseUrl}/embeddings`, {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                    'Authorization': `Bearer ${this.apiKey}`,
-                },
-                body: JSON.stringify({
-                    model: this.defaultEmbedModel,
-                    input: texts,
-                }),
-            });
-            if (!response.ok) {
-                const errorText = await response.text();
-                throw new Error(`OpenAI API error: ${response.status} ${errorText}`);
-            }
-            const data = await response.json();
-            const embeddings = data.data?.map((item) => item.embedding) || [];
-            if (texts.length === 1) {
-                return embeddings[0];
-            }
-            return embeddings;
-        }, {
-            maxRetries: 5,
-            baseDelay: 2000,
-            maxDelay: 60000,
-            operationName: 'openai-provider-embed',
-        });
-    }
-    async embedQuery(query) {
-        // OpenAI doesn't have separate query embeddings, use regular embed
-        const result = await this.embed(query);
-        return Array.isArray(result[0]) ? result[0] : result;
-    }
-    async countTokens(text, _model) {
-        return Promise.resolve(countTokens(text));
-    }
-    async isAvailable() {
-        try {
-            // Simple availability check - try a minimal API call
-            const response = await fetch(`${this.baseUrl}/models`, {
-                method: 'GET',
-                headers: {
-                    'Authorization': `Bearer ${this.apiKey}`,
-                },
-            });
-            return response.ok;
-        }
-        catch {
-            return false;
-        }
-    }
-    handleError(error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        const lowerMessage = errorMessage.toLowerCase();
-        // Rate limiting (429)
-        if (errorMessage.includes('429') || lowerMessage.includes('rate limit') || lowerMessage.includes('rate_limit')) {
-            return {
-                type: 'rate_limit',
-                retryable: false,
-                message: 'Rate limit exceeded',
-            };
-        }
-        // Authentication errors (401)
-        if (errorMessage.includes('401') || errorMessage.includes('Unauthorized')) {
-            return {
-                type: 'auth_error',
-                retryable: false,
-                message: 'Authentication failed - check API key',
-            };
-        }
-        // Quota exceeded (429 or specific messages)
-        if (errorMessage.includes('quota') || errorMessage.includes('insufficient_quota')) {
-            return {
-                type: 'quota_exceeded',
-                retryable: false,
-                message: 'API quota exceeded',
-            };
-        }
-        // Network errors
-        if (errorMessage.includes('network') || errorMessage.includes('timeout') || errorMessage.includes('ECONNREFUSED')) {
-            return {
-                type: 'network_error',
-                retryable: true,
-                message: errorMessage,
-            };
-        }
-        // Default to retryable
-        return {
-            type: 'unknown',
-            retryable: true,
-            message: errorMessage,
-        };
-    }
-}
-//# sourceMappingURL=openai-provider.js.map