tabby-ai-assistant 1.0.13 → 1.0.15

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

@@ -1,9 +1,9 @@
 import { Injectable } from '@angular/core';
-import { Observable, from } from 'rxjs';
+import { Observable, Observer, from } from 'rxjs';
 import axios, { AxiosInstance } from 'axios';
 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 { ProviderCapability, ValidationResult } from '../../types/provider.types';
+import { ChatRequest, ChatResponse, CommandRequest, CommandResponse, ExplainRequest, ExplainResponse, AnalysisRequest, AnalysisResponse, MessageRole, StreamEvent } from '../../types/ai.types';
 import { LoggerService } from '../core/logger.service';
 
 /**
@@ -137,11 +137,144 @@ export class GlmProviderService extends BaseAiProvider {
     }
 
     /**
-     * 流式聊天功能 - 暂未实现，回退到非流式
+     * 流式聊天功能 - 支持工具调用事件
      */
-    chatStream(request: ChatRequest): Observable<any> {
-        // 回退到非流式
-        return from(this.chat(request));
+    chatStream(request: ChatRequest): Observable<StreamEvent> {
+        return new Observable<StreamEvent>((subscriber: Observer<StreamEvent>) => {
+            if (!this.client) {
+                const error = new Error('GLM client not initialized');
+                subscriber.next({ type: 'error', error: error.message });
+                subscriber.error(error);
+                return;
+            }
+
+            let currentToolId = '';
+            let currentToolName = '';
+            let currentToolInput = '';
+            let fullContent = '';
+
+            const abortController = new AbortController();
+
+            const runStream = async () => {
+                try {
+                    const response = await this.client!.post('/v1/messages', {
+                        model: this.config?.model || 'glm-4.6',
+                        max_tokens: request.maxTokens || 1000,
+                        system: request.systemPrompt || this.getDefaultSystemPrompt(),
+                        messages: this.transformMessages(request.messages),
+                        temperature: request.temperature || 0.95,
+                        stream: true
+                    }, {
+                        responseType: 'stream'
+                    });
+
+                    const stream = response.data;
+                    const decoder = new TextDecoder();
+                    let buffer = '';
+
+                    for await (const chunk of stream) {
+                        if (abortController.signal.aborted) break;
+
+                        buffer += decoder.decode(chunk, { stream: true });
+                        const lines = buffer.split('\n');
+                        buffer = lines.pop() || '';
+
+                        for (const line of lines) {
+                            if (line.startsWith('data:')) {
+                                const data = line.slice(5).trim();
+                                if (data === '[DONE]') continue;
+
+                                try {
+                                    const parsed = JSON.parse(data);
+                                    const eventType = parsed.type;
+                                    const eventData = parsed;
+
+                                    this.logger.debug('Stream event', { type: eventType });
+
+                                    // 处理文本增量
+                                    if (eventType === 'content_block_delta' && eventData.delta?.type === 'text_delta') {
+                                        const textDelta = eventData.delta.text;
+                                        fullContent += textDelta;
+                                        subscriber.next({
+                                            type: 'text_delta',
+                                            textDelta
+                                        });
+                                    }
+                                    // 处理工具调用开始
+                                    else if (eventType === 'content_block_start' && eventData.content_block?.type === 'tool_use') {
+                                        currentToolId = eventData.content_block.id || `tool_${Date.now()}`;
+                                        currentToolName = eventData.content_block.name;
+                                        currentToolInput = '';
+                                        subscriber.next({
+                                            type: 'tool_use_start',
+                                            toolCall: {
+                                                id: currentToolId,
+                                                name: currentToolName,
+                                                input: {}
+                                            }
+                                        });
+                                        this.logger.debug('Stream event', { type: 'tool_use_start', name: currentToolName });
+                                    }
+                                    // 处理工具调用参数
+                                    else if (eventType === 'content_block_delta' && eventData.delta?.type === 'input_json_delta') {
+                                        currentToolInput += eventData.delta.partial_json || '';
+                                    }
+                                    // 处理工具调用结束
+                                    else if (eventType === 'content_block_stop') {
+                                        if (currentToolId && currentToolName) {
+                                            let parsedInput = {};
+                                            try {
+                                                parsedInput = JSON.parse(currentToolInput || '{}');
+                                            } catch (e) {
+                                                // 使用原始输入
+                                            }
+                                            subscriber.next({
+                                                type: 'tool_use_end',
+                                                toolCall: {
+                                                    id: currentToolId,
+                                                    name: currentToolName,
+                                                    input: parsedInput
+                                                }
+                                            });
+                                            this.logger.debug('Stream event', { type: 'tool_use_end', name: currentToolName });
+                                            currentToolId = '';
+                                            currentToolName = '';
+                                            currentToolInput = '';
+                                        }
+                                    }
+                                } catch (e) {
+                                    // 忽略解析错误
+                                }
+                            }
+                        }
+                    }
+
+                    subscriber.next({
+                        type: 'message_end',
+                        message: {
+                            id: this.generateId(),
+                            role: MessageRole.ASSISTANT,
+                            content: fullContent,
+                            timestamp: new Date()
+                        }
+                    });
+                    this.logger.debug('Stream event', { type: 'message_end', contentLength: fullContent.length });
+                    subscriber.complete();
+
+                } catch (error) {
+                    if ((error as any).name !== 'AbortError') {
+                        const errorMessage = `GLM stream failed: ${error instanceof Error ? error.message : String(error)}`;
+                        this.logger.error('Stream error', error);
+                        subscriber.next({ type: 'error', error: errorMessage });
+                        subscriber.error(new Error(errorMessage));
+                    }
+                }
+            };
+
+            runStream();
+
+            return () => abortController.abort();
+        });
     }
 
     /**
@@ -213,39 +346,19 @@ export class GlmProviderService extends BaseAiProvider {
         return this.parseAnalysisResponse(response.message.content);
     }
 
-    /**
-     * 健康检查
-     */
-    async healthCheck(): Promise<HealthStatus> {
-        try {
-            if (!this.client) {
-                return HealthStatus.UNHEALTHY;
-            }
-
-            // 简单的测试请求
-            const response = await this.client.post('/v1/messages', {
-                model: this.config?.model || 'glm-4.6',
-                max_tokens: 1,
-                messages: [
-                    {
-                        role: 'user',
-                        content: [{ type: 'text', text: 'Hi' }]
-                    }
-                ]
-            });
-
-            if (response.status === 200) {
-                this.lastHealthCheck = { status: HealthStatus.HEALTHY, timestamp: new Date() };
-                return HealthStatus.HEALTHY;
-            }
+    protected async sendTestRequest(request: ChatRequest): Promise<ChatResponse> {
+        if (!this.client) {
+            throw new Error('GLM client not initialized');
+        }
 
-            return HealthStatus.DEGRADED;
+        const response = await this.client.post('/v1/messages', {
+            model: this.config?.model || 'glm-4.6',
+            max_tokens: request.maxTokens || 1,
+            messages: this.transformMessages(request.messages),
+            temperature: request.temperature || 0
+        });
 
-        } catch (error) {
-            this.logger.error('GLM health check failed', error);
-            this.lastHealthCheck = { status: HealthStatus.UNHEALTHY, timestamp: new Date() };
-            return HealthStatus.UNHEALTHY;
-        }
+        return this.transformChatResponse(response.data);
     }
 
     /**

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

@@ -2,7 +2,7 @@ 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 { ProviderCapability, ValidationResult } from '../../types/provider.types';
 import { ChatRequest, ChatResponse, CommandRequest, CommandResponse, ExplainRequest, ExplainResponse, AnalysisRequest, AnalysisResponse, MessageRole, StreamEvent } from '../../types/ai.types';
 import { LoggerService } from '../core/logger.service';
 
@@ -116,12 +116,16 @@ 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'));
+                const error = new Error('Minimax client not initialized');
+                subscriber.next({ type: 'error', error: error.message });
+                subscriber.error(error);
                 return;
             }
 
             this.logRequest(request);
 
+            const abortController = new AbortController();
+
             const runStream = async () => {
                 try {
                     // 注意：SDK 类型定义可能不包含 tools，但 API 实际支持
@@ -141,6 +145,10 @@ export class MinimaxProviderService extends BaseAiProvider {
                     let currentToolInput = '';
 
                     for await (const event of stream) {
+                        if (abortController.signal.aborted) break;
+
+                        this.logger.debug('Stream event', { type: event.type });
+
                         if (event.type === 'content_block_delta') {
                             const delta = event.delta as any;
                             // 文本增量
@@ -162,7 +170,15 @@ export class MinimaxProviderService extends BaseAiProvider {
                                 currentToolId = block.id;
                                 currentToolName = block.name;
                                 currentToolInput = '';
-                                subscriber.next({ type: 'tool_use_start' });
+                                subscriber.next({
+                                    type: 'tool_use_start',
+                                    toolCall: {
+                                        id: currentToolId,
+                                        name: currentToolName,
+                                        input: {}
+                                    }
+                                });
+                                this.logger.debug('Stream event', { type: 'tool_use_start', name: currentToolName });
                             }
                         }
                         // 内容块结束
@@ -183,6 +199,7 @@ export class MinimaxProviderService extends BaseAiProvider {
                                         input: parsedInput
                                     }
                                 });
+                                this.logger.debug('Stream event', { type: 'tool_use_end', name: currentToolName });
                                 // 重置
                                 currentToolId = '';
                                 currentToolName = '';
@@ -197,19 +214,22 @@ export class MinimaxProviderService extends BaseAiProvider {
                         type: 'message_end',
                         message: this.transformChatResponse(finalMessage).message
                     });
+                    this.logger.debug('Stream event', { type: 'message_end' });
                     subscriber.complete();
                 } catch (error) {
-                    this.logError(error, { request });
-                    subscriber.error(new Error(`Minimax stream failed: ${error instanceof Error ? error.message : String(error)}`));
+                    if ((error as any).name !== 'AbortError') {
+                        const errorMessage = `Minimax stream failed: ${error instanceof Error ? error.message : String(error)}`;
+                        this.logError(error, { request });
+                        subscriber.next({ type: 'error', error: errorMessage });
+                        subscriber.error(new Error(errorMessage));
+                    }
                 }
             };
 
             runStream();
 
             // 返回取消订阅的处理函数
-            return () => {
-                this.logger.debug('Stream subscription cancelled');
-            };
+            return () => abortController.abort();
         });
     }
 
@@ -282,35 +302,19 @@ export class MinimaxProviderService extends BaseAiProvider {
         return this.parseAnalysisResponse(response.message.content);
     }
 
-    /**
-     * 健康检查
-     */
-    async healthCheck(): Promise<HealthStatus> {
-        try {
-            if (!this.client) {
-                return HealthStatus.UNHEALTHY;
-            }
-
-            // 简单的测试请求
-            const _response = await this.client.messages.create({
-                model: this.config?.model || 'MiniMax-M2',
-                max_tokens: 1,
-                messages: [
-                    {
-                        role: 'user',
-                        content: 'Hi'
-                    }
-                ]
-            });
+    protected async sendTestRequest(request: ChatRequest): Promise<ChatResponse> {
+        if (!this.client) {
+            throw new Error('Minimax client not initialized');
+        }
 
-            this.lastHealthCheck = { status: HealthStatus.HEALTHY, timestamp: new Date() };
-            return HealthStatus.HEALTHY;
+        const response = await this.client.messages.create({
+            model: this.config?.model || 'MiniMax-M2',
+            max_tokens: request.maxTokens || 1,
+            messages: this.transformMessages(request.messages),
+            temperature: request.temperature || 0
+        });
 
-        } catch (error) {
-            this.logger.error('Minimax health check failed', error);
-            this.lastHealthCheck = { status: HealthStatus.UNHEALTHY, timestamp: new Date() };
-            return HealthStatus.UNHEALTHY;
-        }
+        return this.transformChatResponse(response);
     }
 
     /**
@@ -343,8 +347,9 @@ export class MinimaxProviderService extends BaseAiProvider {
      */
     protected transformMessages(messages: any[]): any[] {
         // 过滤掉系统消息（system role 不应该在 messages 数组中）
+        // 保留 user, assistant, tool 角色的消息
         const filteredMessages = messages.filter(msg =>
-            msg.role === 'user' || msg.role === 'assistant'
+            msg.role === 'user' || msg.role === 'assistant' || msg.role === 'tool'
         );
 
         this.logger.info('Transforming messages', {
@@ -353,10 +358,20 @@ export class MinimaxProviderService extends BaseAiProvider {
             roles: messages.map(m => m.role)
         });
 
-        return filteredMessages.map(msg => ({
-            role: msg.role === 'user' ? 'user' : 'assistant',
-            content: String(msg.content || '')
-        }));
+        return filteredMessages.map(msg => {
+            // tool 角色消息转换为 user 角色（Anthropic API 不直接支持 tool 角色）
+            // 但内容保留工具结果标识，让 AI 理解这是工具执行结果
+            if (msg.role === 'tool') {
+                return {
+                    role: 'user',
+                    content: String(msg.content || '')
+                };
+            }
+            return {
+                role: msg.role === 'user' ? 'user' : 'assistant',
+                content: String(msg.content || '')
+            };
+        });
     }
 
     /**

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

@@ -1,7 +1,7 @@
 import { Injectable } from '@angular/core';
-import { Observable, Observer, from } from 'rxjs';
+import { Observable, Observer } from 'rxjs';
 import { BaseAiProvider } from './base-provider.service';
-import { ProviderCapability, HealthStatus, ValidationResult } from '../../types/provider.types';
+import { ProviderCapability, ValidationResult } from '../../types/provider.types';
 import { ChatRequest, ChatResponse, StreamEvent, MessageRole, CommandRequest, CommandResponse, ExplainRequest, ExplainResponse, AnalysisRequest, AnalysisResponse } from '../../types/ai.types';
 import { LoggerService } from '../core/logger.service';
 
@@ -74,7 +74,7 @@ export class OllamaProviderService extends BaseAiProvider {
     }
 
     /**
-     * 流式聊天
+     * 流式聊天功能 - 支持工具调用事件
      */
     chatStream(request: ChatRequest): Observable<StreamEvent> {
         return new Observable<StreamEvent>((subscriber: Observer<StreamEvent>) => {
@@ -108,9 +108,16 @@ export class OllamaProviderService extends BaseAiProvider {
                         throw new Error('No response body');
                     }
 
+                    // 工具调用状态跟踪
+                    let currentToolCallId = '';
+                    let currentToolCallName = '';
+                    let currentToolInput = '';
+                    let currentToolIndex = -1;
                     let fullContent = '';
 
                     while (true) {
+                        if (abortController.signal.aborted) break;
+
                         const { done, value } = await reader.read();
                         if (done) break;
 
@@ -123,8 +130,62 @@ export class OllamaProviderService extends BaseAiProvider {
 
                             try {
                                 const parsed = JSON.parse(data);
-                                const delta = parsed.choices[0]?.delta?.content;
-                                if (delta) {
+                                const choice = parsed.choices?.[0];
+
+                                this.logger.debug('Stream event', { type: 'delta', hasToolCalls: !!choice?.delta?.tool_calls });
+
+                                // 处理工具调用块
+                                if (choice?.delta?.tool_calls?.length > 0) {
+                                    for (const toolCall of choice.delta.tool_calls) {
+                                        const index = toolCall.index || 0;
+
+                                        // 新工具调用开始
+                                        if (currentToolIndex !== index) {
+                                            if (currentToolIndex >= 0) {
+                                                // 发送前一个工具调用的结束事件
+                                                let parsedInput = {};
+                                                try {
+                                                    parsedInput = JSON.parse(currentToolInput || '{}');
+                                                } catch (e) {
+                                                    // 使用原始输入
+                                                }
+                                                subscriber.next({
+                                                    type: 'tool_use_end',
+                                                    toolCall: {
+                                                        id: currentToolCallId,
+                                                        name: currentToolCallName,
+                                                        input: parsedInput
+                                                    }
+                                                });
+                                                this.logger.debug('Stream event', { type: 'tool_use_end', name: currentToolCallName });
+                                            }
+
+                                            currentToolIndex = index;
+                                            currentToolCallId = toolCall.id || `tool_${Date.now()}_${index}`;
+                                            currentToolCallName = toolCall.function?.name || '';
+                                            currentToolInput = toolCall.function?.arguments || '';
+
+                                            // 发送工具调用开始事件
+                                            subscriber.next({
+                                                type: 'tool_use_start',
+                                                toolCall: {
+                                                    id: currentToolCallId,
+                                                    name: currentToolCallName,
+                                                    input: {}
+                                                }
+                                            });
+                                            this.logger.debug('Stream event', { type: 'tool_use_start', name: currentToolCallName });
+                                        } else {
+                                            // 继续累积参数
+                                            if (toolCall.function?.arguments) {
+                                                currentToolInput += toolCall.function.arguments;
+                                            }
+                                        }
+                                    }
+                                }
+                                // 处理文本增量
+                                else if (choice?.delta?.content) {
+                                    const delta = choice.delta.content;
                                     fullContent += delta;
                                     subscriber.next({
                                         type: 'text_delta',
@@ -137,6 +198,25 @@ export class OllamaProviderService extends BaseAiProvider {
                         }
                     }
 
+                    // 发送最后一个工具调用的结束事件
+                    if (currentToolIndex >= 0) {
+                        let parsedInput = {};
+                        try {
+                            parsedInput = JSON.parse(currentToolInput || '{}');
+                        } catch (e) {
+                            // 使用原始输入
+                        }
+                        subscriber.next({
+                            type: 'tool_use_end',
+                            toolCall: {
+                                id: currentToolCallId,
+                                name: currentToolCallName,
+                                input: parsedInput
+                            }
+                        });
+                        this.logger.debug('Stream event', { type: 'tool_use_end', name: currentToolCallName });
+                    }
+
                     subscriber.next({
                         type: 'message_end',
                         message: {
@@ -146,11 +226,14 @@ export class OllamaProviderService extends BaseAiProvider {
                             timestamp: new Date()
                         }
                     });
+                    this.logger.debug('Stream event', { type: 'message_end', contentLength: fullContent.length });
                     subscriber.complete();
                 } catch (error) {
                     if ((error as any).name !== 'AbortError') {
+                        const errorMessage = `Ollama stream failed: ${error instanceof Error ? error.message : String(error)}`;
                         this.logError(error, { request });
-                        subscriber.error(new Error(`Ollama stream failed: ${error instanceof Error ? error.message : String(error)}`));
+                        subscriber.next({ type: 'error', error: errorMessage });
+                        subscriber.error(new Error(errorMessage));
                     }
                 }
             };
@@ -162,30 +245,36 @@ export class OllamaProviderService extends BaseAiProvider {
         });
     }
 
-    /**
-     * 健康检查 - 检测 Ollama 服务是否运行
-     */
-    async healthCheck(): Promise<HealthStatus> {
-        try {
-            const controller = new AbortController();
-            const timeoutId = setTimeout(() => controller.abort(), 5000);
-
-            const response = await fetch(`${this.getBaseURL()}/models`, {
-                method: 'GET',
-                signal: controller.signal
-            });
-
-            clearTimeout(timeoutId);
+    protected async sendTestRequest(request: ChatRequest): Promise<ChatResponse> {
+        const response = await fetch(`${this.getBaseURL()}/chat/completions`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                model: this.config?.model || 'llama3.1',
+                messages: this.transformMessages(request.messages),
+                max_tokens: request.maxTokens || 1,
+                temperature: request.temperature || 0
+            })
+        });
 
-            if (response.ok) {
-                this.lastHealthCheck = { status: HealthStatus.HEALTHY, timestamp: new Date() };
-                return HealthStatus.HEALTHY;
-            }
-            return HealthStatus.UNHEALTHY;
-        } catch (error) {
-            this.logger.warn('Ollama health check failed', error);
-            return HealthStatus.UNHEALTHY;
+        if (!response.ok) {
+            throw new Error(`Ollama API error: ${response.status}`);
         }
+
+        const data = await response.json();
+        return {
+            message: {
+                id: this.generateId(),
+                role: MessageRole.ASSISTANT,
+                content: data.choices[0]?.message?.content || '',
+                timestamp: new Date()
+            },
+            usage: data.usage ? {
+                promptTokens: data.usage.prompt_tokens,
+                completionTokens: data.usage.completion_tokens,
+                totalTokens: data.usage.total_tokens
+            } : undefined
+        };
     }
 
     /**