@xagent-ai/cli 1.0.1

package/dist/ai-client.js

@@ -0,0 +1,1280 @@
+import axios from 'axios';
+// Markdown渲染辅助函数
+function renderMarkdown(text) {
+    // 代码块渲染
+    text = text.replace(/```(\w*)\n([\s\S]*?)```/g, (_, lang, code) => {
+        return `\n┌─[${lang || 'code'}]\n${code.trim().split('\n').map((l) => '│ ' + l).join('\n')}\n└─\n`;
+    });
+    // 行内代码渲染
+    text = text.replace(/`([^`]+)`/g, '`$1`');
+    // 粗体渲染
+    text = text.replace(/\*\*([^*]+)\*\*/g, '●$1○');
+    // 斜体渲染
+    text = text.replace(/\*([^*]+)\*/g, '/$1/');
+    // 列表渲染
+    text = text.replace(/^- (.*$)/gm, '○ $1');
+    text = text.replace(/^\d+\. (.*$)/gm, '• $1');
+    // 标题渲染
+    text = text.replace(/^### (.*$)/gm, '\n━━━ $1 ━━━\n');
+    text = text.replace(/^## (.*$)/gm, '\n━━━━━ $1 ━━━━━\n');
+    text = text.replace(/^# (.*$)/gm, '\n━━━━━━━ $1 ━━━━━━━\n');
+    // 引用渲染
+    text = text.replace(/^> (.*$)/gm, '│ │ $1');
+    // 链接渲染
+    text = text.replace(/\[([^\]]+)\]\(([^)]+)\)/g, '[$1]($2)');
+    return text;
+}
+// 格式化消息内容
+function formatMessageContent(content) {
+    if (typeof content === 'string') {
+        return renderMarkdown(content);
+    }
+    const parts = [];
+    let hasToolUse = false;
+    for (const block of content) {
+        if (block.type === 'text') {
+            parts.push(renderMarkdown(block.text || ''));
+        }
+        else if (block.type === 'tool_use') {
+            hasToolUse = true;
+            parts.push(`[🔧 TOOL CALL PENDING: ${block.name}]`);
+        }
+        else if (block.type === 'tool_result') {
+            const result = typeof block.content === 'string' ? block.content : JSON.stringify(block.content);
+            parts.push(`[✅ TOOL RESULT]\n${result}`);
+        }
+        else if (block.type === 'thinking') {
+            parts.push(`[🧠 THINKING]\n${block.thinking || ''}`);
+        }
+    }
+    if (hasToolUse) {
+        parts.push('\n[⚠️  Note: Tool calls are executed by the framework, not displayed here]');
+    }
+    return parts.join('\n');
+}
+// 分类展示消息
+function displayMessages(messages, systemPrompt) {
+    const roleColors = {
+        system: '🟫 SYSTEM',
+        user: '👤 USER',
+        assistant: '🤖 ASSISTANT',
+        tool: '🔧 TOOL'
+    };
+    // 先显示system消息（如果有单独的systemPrompt参数）
+    if (systemPrompt) {
+        console.log('\n┌─────────────────────────────────────────────────────────────┐');
+        console.log('│ 🟫 SYSTEM                                                     │');
+        console.log('├─────────────────────────────────────────────────────────────┤');
+        console.log(renderMarkdown(systemPrompt).split('\n').map((l) => '│ ' + l).join('\n'));
+        console.log('└─────────────────────────────────────────────────────────────┘');
+    }
+    // 遍历所有消息
+    for (let i = 0; i < messages.length; i++) {
+        const msg = messages[i];
+        const role = msg.role;
+        const roleLabel = roleColors[role] || `● ${role.toUpperCase()}`;
+        console.log(`\n┌─────────────────────────────────────────────────────────────┐`);
+        console.log(`│ ${roleLabel} (${i + 1}/${messages.length})                                          │`);
+        console.log('├─────────────────────────────────────────────────────────────┤');
+        // 显示reasoning_content（如果有）
+        if (msg.reasoning_content) {
+            console.log('│ 🧠 REASONING:');
+            console.log('│ ───────────────────────────────────────────────────────────');
+            const reasoningLines = renderMarkdown(msg.reasoning_content).split('\n');
+            for (const line of reasoningLines.slice(0, 20)) {
+                console.log('│ ' + line.slice(0, 62));
+            }
+            if (msg.reasoning_content.length > 1000)
+                console.log('│ ... (truncated)');
+            console.log('│ ───────────────────────────────────────────────────────────');
+        }
+        // 显示主要内容
+        const content = formatMessageContent(msg.content);
+        const lines = content.split('\n');
+        for (const line of lines.slice(0, 50)) {
+            console.log('│ ' + line.slice(0, 62));
+        }
+        if (lines.length > 50) {
+            console.log('│ ... (' + (lines.length - 50) + ' more lines)');
+        }
+        console.log('└─────────────────────────────────────────────────────────────┘');
+    }
+}
+// 格式化响应内容
+function formatResponseContent(content) {
+    if (typeof content === 'string') {
+        return renderMarkdown(content);
+    }
+    const parts = [];
+    let hasToolUse = false;
+    for (const block of content) {
+        if (block.type === 'text') {
+            parts.push(renderMarkdown(block.text || ''));
+        }
+        else if (block.type === 'tool_use') {
+            hasToolUse = true;
+            // 工具调用通过 tool_calls 字段处理，不在此显示
+        }
+        else if (block.type === 'tool_result') {
+            const result = typeof block.content === 'string' ? block.content : JSON.stringify(block.content);
+            parts.push(`[✅ TOOL RESULT]\n${result}`);
+        }
+        else if (block.type === 'thinking') {
+            parts.push(`[🧠 THINKING]\n${block.thinking || ''}`);
+        }
+        else if (block.type === 'image') {
+            parts.push('[IMAGE]');
+        }
+    }
+    if (hasToolUse) {
+        parts.push('\n[⚠️  Note: Tool calls are executed via tool_calls field, not shown here]');
+    }
+    return parts.join('\n');
+}
+// 检测是否为 Anthropic 兼容 API（使用 x-api-key 认证头）
+function isAnthropicCompatible(baseUrl) {
+    return baseUrl.includes('anthropic') ||
+        baseUrl.includes('minimaxi.com') ||
+        baseUrl.includes('minimax.chat');
+}
+// MiniMax API 路径检测
+function detectMiniMaxAPI(baseUrl) {
+    return baseUrl.includes('minimax.chat') ||
+        baseUrl.includes('minimaxi.com');
+}
+// 获取 MiniMax 的正确端点路径
+function getMiniMaxEndpoint(baseUrl) {
+    // MiniMax Anthropic 格式: https://api.minimax.chat/anthropic + /v1/messages
+    if (baseUrl.includes('/anthropic')) {
+        return { endpoint: '/v1/messages', format: 'anthropic' };
+    }
+    // MiniMax OpenAI 格式: https://api.minimaxi.com/v1 + /chat/completions
+    if (baseUrl.includes('/v1') && !baseUrl.includes('/anthropic')) {
+        return { endpoint: '/chat/completions', format: 'openai' };
+    }
+    // 默认使用 Anthropic 格式
+    return { endpoint: '/v1/messages', format: 'anthropic' };
+}
+export class AIClient {
+    client;
+    authConfig;
+    constructor(authConfig) {
+        this.authConfig = authConfig;
+        const isMiniMax = detectMiniMaxAPI(authConfig.baseUrl || '');
+        const isAnthropicOfficial = !isMiniMax && isAnthropicCompatible(authConfig.baseUrl || '');
+        const headers = {
+            'Content-Type': 'application/json'
+        };
+        if (isMiniMax) {
+            // MiniMax: 使用 x-api-key 认证头
+            headers['x-api-key'] = authConfig.apiKey || '';
+            headers['anthropic-version'] = '2023-06-01';
+        }
+        else if (isAnthropicOfficial) {
+            // Anthropic 官方: 使用 x-api-key 认证头
+            headers['x-api-key'] = authConfig.apiKey || '';
+            headers['anthropic-version'] = '2023-06-01';
+            headers['anthropic-dangerous-direct-browser-access'] = 'true';
+        }
+        else {
+            // 其他 OpenAI 兼容: 使用 Bearer token
+            headers['Authorization'] = `Bearer ${authConfig.apiKey}`;
+        }
+        this.client = axios.create({
+            baseURL: authConfig.baseUrl,
+            headers,
+            timeout: 240000
+        });
+    }
+    // 将 OpenAI 格式消息转换为 Anthropic 格式
+    convertToAnthropicFormat(messages, systemPrompt) {
+        const systemMessages = messages.filter(m => m.role === 'system');
+        const otherMessages = messages.filter(m => m.role !== 'system');
+        const systemContent = systemMessages[0]?.content;
+        const system = systemPrompt || (typeof systemContent === 'string' ? systemContent : '');
+        const anthropicMessages = [];
+        for (const msg of otherMessages) {
+            const blocks = [];
+            if (typeof msg.content === 'string') {
+                blocks.push({ type: 'text', text: msg.content });
+            }
+            else if (Array.isArray(msg.content)) {
+                for (const block of msg.content) {
+                    if (block.type === 'text' && 'text' in block) {
+                        blocks.push({ type: 'text', text: block.text });
+                    }
+                    else if (block.type === 'tool_use') {
+                        blocks.push({
+                            type: 'tool_use',
+                            id: block.id,
+                            name: block.function?.name || block.name,
+                            input: block.function?.arguments || block.input
+                        });
+                    }
+                    else if (block.type === 'tool_result') {
+                        blocks.push({
+                            type: 'tool_result',
+                            tool_use_id: block.tool_call_id || block.tool_use_id,
+                            content: typeof block.content === 'string'
+                                ? block.content
+                                : JSON.stringify(block.content)
+                        });
+                    }
+                    else if (block.type === 'thinking') {
+                        blocks.push({ type: 'thinking', thinking: block.thinking });
+                    }
+                }
+            }
+            // 处理 tool_calls (OpenAI 格式)
+            if (msg.tool_calls) {
+                for (const tc of msg.tool_calls) {
+                    blocks.push({
+                        type: 'tool_use',
+                        id: tc.id,
+                        name: tc.function?.name,
+                        input: tc.function?.arguments ? (typeof tc.function.arguments === 'string' ? JSON.parse(tc.function.arguments) : tc.function.arguments) : {}
+                    });
+                }
+            }
+            if (blocks.length > 0) {
+                anthropicMessages.push({
+                    role: msg.role === 'tool' ? 'user' : msg.role,
+                    content: blocks
+                });
+            }
+        }
+        return { system, messages: anthropicMessages };
+    }
+    async chatCompletion(messages, options = {}) {
+        const model = options.model || this.authConfig.modelName || 'gpt-4';
+        const isMiniMax = detectMiniMaxAPI(this.authConfig.baseUrl || '');
+        if (isMiniMax) {
+            return this.minimaxChatCompletion(messages, options);
+        }
+        const isAnthropic = isAnthropicCompatible(this.authConfig.baseUrl || '');
+        if (isAnthropic) {
+            return this.anthropicNativeChatCompletion(messages, options);
+        }
+        // OpenAI 格式请求
+        const requestBody = {
+            model,
+            messages,
+            temperature: options.temperature ?? 0.7,
+            stream: options.stream ?? false
+        };
+        if (options.maxTokens && options.maxTokens > 0) {
+            requestBody.max_tokens = options.maxTokens;
+        }
+        if (options.tools && options.tools.length > 0) {
+            requestBody.tools = options.tools;
+            requestBody.tool_choice = options.toolChoice || 'auto';
+        }
+        if (options.thinkingTokens && options.thinkingTokens > 0) {
+            requestBody.max_completion_tokens = options.thinkingTokens;
+        }
+        // 调试输出（受showAIDebugInfo配置控制）
+        const showDebug = this.authConfig.showAIDebugInfo ?? false;
+        if (showDebug) {
+            console.log('\n╔══════════════════════════════════════════════════════════╗');
+            console.log('║                    AI REQUEST DEBUG                      ║');
+            console.log('╚══════════════════════════════════════════════════════════╝');
+            console.log(`📦 Model: ${model}`);
+            console.log(`🌐 Base URL: ${this.authConfig.baseUrl}`);
+            console.log(`💬 Total Messages: ${messages.length} 条`);
+            if (options.temperature !== undefined)
+                console.log(`🌡️  Temperature: ${options.temperature}`);
+            if (options.maxTokens)
+                console.log(`📏 Max Tokens: ${options.maxTokens}`);
+            if (options.tools?.length)
+                console.log(`🔧 Tools: ${options.tools.length} 个`);
+            if (options.thinkingTokens)
+                console.log(`🧠 Thinking Tokens: ${options.thinkingTokens}`);
+            console.log('─'.repeat(60));
+            // 分离system消息
+            const systemMsgs = messages.filter(m => m.role === 'system');
+            const otherMsgs = messages.filter(m => m.role !== 'system');
+            if (systemMsgs.length > 0) {
+                const systemContent = typeof systemMsgs[0].content === 'string'
+                    ? systemMsgs[0].content
+                    : formatMessageContent(systemMsgs[0].content);
+                console.log('\n┌─────────────────────────────────────────────────────────────┐');
+                console.log('│ 🟫 SYSTEM                                                     │');
+                console.log('├─────────────────────────────────────────────────────────────┤');
+                console.log(renderMarkdown(systemContent).split('\n').map(l => '│ ' + l).join('\n'));
+                console.log('└─────────────────────────────────────────────────────────────┘');
+            }
+            displayMessages(otherMsgs);
+            console.log('\n📤 Sending request to API...\n');
+        }
+        try {
+            const response = await this.client.post('/chat/completions', requestBody);
+            if (showDebug) {
+                console.log('\n╔══════════════════════════════════════════════════════════╗');
+                console.log('║                   AI RESPONSE DEBUG                      ║');
+                console.log('╚══════════════════════════════════════════════════════════╝');
+                console.log(`🆔 ID: ${response.data.id}`);
+                console.log(`🤖 Model: ${response.data.model}`);
+                const usage = response.data.usage;
+                if (usage) {
+                    console.log(`📊 Tokens: ${usage.prompt_tokens} (prompt) + ${usage.completion_tokens} (completion) = ${usage.total_tokens} (total)`);
+                }
+                const choice = response.data.choices?.[0];
+                if (choice) {
+                    console.log(`🏁 Finish Reason: ${choice.finish_reason}`);
+                    console.log('\n┌─────────────────────────────────────────────────────────────┐');
+                    console.log('│ 🤖 ASSISTANT                                                 │');
+                    console.log('├─────────────────────────────────────────────────────────────┤');
+                    // 显示reasoning_content（如果有）
+                    if (choice.message.reasoning_content) {
+                        console.log('│ 🧠 REASONING:');
+                        console.log('│ ───────────────────────────────────────────────────────────');
+                        const reasoningLines = renderMarkdown(choice.message.reasoning_content).split('\n');
+                        for (const line of reasoningLines.slice(0, 15)) {
+                            console.log('│ ' + line.slice(0, 62));
+                        }
+                        if (choice.message.reasoning_content.length > 800)
+                            console.log('│ ... (truncated)');
+                        console.log('│ ───────────────────────────────────────────────────────────');
+                    }
+                    // 显示主要内容
+                    const content = formatResponseContent(choice.message.content);
+                    const lines = content.split('\n');
+                    console.log('│ 💬 CONTENT:');
+                    console.log('│ ───────────────────────────────────────────────────────────');
+                    for (const line of lines.slice(0, 40)) {
+                        console.log('│ ' + line.slice(0, 62));
+                    }
+                    if (lines.length > 40) {
+                        console.log(`│ ... (${lines.length - 40} more lines)`);
+                    }
+                    console.log('└─────────────────────────────────────────────────────────────┘');
+                }
+                console.log('╔══════════════════════════════════════════════════════════╗');
+                console.log('║                    RESPONSE ENDED                        ║');
+                console.log('╚══════════════════════════════════════════════════════════╝\n');
+            }
+            return response.data;
+        }
+        catch (error) {
+            if (error.response) {
+                throw new Error(`API Error: ${error.response.status} - ${JSON.stringify(error.response.data)}`);
+            }
+            else if (error.request) {
+                throw new Error('Network error: No response received from server');
+            }
+            else {
+                throw new Error(`Request error: ${error.message}`);
+            }
+        }
+    }
+    // Anthropic 官方原生 API（使用 /v1/messages 端点）
+    async anthropicNativeChatCompletion(messages, options = {}) {
+        const { system, messages: anthropicMessages } = this.convertToAnthropicFormat(messages);
+        const requestBody = {
+            model: options.model || this.authConfig.modelName || 'claude-sonnet-4-20250514',
+            messages: anthropicMessages,
+            temperature: options.temperature ?? 1.0,
+            stream: false,
+            max_tokens: options.maxTokens || 4096
+        };
+        if (system) {
+            requestBody.system = system;
+        }
+        // Anthropic 原生工具格式
+        if (options.tools && options.tools.length > 0) {
+            requestBody.tools = options.tools.map(tool => ({
+                name: tool.function.name,
+                description: tool.function.description,
+                input_schema: tool.function.parameters || { type: 'object', properties: {} }
+            }));
+            // 转换 tool_choice 从 OpenAI 格式到 Anthropic 格式
+            const toolChoice = options.toolChoice;
+            if (toolChoice === 'none') {
+                requestBody.tool_choice = { type: 'auto' };
+            }
+            else if (toolChoice && typeof toolChoice === 'object') {
+                if (toolChoice.type === 'function' && toolChoice.function) {
+                    requestBody.tool_choice = { type: 'tool', tool: { name: toolChoice.function.name } };
+                }
+                else {
+                    requestBody.tool_choice = { type: 'auto' };
+                }
+            }
+            else {
+                requestBody.tool_choice = { type: 'auto' };
+            }
+        }
+        // Anthropic thinking 模式
+        if (options.thinkingTokens && options.thinkingTokens > 0) {
+            requestBody.thinking = { type: 'enabled', budget_tokens: options.thinkingTokens };
+        }
+        // 调试输出（受showAIDebugInfo配置控制）
+        const showDebug = this.authConfig.showAIDebugInfo ?? false;
+        if (showDebug) {
+            console.log('\n╔══════════════════════════════════════════════════════════╗');
+            console.log('║              AI REQUEST DEBUG (ANTHROPIC)                ║');
+            console.log('╚══════════════════════════════════════════════════════════╝');
+            console.log(`📦 Model: ${requestBody.model}`);
+            console.log(`🌐 Base URL: ${this.authConfig.baseUrl}`);
+            console.log(`💬 Total Messages: ${anthropicMessages.length} 条`);
+            if (requestBody.temperature)
+                console.log(`🌡️  Temperature: ${requestBody.temperature}`);
+            if (requestBody.max_tokens)
+                console.log(`📏 Max Tokens: ${requestBody.max_tokens}`);
+            if (requestBody.tools)
+                console.log(`🔧 Tools: ${requestBody.tools.length} 个`);
+            if (requestBody.thinking)
+                console.log(`🧠 Thinking Budget: ${requestBody.thinking.budget_tokens}`);
+            console.log('─'.repeat(60));
+            // 显示system消息
+            if (system) {
+                console.log('\n┌─────────────────────────────────────────────────────────────┐');
+                console.log('│ 🟫 SYSTEM                                                     │');
+                console.log('├─────────────────────────────────────────────────────────────┤');
+                console.log(renderMarkdown(system).split('\n').map(l => '│ ' + l).join('\n'));
+                console.log('└─────────────────────────────────────────────────────────────┘');
+            }
+            // 显示用户和助手消息
+            displayMessages(anthropicMessages);
+            console.log('\n📤 Sending to Anthropic API (v1/messages)...\n');
+        }
+        try {
+            // 使用 Anthropic 原生端点 /v1/messages
+            const response = await this.client.post('/v1/messages', requestBody);
+            if (showDebug) {
+                console.log('\n╔══════════════════════════════════════════════════════════╗');
+                console.log('║             AI RESPONSE DEBUG (ANTHROPIC)                ║');
+                console.log('╚══════════════════════════════════════════════════════════╝');
+                console.log(`🆔 ID: ${response.data.id}`);
+                console.log(`🤖 Model: ${response.data.model}`);
+                const usage = response.data.usage;
+                if (usage) {
+                    console.log(`📊 Tokens: ${usage.input_tokens} (input) + ${usage.output_tokens} (output) = ${usage.input_tokens + usage.output_tokens} (total)`);
+                }
+                console.log(`🏁 Stop Reason: ${response.data.stop_reason}`);
+                console.log('\n┌─────────────────────────────────────────────────────────────┐');
+                console.log('│ 🤖 ASSISTANT                                                 │');
+                console.log('├─────────────────────────────────────────────────────────────┤');
+                const content = response.data.content || [];
+                const reasoning = content.filter((c) => c.type === 'thinking').map((c) => c.thinking).join('');
+                const textContent = content.filter((c) => c.type === 'text').map((c) => c.text).join('');
+                // 显示thinking
+                if (reasoning) {
+                    console.log('│ 🧠 REASONING:');
+                    console.log('│ ───────────────────────────────────────────────────────────');
+                    const reasoningLines = renderMarkdown(reasoning).split('\n');
+                    for (const line of reasoningLines.slice(0, 15)) {
+                        console.log('│ ' + line.slice(0, 62));
+                    }
+                    if (reasoning.length > 800)
+                        console.log('│ ... (truncated)');
+                    console.log('│ ───────────────────────────────────────────────────────────');
+                }
+                // 显示内容
+                console.log('│ 💬 CONTENT:');
+                console.log('│ ───────────────────────────────────────────────────────────');
+                const lines = renderMarkdown(textContent).split('\n');
+                for (const line of lines.slice(0, 40)) {
+                    console.log('│ ' + line.slice(0, 62));
+                }
+                if (lines.length > 40) {
+                    console.log(`│ ... (${lines.length - 40} more lines)`);
+                }
+                console.log('└─────────────────────────────────────────────────────────────┘');
+                console.log('\n╔══════════════════════════════════════════════════════════╗');
+                console.log('║                    RESPONSE ENDED                        ║');
+                console.log('╚══════════════════════════════════════════════════════════╝\n');
+            }
+            return this.convertFromAnthropicNativeResponse(response.data);
+        }
+        catch (error) {
+            if (error.response) {
+                throw new Error(`API Error: ${error.response.status} - ${JSON.stringify(error.response.data)}`);
+            }
+            else if (error.request) {
+                throw new Error('Network error: No response received from server');
+            }
+            else {
+                throw new Error(`Request error: ${error.message}`);
+            }
+        }
+    }
+    // MiniMax API（根据 baseUrl 自动选择 Anthropic 或 OpenAI 格式）
+    async minimaxChatCompletion(messages, options = {}) {
+        const { system, messages: anthropicMessages } = this.convertToAnthropicFormat(messages);
+        const { endpoint, format } = getMiniMaxEndpoint(this.authConfig.baseUrl || '');
+        const requestBody = {
+            model: options.model || this.authConfig.modelName || 'MiniMax-M2',
+            messages: format === 'anthropic' ? anthropicMessages : messages,
+            temperature: options.temperature ?? 1.0,
+            stream: false,
+            max_tokens: options.maxTokens || 4096
+        };
+        if (system && format === 'anthropic') {
+            requestBody.system = system;
+        }
+        if (format === 'anthropic') {
+            // Anthropic format tools
+            if (options.tools && options.tools.length > 0) {
+                requestBody.tools = options.tools.map(tool => ({
+                    name: tool.function.name,
+                    description: tool.function.description,
+                    input_schema: tool.function.parameters || { type: 'object', properties: {} }
+                }));
+                const toolChoice = options.toolChoice;
+                if (toolChoice === 'none') {
+                    requestBody.tool_choice = { type: 'auto' };
+                }
+                else if (toolChoice && typeof toolChoice === 'object') {
+                    if (toolChoice.type === 'function' && toolChoice.function) {
+                        requestBody.tool_choice = { type: 'tool', tool: { name: toolChoice.function.name } };
+                    }
+                    else {
+                        requestBody.tool_choice = { type: 'auto' };
+                    }
+                }
+                else {
+                    requestBody.tool_choice = { type: 'auto' };
+                }
+            }
+        }
+        else {
+            // OpenAI 格式的工具
+            if (options.tools && options.tools.length > 0) {
+                requestBody.tools = options.tools;
+                requestBody.tool_choice = options.toolChoice || 'auto';
+            }
+        }
+        // 调试输出（受showAIDebugInfo配置控制）
+        const showDebug = this.authConfig.showAIDebugInfo ?? false;
+        if (showDebug) {
+            console.log('\n╔══════════════════════════════════════════════════════════╗');
+            console.log('║               AI REQUEST DEBUG (MINIMAX)                 ║');
+            console.log('╚══════════════════════════════════════════════════════════╝');
+            console.log(`📦 Model: ${requestBody.model}`);
+            console.log(`🔗 Format: ${format.toUpperCase()} | Endpoint: ${endpoint}`);
+            console.log(`🌐 Base URL: ${this.authConfig.baseUrl}`);
+            console.log(`💬 Total Messages: ${requestBody.messages.length} 条`);
+            if (requestBody.temperature)
+                console.log(`🌡️  Temperature: ${requestBody.temperature}`);
+            if (requestBody.max_tokens)
+                console.log(`📏 Max Tokens: ${requestBody.max_tokens}`);
+            if (requestBody.tools)
+                console.log(`🔧 Tools: ${requestBody.tools.length} 个`);
+            console.log('─'.repeat(60));
+            // 显示system消息
+            if (system && format === 'anthropic') {
+                console.log('\n┌─────────────────────────────────────────────────────────────┐');
+                console.log('│ 🟫 SYSTEM                                                     │');
+                console.log('├─────────────────────────────────────────────────────────────┤');
+                console.log(renderMarkdown(system).split('\n').map(l => '│ ' + l).join('\n'));
+                console.log('└─────────────────────────────────────────────────────────────┘');
+            }
+            // 显示其他消息
+            displayMessages(requestBody.messages);
+            console.log('\n📤 Sending to MiniMax API...\n');
+        }
+        try {
+            // MiniMax 使用正确的端点
+            const response = await this.client.post(endpoint, requestBody);
+            if (showDebug) {
+                console.log('\n╔══════════════════════════════════════════════════════════╗');
+                console.log('║              AI RESPONSE DEBUG (MINIMAX)                 ║');
+                console.log('╚══════════════════════════════════════════════════════════╝');
+                console.log(`🆔 ID: ${response.data.id}`);
+                console.log(`🤖 Model: ${response.data.model}`);
+                const usage = response.data.usage;
+                if (usage) {
+                    console.log(`📊 Tokens: ${usage.prompt_tokens} (prompt) + ${usage.completion_tokens} (completion) = ${usage.total_tokens} (total)`);
+                }
+                console.log(`🏁 Stop Reason: ${response.data.stop_reason}`);
+                console.log('\n┌─────────────────────────────────────────────────────────────┐');
+                console.log('│ 🤖 ASSISTANT                                                 │');
+                console.log('├─────────────────────────────────────────────────────────────┤');
+                const message = response.data.choices?.[0]?.message;
+                const content = typeof message?.content === 'string' ? message.content : JSON.stringify(message?.content);
+                console.log('│ 💬 CONTENT:');
+                console.log('│ ───────────────────────────────────────────────────────────');
+                const lines = renderMarkdown(content).split('\n');
+                for (const line of lines.slice(0, 40)) {
+                    console.log('│ ' + line.slice(0, 62));
+                }
+                if (lines.length > 40) {
+                    console.log(`│ ... (${lines.length - 40} more lines)`);
+                }
+                console.log('└─────────────────────────────────────────────────────────────┘');
+                console.log('\n╔══════════════════════════════════════════════════════════╗');
+                console.log('║                    RESPONSE ENDED                        ║');
+                console.log('╚══════════════════════════════════════════════════════════╝\n');
+            }
+            if (format === 'anthropic') {
+                return this.convertFromAnthropicNativeResponse(response.data);
+            }
+            else {
+                return this.convertFromMiniMaxResponse(response.data);
+            }
+        }
+        catch (error) {
+            if (error.response) {
+                throw new Error(`API Error: ${error.response.status} - ${JSON.stringify(error.response.data)}`);
+            }
+            else if (error.request) {
+                throw new Error('Network error: No response received from server');
+            }
+            else {
+                throw new Error(`Request error: ${error.message}`);
+            }
+        }
+    }
+    // 将 Anthropic 原生响应转换为统一格式
+    convertFromAnthropicNativeResponse(anthropicResponse) {
+        const content = anthropicResponse.content || [];
+        let textContent = '';
+        let reasoningContent = '';
+        const toolCalls = [];
+        for (const block of content) {
+            if (block.type === 'text') {
+                textContent += block.text || '';
+            }
+            else if (block.type === 'thinking') {
+                reasoningContent += block.thinking || '';
+            }
+            else if (block.type === 'tool_use') {
+                toolCalls.push({
+                    id: block.id,
+                    type: 'function',
+                    function: {
+                        name: block.name,
+                        arguments: JSON.stringify(block.input || {})
+                    }
+                });
+            }
+        }
+        return {
+            id: anthropicResponse.id || `anthropic-${Date.now()}`,
+            object: 'chat.completion',
+            created: Math.floor(Date.now() / 1000),
+            model: anthropicResponse.model || this.authConfig.modelName || 'claude-sonnet-4-20250514',
+            choices: [{
+                    index: 0,
+                    message: {
+                        role: 'assistant',
+                        content: textContent,
+                        reasoning_content: reasoningContent || undefined,
+                        tool_calls: toolCalls.length > 0 ? toolCalls : undefined
+                    },
+                    finish_reason: anthropicResponse.stop_reason === 'end_turn' ? 'stop' :
+                        anthropicResponse.stop_reason === 'max_tokens' ? 'length' : 'stop'
+                }],
+            usage: anthropicResponse.usage ? {
+                prompt_tokens: anthropicResponse.usage.input_tokens || 0,
+                completion_tokens: anthropicResponse.usage.output_tokens || 0,
+                total_tokens: (anthropicResponse.usage.input_tokens || 0) + (anthropicResponse.usage.output_tokens || 0)
+            } : undefined
+        };
+    }
+    // 将 MiniMax 响应转换为统一格式
+    convertFromMiniMaxResponse(minimaxResponse) {
+        const message = minimaxResponse.choices?.[0]?.message;
+        const content = message?.content;
+        let textContent = '';
+        let reasoningContent = '';
+        const toolCalls = [];
+        if (typeof content === 'string') {
+            textContent = content.trim();
+        }
+        else if (Array.isArray(content)) {
+            for (const block of content) {
+                if (block.type === 'text') {
+                    textContent += block.text || '';
+                }
+                else if (block.type === 'thinking') {
+                    reasoningContent += block.thinking || '';
+                }
+                else if (block.type === 'tool_use') {
+                    toolCalls.push({
+                        id: block.id,
+                        type: 'function',
+                        function: {
+                            name: block.name,
+                            arguments: JSON.stringify(block.input || {})
+                        }
+                    });
+                }
+            }
+        }
+        return {
+            id: minimaxResponse.id || `minimax-${Date.now()}`,
+            object: 'chat.completion',
+            created: Math.floor(Date.now() / 1000),
+            model: minimaxResponse.model || this.authConfig.modelName || 'MiniMax-M2',
+            choices: [{
+                    index: 0,
+                    message: {
+                        role: 'assistant',
+                        content: textContent,
+                        reasoning_content: reasoningContent || undefined,
+                        tool_calls: toolCalls.length > 0 ? toolCalls : undefined
+                    },
+                    finish_reason: minimaxResponse.stop_reason === 'end_turn' ? 'stop' :
+                        minimaxResponse.stop_reason === 'max_tokens' ? 'length' : 'stop'
+                }],
+            usage: minimaxResponse.usage
+        };
+    }
+    async *streamChatCompletion(messages, options = {}) {
+        const isMiniMax = detectMiniMaxAPI(this.authConfig.baseUrl || '');
+        if (isMiniMax) {
+            yield* this.minimaxStreamChatCompletion(messages, options);
+            return;
+        }
+        const isAnthropic = isAnthropicCompatible(this.authConfig.baseUrl || '');
+        if (isAnthropic) {
+            yield* this.anthropicNativeStreamChatCompletion(messages, options);
+            return;
+        }
+        // OpenAI 流式响应
+        const model = options.model || this.authConfig.modelName || 'gpt-4';
+        const requestBody = {
+            model,
+            messages,
+            temperature: options.temperature ?? 0.7,
+            stream: true
+        };
+        if (options.maxTokens && options.maxTokens > 0) {
+            requestBody.max_tokens = options.maxTokens;
+        }
+        if (options.tools && options.tools.length > 0) {
+            requestBody.tools = options.tools;
+            requestBody.tool_choice = options.toolChoice || 'auto';
+        }
+        if (options.thinkingTokens && options.thinkingTokens > 0) {
+            requestBody.max_completion_tokens = options.thinkingTokens;
+        }
+        // 调试输出（受showAIDebugInfo配置控制）
+        const showDebug = this.authConfig.showAIDebugInfo ?? false;
+        if (showDebug) {
+            console.log('\n╔══════════════════════════════════════════════════════════╗');
+            console.log('║              AI REQUEST DEBUG (STREAM)                   ║');
+            console.log('╚══════════════════════════════════════════════════════════╝');
+            console.log(`📦 Model: ${model}`);
+            console.log(`🌐 Base URL: ${this.authConfig.baseUrl}`);
+            console.log(`💬 Total Messages: ${messages.length} 条`);
+            if (options.temperature)
+                console.log(`🌡️  Temperature: ${options.temperature}`);
+            if (options.maxTokens)
+                console.log(`📏 Max Tokens: ${options.maxTokens}`);
+            if (options.tools?.length)
+                console.log(`🔧 Tools: ${options.tools.length} 个`);
+            console.log('─'.repeat(60));
+            // 分离并显示消息
+            const systemMsgs = messages.filter(m => m.role === 'system');
+            const otherMsgs = messages.filter(m => m.role !== 'system');
+            if (systemMsgs.length > 0) {
+                const systemContent = typeof systemMsgs[0].content === 'string'
+                    ? systemMsgs[0].content
+                    : formatMessageContent(systemMsgs[0].content);
+                console.log('\n┌─────────────────────────────────────────────────────────────┐');
+                console.log('│ 🟫 SYSTEM                                                     │');
+                console.log('├─────────────────────────────────────────────────────────────┤');
+                console.log(renderMarkdown(systemContent).split('\n').map(l => '│ ' + l).join('\n'));
+                console.log('└─────────────────────────────────────────────────────────────┘');
+            }
+            displayMessages(otherMsgs);
+            console.log('\n📤 Starting stream...\n');
+        }
+        try {
+            const response = await this.client.post('/chat/completions', requestBody, {
+                responseType: 'stream'
+            });
+            console.log('📥 Receiving stream chunks...\n');
+            let buffer = '';
+            let chunkCount = 0;
+            let outputBuffer = '';
+            for await (const chunk of response.data) {
+                buffer += chunk.toString();
+                const lines = buffer.split('\n');
+                buffer = lines.pop() || '';
+                for (const line of lines) {
+                    const trimmedLine = line.trim();
+                    if (!trimmedLine)
+                        continue;
+                    if (trimmedLine.startsWith('data: ')) {
+                        const data = trimmedLine.slice(6);
+                        if (data === '[DONE]') {
+                            if (showDebug) {
+                                console.log('\n╔══════════════════════════════════════════════════════════╗');
+                                console.log('║              STREAM COMPLETED                            ║');
+                                console.log('╚══════════════════════════════════════════════════════════╝');
+                                console.log(`📦 Total chunks: ${chunkCount}`);
+                                console.log(`📏 Total output: ${outputBuffer.length} chars`);
+                                console.log('\n┌─────────────────────────────────────────────────────────────┐');
+                                console.log('│ 🤖 ASSISTANT OUTPUT                                        │');
+                                console.log('├─────────────────────────────────────────────────────────────┤');
+                                console.log('│ 💬 CONTENT:');
+                                console.log('│ ───────────────────────────────────────────────────────────');
+                                const lines = renderMarkdown(outputBuffer).split('\n');
+                                for (const line of lines.slice(0, 30)) {
+                                    console.log('│ ' + line.slice(0, 62));
+                                }
+                                if (lines.length > 30) {
+                                    console.log(`│ ... (${lines.length - 30} more lines)`);
+                                }
+                                console.log('└─────────────────────────────────────────────────────────────┘');
+                                console.log('');
+                            }
+                            return;
+                        }
+                        try {
+                            const parsed = JSON.parse(data);
+                            const delta = parsed.choices?.[0]?.delta;
+                            if (delta?.content) {
+                                chunkCount++;
+                                outputBuffer += delta.content;
+                                yield delta.content;
+                            }
+                            else if (delta?.reasoning_content) {
+                                chunkCount++;
+                                outputBuffer += delta.reasoning_content;
+                                yield delta.reasoning_content;
+                            }
+                        }
+                        catch (e) {
+                            // Silently ignore parsing errors
+                        }
+                    }
+                }
+            }
+            if (buffer.trim()) {
+                const trimmedLine = buffer.trim();
+                if (trimmedLine.startsWith('data: ')) {
+                    const data = trimmedLine.slice(6);
+                    if (data !== '[DONE]') {
+                        try {
+                            const parsed = JSON.parse(data);
+                            const delta = parsed.choices?.[0]?.delta;
+                            if (delta?.content) {
+                                yield delta.content;
+                            }
+                            else if (delta?.reasoning_content) {
+                                yield delta.reasoning_content;
+                            }
+                        }
+                        catch (e) {
+                            // Ignore final parsing errors
+                        }
+                    }
+                }
+            }
+            console.log('\n╔══════════════════════════════════════════════════════════╗');
+            console.log('║              STREAM COMPLETED                            ║');
+            console.log('╚══════════════════════════════════════════════════════════╝\n');
+        }
+        catch (error) {
+            if (error.response) {
+                throw new Error(`API Error: ${error.response.status} - ${JSON.stringify(error.response.data)}`);
+            }
+            else if (error.request) {
+                throw new Error('Network error: No response received from server');
+            }
+            else {
+                throw new Error(`Request error: ${error.message}`);
+            }
+        }
+    }
+    // Anthropic 原生流式响应（/v1/messages 端点）
+    async *anthropicNativeStreamChatCompletion(messages, options = {}) {
+        const { system, messages: anthropicMessages } = this.convertToAnthropicFormat(messages);
+        const requestBody = {
+            model: options.model || this.authConfig.modelName || 'claude-sonnet-4-20250514',
+            messages: anthropicMessages,
+            temperature: options.temperature ?? 1.0,
+            stream: true,
+            max_tokens: options.maxTokens || 4096
+        };
+        if (system) {
+            requestBody.system = system;
+        }
+        // Anthropic 原生工具格式
+        if (options.tools && options.tools.length > 0) {
+            requestBody.tools = options.tools.map(tool => ({
+                name: tool.function.name,
+                description: tool.function.description,
+                input_schema: tool.function.parameters || { type: 'object', properties: {} }
+            }));
+            const toolChoice = options.toolChoice;
+            if (toolChoice === 'none') {
+                requestBody.tool_choice = { type: 'auto' };
+            }
+            else if (toolChoice && typeof toolChoice === 'object') {
+                if (toolChoice.type === 'function' && toolChoice.function) {
+                    requestBody.tool_choice = { type: 'tool', tool: { name: toolChoice.function.name } };
+                }
+                else {
+                    requestBody.tool_choice = { type: 'auto' };
+                }
+            }
+            else {
+                requestBody.tool_choice = { type: 'auto' };
+            }
+        }
+        if (options.thinkingTokens && options.thinkingTokens > 0) {
+            requestBody.thinking = { type: 'enabled', budget_tokens: options.thinkingTokens };
+        }
+        // 调试输出（受showAIDebugInfo配置控制）
+        const showDebug = this.authConfig.showAIDebugInfo ?? false;
+        if (showDebug) {
+            console.log('\n╔══════════════════════════════════════════════════════════╗');
+            console.log('║         AI REQUEST DEBUG (ANTHROPIC STREAM)             ║');
+            console.log('╚══════════════════════════════════════════════════════════╝');
+            console.log(`📦 Model: ${requestBody.model}`);
+            console.log(`🌐 Base URL: ${this.authConfig.baseUrl}`);
+            console.log(`💬 Total Messages: ${anthropicMessages.length} 条`);
+            if (requestBody.temperature)
+                console.log(`🌡️  Temperature: ${requestBody.temperature}`);
+            if (requestBody.max_tokens)
+                console.log(`📏 Max Tokens: ${requestBody.max_tokens}`);
+            if (requestBody.thinking)
+                console.log(`🧠 Thinking Budget: ${requestBody.thinking.budget_tokens}`);
+            console.log('─'.repeat(60));
+            // 显示system消息
+            if (system) {
+                console.log('\n┌─────────────────────────────────────────────────────────────┐');
+                console.log('│ 🟫 SYSTEM                                                     │');
+                console.log('├─────────────────────────────────────────────────────────────┤');
+                console.log(renderMarkdown(system).split('\n').map(l => '│ ' + l).join('\n'));
+                console.log('└─────────────────────────────────────────────────────────────┘');
+            }
+            displayMessages(anthropicMessages);
+            console.log('\n📤 Starting Anthropic stream...\n');
+        }
+        try {
+            // Anthropic 原生流式端点 /v1/messages
+            const response = await this.client.post('/v1/messages', requestBody, {
+                responseType: 'stream'
+            });
+            console.log('📥 Receiving Anthropic stream chunks...\n');
+            let buffer = '';
+            let outputBuffer = '';
+            for await (const chunk of response.data) {
+                buffer += chunk.toString();
+                const lines = buffer.split('\n');
+                buffer = lines.pop() || '';
+                for (const line of lines) {
+                    const trimmedLine = line.trim();
+                    if (!trimmedLine)
+                        continue;
+                    // Anthropic 流式格式: data: {"type":"content_block_delta",...}
+                    if (trimmedLine.startsWith('data: ')) {
+                        const data = trimmedLine.slice(6);
+                        try {
+                            const parsed = JSON.parse(data);
+                            // Anthropic 事件类型
+                            if (parsed.type === 'content_block_delta') {
+                                if (parsed.delta?.type === 'text_delta' && parsed.delta.text) {
+                                    outputBuffer += parsed.delta.text;
+                                    yield parsed.delta.text;
+                                }
+                                else if (parsed.delta?.type === 'thinking_delta' && parsed.delta.thinking) {
+                                    outputBuffer += parsed.delta.thinking;
+                                    yield parsed.delta.thinking;
+                                }
+                            }
+                            else if (parsed.type === 'message_delta') {
+                                if (parsed.delta?.stop_reason) {
+                                    // 消息结束
+                                    if (showDebug) {
+                                        console.log('\n╔══════════════════════════════════════════════════════════╗');
+                                        console.log('║              STREAM COMPLETED                            ║');
+                                        console.log('╚══════════════════════════════════════════════════════════╝');
+                                        console.log(`📏 Total output: ${outputBuffer.length} chars`);
+                                        console.log('\n┌─────────────────────────────────────────────────────────────┐');
+                                        console.log('│ 🤖 ASSISTANT OUTPUT                                        │');
+                                        console.log('├─────────────────────────────────────────────────────────────┤');
+                                        console.log('│ 💬 CONTENT:');
+                                        console.log('│ ───────────────────────────────────────────────────────────');
+                                        const lines = renderMarkdown(outputBuffer).split('\n');
+                                        for (const line of lines.slice(0, 30)) {
+                                            console.log('│ ' + line.slice(0, 62));
+                                        }
+                                        if (lines.length > 30) {
+                                            console.log(`│ ... (${lines.length - 30} more lines)`);
+                                        }
+                                        console.log('└─────────────────────────────────────────────────────────────┘');
+                                        console.log('');
+                                    }
+                                    return;
+                                }
+                            }
+                        }
+                        catch (e) {
+                            // 忽略解析错误
+                        }
+                    }
+                }
+            }
+            console.log('\n╔══════════════════════════════════════════════════════════╗');
+            console.log('║              STREAM COMPLETED                            ║');
+            console.log('╚══════════════════════════════════════════════════════════╝\n');
+        }
+        catch (error) {
+            if (error.response) {
+                throw new Error(`API Error: ${error.response.status} - ${JSON.stringify(error.response.data)}`);
+            }
+            else if (error.request) {
+                throw new Error('Network error: No response received from server');
+            }
+            else {
+                throw new Error(`Request error: ${error.message}`);
+            }
+        }
+    }
+    // MiniMax 流式响应（根据 baseUrl 自动选择格式）
+    async *minimaxStreamChatCompletion(messages, options = {}) {
+        const { system, messages: anthropicMessages } = this.convertToAnthropicFormat(messages);
+        const { endpoint, format } = getMiniMaxEndpoint(this.authConfig.baseUrl || '');
+        const requestBody = {
+            model: options.model || this.authConfig.modelName || 'MiniMax-M2',
+            messages: format === 'anthropic' ? anthropicMessages : messages,
+            temperature: options.temperature ?? 1.0,
+            stream: true,
+            max_tokens: options.maxTokens || 4096
+        };
+        if (system && format === 'anthropic') {
+            requestBody.system = system;
+        }
+        if (format === 'anthropic') {
+            // Anthropic 格式的工具
+            if (options.tools && options.tools.length > 0) {
+                requestBody.tools = options.tools.map(tool => ({
+                    name: tool.function.name,
+                    description: tool.function.description,
+                    input_schema: tool.function.parameters || { type: 'object', properties: {} }
+                }));
+                const toolChoice = options.toolChoice;
+                if (toolChoice === 'none') {
+                    requestBody.tool_choice = { type: 'auto' };
+                }
+                else if (toolChoice && typeof toolChoice === 'object') {
+                    if (toolChoice.type === 'function' && toolChoice.function) {
+                        requestBody.tool_choice = { type: 'tool', tool: { name: toolChoice.function.name } };
+                    }
+                    else {
+                        requestBody.tool_choice = { type: 'auto' };
+                    }
+                }
+                else {
+                    requestBody.tool_choice = { type: 'auto' };
+                }
+            }
+        }
+        else {
+            // OpenAI 格式的工具
+            if (options.tools && options.tools.length > 0) {
+                requestBody.tools = options.tools;
+                requestBody.tool_choice = options.toolChoice || 'auto';
+            }
+        }
+        console.log('\n╔══════════════════════════════════════════════════════════╗');
+        console.log('║            AI REQUEST DEBUG (MINIMAX STREAM)             ║');
+        console.log('╚══════════════════════════════════════════════════════════╝');
+        console.log(`📦 Model: ${requestBody.model}`);
+        console.log(`🔗 Format: ${format.toUpperCase()} | Endpoint: ${endpoint}`);
+        console.log(`🌐 Base URL: ${this.authConfig.baseUrl}`);
+        console.log(`💬 Total Messages: ${requestBody.messages.length} 条`);
+        if (requestBody.temperature)
+            console.log(`🌡️  Temperature: ${requestBody.temperature}`);
+        if (requestBody.max_tokens)
+            console.log(`📏 Max Tokens: ${requestBody.max_tokens}`);
+        console.log('─'.repeat(60));
+        // 显示system消息
+        if (system && format === 'anthropic') {
+            console.log('\n┌─────────────────────────────────────────────────────────────┐');
+            console.log('│ 🟫 SYSTEM                                                     │');
+            console.log('├─────────────────────────────────────────────────────────────┤');
+            console.log(renderMarkdown(system).split('\n').map(l => '│ ' + l).join('\n'));
+            console.log('└─────────────────────────────────────────────────────────────┘');
+        }
+        displayMessages(requestBody.messages);
+        console.log('\n📤 Starting MiniMax stream...\n');
+        try {
+            // MiniMax uses correct endpoint
+            const response = await this.client.post(endpoint, requestBody, {
+                responseType: 'stream'
+            });
+            console.log('📥 Receiving MiniMax stream chunks...\n');
+            let buffer = '';
+            let outputBuffer = '';
+            for await (const chunk of response.data) {
+                buffer += chunk.toString();
+                const lines = buffer.split('\n');
+                buffer = lines.pop() || '';
+                for (const line of lines) {
+                    const trimmedLine = line.trim();
+                    if (!trimmedLine)
+                        continue;
+                    // 根据格式解析不同的流式响应
+                    if (format === 'anthropic') {
+                        // Anthropic SSE 格式: data: {"type":"content_block_delta",...}
+                        if (trimmedLine.startsWith('data: ')) {
+                            const data = trimmedLine.slice(6);
+                            try {
+                                const parsed = JSON.parse(data);
+                                if (parsed.type === 'content_block_delta') {
+                                    if (parsed.delta?.type === 'text_delta' && parsed.delta.text) {
+                                        yield parsed.delta.text;
+                                    }
+                                    else if (parsed.delta?.type === 'thinking_delta' && parsed.delta.thinking) {
+                                        yield parsed.delta.thinking;
+                                    }
+                                }
+                                else if (parsed.type === 'message_delta') {
+                                    if (parsed.delta?.stop_reason) {
+                                        console.log('\n╔══════════════════════════════════════════════════════════╗');
+                                        console.log('║              STREAM COMPLETED                            ║');
+                                        console.log('╚══════════════════════════════════════════════════════════╝');
+                                        console.log(`📏 Total output: ${outputBuffer.length} chars`);
+                                        console.log('\n┌─────────────────────────────────────────────────────────────┐');
+                                        console.log('│ 🤖 ASSISTANT OUTPUT                                        │');
+                                        console.log('├─────────────────────────────────────────────────────────────┤');
+                                        console.log('│ 💬 CONTENT:');
+                                        console.log('│ ───────────────────────────────────────────────────────────');
+                                        const lines = renderMarkdown(outputBuffer).split('\n');
+                                        for (const line of lines.slice(0, 30)) {
+                                            console.log('│ ' + line.slice(0, 62));
+                                        }
+                                        if (lines.length > 30) {
+                                            console.log(`│ ... (${lines.length - 30} more lines)`);
+                                        }
+                                        console.log('└─────────────────────────────────────────────────────────────┘');
+                                        console.log('');
+                                        return;
+                                    }
+                                }
+                            }
+                            catch (e) {
+                                // 忽略解析错误
+                            }
+                        }
+                    }
+                    else {
+                        // OpenAI SSE 格式: data: {...}
+                        if (trimmedLine.startsWith('data: ')) {
+                            const data = trimmedLine.slice(6);
+                            if (data === '[DONE]')
+                                continue;
+                            try {
+                                const parsed = JSON.parse(data);
+                                const delta = parsed.choices?.[0]?.delta;
+                                if (delta?.content) {
+                                    outputBuffer += delta.content;
+                                    yield delta.content;
+                                }
+                                else if (delta?.reasoning_content) {
+                                    outputBuffer += delta.reasoning_content;
+                                    yield delta.reasoning_content;
+                                }
+                            }
+                            catch (e) {
+                                // 忽略解析错误
+                            }
+                        }
+                    }
+                }
+            }
+            console.log('\n╔══════════════════════════════════════════════════════════╗');
+            console.log('║              STREAM COMPLETED                            ║');
+            console.log('╚══════════════════════════════════════════════════════════╝\n');
+        }
+        catch (error) {
+            if (error.response) {
+                throw new Error(`API Error: ${error.response.status} - ${JSON.stringify(error.response.data)}`);
+            }
+            else if (error.request) {
+                throw new Error('Network error: No response received from server');
+            }
+            else {
+                throw new Error(`Request error: ${error.message}`);
+            }
+        }
+    }
+    async listModels() {
+        try {
+            const response = await this.client.get('/models');
+            return response.data.data || [];
+        }
+        catch (error) {
+            console.error('Failed to list models:', error);
+            return [];
+        }
+    }
+    updateAuthConfig(authConfig) {
+        this.authConfig = authConfig;
+        this.client.defaults.baseURL = authConfig.baseUrl;
+        const isMiniMax = detectMiniMaxAPI(authConfig.baseUrl || '');
+        const isAnthropic = !isMiniMax && isAnthropicCompatible(authConfig.baseUrl || '');
+        if (isMiniMax || isAnthropic) {
+            // MiniMax/Anthropic: Use x-api-key auth header
+            this.client.defaults.headers['x-api-key'] = authConfig.apiKey || '';
+            this.client.defaults.headers['anthropic-version'] = '2023-06-01';
+            // Clear Bearer header
+            delete this.client.defaults.headers['Authorization'];
+        }
+        else {
+            // OpenAI compatible: Use Bearer token
+            this.client.defaults.headers['Authorization'] = `Bearer ${authConfig.apiKey}`;
+            // Clear x-api-key header
+            delete this.client.defaults.headers['x-api-key'];
+            delete this.client.defaults.headers['anthropic-version'];
+        }
+    }
+    getAuthConfig() {
+        return { ...this.authConfig };
+    }
+    // Check if messages contain tool calls
+    hasToolCalls(messages) {
+        return messages.some(msg => {
+            if (msg.tool_calls && msg.tool_calls.length > 0)
+                return true;
+            if (Array.isArray(msg.content)) {
+                return msg.content.some(block => block.type === 'tool_use' ||
+                    block.type === 'tool_result');
+            }
+            return false;
+        });
+    }
+}
+export function detectThinkingKeywords(text) {
+    const ultraKeywords = ['super think', 'extreme think', 'deep think', 'full think', 'ultra think', 'careful think',
+        'ultrathink', 'think really super hard', 'think intensely'];
+    const megaKeywords = ['strong think', 'powerful think', 'think hard', 'try hard to think', 'think well', 'think carefully',
+        'megathink', 'think really hard', 'think a lot'];
+    const hardKeywords = ['think again', 'think more', 'think clearly', 'think thoroughly', 'consider carefully',
+        'think about it', 'think more', 'think harder'];
+    const normalKeywords = ['think', 'think', 'consider', 'think'];
+    const lowerText = text.toLowerCase();
+    if (ultraKeywords.some(keyword => lowerText.includes(keyword.toLowerCase()))) {
+        return 'ultra';
+    }
+    else if (megaKeywords.some(keyword => lowerText.includes(keyword.toLowerCase()))) {
+        return 'mega';
+    }
+    else if (hardKeywords.some(keyword => lowerText.includes(keyword.toLowerCase()))) {
+        return 'hard';
+    }
+    else if (normalKeywords.some(keyword => lowerText.includes(keyword.toLowerCase()))) {
+        return 'normal';
+    }
+    return 'none';
+}
+export function getThinkingTokens(mode) {
+    const tokensMap = {
+        none: 0,
+        normal: 2000,
+        hard: 4000,
+        mega: 10000,
+        ultra: 32000
+    };
+    return tokensMap[mode];
+}
+//# sourceMappingURL=ai-client.js.map