orquesta-cli 0.1.12

package/dist/core/llm/llm-client.js

@@ -0,0 +1,1000 @@
+import axios from 'axios';
+import { configManager } from '../config/config-manager.js';
+import { NetworkError, APIError, TimeoutError, ConnectionError, } from '../../errors/network.js';
+import { LLMError, TokenLimitError, RateLimitError, ContextLengthError, } from '../../errors/llm.js';
+import { logger, isLLMLogEnabled } from '../../utils/logger.js';
+import { usageTracker } from '../usage-tracker.js';
+export class LLMClient {
+    axiosInstance;
+    baseUrl;
+    apiKey;
+    model;
+    modelName;
+    currentAbortController = null;
+    isInterrupted = false;
+    static DEFAULT_MAX_RETRIES = 3;
+    constructor() {
+        const endpoint = configManager.getCurrentEndpoint();
+        const currentModel = configManager.getCurrentModel();
+        if (!endpoint || !currentModel) {
+            throw new Error('No endpoint or model configured. Run: open config init');
+        }
+        this.baseUrl = endpoint.baseUrl;
+        this.apiKey = endpoint.apiKey || '';
+        this.model = currentModel.id;
+        this.modelName = currentModel.name;
+        this.axiosInstance = axios.create({
+            baseURL: this.baseUrl,
+            headers: {
+                'Content-Type': 'application/json',
+                ...(this.apiKey && { Authorization: `Bearer ${this.apiKey}` }),
+            },
+            timeout: 600000,
+        });
+    }
+    preprocessMessages(messages, modelId) {
+        return messages.map((msg) => {
+            if (msg.role !== 'assistant') {
+                return msg;
+            }
+            const msgAny = msg;
+            let processedMsg = { ...msg };
+            if (msgAny.reasoning_content && (!msg.content || msg.content.trim() === '')) {
+                processedMsg.content = msgAny.reasoning_content;
+                delete processedMsg.reasoning_content;
+            }
+            if (/^gpt-oss-(120b|20b)$/i.test(modelId)) {
+                if (msg.tool_calls && msg.tool_calls.length > 0) {
+                    if (!processedMsg.content || processedMsg.content.trim() === '') {
+                        const toolNames = msg.tool_calls.map(tc => tc.function.name).join(', ');
+                        processedMsg.content = msgAny.reasoning || `Calling tools: ${toolNames}`;
+                    }
+                }
+            }
+            if (processedMsg.content === undefined || processedMsg.content === null) {
+                processedMsg.content = '';
+            }
+            return processedMsg;
+        });
+    }
+    async chatCompletion(options, retryConfig) {
+        const maxRetries = retryConfig?.disableRetry ? 1 : (retryConfig?.maxRetries ?? LLMClient.DEFAULT_MAX_RETRIES);
+        const currentAttempt = retryConfig?.currentAttempt ?? 1;
+        logger.enter('chatCompletion', {
+            model: options.model || this.model,
+            messagesCount: options.messages?.length || 0,
+            hasTools: !!options.tools,
+            attempt: currentAttempt,
+            maxRetries
+        });
+        const url = '/chat/completions';
+        try {
+            logger.flow('Starting message preprocessing');
+            const modelId = options.model || this.model;
+            const processedMessages = options.messages ?
+                this.preprocessMessages(options.messages, modelId) : [];
+            logger.vars({ name: 'modelId', value: modelId }, { name: 'originalMessages', value: options.messages?.length || 0 }, { name: 'processedMessages', value: processedMessages.length }, { name: 'temperature', value: options.temperature ?? 0.7 });
+            const requestBody = {
+                model: modelId,
+                messages: processedMessages,
+                temperature: options.temperature ?? 0.7,
+                max_tokens: options.max_tokens,
+                stream: false,
+                ...(options.tools && {
+                    tools: options.tools,
+                    parallel_tool_calls: false,
+                    ...(options.tool_choice && { tool_choice: options.tool_choice }),
+                }),
+            };
+            logger.flow('API request preparation complete');
+            logger.httpRequest('POST', `${this.baseUrl}${url}`, {
+                model: modelId,
+                messages: `${processedMessages.length} messages`,
+                temperature: requestBody.temperature,
+                max_tokens: requestBody.max_tokens,
+                tools: options.tools ? `${options.tools.length} tools` : 'none',
+            });
+            logger.verbose('Full Request Body', requestBody);
+            if (isLLMLogEnabled()) {
+                logger.llmRequest(processedMessages, modelId, options.tools);
+            }
+            logger.startTimer('llm-api-call');
+            this.currentAbortController = new AbortController();
+            const response = await this.axiosInstance.post(url, requestBody, {
+                signal: this.currentAbortController.signal,
+            });
+            this.currentAbortController = null;
+            const elapsed = logger.endTimer('llm-api-call');
+            logger.flow('API response received');
+            if (!response.data.choices || !Array.isArray(response.data.choices)) {
+                logger.error('Invalid response structure - missing choices array', response.data);
+                throw new Error('Invalid LLM response format. Missing choices array.');
+            }
+            logger.httpResponse(response.status, response.statusText, {
+                choices: response.data.choices.length,
+                usage: response.data.usage,
+            });
+            logger.verbose('Full Response', response.data);
+            logger.vars({ name: 'responseChoices', value: response.data.choices.length }, { name: 'tokensUsed', value: response.data.usage?.total_tokens || 0 }, { name: 'responseTime', value: elapsed });
+            if (isLLMLogEnabled()) {
+                const responseContent = response.data.choices[0]?.message?.content || '';
+                const toolCalls = response.data.choices[0]?.message?.tool_calls;
+                logger.llmResponse(responseContent, toolCalls);
+            }
+            const reasoningContent = response.data.choices[0]?.message?.reasoning;
+            const maxTokens = options.max_tokens;
+            const isInternalCall = maxTokens && maxTokens < 500;
+            if (reasoningContent && !isInternalCall) {
+                const { emitReasoning } = await import('../../tools/llm/simple/file-tools.js');
+                emitReasoning(reasoningContent, false);
+                logger.debug('Reasoning content emitted', { length: reasoningContent.length });
+            }
+            else if (reasoningContent && isInternalCall) {
+                logger.debug('Reasoning skipped (internal call)', { maxTokens, length: reasoningContent.length });
+            }
+            if (response.data.usage) {
+                const promptTokens = response.data.usage.prompt_tokens || 0;
+                usageTracker.recordUsage(this.model, promptTokens, response.data.usage.completion_tokens || 0, undefined, promptTokens);
+            }
+            logger.exit('chatCompletion', {
+                success: true,
+                choices: response.data.choices.length,
+                elapsed
+            });
+            return response.data;
+        }
+        catch (error) {
+            this.currentAbortController = null;
+            if (axios.isCancel(error) || (error instanceof Error && error.name === 'CanceledError')) {
+                logger.flow('API call canceled (user interrupt)');
+                logger.exit('chatCompletion', { success: false, aborted: true });
+                throw new Error('INTERRUPTED');
+            }
+            if (currentAttempt < maxRetries && this.isRetryableError(error)) {
+                const delay = Math.pow(2, currentAttempt - 1) * 1000;
+                logger.debug(`LLM call failed (${currentAttempt}/${maxRetries}), retrying after ${delay}ms...`, {
+                    error: error.message,
+                    attempt: currentAttempt,
+                    maxRetries,
+                    delay
+                });
+                await this.sleep(delay);
+                return this.chatCompletion(options, {
+                    maxRetries,
+                    currentAttempt: currentAttempt + 1,
+                });
+            }
+            logger.flow('API call failed - Error handling');
+            if (currentAttempt > 1) {
+                logger.error(`LLM call final failure after ${maxRetries} retries`, {
+                    error: error.message,
+                    attempts: currentAttempt
+                });
+            }
+            logger.exit('chatCompletion', { success: false, error: error.message, attempts: currentAttempt });
+            throw this.handleError(error, {
+                method: 'POST',
+                url,
+                body: options,
+            });
+        }
+    }
+    abort() {
+        logger.flow('LLM interrupt - Stopping all operations');
+        this.isInterrupted = true;
+        if (this.currentAbortController) {
+            this.currentAbortController.abort();
+            this.currentAbortController = null;
+        }
+    }
+    checkInterrupted() {
+        return this.isInterrupted;
+    }
+    resetInterrupt() {
+        this.isInterrupted = false;
+    }
+    isRequestActive() {
+        return this.currentAbortController !== null;
+    }
+    isRetryableError(error) {
+        if (error instanceof Error && error.message === 'INTERRUPTED') {
+            return false;
+        }
+        if (axios.isAxiosError(error)) {
+            const axiosError = error;
+            if (!axiosError.response) {
+                const retryableCodes = ['ECONNREFUSED', 'ETIMEDOUT', 'ECONNRESET', 'ECONNABORTED', 'ENOTFOUND', 'EHOSTUNREACH'];
+                if (axiosError.code && retryableCodes.includes(axiosError.code)) {
+                    return true;
+                }
+                if (axiosError.message.includes('timeout')) {
+                    return true;
+                }
+                return true;
+            }
+            const status = axiosError.response.status;
+            if (status === 429) {
+                return true;
+            }
+            if (status >= 500) {
+                return true;
+            }
+            return false;
+        }
+        return false;
+    }
+    sleep(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+    async *chatCompletionStream(options) {
+        const url = '/chat/completions';
+        try {
+            const modelId = options.model || this.model;
+            const processedMessages = options.messages ?
+                this.preprocessMessages(options.messages, modelId) : [];
+            const requestBody = {
+                model: modelId,
+                messages: processedMessages,
+                temperature: options.temperature ?? 0.7,
+                max_tokens: options.max_tokens,
+                stream: true,
+                ...(options.tools && {
+                    tools: options.tools,
+                    ...(options.tool_choice && { tool_choice: options.tool_choice }),
+                }),
+            };
+            logger.httpRequest('POST (stream)', `${this.baseUrl}${url}`, {
+                model: modelId,
+                messages: `${processedMessages.length} messages`,
+                temperature: requestBody.temperature,
+                max_tokens: requestBody.max_tokens,
+            });
+            logger.verbose('Full Streaming Request Body', requestBody);
+            this.currentAbortController = new AbortController();
+            const response = await this.axiosInstance.post(url, requestBody, {
+                responseType: 'stream',
+                signal: this.currentAbortController.signal,
+            });
+            logger.debug('Streaming response started', { status: response.status });
+            const stream = response.data;
+            let buffer = '';
+            let chunkCount = 0;
+            const maxTokens = options.max_tokens;
+            const isInternalCall = maxTokens && maxTokens < 500;
+            const { emitReasoning } = await import('../../tools/llm/simple/file-tools.js');
+            try {
+                for await (const chunk of stream) {
+                    if (this.isInterrupted) {
+                        logger.flow('Interrupt detected during streaming - stopping');
+                        throw new Error('INTERRUPTED');
+                    }
+                    buffer += chunk.toString();
+                    const lines = buffer.split('\n');
+                    buffer = lines.pop() || '';
+                    for (const line of lines) {
+                        const trimmed = line.trim();
+                        if (!trimmed || trimmed === 'data: [DONE]')
+                            continue;
+                        if (trimmed.startsWith('data: ')) {
+                            try {
+                                const jsonStr = trimmed.slice(6);
+                                const data = JSON.parse(jsonStr);
+                                chunkCount++;
+                                const reasoningDelta = data.choices[0]?.delta?.reasoning;
+                                if (reasoningDelta && !isInternalCall) {
+                                    emitReasoning(reasoningDelta, true);
+                                    logger.debug('Reasoning delta emitted', { length: reasoningDelta.length });
+                                }
+                                else if (reasoningDelta && isInternalCall) {
+                                    logger.debug('Reasoning delta skipped (internal call)', { maxTokens });
+                                }
+                                yield data;
+                            }
+                            catch (parseError) {
+                                logger.debug('Skipping invalid chunk', { line: trimmed });
+                                continue;
+                            }
+                        }
+                    }
+                }
+            }
+            finally {
+                this.currentAbortController = null;
+            }
+            logger.debug('Streaming response completed', { chunkCount });
+        }
+        catch (error) {
+            throw this.handleError(error, {
+                method: 'POST (stream)',
+                url,
+                body: options,
+            });
+        }
+    }
+    async sendMessage(userMessage, systemPrompt) {
+        logger.enter('sendMessage', {
+            messageLength: userMessage.length,
+            hasSystemPrompt: !!systemPrompt
+        });
+        logger.flow('Constructing message array');
+        const messages = [];
+        if (systemPrompt) {
+            logger.vars({ name: 'systemPrompt', value: systemPrompt.substring(0, 100) + (systemPrompt.length > 100 ? '...' : '') });
+            messages.push({
+                role: 'system',
+                content: systemPrompt,
+            });
+        }
+        messages.push({
+            role: 'user',
+            content: userMessage,
+        });
+        logger.vars({ name: 'totalMessages', value: messages.length }, { name: 'userMessage', value: userMessage.substring(0, 100) + (userMessage.length > 100 ? '...' : '') });
+        logger.flow('Calling LLM API');
+        logger.startTimer('sendMessage-api');
+        const response = await this.chatCompletion({ messages });
+        const elapsed = logger.endTimer('sendMessage-api');
+        logger.flow('Processing response');
+        if (response.choices.length === 0) {
+            logger.flow('No response - Error occurred');
+            logger.exit('sendMessage', { success: false, reason: 'No response from LLM' });
+            throw new Error('No response from LLM');
+        }
+        const responseContent = response.choices[0]?.message.content || '';
+        logger.vars({ name: 'responseLength', value: responseContent.length }, { name: 'apiTime', value: elapsed });
+        logger.exit('sendMessage', {
+            success: true,
+            responseLength: responseContent.length,
+            elapsed
+        });
+        return responseContent;
+    }
+    async *sendMessageStream(userMessage, systemPrompt) {
+        const messages = [];
+        if (systemPrompt) {
+            messages.push({
+                role: 'system',
+                content: systemPrompt,
+            });
+        }
+        messages.push({
+            role: 'user',
+            content: userMessage,
+        });
+        for await (const chunk of this.chatCompletionStream({ messages })) {
+            const content = chunk.choices[0]?.delta?.content;
+            if (content) {
+                yield content;
+            }
+        }
+    }
+    async chatCompletionWithTools(messages, tools, options) {
+        let workingMessages = [...messages];
+        const toolCallHistory = [];
+        let iterations = 0;
+        let contextLengthRecoveryAttempted = false;
+        let noToolCallRetries = 0;
+        let finalResponseFailures = 0;
+        const MAX_NO_TOOL_CALL_RETRIES = 3;
+        const MAX_FINAL_RESPONSE_FAILURES = 3;
+        while (true) {
+            if (this.isInterrupted) {
+                logger.flow('Interrupt detected - stopping tool loop');
+                throw new Error('INTERRUPTED');
+            }
+            iterations++;
+            if (options?.getPendingMessage && options?.clearPendingMessage) {
+                const pendingMsg = options.getPendingMessage();
+                if (pendingMsg) {
+                    logger.flow('Injecting pending user message into conversation');
+                    workingMessages.push({ role: 'user', content: pendingMsg });
+                    options.clearPendingMessage();
+                }
+            }
+            let response;
+            try {
+                response = await this.chatCompletion({
+                    messages: workingMessages,
+                    tools,
+                    tool_choice: 'required',
+                });
+            }
+            catch (error) {
+                if (error instanceof ContextLengthError && !contextLengthRecoveryAttempted) {
+                    contextLengthRecoveryAttempted = true;
+                    logger.flow('ContextLengthError detected - attempting recovery with compact');
+                    let rollbackIdx = workingMessages.length - 1;
+                    while (rollbackIdx >= 0 && workingMessages[rollbackIdx]?.role === 'tool') {
+                        rollbackIdx--;
+                    }
+                    if (rollbackIdx >= 0 && workingMessages[rollbackIdx]?.tool_calls) {
+                        workingMessages = workingMessages.slice(0, rollbackIdx);
+                        logger.debug('Rolled back messages to before last tool execution', {
+                            removedCount: workingMessages.length - rollbackIdx,
+                        });
+                    }
+                    const { CompactManager } = await import('../compact/compact-manager.js');
+                    const { buildCompactedMessages } = await import('../compact/compact-prompts.js');
+                    const compactManager = new CompactManager(this);
+                    const compactResult = await compactManager.compact(workingMessages, {
+                        workingDirectory: process.cwd(),
+                    });
+                    if (compactResult.success && compactResult.compactedSummary) {
+                        const compactedMessages = buildCompactedMessages(compactResult.compactedSummary, {
+                            workingDirectory: process.cwd(),
+                        });
+                        workingMessages = [...compactedMessages];
+                        logger.flow('Compact completed, retrying with reduced context', {
+                            originalCount: compactResult.originalMessageCount,
+                            newCount: compactedMessages.length,
+                        });
+                        continue;
+                    }
+                    else {
+                        logger.error('Compact failed during recovery', { error: compactResult.error });
+                        throw error;
+                    }
+                }
+                throw error;
+            }
+            if (this.isInterrupted) {
+                logger.flow('Interrupt detected after LLM call - stopping');
+                throw new Error('INTERRUPTED');
+            }
+            const choice = response.choices[0];
+            if (!choice) {
+                throw new Error('Cannot find choice in response.');
+            }
+            const assistantMessage = choice.message;
+            workingMessages.push(assistantMessage);
+            if (assistantMessage.tool_calls && assistantMessage.tool_calls.length > 0) {
+                if (assistantMessage.tool_calls.length > 1) {
+                    const toolNames = assistantMessage.tool_calls.map(tc => tc.function.name).join(', ');
+                    logger.warn(`[MULTI-TOOL DETECTED] LLM returned ${assistantMessage.tool_calls.length} tools: ${toolNames}`);
+                }
+                for (const toolCall of assistantMessage.tool_calls) {
+                    const toolName = toolCall.function.name;
+                    let toolArgs;
+                    try {
+                        toolArgs = JSON.parse(toolCall.function.arguments);
+                    }
+                    catch (parseError) {
+                        const errorMsg = `Tool argument parsing failed for ${toolName}`;
+                        logger.error(errorMsg, parseError);
+                        logger.debug('Raw arguments', { raw: toolCall.function.arguments });
+                        workingMessages.push({
+                            role: 'tool',
+                            content: `Error: Failed to parse tool arguments - ${parseError instanceof Error ? parseError.message : 'Unknown error'}`,
+                            tool_call_id: toolCall.id,
+                        });
+                        toolCallHistory.push({
+                            tool: toolName,
+                            args: { raw: toolCall.function.arguments },
+                            result: `Error: Argument parsing failed`,
+                        });
+                        continue;
+                    }
+                    const { executeFileTool, requestToolApproval } = await import('../../tools/llm/simple/file-tools.js');
+                    const approvalResult = await requestToolApproval(toolName, toolArgs);
+                    if (approvalResult && typeof approvalResult === 'object' && approvalResult.reject) {
+                        logger.flow(`Tool rejected by user: ${toolName}`);
+                        const rejectMessage = approvalResult.comment
+                            ? `Tool execution rejected by user. Reason: ${approvalResult.comment}`
+                            : 'Tool execution rejected by user.';
+                        workingMessages.push({
+                            role: 'tool',
+                            content: rejectMessage,
+                            tool_call_id: toolCall.id,
+                        });
+                        toolCallHistory.push({
+                            tool: toolName,
+                            args: toolArgs,
+                            result: rejectMessage,
+                        });
+                        continue;
+                    }
+                    logger.debug(`Executing tool: ${toolName}`, toolArgs);
+                    let result;
+                    try {
+                        result = await executeFileTool(toolName, toolArgs);
+                        logger.toolExecution(toolName, toolArgs, result);
+                        if (isLLMLogEnabled()) {
+                            logger.llmToolResult(toolName, result.result || '', result.success);
+                        }
+                        if (toolName === 'final_response') {
+                            if (result.success && result.metadata?.['isFinalResponse']) {
+                                logger.flow('final_response tool executed successfully - returning');
+                                workingMessages.push({
+                                    role: 'tool',
+                                    content: result.result || '',
+                                    tool_call_id: toolCall.id,
+                                });
+                                toolCallHistory.push({
+                                    tool: toolName,
+                                    args: toolArgs,
+                                    result: result.result || '',
+                                });
+                                return {
+                                    message: {
+                                        role: 'assistant',
+                                        content: result.result || '',
+                                    },
+                                    toolCalls: toolCallHistory,
+                                    allMessages: workingMessages,
+                                };
+                            }
+                            else {
+                                finalResponseFailures++;
+                                logger.flow(`final_response failed (attempt ${finalResponseFailures}/${MAX_FINAL_RESPONSE_FAILURES}): ${result.error}`);
+                                if (finalResponseFailures >= MAX_FINAL_RESPONSE_FAILURES) {
+                                    logger.warn('Max final_response failures exceeded - forcing completion');
+                                    const fallbackMessage = toolArgs['message'] || 'Task completed with incomplete TODOs.';
+                                    const { emitAssistantResponse } = await import('../../tools/llm/simple/file-tools.js');
+                                    emitAssistantResponse(fallbackMessage);
+                                    return {
+                                        message: { role: 'assistant', content: fallbackMessage },
+                                        toolCalls: toolCallHistory,
+                                        allMessages: workingMessages,
+                                    };
+                                }
+                            }
+                        }
+                    }
+                    catch (toolError) {
+                        logger.toolExecution(toolName, toolArgs, undefined, toolError);
+                        if (isLLMLogEnabled()) {
+                            const errorMsg = toolError instanceof Error ? toolError.message : String(toolError);
+                            logger.llmToolResult(toolName, `Error: ${errorMsg}`, false);
+                        }
+                        result = {
+                            success: false,
+                            error: toolError instanceof Error ? toolError.message : String(toolError),
+                        };
+                    }
+                    workingMessages.push({
+                        role: 'tool',
+                        content: result.success ? result.result || '' : `Error: ${result.error}`,
+                        tool_call_id: toolCall.id,
+                    });
+                    toolCallHistory.push({
+                        tool: toolName,
+                        args: toolArgs,
+                        result: result.success ? result.result || '' : `Error: ${result.error}`,
+                    });
+                    if (this.isInterrupted) {
+                        logger.flow('Interrupt detected after tool execution - stopping');
+                        throw new Error('INTERRUPTED');
+                    }
+                }
+                continue;
+            }
+            else {
+                noToolCallRetries++;
+                logger.flow(`No tool call - enforcing tool usage (attempt ${noToolCallRetries}/${MAX_NO_TOOL_CALL_RETRIES})`);
+                if (noToolCallRetries > MAX_NO_TOOL_CALL_RETRIES) {
+                    logger.warn('Max no-tool-call retries exceeded - returning content as final response');
+                    const fallbackContent = assistantMessage.content || 'Task completed.';
+                    const { emitAssistantResponse } = await import('../../tools/llm/simple/file-tools.js');
+                    emitAssistantResponse(fallbackContent);
+                    return {
+                        message: { role: 'assistant', content: fallbackContent },
+                        toolCalls: toolCallHistory,
+                        allMessages: workingMessages,
+                    };
+                }
+                const hasMalformedToolCall = assistantMessage.content &&
+                    (/<tool_call>/i.test(assistantMessage.content) ||
+                        /<arg_key>/i.test(assistantMessage.content) ||
+                        /<arg_value>/i.test(assistantMessage.content) ||
+                        /<\/tool_call>/i.test(assistantMessage.content) ||
+                        /bash<arg_key>/i.test(assistantMessage.content));
+                const retryMessage = hasMalformedToolCall
+                    ? 'Your previous response contained a malformed tool call (XML tags in content). You MUST use the proper tool_calls API format. Use final_response tool to deliver your message to the user.'
+                    : 'You must use tools for all actions. Use final_response tool to deliver your final message to the user after completing all tasks.';
+                workingMessages.push({
+                    role: 'user',
+                    content: retryMessage,
+                });
+                logger.debug('Enforcing tool call - added retry message');
+                continue;
+            }
+        }
+    }
+    getModelInfo() {
+        return {
+            model: this.modelName,
+            endpoint: this.baseUrl,
+        };
+    }
+    handleError(error, requestContext) {
+        logger.error('LLM Client Error', error);
+        if (requestContext) {
+            logger.debug('Request Context', requestContext);
+        }
+        if (axios.isAxiosError(error)) {
+            const axiosError = error;
+            if (axiosError.code === 'ECONNABORTED' || axiosError.message.includes('timeout')) {
+                logger.error('Request Timeout', {
+                    timeout: this.axiosInstance.defaults.timeout,
+                    endpoint: this.baseUrl,
+                });
+                return new TimeoutError(this.axiosInstance.defaults.timeout || 60000, {
+                    cause: axiosError,
+                    details: {
+                        endpoint: this.baseUrl,
+                        method: requestContext?.method,
+                        url: requestContext?.url,
+                    },
+                });
+            }
+            if (axiosError.response) {
+                const status = axiosError.response.status;
+                const data = axiosError.response.data;
+                const errorMessage = data?.error?.message || data?.message || axiosError.message;
+                const errorType = data?.error?.type || 'unknown';
+                const errorCode = data?.error?.code || data?.code;
+                logger.error('=== API ERROR DETAILS ===', {
+                    status,
+                    statusText: axiosError.response.statusText,
+                    endpoint: this.baseUrl,
+                    model: this.model,
+                    errorMessage,
+                    errorType,
+                    errorCode,
+                    responseBody: JSON.stringify(data, null, 2),
+                    requestMethod: requestContext?.method,
+                    requestUrl: requestContext?.url,
+                    requestBody: requestContext?.body
+                        ? JSON.stringify(requestContext.body, null, 2).substring(0, 5000)
+                        : undefined,
+                    responseHeaders: axiosError.response.headers,
+                });
+                logger.httpResponse(status, axiosError.response.statusText, data);
+                if (errorType === 'invalid_request_error' &&
+                    (errorMessage.includes('context_length_exceeded') ||
+                        errorMessage.includes('maximum context length') ||
+                        errorCode === 'context_length_exceeded')) {
+                    const maxLength = data?.error?.param?.max_tokens || 'unknown';
+                    logger.error('Context Length Exceeded', {
+                        maxLength,
+                        errorMessage,
+                        model: this.model,
+                    });
+                    return new ContextLengthError(typeof maxLength === 'number' ? maxLength : 0, undefined, {
+                        cause: axiosError,
+                        details: {
+                            model: this.model,
+                            endpoint: this.baseUrl,
+                            errorType,
+                            fullError: data,
+                        },
+                    });
+                }
+                if (errorMessage.includes('token') &&
+                    (errorMessage.includes('limit') || errorMessage.includes('exceeded'))) {
+                    logger.error('Token Limit Error', {
+                        errorMessage,
+                        model: this.model,
+                    });
+                    return new TokenLimitError(0, undefined, {
+                        cause: axiosError,
+                        details: {
+                            model: this.model,
+                            endpoint: this.baseUrl,
+                            fullError: data,
+                        },
+                        userMessage: errorMessage,
+                    });
+                }
+                if (status === 429) {
+                    const retryAfter = axiosError.response.headers['retry-after'];
+                    const retrySeconds = retryAfter ? parseInt(retryAfter) : undefined;
+                    logger.error('Rate Limit Exceeded', {
+                        retryAfter: retrySeconds,
+                        errorMessage,
+                    });
+                    return new RateLimitError(retrySeconds, {
+                        cause: axiosError,
+                        details: {
+                            endpoint: this.baseUrl,
+                            model: this.model,
+                            fullError: data,
+                        },
+                    });
+                }
+                if (status === 401) {
+                    logger.error('Authentication Failed', {
+                        endpoint: this.baseUrl,
+                        errorMessage,
+                    });
+                    return new APIError(`Authentication failed: ${errorMessage}`, status, this.baseUrl, {
+                        cause: axiosError,
+                        details: {
+                            apiKeyProvided: !!this.apiKey,
+                            apiKeyLength: this.apiKey?.length || 0,
+                            fullError: data,
+                        },
+                        isRecoverable: false,
+                        userMessage: `Invalid API key. Please check your settings.\nDetails: ${errorMessage}`,
+                    });
+                }
+                if (status === 403) {
+                    logger.error('Access Forbidden', {
+                        endpoint: this.baseUrl,
+                        errorMessage,
+                    });
+                    return new APIError(`Access denied: ${errorMessage}`, status, this.baseUrl, {
+                        cause: axiosError,
+                        details: {
+                            fullError: data,
+                        },
+                        isRecoverable: false,
+                    });
+                }
+                if (status === 404) {
+                    logger.error('Endpoint Not Found', {
+                        endpoint: this.baseUrl,
+                        url: requestContext?.url,
+                        errorMessage,
+                    });
+                    return new APIError(`Endpoint not found: ${errorMessage}`, status, this.baseUrl, {
+                        cause: axiosError,
+                        details: {
+                            url: requestContext?.url,
+                            fullError: data,
+                        },
+                        isRecoverable: false,
+                        userMessage: `API endpoint does not exist.\nURL: ${this.baseUrl}${requestContext?.url || ''}\nDetails: ${errorMessage}`,
+                    });
+                }
+                if (status >= 500) {
+                    logger.error('Server Error', {
+                        status,
+                        endpoint: this.baseUrl,
+                        errorMessage,
+                    });
+                    return new APIError(`Server error (${status}): ${errorMessage}`, status, this.baseUrl, {
+                        cause: axiosError,
+                        details: {
+                            fullError: data,
+                        },
+                        isRecoverable: true,
+                    });
+                }
+                logger.error('API Error', {
+                    status,
+                    endpoint: this.baseUrl,
+                    errorMessage,
+                    errorType,
+                    errorCode,
+                });
+                return new APIError(`API error (${status}): ${errorMessage}`, status, this.baseUrl, {
+                    cause: axiosError,
+                    details: {
+                        errorType,
+                        errorCode,
+                        fullError: data,
+                    },
+                    userMessage: `API request failed (${status}):\n${errorMessage}\n\nError type: ${errorType}\nError code: ${errorCode}`,
+                });
+            }
+            else if (axiosError.request) {
+                const errorCode = axiosError.code;
+                logger.error('Network Error - No Response', {
+                    code: errorCode,
+                    endpoint: this.baseUrl,
+                    message: axiosError.message,
+                });
+                if (errorCode === 'ECONNREFUSED' ||
+                    errorCode === 'ENOTFOUND' ||
+                    errorCode === 'ECONNRESET' ||
+                    errorCode === 'EHOSTUNREACH') {
+                    return new ConnectionError(this.baseUrl, {
+                        cause: axiosError,
+                        details: {
+                            code: errorCode,
+                            message: axiosError.message,
+                        },
+                        userMessage: `Cannot connect to server.\nEndpoint: ${this.baseUrl}\nError code: ${errorCode}\nDetails: ${axiosError.message}\n\nPlease check network connection and endpoint URL.`,
+                    });
+                }
+                return new NetworkError(`Network error: ${axiosError.message}`, {
+                    cause: axiosError,
+                    details: {
+                        code: errorCode,
+                        endpoint: this.baseUrl,
+                    },
+                    userMessage: `Network connection failed.\nEndpoint: ${this.baseUrl}\nError: ${axiosError.message}`,
+                });
+            }
+            logger.error('Axios Error', {
+                code: axiosError.code,
+                message: axiosError.message,
+            });
+            return new LLMError(`LLM client error: ${axiosError.message}`, {
+                cause: axiosError,
+                details: {
+                    code: axiosError.code,
+                },
+            });
+        }
+        if (error instanceof Error) {
+            logger.error('Unexpected Error', error);
+            return new LLMError(`Unexpected error: ${error.message}`, {
+                cause: error,
+                userMessage: `An error occurred:\n${error.message}\n\nStack:\n${error.stack}`,
+            });
+        }
+        logger.error('Unknown Error Type', { error });
+        return new LLMError('An unknown error occurred.', {
+            details: { unknownError: error },
+        });
+    }
+    async chatCompletionWithRetry(options, maxRetries = 3) {
+        return this.chatCompletion(options, { maxRetries });
+    }
+    async healthCheck() {
+        const endpoint = configManager.getCurrentEndpoint();
+        const model = configManager.getCurrentModel();
+        if (!endpoint || !model) {
+            return { success: false, error: 'No endpoint or model configured' };
+        }
+        const startTime = Date.now();
+        try {
+            const response = await this.axiosInstance.post('/chat/completions', {
+                model: model.id,
+                messages: [{ role: 'user', content: 'ping' }],
+                max_tokens: 5,
+            });
+            const latency = Date.now() - startTime;
+            if (response.status === 200 && response.data.choices?.[0]?.message) {
+                return { success: true, latency };
+            }
+            else {
+                return { success: false, latency, error: 'Invalid response format' };
+            }
+        }
+        catch (error) {
+            const latency = Date.now() - startTime;
+            const axiosError = error;
+            if (axiosError.response) {
+                const status = axiosError.response.status;
+                return { success: false, latency, error: `HTTP ${status}` };
+            }
+            else if (axiosError.request) {
+                return { success: false, latency, error: 'Connection failed' };
+            }
+            else {
+                return { success: false, latency, error: axiosError.message || 'Unknown error' };
+            }
+        }
+    }
+    static async healthCheckAll() {
+        const endpoints = configManager.getAllEndpoints();
+        const results = new Map();
+        for (const endpoint of endpoints) {
+            const modelResults = [];
+            for (const model of endpoint.models) {
+                if (!model.enabled) {
+                    modelResults.push({
+                        modelId: model.id,
+                        healthy: false,
+                        error: 'Model disabled',
+                    });
+                    continue;
+                }
+                const startTime = Date.now();
+                try {
+                    const axiosInstance = axios.create({
+                        baseURL: endpoint.baseUrl,
+                        headers: {
+                            'Content-Type': 'application/json',
+                            ...(endpoint.apiKey && { Authorization: `Bearer ${endpoint.apiKey}` }),
+                        },
+                        timeout: 30000,
+                    });
+                    const response = await axiosInstance.post('/chat/completions', {
+                        model: model.id,
+                        messages: [{ role: 'user', content: 'ping' }],
+                        max_tokens: 5,
+                    });
+                    const latency = Date.now() - startTime;
+                    if (response.status === 200 && response.data.choices?.[0]?.message) {
+                        modelResults.push({ modelId: model.id, healthy: true, latency });
+                    }
+                    else {
+                        modelResults.push({
+                            modelId: model.id,
+                            healthy: false,
+                            latency,
+                            error: 'Invalid response',
+                        });
+                    }
+                }
+                catch (error) {
+                    const latency = Date.now() - startTime;
+                    const axiosError = error;
+                    let errorMessage = 'Unknown error';
+                    if (axiosError.response) {
+                        errorMessage = `HTTP ${axiosError.response.status}`;
+                    }
+                    else if (axiosError.code === 'ECONNREFUSED') {
+                        errorMessage = 'Connection refused';
+                    }
+                    else if (axiosError.code === 'ETIMEDOUT' || axiosError.code === 'ECONNABORTED') {
+                        errorMessage = 'Timeout';
+                    }
+                    else if (axiosError.request) {
+                        errorMessage = 'Network error';
+                    }
+                    modelResults.push({
+                        modelId: model.id,
+                        healthy: false,
+                        latency,
+                        error: errorMessage,
+                    });
+                }
+            }
+            results.set(endpoint.id, modelResults);
+        }
+        return results;
+    }
+    static async testConnection(baseUrl, apiKey, model) {
+        const startTime = Date.now();
+        try {
+            const axiosInstance = axios.create({
+                baseURL: baseUrl,
+                headers: {
+                    'Content-Type': 'application/json',
+                    ...(apiKey && { Authorization: `Bearer ${apiKey}` }),
+                },
+                timeout: 60000,
+            });
+            const response = await axiosInstance.post('/chat/completions', {
+                model: model,
+                messages: [
+                    {
+                        role: 'user',
+                        content: 'test',
+                    },
+                ],
+                max_tokens: 10,
+            });
+            const latency = Date.now() - startTime;
+            if (response.status === 200 && response.data.choices?.[0]?.message) {
+                return { success: true, latency };
+            }
+            else {
+                return { success: false, latency, error: 'Invalid response format' };
+            }
+        }
+        catch (error) {
+            const latency = Date.now() - startTime;
+            const axiosError = error;
+            if (axiosError.response) {
+                const status = axiosError.response.status;
+                const data = axiosError.response.data;
+                const message = data?.error?.message || axiosError.message;
+                if (status === 401) {
+                    return { success: false, latency, error: 'Invalid API key.' };
+                }
+                else if (status === 404) {
+                    return { success: false, latency, error: 'Endpoint or model not found.' };
+                }
+                else {
+                    return { success: false, latency, error: `API error (${status}): ${message}` };
+                }
+            }
+            else if (axiosError.request) {
+                return { success: false, latency, error: `Network error: Cannot connect to endpoint.` };
+            }
+            else {
+                return { success: false, latency, error: axiosError.message || 'Unknown error' };
+            }
+        }
+    }
+}
+export function createLLMClient() {
+    return new LLMClient();
+}
+//# sourceMappingURL=llm-client.js.map