@calliopelabs/cli 0.8.20 → 2.0.2

package/dist/providers.js

@@ -1,1146 +0,0 @@
-/**
- * Calliope CLI - LLM Providers
- *
- * Handles communication with different LLM providers.
- */
-import Anthropic from '@anthropic-ai/sdk';
-import { GoogleGenerativeAI } from '@google/generative-ai';
-import OpenAI from 'openai';
-import * as config from './config.js';
-import { withRetry } from './errors.js';
-import { getModelContextLimit } from './model-detection.js';
-import { DEFAULT_MODELS } from './types.js';
-/**
- * Extract text from MessageContent
- */
-function getTextContent(content) {
-    if (typeof content === 'string') {
-        return content;
-    }
-    return content
-        .filter(block => block.type === 'text')
-        .map(block => block.text)
-        .join('\n');
-}
-/**
- * Convert MessageContent to Anthropic content format
- */
-function toAnthropicContent(content) {
-    if (typeof content === 'string') {
-        return content;
-    }
-    return content.map(block => {
-        if (block.type === 'text') {
-            return { type: 'text', text: block.text };
-        }
-        else if (block.type === 'image') {
-            return {
-                type: 'image',
-                source: {
-                    type: 'base64',
-                    media_type: block.mediaType,
-                    data: block.data,
-                },
-            };
-        }
-        return { type: 'text', text: '' };
-    });
-}
-/**
- * Convert MessageContent to OpenAI content format
- */
-function toOpenAIContent(content) {
-    if (typeof content === 'string') {
-        return content;
-    }
-    return content.map(block => {
-        if (block.type === 'text') {
-            return { type: 'text', text: block.text };
-        }
-        else if (block.type === 'image') {
-            return {
-                type: 'image_url',
-                image_url: {
-                    url: `data:${block.mediaType};base64,${block.data}`,
-                },
-            };
-        }
-        return { type: 'text', text: '' };
-    });
-}
-// Constants
-const MAX_TOKENS = 8192;
-const MIN_OUTPUT_TOKENS = 1024; // Minimum output tokens to request
-const CONTEXT_BUFFER_PERCENT = 0.08; // 8% of context as safety buffer
-const CONTEXT_BUFFER_MIN = 5000; // Minimum 5k buffer
-// Debug logging helper
-const DEBUG = process.env.CALLIOPE_DEBUG === '1';
-function debugLog(message, ...args) {
-    if (DEBUG)
-        console.log(`[DEBUG] ${message}`, ...args);
-}
-/**
- * Estimate tokens from messages (conservative: ~3 chars per token)
- * Uses conservative estimation to avoid context overflow
- */
-function estimateInputTokens(messages, tools) {
-    let totalChars = 0;
-    for (const msg of messages) {
-        // Add per-message overhead (role, structure, etc.)
-        totalChars += 50;
-        if (typeof msg.content === 'string') {
-            totalChars += msg.content.length;
-        }
-        else if (Array.isArray(msg.content)) {
-            for (const block of msg.content) {
-                if (block.type === 'text') {
-                    totalChars += block.text.length;
-                }
-                else if (block.type === 'image') {
-                    // Images are roughly 85 tokens per tile (assuming ~750 tokens average)
-                    totalChars += 3000;
-                }
-            }
-        }
-        // Add overhead for tool calls in assistant messages
-        if (msg.toolCalls) {
-            totalChars += JSON.stringify(msg.toolCalls).length;
-        }
-    }
-    // Add tool definitions overhead
-    if (tools.length > 0) {
-        totalChars += JSON.stringify(tools).length;
-    }
-    // Very conservative estimate: 2.5 characters per token
-    // Plus 35% overhead for message structure, system prompt, and formatting
-    return Math.ceil((totalChars / 2.5) * 1.35);
-}
-/**
- * Calculate dynamic max_tokens based on available context space
- */
-function calculateMaxTokens(provider, model, messages, tools) {
-    const contextLimit = getModelContextLimit(provider, model);
-    const estimatedInput = estimateInputTokens(messages, tools);
-    // Use percentage-based buffer with minimum floor
-    const buffer = Math.max(CONTEXT_BUFFER_MIN, Math.ceil(contextLimit * CONTEXT_BUFFER_PERCENT));
-    const available = contextLimit - estimatedInput - buffer;
-    debugLog(`Context calculation: limit=${contextLimit}, input≈${estimatedInput}, buffer=${buffer}, available=${available}`);
-    // Ensure we have at least MIN_OUTPUT_TOKENS, up to MAX_TOKENS
-    if (available < MIN_OUTPUT_TOKENS) {
-        debugLog(`WARNING: Very limited output space (${available}), using minimum ${MIN_OUTPUT_TOKENS}`);
-        return MIN_OUTPUT_TOKENS;
-    }
-    return Math.min(MAX_TOKENS, available);
-}
-/**
- * Check if context needs summarization based on actual token usage
- * Call this with the input_tokens from the last API response
- */
-export function needsSummarization(provider, model, actualInputTokens) {
-    const contextLimit = getModelContextLimit(provider, model);
-    const threshold = contextLimit * 0.85; // Trigger summarization at 85% full
-    return actualInputTokens >= threshold;
-}
-/**
- * Get context health info
- */
-export function getContextHealth(provider, model, actualInputTokens) {
-    const limit = getModelContextLimit(provider, model);
-    const percent = Math.round((actualInputTokens / limit) * 100);
-    return {
-        limit,
-        used: actualInputTokens,
-        percent,
-        needsSummarization: actualInputTokens >= limit * 0.85,
-    };
-}
-/**
- * Estimate context usage before making a request (for pre-request summarization)
- * Uses conservative estimation since we don't have actual token counts yet
- */
-export function estimateContextUsage(provider, model, messages, tools) {
-    const estimated = estimateInputTokens(messages, tools);
-    const limit = getModelContextLimit(provider, model);
-    const percent = Math.round((estimated / limit) * 100);
-    return {
-        estimated,
-        limit,
-        percent,
-        needsSummarization: estimated >= limit * 0.80, // More aggressive threshold for estimates
-    };
-}
-// ============================================================================
-// LLM Response Validation
-// ============================================================================
-/** Maximum allowed content length (1MB) to prevent memory issues */
-const MAX_CONTENT_LENGTH = 1024 * 1024;
-/**
- * Validate and sanitize LLM response
- */
-function validateLLMResponse(response) {
-    // Ensure content is a string
-    if (response.content === null || response.content === undefined) {
-        response.content = '';
-    }
-    else if (typeof response.content !== 'string') {
-        response.content = String(response.content);
-    }
-    // Truncate if too long to prevent memory issues
-    if (response.content.length > MAX_CONTENT_LENGTH) {
-        debugLog('Response content truncated from', response.content.length, 'to', MAX_CONTENT_LENGTH);
-        response.content = response.content.slice(0, MAX_CONTENT_LENGTH) + '\n... [truncated]';
-    }
-    // Validate tool calls if present
-    if (response.toolCalls) {
-        response.toolCalls = response.toolCalls.filter(call => {
-            if (!call.id || typeof call.id !== 'string') {
-                debugLog('Invalid tool call: missing or invalid id', call);
-                return false;
-            }
-            if (!call.name || typeof call.name !== 'string') {
-                debugLog('Invalid tool call: missing or invalid name', call);
-                return false;
-            }
-            if (call.arguments === null || call.arguments === undefined) {
-                call.arguments = {};
-            }
-            return true;
-        });
-        if (response.toolCalls.length === 0) {
-            response.toolCalls = undefined;
-        }
-    }
-    // Ensure valid finish reason
-    if (!['stop', 'tool_use', 'length', 'error'].includes(response.finishReason)) {
-        response.finishReason = 'stop';
-    }
-    return response;
-}
-// ============================================================================
-/**
- * Models that require the Responses API instead of Chat Completions
- * These are OpenAI's newer reasoning models that only work with /v1/responses
- */
-const RESPONSES_API_MODELS = [
-    'o3',
-    'o3-mini',
-    'o3-pro',
-    'o4-mini',
-    'gpt-5',
-];
-/**
- * Check if a model requires the Responses API
- */
-function requiresResponsesAPI(model) {
-    return RESPONSES_API_MODELS.some(m => model.startsWith(m));
-}
-// API base URLs for OpenAI-compatible providers
-const PROVIDER_BASE_URLS = {
-    openrouter: 'https://openrouter.ai/api/v1',
-    together: 'https://api.together.xyz/v1',
-    groq: 'https://api.groq.com/openai/v1',
-    fireworks: 'https://api.fireworks.ai/inference/v1',
-    mistral: 'https://api.mistral.ai/v1',
-    ai21: 'https://api.ai21.com/studio/v1',
-    huggingface: 'https://api-inference.huggingface.co/v1',
-};
-/**
- * Convert messages to OpenAI format
- */
-function toOpenAIMessages(messages) {
-    return messages.map(m => {
-        if (m.role === 'tool') {
-            return {
-                role: 'tool',
-                tool_call_id: m.toolCallId || '',
-                content: typeof m.content === 'string' ? m.content : JSON.stringify(m.content),
-            };
-        }
-        if (m.toolCalls && m.toolCalls.length > 0) {
-            return {
-                role: 'assistant',
-                content: typeof m.content === 'string' ? m.content : (m.content ? JSON.stringify(m.content) : null),
-                tool_calls: m.toolCalls.map(tc => ({
-                    id: tc.id,
-                    type: 'function',
-                    function: {
-                        name: tc.name,
-                        arguments: JSON.stringify(tc.arguments),
-                    },
-                })),
-            };
-        }
-        // Handle multi-modal content for user messages
-        if (m.role === 'user' && Array.isArray(m.content)) {
-            return {
-                role: 'user',
-                content: toOpenAIContent(m.content),
-            };
-        }
-        return {
-            role: m.role,
-            content: typeof m.content === 'string' ? m.content : JSON.stringify(m.content),
-        };
-    });
-}
-/**
- * Convert tools to OpenAI format
- */
-function toOpenAITools(tools) {
-    return tools.map(t => ({
-        type: 'function',
-        function: {
-            name: t.name,
-            description: t.description,
-            parameters: t.parameters,
-        },
-    }));
-}
-/**
- * Parse tool calls from OpenAI response
- */
-function parseOpenAIToolCalls(toolCalls) {
-    if (!toolCalls)
-        return [];
-    const result = [];
-    for (const tc of toolCalls) {
-        let parsedArgs = {};
-        try {
-            parsedArgs = JSON.parse(tc.function.arguments);
-        }
-        catch (error) {
-            const parseError = error instanceof SyntaxError ? error.message : 'Unknown parse error';
-            throw new Error(`Invalid tool arguments from LLM: ${parseError}. Raw: ${tc.function.arguments.substring(0, 200)}`);
-        }
-        result.push({
-            id: tc.id,
-            name: tc.function.name,
-            arguments: parsedArgs,
-        });
-    }
-    return result;
-}
-/**
- * Get available providers based on configured API keys
- */
-export function getAvailableProviders() {
-    const providers = [];
-    if (config.getApiKey('anthropic'))
-        providers.push('anthropic');
-    if (config.getApiKey('google'))
-        providers.push('google');
-    if (config.getApiKey('openai'))
-        providers.push('openai');
-    if (config.getApiKey('openrouter'))
-        providers.push('openrouter');
-    if (config.getApiKey('together'))
-        providers.push('together');
-    if (config.getApiKey('groq'))
-        providers.push('groq');
-    if (config.getApiKey('mistral'))
-        providers.push('mistral');
-    if (config.getBaseUrl('ollama'))
-        providers.push('ollama');
-    if (config.getApiKey('ai21'))
-        providers.push('ai21');
-    if (config.getApiKey('huggingface'))
-        providers.push('huggingface');
-    if (config.getBaseUrl('litellm'))
-        providers.push('litellm');
-    return providers;
-}
-/**
- * Select the best available provider
- */
-export function selectProvider(preferred) {
-    if (preferred !== 'auto') {
-        // For Ollama/LiteLLM, check base URL instead of API key
-        if (preferred === 'ollama' || preferred === 'litellm') {
-            if (config.getBaseUrl(preferred))
-                return preferred;
-        }
-        else {
-            const key = config.getApiKey(preferred);
-            if (key)
-                return preferred;
-        }
-    }
-    // Auto-select: prefer Anthropic > OpenAI > Google > others
-    const priority = ['anthropic', 'openai', 'google', 'mistral', 'openrouter', 'together', 'groq', 'ollama', 'litellm'];
-    for (const p of priority) {
-        if (p === 'ollama' || p === 'litellm') {
-            if (config.getBaseUrl(p))
-                return p;
-        }
-        else if (config.getApiKey(p)) {
-            return p;
-        }
-    }
-    throw new Error('No API keys configured. Run `calliope --setup` to configure.');
-}
-/**
- * Chat with the selected provider (with automatic retry)
- */
-export async function chat(provider, messages, tools, model, onToken, onRetry) {
-    const actualProvider = selectProvider(provider);
-    const actualModel = model || DEFAULT_MODELS[actualProvider];
-    const doChat = async () => {
-        let response;
-        switch (actualProvider) {
-            case 'anthropic':
-                response = await chatAnthropic(messages, tools, actualModel, onToken);
-                break;
-            case 'google':
-                response = await chatGoogle(messages, tools, actualModel);
-                break;
-            case 'openai':
-                response = await chatOpenAI(messages, tools, actualModel, onToken);
-                break;
-            case 'openrouter':
-            case 'together':
-            case 'groq':
-            case 'fireworks':
-            case 'mistral':
-            case 'ai21':
-            case 'huggingface':
-            case 'ollama':
-            case 'litellm':
-                response = await chatOpenAICompatible(actualProvider, messages, tools, actualModel, onToken);
-                break;
-            default:
-                throw new Error(`Provider ${actualProvider} not implemented`);
-        }
-        // Validate and sanitize response before returning
-        return validateLLMResponse(response);
-    };
-    // Wrap with retry logic
-    return withRetry(doChat, {
-        maxRetries: 2,
-        initialDelayMs: 1000,
-        onRetry: onRetry,
-    });
-}
-/**
- * Chat with Anthropic Claude
- */
-async function chatAnthropic(messages, tools, model, onToken) {
-    const apiKey = config.getApiKey('anthropic');
-    if (!apiKey)
-        throw new Error('Anthropic API key not configured');
-    const client = new Anthropic({ apiKey });
-    // Extract system message
-    const systemMessage = messages.find(m => m.role === 'system');
-    const chatMessages = messages.filter(m => m.role !== 'system');
-    // Convert to Anthropic format
-    const anthropicMessages = chatMessages.map(m => {
-        if (m.role === 'tool') {
-            return {
-                role: 'user',
-                content: [{
-                        type: 'tool_result',
-                        tool_use_id: m.toolCallId || '',
-                        content: typeof m.content === 'string' ? m.content : JSON.stringify(m.content),
-                    }],
-            };
-        }
-        if (m.toolCalls && m.toolCalls.length > 0) {
-            const textContent = typeof m.content === 'string' ? m.content :
-                (Array.isArray(m.content) ? m.content.filter(b => b.type === 'text').map(b => b.text).join('\n') : '');
-            return {
-                role: 'assistant',
-                content: [
-                    ...(textContent ? [{ type: 'text', text: textContent }] : []),
-                    ...m.toolCalls.map(tc => ({
-                        type: 'tool_use',
-                        id: tc.id,
-                        name: tc.name,
-                        input: tc.arguments,
-                    })),
-                ],
-            };
-        }
-        // Handle multi-modal content for user messages
-        if (m.role === 'user' && Array.isArray(m.content)) {
-            return {
-                role: 'user',
-                content: toAnthropicContent(m.content),
-            };
-        }
-        const content = typeof m.content === 'string' ? m.content : JSON.stringify(m.content);
-        return {
-            role: m.role,
-            // Anthropic requires non-empty content for all non-final messages
-            content: content || '(continued)',
-        };
-    });
-    // Convert tools to Anthropic format
-    const anthropicTools = tools.map(t => ({
-        name: t.name,
-        description: t.description,
-        input_schema: t.parameters,
-    }));
-    // Calculate dynamic max_tokens based on available context space
-    const dynamicMaxTokens = calculateMaxTokens('anthropic', model, messages, tools);
-    debugLog(`Anthropic request: model=${model}, max_tokens=${dynamicMaxTokens}`);
-    // Use streaming if callback provided - handles both text and tool calls
-    if (onToken) {
-        let content = '';
-        let inputTokens = 0;
-        let outputTokens = 0;
-        const toolCalls = [];
-        let currentToolId = '';
-        let currentToolName = '';
-        let currentToolInput = '';
-        let finishReason = 'stop';
-        try {
-            const stream = await client.messages.stream({
-                model,
-                max_tokens: dynamicMaxTokens,
-                system: systemMessage ? getTextContent(systemMessage.content) : '',
-                messages: anthropicMessages,
-                tools: anthropicTools.length > 0 ? anthropicTools : undefined,
-            });
-            for await (const event of stream) {
-                if (event.type === 'content_block_start') {
-                    if (event.content_block.type === 'tool_use') {
-                        currentToolId = event.content_block.id;
-                        currentToolName = event.content_block.name;
-                        currentToolInput = '';
-                    }
-                }
-                else if (event.type === 'content_block_delta') {
-                    if (event.delta.type === 'text_delta') {
-                        const text = event.delta.text;
-                        content += text;
-                        onToken(text);
-                    }
-                    else if (event.delta.type === 'input_json_delta') {
-                        currentToolInput += event.delta.partial_json;
-                    }
-                }
-                else if (event.type === 'content_block_stop') {
-                    if (currentToolId && currentToolName) {
-                        try {
-                            toolCalls.push({
-                                id: currentToolId,
-                                name: currentToolName,
-                                arguments: JSON.parse(currentToolInput || '{}'),
-                            });
-                        }
-                        catch {
-                            toolCalls.push({
-                                id: currentToolId,
-                                name: currentToolName,
-                                arguments: {},
-                            });
-                        }
-                        currentToolId = '';
-                        currentToolName = '';
-                        currentToolInput = '';
-                    }
-                }
-                else if (event.type === 'message_delta') {
-                    if (event.usage) {
-                        outputTokens = event.usage.output_tokens;
-                    }
-                    if (event.delta.stop_reason === 'tool_use') {
-                        finishReason = 'tool_use';
-                    }
-                    else if (event.delta.stop_reason === 'max_tokens') {
-                        finishReason = 'length';
-                    }
-                }
-                else if (event.type === 'message_start' && event.message.usage) {
-                    inputTokens = event.message.usage.input_tokens;
-                }
-            }
-            return {
-                content,
-                toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
-                finishReason,
-                usage: { inputTokens, outputTokens },
-            };
-        }
-        catch (streamError) {
-            // Fall back to non-streaming on error
-            console.error('Anthropic streaming failed, falling back:', streamError);
-        }
-    }
-    // Non-streaming request
-    const response = await client.messages.create({
-        model,
-        max_tokens: dynamicMaxTokens,
-        system: systemMessage ? getTextContent(systemMessage.content) : '',
-        messages: anthropicMessages,
-        tools: anthropicTools.length > 0 ? anthropicTools : undefined,
-    });
-    // Parse response
-    let content = '';
-    const toolCalls = [];
-    for (const block of response.content) {
-        if (block.type === 'text') {
-            content += block.text;
-        }
-        else if (block.type === 'tool_use') {
-            toolCalls.push({
-                id: block.id,
-                name: block.name,
-                arguments: block.input,
-            });
-        }
-    }
-    // Map Anthropic stop reasons to our finish reasons
-    let finishReason = 'stop';
-    if (response.stop_reason === 'tool_use') {
-        finishReason = 'tool_use';
-    }
-    else if (response.stop_reason === 'max_tokens') {
-        finishReason = 'length';
-    }
-    return {
-        content,
-        toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
-        finishReason,
-        usage: {
-            inputTokens: response.usage.input_tokens,
-            outputTokens: response.usage.output_tokens,
-        },
-    };
-}
-/**
- * Chat with Google Gemini
- */
-async function chatGoogle(messages, tools, model) {
-    const apiKey = config.getApiKey('google');
-    if (!apiKey)
-        throw new Error('Google API key not configured');
-    const genAI = new GoogleGenerativeAI(apiKey);
-    const genModel = genAI.getGenerativeModel({ model });
-    // Build history (exclude last message)
-    const history = messages.slice(0, -1).filter(m => m.role !== 'system').map(m => ({
-        role: m.role === 'assistant' ? 'model' : 'user',
-        parts: [{ text: getTextContent(m.content) }],
-    }));
-    if (messages.length === 0) {
-        throw new Error('No messages provided');
-    }
-    const lastMessage = messages[messages.length - 1];
-    const systemMessage = messages.find(m => m.role === 'system');
-    const chat = genModel.startChat({
-        history,
-        systemInstruction: systemMessage ? getTextContent(systemMessage.content) : undefined,
-    });
-    // Convert last message to Gemini format (with image support)
-    const lastMessageParts = [];
-    if (typeof lastMessage.content === 'string') {
-        lastMessageParts.push({ text: lastMessage.content });
-    }
-    else {
-        for (const block of lastMessage.content) {
-            if (block.type === 'text') {
-                lastMessageParts.push({ text: block.text });
-            }
-            else if (block.type === 'image') {
-                lastMessageParts.push({
-                    inlineData: {
-                        mimeType: block.mediaType,
-                        data: block.data,
-                    },
-                });
-            }
-        }
-    }
-    const result = await chat.sendMessage(lastMessageParts);
-    const response = result.response;
-    const text = response.text();
-    // Check for function calls
-    const toolCalls = [];
-    const candidates = response.candidates || [];
-    for (const candidate of candidates) {
-        for (const part of candidate.content?.parts || []) {
-            if ('functionCall' in part && part.functionCall) {
-                toolCalls.push({
-                    id: `gemini_${Date.now()}_${Math.random().toString(36).slice(2)}`,
-                    name: part.functionCall.name,
-                    arguments: part.functionCall.args,
-                });
-            }
-        }
-    }
-    return {
-        content: text,
-        toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
-        finishReason: toolCalls.length > 0 ? 'tool_use' : 'stop',
-    };
-}
-/**
- * Convert messages to Responses API input format
- */
-function toResponsesInput(messages) {
-    const input = [];
-    for (const m of messages) {
-        if (m.role === 'system') {
-            // System messages become developer messages in Responses API
-            input.push({
-                role: 'developer',
-                content: typeof m.content === 'string' ? m.content : JSON.stringify(m.content),
-            });
-        }
-        else if (m.role === 'tool') {
-            // Tool results become function_call_output items
-            input.push({
-                type: 'function_call_output',
-                call_id: m.toolCallId || '',
-                output: typeof m.content === 'string' ? m.content : JSON.stringify(m.content),
-            });
-        }
-        else if (m.role === 'assistant') {
-            // Assistant messages with tool calls
-            if (m.toolCalls && m.toolCalls.length > 0) {
-                // First add any text content as a message
-                const textContent = typeof m.content === 'string' ? m.content :
-                    (Array.isArray(m.content) ? m.content.filter(b => b.type === 'text').map(b => b.text).join('\n') : '');
-                if (textContent) {
-                    input.push({
-                        role: 'assistant',
-                        content: textContent,
-                    });
-                }
-                // Then add each tool call as a function_call item
-                for (const tc of m.toolCalls) {
-                    input.push({
-                        type: 'function_call',
-                        call_id: tc.id,
-                        name: tc.name,
-                        arguments: JSON.stringify(tc.arguments),
-                    });
-                }
-            }
-            else {
-                input.push({
-                    role: 'assistant',
-                    content: typeof m.content === 'string' ? m.content : JSON.stringify(m.content),
-                });
-            }
-        }
-        else if (m.role === 'user') {
-            // Handle multi-modal content for user messages
-            if (Array.isArray(m.content)) {
-                const parts = [];
-                for (const block of m.content) {
-                    if (block.type === 'text') {
-                        parts.push({ type: 'input_text', text: block.text });
-                    }
-                    else if (block.type === 'image') {
-                        parts.push({
-                            type: 'input_image',
-                            image_url: { url: `data:${block.mediaType};base64,${block.data}` },
-                        });
-                    }
-                }
-                input.push({ role: 'user', content: parts });
-            }
-            else {
-                input.push({
-                    role: 'user',
-                    content: m.content,
-                });
-            }
-        }
-    }
-    return input;
-}
-/**
- * Convert tools to Responses API format
- */
-function toResponsesTools(tools) {
-    return tools.map(t => ({
-        type: 'function',
-        name: t.name,
-        description: t.description,
-        parameters: t.parameters,
-        strict: false,
-    }));
-}
-/**
- * Type guard for text delta events
- */
-function isTextDeltaEvent(event) {
-    return event.type === 'response.output_text.delta';
-}
-/**
- * Type guard for function call done events
- */
-function isFunctionCallDoneEvent(event) {
-    return event.type === 'response.function_call_arguments.done';
-}
-/**
- * Type guard for completed events
- */
-function isCompletedEvent(event) {
-    return event.type === 'response.completed';
-}
-/**
- * Type guard for function call output items
- */
-function isFunctionCallOutput(item) {
-    return item.type === 'function_call';
-}
-/**
- * Chat with OpenAI using the Responses API (for o3, o4-mini, etc.)
- */
-async function chatOpenAIResponses(messages, tools, model, onToken) {
-    const apiKey = config.getApiKey('openai');
-    if (!apiKey)
-        throw new Error('OpenAI API key not configured');
-    const client = new OpenAI({ apiKey });
-    const responsesInput = toResponsesInput(messages);
-    const responsesTools = toResponsesTools(tools);
-    // Calculate dynamic max_tokens based on available context space
-    const dynamicMaxTokens = calculateMaxTokens('openai', model, messages, tools);
-    debugLog(`OpenAI Responses API request: model=${model}, max_tokens=${dynamicMaxTokens}`);
-    // Use streaming if callback provided
-    if (onToken) {
-        let content = '';
-        const toolCalls = [];
-        let finishReason = 'stop';
-        let inputTokens = 0;
-        let outputTokens = 0;
-        try {
-            // Note: OpenAI SDK types don't fully match Responses API yet
-            // We use our own type definitions and cast through unknown for SDK interop
-            const streamParams = {
-                model,
-                input: responsesInput,
-                tools: responsesTools.length > 0 ? responsesTools : undefined,
-                max_output_tokens: dynamicMaxTokens,
-            };
-            const stream = client.responses.stream(streamParams);
-            for await (const event of stream) {
-                const typedEvent = event;
-                if (isTextDeltaEvent(typedEvent)) {
-                    content += typedEvent.delta;
-                    onToken(typedEvent.delta);
-                }
-                else if (isFunctionCallDoneEvent(typedEvent)) {
-                    toolCalls.push({
-                        id: typedEvent.call_id || `call_${Date.now()}`,
-                        name: typedEvent.name,
-                        arguments: JSON.parse(typedEvent.arguments || '{}'),
-                    });
-                    finishReason = 'tool_use';
-                }
-                else if (isCompletedEvent(typedEvent)) {
-                    const response = typedEvent.response;
-                    if (response?.usage) {
-                        inputTokens = response.usage.input_tokens || 0;
-                        outputTokens = response.usage.output_tokens || 0;
-                    }
-                    if (response?.status === 'incomplete') {
-                        finishReason = 'length';
-                    }
-                }
-            }
-            return {
-                content,
-                toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
-                finishReason,
-                usage: { inputTokens, outputTokens },
-            };
-        }
-        catch (streamError) {
-            debugLog('Responses API streaming failed, falling back to non-streaming:', streamError);
-        }
-    }
-    // Non-streaming request
-    const createParams = {
-        model,
-        input: responsesInput,
-        tools: responsesTools.length > 0 ? responsesTools : undefined,
-        max_output_tokens: dynamicMaxTokens,
-    };
-    const response = await client.responses.create(createParams);
-    // Extract content and tool calls from response
-    let content = response.output_text || '';
-    const toolCalls = [];
-    // Process output items for tool calls
-    for (const item of response.output) {
-        if (isFunctionCallOutput(item)) {
-            toolCalls.push({
-                id: item.call_id || item.id || `call_${Date.now()}`,
-                name: item.name,
-                arguments: typeof item.arguments === 'string'
-                    ? JSON.parse(item.arguments)
-                    : item.arguments,
-            });
-        }
-    }
-    // Determine finish reason
-    let finishReason = 'stop';
-    if (toolCalls.length > 0) {
-        finishReason = 'tool_use';
-    }
-    else if (response.status === 'incomplete') {
-        finishReason = 'length';
-    }
-    return {
-        content,
-        toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
-        finishReason,
-        usage: response.usage ? {
-            inputTokens: response.usage.input_tokens,
-            outputTokens: response.usage.output_tokens,
-        } : undefined,
-    };
-}
-/**
- * Chat with OpenAI
- */
-async function chatOpenAI(messages, tools, model, onToken) {
-    // Route to Responses API for models that require it (o3, o4-mini, etc.)
-    if (requiresResponsesAPI(model)) {
-        return chatOpenAIResponses(messages, tools, model, onToken);
-    }
-    const apiKey = config.getApiKey('openai');
-    if (!apiKey)
-        throw new Error('OpenAI API key not configured');
-    const client = new OpenAI({ apiKey });
-    const openaiMessages = toOpenAIMessages(messages);
-    const openaiTools = toOpenAITools(tools);
-    // Calculate dynamic max_tokens based on available context space
-    const dynamicMaxTokens = calculateMaxTokens('openai', model, messages, tools);
-    debugLog(`OpenAI request: model=${model}, max_tokens=${dynamicMaxTokens}`);
-    // Use streaming if callback provided
-    // Stream text content while collecting tool calls
-    if (onToken) {
-        let content = '';
-        let toolCallDeltas = {};
-        let finishReason = 'stop';
-        try {
-            const stream = await client.chat.completions.create({
-                model,
-                messages: openaiMessages,
-                tools: openaiTools.length > 0 ? openaiTools : undefined,
-                max_tokens: dynamicMaxTokens,
-                stream: true,
-            });
-            for await (const chunk of stream) {
-                const choice = chunk.choices[0];
-                if (!choice)
-                    continue;
-                // Handle text content
-                const textDelta = choice.delta?.content;
-                if (textDelta) {
-                    content += textDelta;
-                    onToken(textDelta);
-                }
-                // Handle tool calls (collect deltas)
-                const toolCallDelta = choice.delta?.tool_calls;
-                if (toolCallDelta) {
-                    for (const tc of toolCallDelta) {
-                        if (!toolCallDeltas[tc.index]) {
-                            toolCallDeltas[tc.index] = { id: '', name: '', arguments: '' };
-                        }
-                        if (tc.id)
-                            toolCallDeltas[tc.index].id = tc.id;
-                        if (tc.function?.name)
-                            toolCallDeltas[tc.index].name = tc.function.name;
-                        if (tc.function?.arguments)
-                            toolCallDeltas[tc.index].arguments += tc.function.arguments;
-                    }
-                }
-                // Track finish reason
-                if (choice.finish_reason === 'tool_calls') {
-                    finishReason = 'tool_use';
-                }
-                else if (choice.finish_reason === 'length') {
-                    finishReason = 'length';
-                }
-            }
-            // Convert tool call deltas to tool calls
-            const toolCalls = Object.values(toolCallDeltas)
-                .filter(tc => tc.id && tc.name)
-                .map(tc => ({
-                id: tc.id,
-                name: tc.name,
-                arguments: JSON.parse(tc.arguments || '{}'),
-            }));
-            if (toolCalls.length > 0) {
-                finishReason = 'tool_use';
-            }
-            return {
-                content,
-                toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
-                finishReason,
-            };
-        }
-        catch (streamError) {
-            // Fall back to non-streaming on error
-            console.error('Streaming failed, falling back to non-streaming:', streamError);
-        }
-    }
-    // Non-streaming request
-    const response = await client.chat.completions.create({
-        model,
-        messages: openaiMessages,
-        tools: openaiTools.length > 0 ? openaiTools : undefined,
-        max_tokens: dynamicMaxTokens,
-    });
-    if (!response.choices || response.choices.length === 0) {
-        throw new Error('Empty response from OpenAI API');
-    }
-    const choice = response.choices[0];
-    const message = choice.message;
-    const toolCalls = parseOpenAIToolCalls(message.tool_calls);
-    // Map OpenAI finish reasons
-    let finishReason = 'stop';
-    if (choice.finish_reason === 'tool_calls') {
-        finishReason = 'tool_use';
-    }
-    else if (choice.finish_reason === 'length') {
-        finishReason = 'length';
-    }
-    return {
-        content: message.content || '',
-        toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
-        finishReason,
-        usage: response.usage ? {
-            inputTokens: response.usage.prompt_tokens,
-            outputTokens: response.usage.completion_tokens,
-        } : undefined,
-    };
-}
-/**
- * Chat with OpenAI-compatible APIs (OpenRouter, Together, Groq, Mistral, etc.)
- */
-async function chatOpenAICompatible(provider, messages, tools, model, onToken) {
-    // Ollama and LiteLLM use base URL, others use API key
-    let apiKey;
-    let baseURL;
-    if (provider === 'ollama') {
-        const ollamaBase = config.getBaseUrl('ollama') || 'http://localhost:11434';
-        // Append /v1 for OpenAI-compatible endpoint, unless already present
-        baseURL = ollamaBase.endsWith('/v1') ? ollamaBase : `${ollamaBase}/v1`;
-        apiKey = 'ollama'; // Ollama doesn't require a real API key
-    }
-    else if (provider === 'litellm') {
-        const litellmBase = config.getBaseUrl('litellm') || 'http://localhost:4000';
-        // Append /v1 for OpenAI-compatible endpoint, unless already present
-        baseURL = litellmBase.endsWith('/v1') ? litellmBase : `${litellmBase}/v1`;
-        apiKey = config.getApiKey('litellm') || 'litellm'; // LiteLLM may or may not require key
-    }
-    else {
-        apiKey = config.getApiKey(provider);
-        if (!apiKey)
-            throw new Error(`${provider} API key not configured`);
-        baseURL = PROVIDER_BASE_URLS[provider];
-        if (!baseURL)
-            throw new Error(`Unknown provider: ${provider}`);
-    }
-    const client = new OpenAI({ apiKey, baseURL });
-    const openaiMessages = toOpenAIMessages(messages);
-    const openaiTools = toOpenAITools(tools);
-    // Calculate dynamic max_tokens based on available context space
-    const dynamicMaxTokens = calculateMaxTokens(provider, model, messages, tools);
-    debugLog(`${provider} request: model=${model}, max_tokens=${dynamicMaxTokens}`);
-    // Use streaming if callback provided
-    // Stream text content while collecting tool calls
-    if (onToken) {
-        let content = '';
-        let toolCallDeltas = {};
-        let finishReason = 'stop';
-        try {
-            const stream = await client.chat.completions.create({
-                model,
-                messages: openaiMessages,
-                tools: openaiTools.length > 0 ? openaiTools : undefined,
-                max_tokens: dynamicMaxTokens,
-                stream: true,
-            });
-            for await (const chunk of stream) {
-                const choice = chunk.choices[0];
-                if (!choice)
-                    continue;
-                // Handle text content
-                const textDelta = choice.delta?.content;
-                if (textDelta) {
-                    content += textDelta;
-                    onToken(textDelta);
-                }
-                // Handle tool calls (collect deltas)
-                const toolCallDelta = choice.delta?.tool_calls;
-                if (toolCallDelta) {
-                    for (const tc of toolCallDelta) {
-                        if (!toolCallDeltas[tc.index]) {
-                            toolCallDeltas[tc.index] = { id: '', name: '', arguments: '' };
-                        }
-                        if (tc.id)
-                            toolCallDeltas[tc.index].id = tc.id;
-                        if (tc.function?.name)
-                            toolCallDeltas[tc.index].name = tc.function.name;
-                        if (tc.function?.arguments)
-                            toolCallDeltas[tc.index].arguments += tc.function.arguments;
-                    }
-                }
-                // Track finish reason
-                if (choice.finish_reason === 'tool_calls') {
-                    finishReason = 'tool_use';
-                }
-                else if (choice.finish_reason === 'length') {
-                    finishReason = 'length';
-                }
-            }
-            // Convert tool call deltas to tool calls
-            const toolCalls = Object.values(toolCallDeltas)
-                .filter(tc => tc.id && tc.name)
-                .map(tc => ({
-                id: tc.id,
-                name: tc.name,
-                arguments: JSON.parse(tc.arguments || '{}'),
-            }));
-            if (toolCalls.length > 0) {
-                finishReason = 'tool_use';
-            }
-            return {
-                content,
-                toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
-                finishReason,
-            };
-        }
-        catch (streamError) {
-            // Fall back to non-streaming on error
-            console.error('Streaming failed, falling back to non-streaming:', streamError);
-        }
-    }
-    // Non-streaming request
-    const response = await client.chat.completions.create({
-        model,
-        messages: openaiMessages,
-        tools: openaiTools.length > 0 ? openaiTools : undefined,
-        max_tokens: dynamicMaxTokens,
-    });
-    if (!response.choices || response.choices.length === 0) {
-        throw new Error(`Empty response from ${provider} API`);
-    }
-    const choice = response.choices[0];
-    const message = choice.message;
-    const toolCalls = parseOpenAIToolCalls(message.tool_calls);
-    // Map finish reasons
-    let finishReason = 'stop';
-    if (choice.finish_reason === 'tool_calls') {
-        finishReason = 'tool_use';
-    }
-    else if (choice.finish_reason === 'length') {
-        finishReason = 'length';
-    }
-    return {
-        content: message.content || '',
-        toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
-        finishReason,
-        usage: response.usage ? {
-            inputTokens: response.usage.prompt_tokens,
-            outputTokens: response.usage.completion_tokens,
-        } : undefined,
-    };
-}
-//# sourceMappingURL=providers.js.map