codehere 0.2.2 → 0.3.0-rc.10

package/dist/infrastructure/providers/local-llm-provider.js

@@ -1,330 +0,0 @@
-/**
- * Provider Layer: LocalLLMProvider
- * OpenAI-compatible local LLM provider (Ollama, LM Studio, on-prem gateways)
- *
- * Phase 4E: Local LLM Provider Implementation
- * Supports any OpenAI-compatible endpoint for chat and embeddings
- */
-import { retryWithBackoff } from '../../error-handler.js';
-import { encoding_for_model } from 'tiktoken';
-// Token counting (tiktoken for OpenAI-compatible models)
-let tokenEncoder = null;
-function getTokenEncoder() {
-    if (!tokenEncoder) {
-        try {
-            tokenEncoder = encoding_for_model('gpt-3.5-turbo'); // OpenAI-compatible encoding
-        }
-        catch {
-            tokenEncoder = encoding_for_model('gpt-4'); // Fallback
-        }
-    }
-    return tokenEncoder;
-}
-function countTokens(text) {
-    try {
-        const encoder = getTokenEncoder();
-        return encoder.encode(text).length;
-    }
-    catch (error) {
-        console.warn('Warning: tiktoken failed for LocalLLMProvider, using character-based estimate (less accurate)');
-        return Math.ceil(text.length / 4);
-    }
-}
-/**
- * LocalLLMProvider
- * Implements IModelProvider for OpenAI-compatible local endpoints
- *
- * Designed for:
- * - Ollama (http://localhost:11434)
- * - LM Studio (http://localhost:1234)
- * - On-prem OpenAI-compatible gateways
- *
- * API Assumptions:
- * - POST {baseUrl}/v1/chat/completions (OpenAI-compatible)
- * - POST {baseUrl}/v1/embeddings (OpenAI-compatible)
- * - Streaming via Server-Sent Events (SSE) if supported
- */
-export class LocalLLMProvider {
-    id = 'local';
-    name = 'Local LLM Provider';
-    capabilities = {
-        chat: true,
-        streaming: true, // Assume streaming is supported (will gracefully fall back if not)
-        embedding: true,
-        embeddingQuery: false, // Local LLMs typically don't have separate query embeddings
-        rerank: false, // Local LLMs typically don't have rerank
-        toolCalling: false, // Not supported initially
-    };
-    baseUrl;
-    defaultChatModel;
-    defaultEmbedModel;
-    constructor(baseUrl, defaultChatModel, defaultEmbedModel) {
-        this.baseUrl = baseUrl || process.env.CODEHERE_LOCAL_BASE_URL || '';
-        if (!this.baseUrl) {
-            throw new Error('CODEHERE_LOCAL_BASE_URL not found in environment for LocalLLMProvider initialization.');
-        }
-        // Remove trailing slash if present
-        this.baseUrl = this.baseUrl.replace(/\/$/, '');
-        this.defaultChatModel = defaultChatModel || process.env.CODEHERE_LOCAL_MODEL || 'local-default';
-        this.defaultEmbedModel = defaultEmbedModel || process.env.CODEHERE_LOCAL_EMBED_MODEL || this.defaultChatModel;
-    }
-    async getModels() {
-        // Return a basic model info for the configured model
-        // In the future, could query the local endpoint for available models
-        return [
-            {
-                id: this.defaultChatModel,
-                name: `Local Model: ${this.defaultChatModel}`,
-                providerId: this.id,
-                providerModelId: this.defaultChatModel,
-                contextWindow: 4096, // Conservative default, actual may vary
-                capabilities: { ...this.capabilities },
-            },
-        ];
-    }
-    getDefaultModel() {
-        return this.defaultChatModel;
-    }
-    async chat(prompt, options) {
-        const model = options?.model || this.defaultChatModel;
-        return await retryWithBackoff(async () => {
-            const response = await fetch(`${this.baseUrl}/v1/chat/completions`, {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                },
-                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 = `Local LLM API error: ${response.status} ${errorText}`;
-                try {
-                    const errorJson = JSON.parse(errorText);
-                    errorMessage = errorJson.error?.message || errorMessage;
-                }
-                catch {
-                    // ignore
-                }
-                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: 3, // Fewer retries for local endpoints
-            baseDelay: 1000,
-            maxDelay: 5000,
-            operationName: 'local-llm-provider-chat',
-        });
-    }
-    async chatStream(prompt, options, onEvent) {
-        const model = options?.model || this.defaultChatModel;
-        let fullText = '';
-        try {
-            const response = await fetch(`${this.baseUrl}/v1/chat/completions`, {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                },
-                body: JSON.stringify({
-                    model,
-                    messages: [{ role: 'user', content: prompt }],
-                    temperature: options?.temperature ?? 0.7,
-                    max_tokens: options?.maxTokens,
-                    stream: true,
-                }),
-            });
-            if (!response.ok || !response.body) {
-                const errorText = await response.text();
-                let errorMessage = `Local LLM API error: ${response.status} ${errorText}`;
-                try {
-                    const errorJson = JSON.parse(errorText);
-                    errorMessage = errorJson.error?.message || errorMessage;
-                }
-                catch {
-                    // ignore
-                }
-                if (onEvent) {
-                    onEvent({ type: 'error', error: new Error(errorMessage) });
-                }
-                throw new Error(errorMessage);
-            }
-            if (onEvent) {
-                onEvent({ type: 'start' });
-            }
-            const reader = response.body.getReader();
-            const decoder = new TextDecoder('utf-8');
-            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.substring(6);
-                        if (data === '[DONE]') {
-                            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) {
-                            // Ignore parse errors for malformed SSE chunks
-                            console.warn('Error parsing stream chunk:', e);
-                        }
-                    }
-                }
-            }
-            if (onEvent) {
-                onEvent({ type: 'complete', text: fullText });
-            }
-            const inputTokens = await this.countTokens(prompt, model);
-            const outputTokens = await this.countTokens(fullText, model);
-            return {
-                text: fullText,
-                model: model,
-                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];
-        const model = this.defaultEmbedModel;
-        return await retryWithBackoff(async () => {
-            const response = await fetch(`${this.baseUrl}/v1/embeddings`, {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                },
-                body: JSON.stringify({
-                    model,
-                    input: texts,
-                }),
-            });
-            if (!response.ok) {
-                const errorText = await response.text();
-                throw new Error(`Local LLM 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: 3,
-            baseDelay: 1000,
-            maxDelay: 5000,
-            operationName: 'local-llm-provider-embed',
-        });
-    }
-    async embedQuery(query) {
-        // Local LLMs typically don't have separate query embeddings
-        // Fall back to regular embed
-        const result = await this.embed(query);
-        return Array.isArray(result[0]) ? result[0] : result;
-    }
-    rerank(_query, _documents, _options) {
-        // Local LLMs typically don't have rerank
-        // ProviderAIService will handle this gracefully by falling back to original order
-        throw new Error('LocalLLMProvider does not support rerank directly.');
-    }
-    async countTokens(text, _model) {
-        return Promise.resolve(countTokens(text));
-    }
-    async isAvailable() {
-        try {
-            // Simple availability check - try to list models or health check
-            // Many local endpoints have a /v1/models endpoint
-            const response = await fetch(`${this.baseUrl}/v1/models`, {
-                method: 'GET',
-            });
-            return response.ok;
-        }
-        catch {
-            // If /v1/models doesn't exist, try a simple chat completion check
-            try {
-                const response = await fetch(`${this.baseUrl}/v1/chat/completions`, {
-                    method: 'POST',
-                    headers: {
-                        'Content-Type': 'application/json',
-                    },
-                    body: JSON.stringify({
-                        model: this.defaultChatModel,
-                        messages: [{ role: 'user', content: 'test' }],
-                        max_tokens: 1,
-                    }),
-                });
-                return response.ok;
-            }
-            catch {
-                return false;
-            }
-        }
-    }
-    handleError(error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        // Network errors (connection refused, timeout)
-        if (errorMessage.includes('network') || errorMessage.includes('timeout') || errorMessage.includes('ECONNREFUSED') || errorMessage.includes('fetch failed')) {
-            return {
-                type: 'network_error',
-                retryable: true,
-                message: 'Network error connecting to local LLM endpoint',
-            };
-        }
-        // Invalid request (400, 404, etc.)
-        if (errorMessage.includes('400') || errorMessage.includes('404') || errorMessage.includes('invalid_request_error')) {
-            return {
-                type: 'invalid_request',
-                retryable: false,
-                message: 'Invalid request to local LLM API',
-            };
-        }
-        // Server errors (500, 502, 503)
-        if (errorMessage.includes('500') || errorMessage.includes('502') || errorMessage.includes('503')) {
-            return {
-                type: 'server_error',
-                retryable: true,
-                message: 'Local LLM server error',
-            };
-        }
-        // Default to unknown and retryable
-        return {
-            type: 'unknown',
-            retryable: true,
-            message: errorMessage,
-        };
-    }
-}
-//# sourceMappingURL=local-llm-provider.js.map

package/dist/infrastructure/providers/model-config.types.js

@@ -1,9 +0,0 @@
-/**
- * Provider Layer: Model Configuration Types
- * Provider-agnostic model configuration structures
- *
- * Phase 4A: Foundation Implementation (No Behavior Change)
- * Minimal types for internal use only - no CLI/config file changes yet
- */
-export {};
-//# sourceMappingURL=model-config.types.js.map

package/dist/infrastructure/providers/model-provider.interface.js

@@ -1,8 +0,0 @@
-/**
- * Provider Layer: IModelProvider Interface
- * Core abstraction for any AI model provider
- *
- * Phase 4A: Foundation Implementation (No Behavior Change)
- */
-export {};
-//# sourceMappingURL=model-provider.interface.js.map