tabby-ai-assistant 1.0.5 → 1.0.6

package/src/services/providers/minimax-provider.service.ts

@@ -1,8 +1,9 @@
 import { Injectable } from '@angular/core';
+import { Observable, Observer } from 'rxjs';
 import { Anthropic } from '@anthropic-ai/sdk';
 import { BaseAiProvider } from './base-provider.service';
 import { ProviderCapability, HealthStatus, ValidationResult } from '../../types/provider.types';
-import { ChatRequest, ChatResponse, CommandRequest, CommandResponse, ExplainRequest, ExplainResponse, AnalysisRequest, AnalysisResponse, MessageRole } from '../../types/ai.types';
+import { ChatRequest, ChatResponse, CommandRequest, CommandResponse, ExplainRequest, ExplainResponse, AnalysisRequest, AnalysisResponse, MessageRole, StreamEvent } from '../../types/ai.types';
 import { LoggerService } from '../core/logger.service';
 
 /**
@@ -79,14 +80,23 @@ export class MinimaxProviderService extends BaseAiProvider {
 
         try {
             const response = await this.withRetry(async () => {
-                const result = await this.client!.messages.create({
+                // 构建请求参数
+                const createParams: any = {
                     model: this.config?.model || 'MiniMax-M2',
                     max_tokens: request.maxTokens || 1000,
                     system: request.systemPrompt || this.getDefaultSystemPrompt(),
                     messages: this.transformMessages(request.messages),
                     temperature: request.temperature || 1.0,
                     stream: request.stream || false
-                });
+                };
+
+                // 如果有工具定义，添加到请求中
+                if (request.tools && request.tools.length > 0) {
+                    createParams.tools = request.tools;
+                    this.logger.info('Adding tools to request', { toolCount: request.tools.length });
+                }
+
+                const result = await this.client!.messages.create(createParams);
 
                 this.logResponse(result);
                 return result;
@@ -100,6 +110,109 @@ export class MinimaxProviderService extends BaseAiProvider {
         }
     }
 
+    /**
+     * 流式聊天功能
+     */
+    chatStream(request: ChatRequest): Observable<StreamEvent> {
+        return new Observable<StreamEvent>((subscriber: Observer<StreamEvent>) => {
+            if (!this.client) {
+                subscriber.error(new Error('Minimax client not initialized'));
+                return;
+            }
+
+            this.logRequest(request);
+
+            const runStream = async () => {
+                try {
+                    // 注意：SDK 类型定义可能不包含 tools，但 API 实际支持
+                    // 使用 as any 绕过类型检查
+                    const stream = (this.client!.messages.stream as any)({
+                        model: this.config?.model || 'MiniMax-M2',
+                        max_tokens: request.maxTokens || 1000,
+                        system: request.systemPrompt || this.getDefaultSystemPrompt(),
+                        messages: this.transformMessages(request.messages),
+                        temperature: request.temperature || 1.0,
+                        tools: request.tools  // 流式 API 支持工具调用
+                    });
+
+                    // 累积工具调用数据
+                    let currentToolId = '';
+                    let currentToolName = '';
+                    let currentToolInput = '';
+
+                    for await (const event of stream) {
+                        if (event.type === 'content_block_delta') {
+                            const delta = event.delta as any;
+                            // 文本增量
+                            if (delta.type === 'text_delta') {
+                                subscriber.next({
+                                    type: 'text_delta',
+                                    textDelta: delta.text
+                                });
+                            }
+                            // 工具输入增量
+                            else if (delta.type === 'input_json_delta') {
+                                currentToolInput += delta.partial_json || '';
+                            }
+                        }
+                        // 工具调用开始
+                        else if (event.type === 'content_block_start') {
+                            const block = event.content_block as any;
+                            if (block.type === 'tool_use') {
+                                currentToolId = block.id;
+                                currentToolName = block.name;
+                                currentToolInput = '';
+                                subscriber.next({ type: 'tool_use_start' });
+                            }
+                        }
+                        // 内容块结束
+                        else if (event.type === 'content_block_stop') {
+                            // 如果有工具调用，发送完整的工具调用
+                            if (currentToolId && currentToolName) {
+                                let parsedInput = {};
+                                try {
+                                    parsedInput = JSON.parse(currentToolInput || '{}');
+                                } catch (e) {
+                                    this.logger.warn('Failed to parse tool input', { input: currentToolInput });
+                                }
+                                subscriber.next({
+                                    type: 'tool_use_end',
+                                    toolCall: {
+                                        id: currentToolId,
+                                        name: currentToolName,
+                                        input: parsedInput
+                                    }
+                                });
+                                // 重置
+                                currentToolId = '';
+                                currentToolName = '';
+                                currentToolInput = '';
+                            }
+                        }
+                    }
+
+                    // 获取最终消息
+                    const finalMessage = await stream.finalMessage();
+                    subscriber.next({
+                        type: 'message_end',
+                        message: this.transformChatResponse(finalMessage).message
+                    });
+                    subscriber.complete();
+                } catch (error) {
+                    this.logError(error, { request });
+                    subscriber.error(new Error(`Minimax stream failed: ${error instanceof Error ? error.message : String(error)}`));
+                }
+            };
+
+            runStream();
+
+            // 返回取消订阅的处理函数
+            return () => {
+                this.logger.debug('Stream subscription cancelled');
+            };
+        });
+    }
+
     /**
      * 生成命令
      */
@@ -231,11 +344,26 @@ export class MinimaxProviderService extends BaseAiProvider {
 
     /**
      * 转换消息格式
+     * Anthropic API 支持两种格式：
+     * 1. 简单字符串: { role: 'user', content: 'Hello' }
+     * 2. 内容块数组: { role: 'user', content: [{ type: 'text', text: 'Hello' }] }
+     * 使用简单字符串格式以确保兼容性
      */
     protected transformMessages(messages: any[]): any[] {
-        return messages.map(msg => ({
-            role: msg.role,
-            content: [{ type: 'text', text: msg.content }]
+        // 过滤掉系统消息（system role 不应该在 messages 数组中）
+        const filteredMessages = messages.filter(msg =>
+            msg.role === 'user' || msg.role === 'assistant'
+        );
+
+        this.logger.info('Transforming messages', {
+            originalCount: messages.length,
+            filteredCount: filteredMessages.length,
+            roles: messages.map(m => m.role)
+        });
+
+        return filteredMessages.map(msg => ({
+            role: msg.role === 'user' ? 'user' : 'assistant',
+            content: String(msg.content || '')
         }));
     }
 
@@ -243,22 +371,74 @@ export class MinimaxProviderService extends BaseAiProvider {
      * 转换聊天响应
      */
     private transformChatResponse(response: any): ChatResponse {
-        const content = response.content[0];
-        const text = content.type === 'text' ? content.text : '';
+        this.logger.info('Transforming chat response', {
+            hasContent: !!response?.content,
+            contentLength: response?.content?.length,
+            responseKeys: Object.keys(response || {})
+        });
+
+        let text = '';
+        let toolCalls: any[] = [];
+
+        // 尝试多种方式提取响应文本和工具调用
+        if (response?.content) {
+            if (Array.isArray(response.content)) {
+                // Anthropic 格式: content 是数组
+                for (const block of response.content) {
+                    if (block.type === 'text') {
+                        text += block.text || '';
+                    } else if (block.type === 'tool_use') {
+                        // 提取工具调用
+                        toolCalls.push({
+                            id: block.id,
+                            name: block.name,
+                            input: block.input
+                        });
+                    }
+                }
+            } else if (typeof response.content === 'string') {
+                // 直接是字符串
+                text = response.content;
+            }
+        } else if (response?.message?.content) {
+            // 某些 API 可能使用 message.content
+            text = response.message.content;
+        } else if (response?.choices?.[0]?.message?.content) {
+            // OpenAI 兼容格式
+            text = response.choices[0].message.content;
+        }
 
-        return {
+        this.logger.info('Extracted response', {
+            textLength: text.length,
+            textPreview: text.substring(0, 100),
+            toolCallCount: toolCalls.length
+        });
+
+        if (!text && toolCalls.length === 0) {
+            this.logger.warn('Empty response text and no tool calls, full response:', response);
+        }
+
+        const result: any = {
             message: {
                 id: this.generateId(),
                 role: MessageRole.ASSISTANT,
                 content: text,
                 timestamp: new Date()
             },
-            usage: response.usage ? {
+            usage: response?.usage ? {
                 promptTokens: response.usage.input_tokens || 0,
                 completionTokens: response.usage.output_tokens || 0,
                 totalTokens: (response.usage.input_tokens || 0) + (response.usage.output_tokens || 0)
             } : undefined
         };
+
+        // 如果有工具调用，添加到响应中
+        if (toolCalls.length > 0) {
+            result.toolCalls = toolCalls;
+            this.logger.info('Tool calls extracted', { toolCalls });
+        }
+
+        return result;
     }
 
     /**
@@ -422,6 +602,24 @@ export class MinimaxProviderService extends BaseAiProvider {
      * 获取默认系统提示
      */
     private getDefaultSystemPrompt(): string {
-        return `你是一个专业的终端命令助手，擅长将自然语言转换为准确的命令，并提供详细的解释。`;
+        return `你是一个专业的终端命令助手，运行在 Tabby 终端中。
+
+## 核心能力
+你可以通过以下工具直接操作终端：
+- write_to_terminal: 向终端写入并执行命令
+- read_terminal_output: 读取终端输出
+- get_terminal_list: 获取所有终端列表
+- get_terminal_cwd: 获取当前工作目录
+
+## 重要规则
+1. 当用户请求执行命令（如"查看当前目录"、"列出文件"等），你必须使用 write_to_terminal 工具来执行
+2. 不要只是描述你"将要做什么"，而是直接调用工具执行
+3. 执行命令后，使用 read_terminal_output 读取结果并报告给用户
+4. 如果不确定当前目录或终端状态，先使用 get_terminal_cwd 或 get_terminal_list 获取信息
+
+## 示例
+用户："查看当前目录的文件"
+正确做法：调用 write_to_terminal 工具，参数 { "command": "dir", "execute": true }
+错误做法：仅回复文字"我将执行 dir 命令"`;
     }
 }