my-ai-chat-framework 1.1.0 → 2.0.0

package/src/index.js

@@ -1,540 +1,15 @@
-// 这是 AI 聊天框架的入口文件
-// 导出所有核心组件供外部使用
-
-import Messages from './core/Messages.js';
-import RequestBuilder from './core/RequestBuilder.js';
-import ApiClient from './core/ApiClient.js';
-import EventEmitter from './core/EventEmitter.js';
-import MessageFormatter from './core/MessageFormatter.js';
-import ToolManager from './core/ToolManager.js';
-import ConfigManager from './core/ConfigManager.js';
-import defaultConfig from './config/defaults.js'; // 默认配置
-
-// 导出所有核心类
-export { Messages, RequestBuilder, ApiClient, EventEmitter, MessageFormatter, ToolManager };
-
-// ChatService类，继承EventEmitter
-class ChatService extends EventEmitter {
-  constructor(options = {}) {
-    super();
-    
-    // 配置：是否自动添加消息（默认启用）
-    this.autoAddMessages = options.autoAddMessages ?? true;
-    
-    // 创建配置管理器
-    this.configManager = new ConfigManager({
-      ...defaultConfig,
-      ...options
-    });
-    
-    // 初始化组件
-    this.messages = new Messages();
-    this.apiClient = new ApiClient(
-      this.configManager.config.api.key,
-      this.configManager.config.api.url
-    );
-    this.requestBuilder = new RequestBuilder(
-      this.configManager.config.model.name,
-      this.messages,
-      {
-        temperature: this.configManager.config.model.temperature,
-        max_tokens: this.configManager.config.model.maxTokens,
-        stream: this.configManager.config.model.stream,
-        reasoning_effort: this.configManager.config.model.reasoningEffort
-      }
-    );
-    this.toolManager = new ToolManager();
-    
-    // 设置配置变更处理器
-    this._setupConfigHandlers();
-    
-    this._setupDefaultListeners();
-  }
-
-  /**
-   * 设置配置变更处理器
-   */
-  _setupConfigHandlers() {
-    // API Key 变更
-    this.configManager.registerHandler('api.key', (newValue) => {
-      this.apiClient.setApiKey(newValue);
-    });
-    
-    // API URL 变更
-    this.configManager.registerHandler('api.url', (newValue) => {
-      this.apiClient.setApiUrl(newValue);
-    });
-    
-    // 模型名称变更
-    this.configManager.registerHandler('model.name', (newValue) => {
-      this.requestBuilder.model = newValue;
-    });
-    
-    // 温度变更
-    this.configManager.registerHandler('model.temperature', (newValue) => {
-      this.requestBuilder.config.temperature = newValue;
-    });
-    
-    // 流式模式变更
-    this.configManager.registerHandler('model.stream', (newValue) => {
-      this.requestBuilder.config.stream = newValue;
-    });
-    
-    // 调试模式变更
-    this.configManager.registerHandler('debug', (newValue) => {
-      if (newValue) {
-        console.log('🔧 调试模式已启用');
-      }
-    });
-    
-    // 监听所有配置变更
-    this.configManager.on('config-changed', (data) => {
-      this.emit('service-config-changed', data);
-    });
-  }
-
-  /**
-   * 便捷方法：快速设置 API
-   */
-  setApi(key, url) {
-    this.configManager.update({
-      api: { key, url }
-    });
-    return this;
-  }
-
-  /**
-   * 便捷方法：快速设置模型
-   */
-  setModel(name, temperature = 0.7) {
-    this.configManager.update({
-      model: { name, temperature }
-    });
-    return this;
-  }
-
-  _setupDefaultListeners() {
-    // 监听API客户端的事件
-    this.apiClient.on('request-start', (data) => {
-      this.emit('request-start', data);
-    });
-    
-    this.apiClient.on('request-success', (data) => {
-      this.emit('request-success', data);
-    });
-    
-    this.apiClient.on('request-error', (data) => {
-      this.emit('request-error', data);
-    });
-    
-    this.apiClient.on('stream-chunk', (data) => {
-      this.emit('stream-chunk', data);
-    });
-
-    // 监听工具管理器的事件
-    this.toolManager.on('tool-execute-start', (data) => {
-      this.emit('tool-execute-start', data);
-    });
-    
-    this.toolManager.on('tool-execute-success', (data) => {
-      this.emit('tool-execute-success', data);
-    });
-    
-    this.toolManager.on('tool-execute-error', (data) => {
-      this.emit('tool-execute-error', data);
-    });
-  }
-
-  /**
-   * 注册工具
-   */
-  registerTool(name, definition, executor) {
-    // 1. 在ToolManager中注册
-    this.toolManager.registerTool(name, definition, executor);
-    
-    // 2. 在Messages中添加工具定义（用于发送给AI）
-    this.messages.addTool(definition);
-    
-    return this; // 支持链式调用
-  }
-
-  /**
-   * 发送消息（支持工具调用）
-   */
-  async send(userMessage, options = {}) {
-    try {
-      // 触发事件：开始发送（符合Messages格式）
-      this.emit('sending', { 
-        role: 'user', 
-        content: userMessage,
-        timestamp: new Date(),
-        eventType: 'sending'
-      });
-      
-      // 添加用户消息
-      this.messages.addUserMessage(userMessage);
-      
-      // 构建请求体（会自动包含工具定义）
-      // 注意：这里需要确保RequestBuilder的配置正确
-      const requestBody = this.requestBuilder.toJSON(
-        options.baseRounds, 
-        options.cycleRounds
-      );
-      
-      // 发送请求
-      const response = await this.apiClient.send(requestBody);
-      const aiMessage = response.choices[0].message;
-      
-      // 检查是否有工具调用
-      if (aiMessage.tool_calls && aiMessage.tool_calls.length > 0) {
-        // 处理工具调用
-        return await this._handleToolCalls(aiMessage);
-      } else {
-        // 普通回复
-        const eventData = await this._handleNormalResponse(aiMessage);
-        return eventData.content;
-      }
-    } catch (error) {
-      this.emit('error', {
-        error: error,
-        message: userMessage,
-        timestamp: new Date()
-      });
-      throw error;
-    }
-  }
-
-  /**
-   * 处理工具调用（支持循环调用）
-   */
-  async _handleToolCalls(aiMessage, maxIterations = 5) {
-    let iteration = 0;
-    let currentMessage = aiMessage;
-    
-    // 循环处理工具调用，直到没有工具调用或达到最大迭代次数
-    while (iteration < maxIterations) {
-      iteration++;
-      
-      // 1. 添加助手消息（包含工具调用和思考内容）
-      this.messages.addAssistantMessage(currentMessage.content || '', {
-        tool_calls: currentMessage.tool_calls,
-        reasoning_content: currentMessage.reasoning_content || '' // ✅ 新增：保存思考内容
-      });
-      
-      // 触发事件：AI请求工具调用
-      this.emit('tool-call-requested', {
-        tool_calls: currentMessage.tool_calls,
-        reasoning_content: currentMessage.reasoning_content, // ✅ 新增：包含思考内容
-        timestamp: new Date(),
-        iteration: iteration
-      });
-      
-      // 2. 执行工具
-      const toolResults = await this.toolManager.executeToolCalls(currentMessage.tool_calls);
-      
-      // 3. 添加工具结果消息
-      for (const result of toolResults) {
-        this.messages.addToolMessage(
-          result.result || result.error || '', 
-          result.tool_call_id
-        );
-      }
-      
-      // 4. 再次发送请求，获取AI对工具结果的响应
-      const requestBody = this.requestBuilder.toJSON();
-      
-      const response = await this.apiClient.send(requestBody);
-      currentMessage = response.choices[0].message;
-      
-      // 5. 检查AI是否还有新的工具调用请求
-      if (!currentMessage.tool_calls || currentMessage.tool_calls.length === 0) {
-        // 没有更多工具调用，结束循环
-        break;
-      }
-    }
-    
-    // 6. 添加最终助手消息 - 使用统一方法处理
-    const eventData = await this._handleAssistantResponse(currentMessage, { 
-      toolIterations: iteration 
-    });
-    
-    return eventData.content;
-  }
-
-  /**
-   * 处理助手回复（统一方法，用于普通和流式请求）
-   */
-  async _handleAssistantResponse(aiMessage, options = {}) {
-    const { isStreaming = false, toolIterations = 0, skipAddMessage = false } = options;
-    
-    // 根据配置决定是否添加消息
-    const shouldAddMessage = this.autoAddMessages && !skipAddMessage;
-    
-    if (shouldAddMessage) {
-      // 添加助手消息，处理空内容
-      this.messages.addAssistantMessage(aiMessage.content || '', {
-        reasoning_content: aiMessage.reasoning_content
-      });
-    }
-    
-    // 统一的事件数据结构（直接使用Messages格式）
-    const eventData = {
-      // 基础字段（Messages格式）
-      role: 'assistant',
-      content: aiMessage.content || '',
-      timestamp: new Date(),
-      
-      // 扩展字段
-      ...(aiMessage.reasoning_content && { reasoning_content: aiMessage.reasoning_content }),
-      ...(aiMessage.tool_calls && { tool_calls: aiMessage.tool_calls }),
-      ...(aiMessage.tool_call_id && { tool_call_id: aiMessage.tool_call_id }),
-      
-      // 框架元数据
-      isStreaming,
-      toolIterations,
-      eventType: isStreaming ? 'stream-complete' : 'response-complete',
-      
-      // 保留原始响应（只有普通请求有）
-      ...(isStreaming ? {} : {
-        response: { choices: [{ message: aiMessage }] }
-      })
-    };
-    
-    // 统一使用 'message' 事件
-    this.emit('message', eventData);
-    
-    return eventData;
-  }
-
-  /**
-   * 处理普通回复
-   */
-  async _handleNormalResponse(aiMessage) {
-    return await this._handleAssistantResponse(aiMessage);
-  }
-
-  /**
-   * 流式发送消息（支持工具调用）
-   */
-  async stream(userMessage, onProgress, onDone, options = {}) {
-    try {
-      // 触发事件：开始发送（符合Messages格式）
-      this.emit('sending', { 
-        role: 'user', 
-        content: userMessage,
-        timestamp: new Date(),
-        eventType: 'sending'
-      });
-      
-      // 添加用户消息
-      this.messages.addUserMessage(userMessage);
-      
-      // 构建请求体 - 关键：设置stream: true
-      const requestBuilder = new RequestBuilder(this.requestBuilder.model, this.messages, {
-        ...this.requestBuilder.config,
-        stream: true  // ✅ 必须设置为true！
-      });
-      
-      const requestBody = requestBuilder.toJSON(
-        options.baseRounds, 
-        options.cycleRounds
-      );
-      
-      // 流式发送 - 使用可选的回调函数
-      const response = await this.apiClient.strSend(
-        requestBody,
-        // 如果 onProgress 是函数就调用，否则用空函数
-        typeof onProgress === 'function' 
-          ? (chunk) => {
-              this.emit('stream-progress', chunk);
-              onProgress(chunk);
-            }
-          : (chunk) => {
-              this.emit('stream-progress', chunk);
-            },
-        typeof onDone === 'function'
-          ? async (finalMessage) => {
-              // 流式完成回调
-              if (finalMessage.tool_calls && finalMessage.tool_calls.length > 0) {
-                // 处理流式中的工具调用
-                await this._handleStreamToolCalls(finalMessage, onProgress, onDone);
-              } else {
-                // 普通流式回复 - 使用统一方法处理（跳过添加消息，因为用户可能已经手动添加了）
-                const eventData = await this._handleAssistantResponse(finalMessage, { 
-                  isStreaming: true, 
-                  skipAddMessage: true 
-                });
-                onDone(eventData);
-              }
-            }
-          : async (finalMessage) => {
-              // 只触发事件，不调用回调
-              if (finalMessage.tool_calls && finalMessage.tool_calls.length > 0) {
-                await this._handleStreamToolCalls(finalMessage);
-              } else {
-                await this._handleAssistantResponse(finalMessage, { 
-                  isStreaming: true, 
-                  skipAddMessage: true 
-                });
-              }
-            }
-      );
-      
-      return response;
-    } catch (error) {
-      this.emit('error', {
-        error: error,
-        message: userMessage,
-        timestamp: new Date()
-      });
-      throw error;
-    }
-  }
-
-  /**
-   * 处理流式传输中的工具调用（支持循环调用）
-   */
-  async _handleStreamToolCalls(aiMessage, onProgress, onDone, maxIterations = 5) {
-    let iteration = 0;
-    let currentMessage = aiMessage;
-    
-    // 循环处理工具调用
-    while (iteration < maxIterations) {
-      iteration++;
-      
-      // 1. 添加助手消息（包含工具调用和思考内容）
-      this.messages.addAssistantMessage(currentMessage.content || '', {
-        tool_calls: currentMessage.tool_calls,
-        reasoning_content: currentMessage.reasoning_content || '' // ✅ 新增：保存思考内容
-      });
-      
-      // 触发事件：AI请求工具调用
-      this.emit('tool-call-requested', {
-        tool_calls: currentMessage.tool_calls,
-        reasoning_content: currentMessage.reasoning_content, // ✅ 新增：包含思考内容
-        timestamp: new Date(),
-        iteration: iteration
-      });
-      
-      // 2. 执行工具
-      const toolResults = await this.toolManager.executeToolCalls(currentMessage.tool_calls);
-      
-      // 3. 添加工具结果消息
-      for (const result of toolResults) {
-        this.messages.addToolMessage(result.result || result.error, result.tool_call_id);
-      }
-      
-      // 4. 再次发送流式请求（包含工具结果）
-      const requestBody = this.requestBuilder.toJSON();
-      
-      // 使用Promise包装流式请求，等待完成
-      await new Promise((resolve, reject) => {
-        this.apiClient.strSend(
-          requestBody,
-          typeof onProgress === 'function'
-            ? (chunk) => {
-                this.emit('stream-progress', chunk);
-                onProgress(chunk);
-              }
-            : (chunk) => {
-                this.emit('stream-progress', chunk);
-              },
-          (finalMessage) => {
-            currentMessage = finalMessage;
-            
-            // 检查是否还有工具调用
-            if (!currentMessage.tool_calls || currentMessage.tool_calls.length === 0) {
-              // 没有更多工具调用，结束循环
-              resolve();
-            } else {
-              // 还有工具调用，继续循环
-              resolve();
-            }
-          }
-        ).catch(reject);
-      });
-      
-      // 如果没有工具调用了，跳出循环
-      if (!currentMessage.tool_calls || currentMessage.tool_calls.length === 0) {
-        break;
-      }
-    }
-    
-    // 添加最终助手消息 - 使用统一方法处理（跳过添加消息）
-    const eventData = await this._handleAssistantResponse(currentMessage, { 
-      isStreaming: true,
-      toolIterations: iteration,
-      skipAddMessage: true 
-    });
-    
-    // 如果有 onDone 回调就调用
-    if (typeof onDone === 'function') {
-      onDone(eventData);
-    }
-  }
-
-  /**
-   * 撤回消息
-   */
-  undo() {
-    const removed = this.messages.undoToAssistant();
-    if (removed.length > 0) {
-      this.emit('undo', {
-        removedMessages: removed,
-        timestamp: new Date()
-      });
-    }
-    return removed;
-  }
-
-  /**
-   * 清空消息
-   */
-  clear() {
-    const removed = this.messages.clearMessages();
-    this.emit('clear', {
-      removedMessages: removed,
-      timestamp: new Date()
-    });
-    return removed;
-  }
-
-  /**
-   * 导出对话数据
-   */
-  export() {
-    const data = this.messages.export();
-    this.emit('export', {
-      data: data,
-      timestamp: new Date()
-    });
-    return data;
-  }
-
-  /**
-   * 导入对话数据
-   */
-  import(data) {
-    this.messages.import(data);
-    this.emit('import', {
-      data: data,
-      timestamp: new Date()
-    });
-    return this;
-  }
-}
-
-// 导出 ChatService
-export { ChatService };
-
-// 导出默认对象
-export default {
-  Messages,
-  RequestBuilder,
-  ApiClient,
-  EventEmitter,
-  MessageFormatter,
-  ToolManager,
-  ChatService,
-  defaultConfig
+import { ChatService } from './core/ChatService.js';
+import { MessageStore } from './core/MessageStore.js';
+import { EventEmitter } from './core/EventEmitter.js';
+import { openaiAdapter } from './adapters/openai.js';
+import { toolCallingPlugin } from './plugins/tool-calling.js';
+
+export { ChatService, MessageStore, EventEmitter, openaiAdapter, toolCallingPlugin };
+
+export default {
+  ChatService,
+  MessageStore,
+  EventEmitter,
+  openaiAdapter,
+  toolCallingPlugin
 };

package/src/plugins/tool-calling.js

@@ -0,0 +1,119 @@
+/**
+ * 工具调用插件
+ * 拦截消息中的 tool_calls，执行注册的工具，并将结果插入对话，然后继续请求
+ */
+export const toolCallingPlugin = {
+  name: 'tool-calling',
+  maxIterations: 5,  // 防止无限循环
+
+  install(chatService) {
+    this.chatService = chatService;
+    this._tools = new Map();   // 工具名 -> { executor, definition }
+
+    // 覆盖 registerTool 方法
+    chatService.registerTool = (name, description, executor) => {
+      this._tools.set(name, { executor, description });
+      // 可选：同时生成工具定义，以便在请求中告知 AI
+      // 这里简化，依赖适配器在请求中自动包含工具定义（如果需要）
+      return chatService;
+    };
+
+    // 拦截发送流程：在发送前注入工具定义（如果需要）
+    // 在流式和非流式响应后检测 tool_calls
+    const originalSend = chatService.send;
+    chatService.send = async (input) => {
+      return this._handleWithTools(originalSend, input, false);
+    };
+
+    const originalStream = chatService.stream;
+    chatService.stream = async (input, onProgress, onDone) => {
+      return this._handleWithTools(originalStream, input, true, onProgress, onDone);
+    };
+  },
+
+  async _handleWithTools(originalMethod, input, isStream, onProgress, onDone) {
+    const self = this;
+    const chat = this.chatService;
+    let iteration = 0;
+
+    // 包装回调，用于递归处理
+    async function processResponse(initialResponse) {
+      let lastResponse = initialResponse;
+      while (iteration < self.maxIterations) {
+        // 检查是否有工具调用
+        const toolCalls = lastResponse?.toolCalls;
+        if (!toolCalls || toolCalls.length === 0) break;
+
+        iteration++;
+        // 执行所有工具
+        const toolResults = [];
+        for (const call of toolCalls) {
+          const toolName = call.function?.name;
+          const args = JSON.parse(call.function?.arguments || '{}');
+          const tool = self._tools.get(toolName);
+          if (!tool) {
+            console.warn(`未找到工具: ${toolName}`);
+            toolResults.push({ tool_call_id: call.id, error: `工具 ${toolName} 未注册`, success: false });
+            continue;
+          }
+          try {
+            const result = await tool.executor(args);
+            toolResults.push({
+              tool_call_id: call.id,
+              content: typeof result === 'string' ? result : JSON.stringify(result),
+              success: true
+            });
+          } catch (err) {
+            console.error(`工具 ${toolName} 执行失败:`, err);
+            toolResults.push({ tool_call_id: call.id, error: err.message, success: false });
+          }
+        }
+
+        // 添加工具结果消息
+        for (const tr of toolResults) {
+          chat.messages.addTool(tr.content || tr.error, tr.tool_call_id);
+        }
+
+        // 再次请求
+        if (isStream) {
+          // 流式重新请求：需要重新构建请求体
+          const userMsg = chat.messages.getLast(); // 实际上应该重新生成请求
+          // 这里简化：直接调用原 stream 方法，但需要避免循环
+          // 实际实现需更细致，我们这里仅示意
+          await new Promise((resolve) => {
+            originalStream.call(chat, null, (chunk) => {
+              if (onProgress) onProgress(chunk);
+              lastResponse = chunk;
+            }, (final) => {
+              lastResponse = final;
+              resolve();
+            });
+          });
+        } else {
+          const reqBody = chat._adapter.buildRequest(chat.messages.getAll(), chat.config);
+          const apiResp = await chat._adapter.send(reqBody, chat.config);
+          lastResponse = chat._adapter.parseResponse(apiResp);
+        }
+      }
+      return lastResponse;
+    }
+
+    if (isStream) {
+      // 流式模式
+      let finalMessage;
+      await originalMethod.call(chat, input,
+        (chunk) => {
+          if (onProgress) onProgress(chunk);
+        },
+        async (final) => {
+          finalMessage = await processResponse(final);
+          if (onDone) onDone(finalMessage);
+        }
+      );
+    } else {
+      const resp = await originalMethod.call(chat, input);
+      const final = await processResponse(resp);
+      return final;
+    }
+  }
+};