codehere 0.2.2 → 0.3.0-rc.1

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

@@ -1,444 +0,0 @@
-/**
- * Provider Layer: CohereProvider
- * Thin wrapper implementing IModelProvider for Cohere API
- *
- * Phase 4A: Foundation Implementation (No Behavior Change)
- *
- * TODO: In Phase 4B, integrate with CohereAIService context compression and prompt building.
- * For now, this is a minimal wrapper that preserves existing Cohere behavior.
- */
-import { CohereClient } from 'cohere-ai';
-import { config } from 'dotenv';
-import { join, dirname } from 'path';
-import { fileURLToPath } from 'url';
-import { encoding_for_model } from 'tiktoken';
-import { retryWithBackoff, cohereCircuitBreaker } from '../../error-handler.js';
-// Load .env (same pattern as CohereAIService)
-try {
-    const __filename = fileURLToPath(import.meta.url);
-    const __dirname = dirname(__filename);
-    const agentDir = join(__dirname, '../../../..');
-    config({ path: join(agentDir, '.env') });
-}
-catch { }
-config();
-// Token counting (same as CohereAIService for consistency)
-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);
-    }
-}
-/**
- * Cohere Provider
- * Minimal wrapper around CohereClient implementing IModelProvider
- */
-export class CohereProvider {
-    id = 'cohere';
-    name = 'Cohere';
-    capabilities = {
-        chat: true,
-        streaming: true,
-        embedding: true,
-        embeddingQuery: true, // Cohere supports separate query embeddings
-        rerank: true,
-        toolCalling: true, // Cohere supports tool calling
-    };
-    client;
-    constructor(apiKey) {
-        const key = apiKey || process.env.COHERE_API_KEY;
-        if (!key) {
-            throw new Error('COHERE_API_KEY not found in environment');
-        }
-        this.client = new CohereClient({ token: key });
-    }
-    async getModels() {
-        // TODO: In Phase 4B, fetch available models from Cohere API if possible
-        // For now, return known Cohere models (updated Sept 2025 - removed deprecated models)
-        return [
-            {
-                id: 'command-r-08-2024',
-                name: 'Command R (08-2024)',
-                providerId: 'cohere',
-                providerModelId: 'command-r-08-2024',
-                contextWindow: 128000,
-                capabilities: {
-                    chat: true,
-                    streaming: true,
-                    embedding: false,
-                    embeddingQuery: false,
-                    rerank: false,
-                    toolCalling: true,
-                },
-            },
-            {
-                id: 'command-r-plus-08-2024',
-                name: 'Command R+ (08-2024)',
-                providerId: 'cohere',
-                providerModelId: 'command-r-plus-08-2024',
-                contextWindow: 128000,
-                capabilities: {
-                    chat: true,
-                    streaming: true,
-                    embedding: false,
-                    embeddingQuery: false,
-                    rerank: false,
-                    toolCalling: true,
-                },
-            },
-            {
-                id: 'command-a-03-2025',
-                name: 'Command A (03-2025)',
-                providerId: 'cohere',
-                providerModelId: 'command-a-03-2025',
-                contextWindow: 256000,
-                capabilities: {
-                    chat: true,
-                    streaming: true,
-                    embedding: false,
-                    embeddingQuery: false,
-                    rerank: false,
-                    toolCalling: true,
-                },
-            },
-            {
-                id: 'command-r7b-12-2024',
-                name: 'Command R7B (12-2024)',
-                providerId: 'cohere',
-                providerModelId: 'command-r7b-12-2024',
-                contextWindow: 128000,
-                capabilities: {
-                    chat: true,
-                    streaming: true,
-                    embedding: false,
-                    embeddingQuery: false,
-                    rerank: false,
-                    toolCalling: true,
-                },
-            },
-            {
-                id: 'embed-english-v3',
-                name: 'Embed English v3.0',
-                providerId: 'cohere',
-                providerModelId: 'embed-english-v3.0',
-                contextWindow: 512,
-                capabilities: {
-                    chat: false,
-                    streaming: false,
-                    embedding: true,
-                    embeddingQuery: true,
-                    rerank: false,
-                    toolCalling: false,
-                },
-            },
-            {
-                id: 'rerank-english-v3',
-                name: 'Rerank English v3.0',
-                providerId: 'cohere',
-                providerModelId: 'rerank-english-v3.0',
-                contextWindow: 4096,
-                capabilities: {
-                    chat: false,
-                    streaming: false,
-                    embedding: false,
-                    embeddingQuery: false,
-                    rerank: true,
-                    toolCalling: false,
-                },
-            },
-        ];
-    }
-    getDefaultModel() {
-        // Check for environment variable override
-        if (process.env.CODEHERE_COHERE_MODEL) {
-            return process.env.CODEHERE_COHERE_MODEL;
-        }
-        // Use command-r-08-2024 as default (command-r and command-r-plus were deprecated Sept 2025)
-        // Available live models: command-r-08-2024, command-r-plus-08-2024, command-a-03-2025, command-r7b-12-2024
-        return 'command-r-08-2024';
-    }
-    async chat(prompt, options) {
-        const model = options?.model || this.getDefaultModel();
-        return await retryWithBackoff(async () => {
-            return await cohereCircuitBreaker.execute(async () => {
-                const response = await this.client.chat({
-                    message: prompt,
-                    ...(model ? { model } : {}),
-                    temperature: options?.temperature ?? 0.7,
-                    ...(options?.maxTokens ? { maxTokens: options.maxTokens } : {}),
-                });
-                const text = response.text || 'No response generated';
-                const inputTokens = countTokens(prompt);
-                const outputTokens = countTokens(text);
-                return {
-                    text,
-                    model: model || 'default',
-                    usage: {
-                        inputTokens,
-                        outputTokens,
-                    },
-                };
-            });
-        }, {
-            maxRetries: 5,
-            baseDelay: 2000,
-            maxDelay: 60000,
-            operationName: 'cohere-provider-chat',
-        });
-    }
-    async chatStream(prompt, options, onEvent) {
-        const model = options?.model || this.getDefaultModel();
-        let fullText = '';
-        try {
-            if (onEvent) {
-                onEvent({ type: 'start' });
-            }
-            // Check if Cohere SDK supports streaming
-            if (typeof this.client.chatStream === 'function') {
-                const stream = await this.client.chatStream({
-                    message: prompt,
-                    ...(model ? { model } : {}),
-                    temperature: options?.temperature ?? 0.7,
-                });
-                for await (const event of stream) {
-                    if (event.eventType === 'text-generation' || event.type === 'text') {
-                        const token = event.text || event.delta || '';
-                        if (token) {
-                            fullText += token;
-                            if (onEvent) {
-                                onEvent({ type: 'delta', text: token });
-                            }
-                        }
-                    }
-                }
-            }
-            else {
-                // Fallback: Use regular chat
-                const response = await this.chat(prompt, options);
-                fullText = response.text;
-                // Simulate streaming by sending chunks
-                if (onEvent && fullText.length > 0) {
-                    const chunkSize = 10;
-                    for (let i = 0; i < fullText.length; i += chunkSize) {
-                        const chunk = fullText.substring(i, i + chunkSize);
-                        onEvent({ type: 'delta', text: chunk });
-                        if (fullText.length > chunkSize * 2) {
-                            await new Promise(resolve => setTimeout(resolve, 50));
-                        }
-                    }
-                }
-            }
-            if (onEvent) {
-                onEvent({ type: 'complete' });
-            }
-            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 () => {
-            return await cohereCircuitBreaker.execute(async () => {
-                const response = await this.client.embed({
-                    texts,
-                    model: 'embed-english-v3.0',
-                    inputType: 'search_document',
-                });
-                const embeddings = response.embeddings;
-                if (texts.length === 1) {
-                    return embeddings[0];
-                }
-                return embeddings;
-            });
-        }, {
-            maxRetries: 5,
-            baseDelay: 2000,
-            maxDelay: 60000,
-            operationName: 'cohere-provider-embed',
-        });
-    }
-    async embedQuery(query) {
-        return await retryWithBackoff(async () => {
-            return await cohereCircuitBreaker.execute(async () => {
-                const response = await this.client.embed({
-                    texts: [query],
-                    model: 'embed-english-v3.0',
-                    inputType: 'search_query',
-                });
-                const embeddings = response.embeddings;
-                if (Array.isArray(embeddings)) {
-                    if (embeddings.length === 0) {
-                        throw new Error('No embedding returned for query');
-                    }
-                    return embeddings[0] || [];
-                }
-                else {
-                    const embeddingsArray = embeddings.float || [];
-                    if (embeddingsArray.length === 0) {
-                        throw new Error('No embedding returned for query');
-                    }
-                    return embeddingsArray[0] || [];
-                }
-            });
-        }, {
-            maxRetries: 5,
-            baseDelay: 2000,
-            maxDelay: 60000,
-            operationName: 'cohere-provider-embed-query',
-        });
-    }
-    async rerank(query, documents, options) {
-        if (documents.length === 0) {
-            return {
-                results: [],
-                model: 'rerank-english-v3.0',
-            };
-        }
-        // Cohere Rerank API has limits, so we cap at 100 documents
-        const documentsToRerank = documents.slice(0, 100);
-        const topN = Math.min(options?.topN ?? 10, documentsToRerank.length);
-        const model = options?.model || 'rerank-english-v3.0';
-        return await retryWithBackoff(async () => {
-            return await cohereCircuitBreaker.execute(async () => {
-                const response = await this.client.rerank({
-                    model,
-                    query,
-                    documents: documentsToRerank,
-                    topN,
-                });
-                const results = (response.results || []).map((result) => ({
-                    index: result.index,
-                    relevanceScore: result.relevanceScore || 0,
-                }));
-                return {
-                    results,
-                    model,
-                };
-            });
-        }, {
-            maxRetries: 3,
-            baseDelay: 2000,
-            maxDelay: 30000,
-            operationName: 'cohere-provider-rerank',
-        });
-    }
-    async countTokens(text, _model) {
-        // TODO: In Phase 4B, use Cohere-specific tokenizer if available
-        // For now, use same tiktoken approach as CohereAIService
-        return Promise.resolve(countTokens(text));
-    }
-    async isAvailable() {
-        try {
-            // Actually test API connectivity with a minimal API call
-            // getModels() doesn't make an API call, so we need to test with a real endpoint
-            const response = await this.client.chat({
-                message: 'test',
-                model: 'command-r-08-2024',
-                maxTokens: 1,
-            });
-            return true;
-        }
-        catch (error) {
-            // Check if it's an auth error (401) - means API is reachable but key is invalid
-            if (error?.statusCode === 401 || error?.status === 401) {
-                return false; // Invalid key
-            }
-            // Other errors might be network issues, but we'll be conservative
-            return false;
-        }
-    }
-    handleError(error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        const lowerMessage = errorMessage.toLowerCase();
-        if (error && typeof error === 'object') {
-            const err = error;
-            // Check for rate limiting (429) - check both statusCode/status and message
-            if (err.statusCode === 429 || err.status === 429 ||
-                lowerMessage.includes('429') ||
-                lowerMessage.includes('rate limit') ||
-                lowerMessage.includes('rate_limit')) {
-                return {
-                    type: 'rate_limit',
-                    retryable: false,
-                    message: 'Rate limit exceeded',
-                };
-            }
-            // Check for authentication errors (401) - check both statusCode/status and message
-            if (err.statusCode === 401 || err.status === 401 ||
-                lowerMessage.includes('401') ||
-                lowerMessage.includes('unauthorized') ||
-                lowerMessage.includes('invalid api token') ||
-                lowerMessage.includes('invalid api key')) {
-                return {
-                    type: 'auth_error',
-                    retryable: false,
-                    message: 'Authentication failed - check API key',
-                };
-            }
-            // Check for trial key quota
-            if (lowerMessage.includes('trial key') && lowerMessage.includes('1000 api calls')) {
-                return {
-                    type: 'quota_exceeded',
-                    retryable: false,
-                    message: 'Trial API key has reached monthly limit (1000 calls/month)',
-                };
-            }
-            // Check for quota exceeded
-            if (lowerMessage.includes('quota') || lowerMessage.includes('insufficient_quota')) {
-                return {
-                    type: 'quota_exceeded',
-                    retryable: false,
-                    message: 'API quota exceeded',
-                };
-            }
-        }
-        // Network errors
-        if (lowerMessage.includes('network') || lowerMessage.includes('timeout') || lowerMessage.includes('econnrefused')) {
-            return {
-                type: 'network_error',
-                retryable: true,
-                message: errorMessage,
-            };
-        }
-        // Default to retryable error
-        return {
-            type: 'unknown',
-            retryable: true,
-            message: errorMessage,
-        };
-    }
-}
-//# sourceMappingURL=cohere-provider.js.map

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

@@ -1,130 +0,0 @@
-/**
- * Provider Layer: FakeProvider
- * Deterministic test provider implementing IModelProvider
- *
- * Phase 4D: FakeProvider Implementation
- * Provides deterministic outputs for testing and local demos without external API calls
- */
-/**
- * FakeProvider
- * Deterministic provider for testing and demos
- *
- * Behavior:
- * - Chat: Returns deterministic responses based on query
- * - Streaming: Simulates streaming by sending words incrementally
- * - Embeddings: Returns fixed-size zero vectors (768 dimensions)
- * - Rerank: Returns documents in original order with fake scores
- * - No external HTTP calls
- */
-export class FakeProvider {
-    id = 'fake';
-    name = 'Fake Provider';
-    capabilities = {
-        chat: true,
-        streaming: true,
-        embedding: true,
-        embeddingQuery: true,
-        rerank: true,
-        toolCalling: false,
-    };
-    defaultModel = 'fake-model-v1';
-    async getModels() {
-        return [
-            {
-                id: 'fake-model-v1',
-                name: 'Fake Model v1',
-                providerId: this.id,
-                providerModelId: 'fake-model-v1',
-                contextWindow: 4096,
-                capabilities: { ...this.capabilities },
-            },
-        ];
-    }
-    getDefaultModel() {
-        return this.defaultModel;
-    }
-    async chat(prompt, options) {
-        // Deterministic response based on prompt
-        // Truncate prompt to first 80 chars for consistency with FakeAIService
-        const promptPreview = prompt.length > 80 ? prompt.substring(0, 80) + '...' : prompt;
-        const text = `FAKE_RESPONSE: ${promptPreview}`;
-        // Simple token counting (character-based estimate)
-        const inputTokens = Math.ceil(prompt.length / 4);
-        const outputTokens = Math.ceil(text.length / 4);
-        return {
-            text,
-            model: options?.model || this.defaultModel,
-            usage: {
-                inputTokens,
-                outputTokens,
-            },
-            finishReason: 'stop',
-        };
-    }
-    async chatStream(prompt, options, onEvent) {
-        // Get the full response first
-        const response = await this.chat(prompt, options);
-        if (onEvent) {
-            onEvent({ type: 'start' });
-            // Simulate streaming by sending words incrementally
-            const words = response.text.split(' ');
-            for (let i = 0; i < words.length; i++) {
-                const word = words[i];
-                const isLast = i === words.length - 1;
-                const delta = isLast ? word : word + ' ';
-                // Small delay to simulate streaming
-                await new Promise(resolve => setTimeout(resolve, 10));
-                onEvent({ type: 'delta', text: delta });
-            }
-            onEvent({ type: 'complete', text: response.text });
-        }
-        return response;
-    }
-    async embed(text) {
-        // Return deterministic fake embeddings (all zeros, 768 dimensions)
-        // Matches FakeAIService behavior
-        const embeddingSize = 768;
-        if (Array.isArray(text)) {
-            return text.map(() => new Array(embeddingSize).fill(0));
-        }
-        return new Array(embeddingSize).fill(0);
-    }
-    async embedQuery(query) {
-        // Return deterministic fake query embedding (768 dimensions)
-        // Matches FakeAIService behavior
-        return new Array(768).fill(0);
-    }
-    async rerank(query, documents, options) {
-        // Return documents in original order with fake decreasing scores
-        // Matches FakeAIService behavior: 0.9, 0.8, 0.7, ...
-        const topN = Math.min(options?.topN || 10, documents.length);
-        const results = Array.from({ length: topN }, (_, i) => ({
-            index: i,
-            relevanceScore: 0.9 - (i * 0.1),
-            text: documents[i],
-        }));
-        return {
-            results,
-            model: options?.model || this.defaultModel,
-        };
-    }
-    async countTokens(text, _model) {
-        // Simple character-based token estimation (4 chars per token)
-        // Matches behavior used in other providers
-        return Math.ceil(text.length / 4);
-    }
-    async isAvailable() {
-        // Fake provider is always available (no external dependencies)
-        return true;
-    }
-    handleError(error) {
-        // Fake provider shouldn't have errors, but handle gracefully
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        return {
-            type: 'unknown',
-            retryable: false,
-            message: `FakeProvider error: ${errorMessage}`,
-        };
-    }
-}
-//# sourceMappingURL=fake-provider.js.map