tabby-ai-assistant 1.0.5 → 1.0.6

package/src/services/core/ai-assistant.service.ts

@@ -1,20 +1,73 @@
-import { Injectable } from '@angular/core';
+import { Injectable, Inject, Optional } from '@angular/core';
 import { Observable, from, throwError } from 'rxjs';
 import { map, catchError, tap } from 'rxjs/operators';
-import { ChatMessage, MessageRole, ChatRequest, ChatResponse, CommandRequest, CommandResponse, ExplainRequest, ExplainResponse } from '../../types/ai.types';
+import { ChatMessage, MessageRole, ChatRequest, ChatResponse, CommandRequest, CommandResponse, ExplainRequest, ExplainResponse, StreamEvent } from '../../types/ai.types';
 import { AiProviderManagerService } from './ai-provider-manager.service';
 import { ConfigProviderService } from './config-provider.service';
 import { TerminalContextService } from '../terminal/terminal-context.service';
+import { TerminalToolsService, ToolCall, ToolResult } from '../terminal/terminal-tools.service';
 import { LoggerService } from './logger.service';
+import { BaseAiProvider } from '../../types/provider.types';
+
+// Import all provider services
+import { OpenAiProviderService } from '../providers/openai-provider.service';
+import { AnthropicProviderService } from '../providers/anthropic-provider.service';
+import { MinimaxProviderService } from '../providers/minimax-provider.service';
+import { GlmProviderService } from '../providers/glm-provider.service';
+import { OpenAiCompatibleProviderService } from '../providers/openai-compatible.service';
+import { OllamaProviderService } from '../providers/ollama-provider.service';
+import { VllmProviderService } from '../providers/vllm-provider.service';
 
 @Injectable({ providedIn: 'root' })
 export class AiAssistantService {
+    // 提供商映射表
+    private providerMapping: { [key: string]: BaseAiProvider } = {};
+
     constructor(
         private providerManager: AiProviderManagerService,
         private config: ConfigProviderService,
         private terminalContext: TerminalContextService,
-        private logger: LoggerService
-    ) {}
+        private terminalTools: TerminalToolsService,
+        private logger: LoggerService,
+        // 注入所有提供商服务
+        @Optional() private openaiProvider: OpenAiProviderService,
+        @Optional() private anthropicProvider: AnthropicProviderService,
+        @Optional() private minimaxProvider: MinimaxProviderService,
+        @Optional() private glmProvider: GlmProviderService,
+        @Optional() private openaiCompatibleProvider: OpenAiCompatibleProviderService,
+        @Optional() private ollamaProvider: OllamaProviderService,
+        @Optional() private vllmProvider: VllmProviderService
+    ) {
+        // 构建提供商映射表
+        this.buildProviderMapping();
+    }
+
+    /**
+     * 构建提供商映射表
+     */
+    private buildProviderMapping(): void {
+        if (this.openaiProvider) {
+            this.providerMapping['openai'] = this.openaiProvider;
+        }
+        if (this.anthropicProvider) {
+            this.providerMapping['anthropic'] = this.anthropicProvider;
+        }
+        if (this.minimaxProvider) {
+            this.providerMapping['minimax'] = this.minimaxProvider;
+        }
+        if (this.glmProvider) {
+            this.providerMapping['glm'] = this.glmProvider;
+        }
+        if (this.openaiCompatibleProvider) {
+            this.providerMapping['openai-compatible'] = this.openaiCompatibleProvider;
+        }
+        if (this.ollamaProvider) {
+            this.providerMapping['ollama'] = this.ollamaProvider;
+        }
+        if (this.vllmProvider) {
+            this.providerMapping['vllm'] = this.vllmProvider;
+        }
+    }
 
     /**
      * 初始化AI助手
@@ -28,15 +81,70 @@ export class AiAssistantService {
             return;
         }
 
+        // 注册并配置所有提供商
+        this.registerAllProviders();
+
         // 设置默认提供商
         const defaultProvider = this.config.getDefaultProvider();
         if (defaultProvider && this.providerManager.hasProvider(defaultProvider)) {
             this.providerManager.setActiveProvider(defaultProvider);
+            this.logger.info(`Active provider set to: ${defaultProvider}`);
+        } else {
+            // 尝试设置第一个已配置的提供商
+            const allConfigs = this.config.getAllProviderConfigs();
+            for (const [name, providerConfig] of Object.entries(allConfigs)) {
+                if (providerConfig?.apiKey && this.providerManager.hasProvider(name)) {
+                    this.providerManager.setActiveProvider(name);
+                    this.config.setDefaultProvider(name);
+                    this.logger.info(`Auto-selected provider: ${name}`);
+                    break;
+                }
+            }
         }
 
         this.logger.info('AI Assistant initialized successfully');
     }
 
+    /**
+     * 注册并配置所有提供商
+     */
+    private registerAllProviders(): void {
+        this.logger.info('Registering AI providers...');
+
+        const allConfigs = this.config.getAllProviderConfigs();
+        let registeredCount = 0;
+
+        for (const [name, providerConfig] of Object.entries(allConfigs)) {
+            const provider = this.providerMapping[name];
+            if (provider) {
+                try {
+                    // 配置提供商（这会初始化客户端）
+                    if (providerConfig) {
+                        provider.configure({
+                            ...providerConfig,
+                            enabled: providerConfig.enabled !== false
+                        });
+                        this.logger.info(`Provider ${name} configured`, {
+                            hasApiKey: !!providerConfig.apiKey,
+                            model: providerConfig.model
+                        });
+                    }
+
+                    // 注册到管理器
+                    this.providerManager.registerProvider(provider);
+                    registeredCount++;
+                    this.logger.info(`Provider registered: ${name}`);
+                } catch (error) {
+                    this.logger.error(`Failed to register provider: ${name}`, error);
+                }
+            } else {
+                this.logger.warn(`Provider not found in mapping: ${name}`);
+            }
+        }
+
+        this.logger.info(`Total providers registered: ${registeredCount}`);
+    }
+
     /**
      * 聊天功能
      */
@@ -54,7 +162,30 @@ export class AiAssistantService {
                 throw new Error(`Provider ${activeProvider.name} does not support chat capability`);
             }
 
-            const response = await activeProvider.chat(request);
+            // 如果启用工具调用，添加工具定义
+            if (request.enableTools !== false) {
+                request.tools = this.terminalTools.getToolDefinitions();
+            }
+
+            let response = await activeProvider.chat(request);
+
+            // 处理工具调用（如果响应包含工具调用）
+            response = await this.handleToolCalls(request, response, activeProvider);
+
+            // 添加：检测未调用工具的问题响应
+            const toolCalls = (response as any).toolCalls;
+            if (!toolCalls || toolCalls.length === 0) {
+                const content = response.message.content.toLowerCase();
+                const intentPatterns = ['我将向', '我会执行', '正在执行', '向终端写入'];
+                const hasExecutionIntent = intentPatterns.some(p => content.includes(p));
+
+                if (hasExecutionIntent) {
+                    this.logger.warn('AI stated execution intent but did not call tools');
+                    // 添加警告消息到响应中
+                    response.message.content += '\n\n⚠️ 注意：命令未实际执行。请明确告诉我需要执行的命令。';
+                }
+            }
+
             this.logger.info('Chat request completed successfully');
             return response;
 
@@ -64,6 +195,150 @@ export class AiAssistantService {
         }
     }
 
+    /**
+     * 流式聊天功能
+     */
+    chatStream(request: ChatRequest): Observable<any> {
+        const activeProvider = this.providerManager.getActiveProvider() as any;
+        if (!activeProvider) {
+            return throwError(() => new Error('No active AI provider available'));
+        }
+
+        // 检查提供商是否支持流式
+        if (!activeProvider.supportsCapability('streaming' as any)) {
+            this.logger.warn(`Provider ${activeProvider.name} does not support streaming, falling back to non-streaming`);
+            return from(this.chat(request));
+        }
+
+        // 添加工具定义
+        if (request.enableTools !== false) {
+            request.tools = this.terminalTools.getToolDefinitions();
+        }
+
+        // 调用流式方法
+        return activeProvider.chatStream(request).pipe(
+            tap((event: StreamEvent) => {
+                // 工具调用完成时执行
+                if (event.type === 'tool_use_end' && event.toolCall) {
+                    this.executeToolAndContinue(event.toolCall, request, activeProvider);
+                }
+            }),
+            catchError(error => {
+                this.logger.error('Stream error', error);
+                return throwError(() => error);
+            })
+        );
+    }
+
+    /**
+     * 执行工具调用（不阻塞流）
+     */
+    private async executeToolAndContinue(
+        toolCall: { id: string; name: string; input: any },
+        request: ChatRequest,
+        provider: any
+    ): Promise<void> {
+        try {
+            const result = await this.terminalTools.executeToolCall({
+                id: toolCall.id,
+                name: toolCall.name,
+                input: toolCall.input
+            });
+            this.logger.info('Tool executed in stream', { name: toolCall.name, result: result.content.substring(0, 100) });
+        } catch (error) {
+            this.logger.error('Tool execution failed in stream', error);
+        }
+    }
+
+    /**
+     * 处理工具调用
+     * @param maxDepth 最大递归深度，避免无限循环
+     */
+    private async handleToolCalls(
+        originalRequest: ChatRequest,
+        response: ChatResponse,
+        provider: BaseAiProvider,
+        depth: number = 0,
+        maxDepth: number = 10
+    ): Promise<ChatResponse> {
+        // 检查响应中是否有工具调用
+        const toolCalls = (response as any).toolCalls as ToolCall[] | undefined;
+
+        if (!toolCalls || toolCalls.length === 0) {
+            return response;
+        }
+
+        // 检查递归深度
+        if (depth >= maxDepth) {
+            this.logger.warn('Max tool call depth reached', { depth, maxDepth });
+            return response;
+        }
+
+        this.logger.info('Tool calls detected', { count: toolCalls.length, depth });
+
+        // 执行所有工具调用
+        const toolResults: ToolResult[] = [];
+        for (const toolCall of toolCalls) {
+            this.logger.info('Executing tool in handleToolCalls', { name: toolCall.name, depth });
+            const result = await this.terminalTools.executeToolCall(toolCall);
+            toolResults.push(result);
+        }
+
+        // 构建包含工具结果的新请求
+        const toolResultsMessage: ChatMessage = {
+            id: `tool_result_${Date.now()}`,
+            role: MessageRole.USER,
+            content: toolResults.map(r =>
+                `工具 ${r.tool_use_id} 结果:\n${r.content}`
+            ).join('\n\n'),
+            timestamp: new Date(),
+            metadata: { toolResults }
+        };
+
+        // 继续对话 - 仍然允许工具调用但递归处理
+        const followUpRequest: ChatRequest = {
+            ...originalRequest,
+            messages: [
+                ...originalRequest.messages,
+                response.message,
+                toolResultsMessage
+            ],
+            tools: this.terminalTools.getToolDefinitions()
+        };
+
+        // 发送后续请求
+        const followUpResponse = await provider.chat(followUpRequest);
+
+        // ===== 关键修复：如果 AI 回复太短，直接附加工具结果 =====
+        const minResponseLength = 50; // 如果回复少于50字符，认为AI没有正确展示结果
+        const toolResultsText = toolResults.map(r => r.content).join('\n\n');
+
+        if (followUpResponse.message.content.length < minResponseLength && toolResultsText.length > 0) {
+            this.logger.info('AI response too short, appending tool results directly', {
+                responseLength: followUpResponse.message.content.length,
+                toolResultsLength: toolResultsText.length
+            });
+
+            // 查找包含终端输出的工具结果
+            const terminalOutput = toolResults.find(r =>
+                r.content.includes('=== 终端输出 ===') ||
+                r.content.includes('✅ 命令已执行')
+            );
+
+            if (terminalOutput) {
+                followUpResponse.message.content =
+                    followUpResponse.message.content + '\n\n' + terminalOutput.content;
+            } else {
+                // 附加所有工具结果
+                followUpResponse.message.content =
+                    followUpResponse.message.content + '\n\n' + toolResultsText;
+            }
+        }
+
+        // 递归处理后续响应中的工具调用
+        return this.handleToolCalls(followUpRequest, followUpResponse, provider, depth + 1, maxDepth);
+    }
+
     /**
      * 生成命令
      */

package/src/services/core/ai-provider-manager.service.ts

@@ -151,7 +151,7 @@ export class AiProviderManagerService implements ProviderManager {
      * 验证所有提供商配置
      */
     async validateAllProviders(): Promise<{ name: string; valid: boolean; errors: string[] }[]> {
-        const results = [];
+        const results: { name: string; valid: boolean; errors: string[] }[] = [];
 
         for (const [name, provider] of this.providers) {
             try {
@@ -177,7 +177,7 @@ export class AiProviderManagerService implements ProviderManager {
      * 检查所有提供商健康状态
      */
     async checkAllProvidersHealth(): Promise<{ provider: string; status: string; latency?: number }[]> {
-        const results = [];
+        const results: { provider: string; status: string; latency?: number }[] = [];
 
         for (const [name, provider] of this.providers) {
             try {