my-ai-chat-framework 1.0.2

package/src/core/ToolManager.js

@@ -0,0 +1,175 @@
+import EventEmitter from './EventEmitter'
+/**
+ * 工具管理器
+ * 负责注册、管理和执行工具
+*/
+class ToolManager extends EventEmitter {
+  constructor() {
+    super()
+    this.tools = new Map() // 工具名 -> 工具函数
+  }
+  /**
+   * 注册工具
+   * @param {string} name - 工具名称
+   * @param {object} toolDefinition - 工具定义（包含描述和参数信息）
+   * @param {Function} executor - 工具执行函数，接受参数对象并返回结果
+   */
+  registerTool(name, toolDefinition, executor) {
+    // 判断是否已经注册过同名工具
+    if (this.tools.has(name)) {
+      throw new Error(`[系统提示异常] 工具 "${name}" 已经注册过了`);
+    }
+
+    //在工具管理器中注册工具的函数
+    this.tools.set(name, {
+      definition: toolDefinition,
+      executor: executor
+    })
+    // 触发工具注册事件，供外部监听
+    this.emit('tool-registered', { name, definition: toolDefinition })
+    // 返回this以支持链式调用
+    return this
+  }
+
+  /**
+   * 执行工具调用
+   * @param {object} toolCall - 工具调用信息，包含工具名称和参数
+   * @returns {Promise<any>} - 工具执行结果
+   */
+  async executeToolCall(toolCall) {
+    const { id, function: func } = toolCall;
+    const { name, arguments: argsStr } = func;
+    
+    if (!this.tools.has(name)) {
+      throw new Error(`未找到工具: ${name}`);
+    }
+    
+    const tool = this.tools.get(name);
+    
+    try {
+      // 解析参数
+      const args = JSON.parse(argsStr);
+      
+      // 触发事件：开始执行工具
+      this.emit('tool-execute-start', { name, args });
+      
+      // 执行工具
+      const result = await tool.executor(args);
+      
+      // 触发事件：工具执行成功
+      this.emit('tool-execute-success', { name, args, result });
+      
+      // 确保返回正确的格式
+      return {
+        tool_call_id: id,  // 必须包含tool_call_id
+        name,
+        result: JSON.stringify(result),
+        success: true
+      };
+    } catch (error) {
+      // 触发事件：工具执行失败
+      this.emit('tool-execute-error', { name, error });
+      
+      // 即使失败也要返回tool_call_id
+      return {
+        tool_call_id: id,
+        name,
+        error: error.message,
+        success: false
+      };
+    }
+  }
+
+   /**
+   * 获取所有工具定义（用于发送给AI）
+   */
+  getToolDefinitions() {
+    const definitions = [];
+    for (const [name, tool] of this.tools) {
+      definitions.push(tool.definition);
+    }
+    return definitions;
+  }
+
+   /**
+   * 检查是否有工具
+   */
+  hasTools() {
+    return this.tools.size > 0;
+  }
+
+   /**
+   * 批量执行工具调用
+   * @param {Array} toolCalls - 工具调用数组
+   * @returns {Promise<Array>} - 所有工具的执行结果
+   */
+  async executeToolCalls(toolCalls) {
+    if (!Array.isArray(toolCalls)) {
+      throw new Error('toolCalls必须是数组');
+    }
+    
+    const results = [];
+    
+    // 并行执行所有工具调用
+    const promises = toolCalls.map(async (toolCall) => {
+      try {
+        const result = await this.executeToolCall(toolCall);
+        return result;
+      } catch (error) {
+        // 某个工具失败，返回错误信息
+        return {
+          tool_call_id: toolCall.id,
+          name: toolCall.function.name,
+          error: error.message,
+          success: false
+        };
+      }
+    });
+    
+    // 等待所有工具执行完成
+    const settledResults = await Promise.allSettled(promises);
+    
+    // 处理结果
+    for (const settled of settledResults) {
+      if (settled.status === 'fulfilled') {
+        results.push(settled.value);
+      } else {
+        // 理论上不会到这里，因为错误已经在上面捕获了
+        results.push({
+          error: settled.reason.message,
+          success: false
+        });
+      }
+    }
+    
+    return results;
+  }
+  
+  /**
+   * 串行执行工具调用（如果需要顺序执行）
+   */
+  async executeToolCallsSequentially(toolCalls) {
+    const results = [];
+    
+    for (const toolCall of toolCalls) {
+      try {
+        const result = await this.executeToolCall(toolCall);
+        results.push(result);
+      } catch (error) {
+        // 某个工具失败，可以选择停止或继续
+        results.push({
+          tool_call_id: toolCall.id,
+          name: toolCall.function.name,
+          error: error.message,
+          success: false
+        });
+        // 可以选择继续执行下一个工具
+        // 或者抛出错误停止执行：throw error;
+      }
+    }
+    
+    return results;
+  }
+}
+
+export default ToolManager

package/src/index.js

@@ -0,0 +1,419 @@
+// 这是 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'; // 新增导入
+
+// 导出所有核心类
+export { Messages, RequestBuilder, ApiClient, EventEmitter, MessageFormatter, ToolManager };
+
+// ChatService类，继承EventEmitter
+class ChatService extends EventEmitter {
+  constructor(apiKey, model = 'deepseek-chat', config = {}) {
+    super();
+    
+    this.messages = new Messages();
+    this.apiClient = new ApiClient(apiKey);
+    this.requestBuilder = new RequestBuilder(model, this.messages, config);
+    this.toolManager = new ToolManager(); // 新增：工具管理器
+    
+    
+    this._setupDefaultListeners();
+  }
+
+  _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 {
+      // 触发事件：开始发送
+      this.emit('sending', { 
+        role: 'user', 
+        content: userMessage,
+        timestamp: new Date()
+      });
+      
+      // 添加用户消息
+      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 {
+        // 普通回复
+        return await this._handleNormalResponse(aiMessage);
+      }
+    } catch (error) {
+      this.emit('error', {
+        error: error,
+        message: userMessage,
+        timestamp: new Date()
+      });
+      throw error;
+    }
+  }
+
+  /**
+   * 处理工具调用（支持循环调用）
+   */
+  async _handleToolCalls(aiMessage, maxIterations = 5) {
+    console.log('🔍 处理工具调用，aiMessage:', aiMessage);
+    
+    let iteration = 0;
+    let currentMessage = aiMessage;
+    
+    // 循环处理工具调用，直到没有工具调用或达到最大迭代次数
+    while (iteration < maxIterations) {
+      iteration++;
+      console.log(`🔄 工具调用迭代 ${iteration}/${maxIterations}`);
+      
+      // 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);
+      console.log('🔍 工具执行结果:', toolResults);
+      
+      // 3. 添加工具结果消息
+      for (const result of toolResults) {
+        console.log('🔍 添加工具消息，result:', result);
+        this.messages.addToolMessage(
+          result.result || result.error || '', 
+          result.tool_call_id
+        );
+      }
+      
+      // 4. 检查当前消息状态
+      console.log('🔍 当前所有消息:', this.messages.getMessages());
+      
+      // 5. 再次发送请求，获取AI对工具结果的响应
+      const requestBody = this.requestBuilder.toJSON();
+      console.log('🔍 第', iteration, '次请求体:', requestBody);
+      
+      const response = await this.apiClient.send(requestBody);
+      currentMessage = response.choices[0].message;
+      
+      // 6. 检查AI是否还有新的工具调用请求
+      if (!currentMessage.tool_calls || currentMessage.tool_calls.length === 0) {
+        // 没有更多工具调用，结束循环
+        console.log('✅ 工具调用完成，AI给出最终回复');
+        break;
+      }
+      
+      console.log('🔄 AI请求了新的工具调用，继续处理...');
+    }
+    
+    // 7. 添加最终助手消息
+    this.messages.addAssistantMessage(currentMessage.content || '', {
+      reasoning_content: currentMessage.reasoning_content || '' // ✅ 新增：保存最终思考内容
+    });
+    
+    // 触发事件：收到最终回复
+    this.emit('message', {
+      role: 'assistant',
+      content: currentMessage.content,
+      reasoning_content: currentMessage.reasoning_content, // ✅ 新增：包含思考内容
+      timestamp: new Date(),
+      response: { choices: [{ message: currentMessage }] },
+      toolIterations: iteration
+    });
+    
+    return currentMessage.content;
+  }
+
+  /**
+   * 处理普通回复
+   */
+  async _handleNormalResponse(aiMessage) {
+    // 添加助手消息，处理空内容
+    this.messages.addAssistantMessage(aiMessage.content || '', {
+      reasoning_content: aiMessage.reasoning_content
+    });
+    
+    // 触发事件：收到回复
+    this.emit('message', {
+      role: 'assistant',
+      content: aiMessage.content,
+      timestamp: new Date(),
+      response: { choices: [{ message: aiMessage }] }
+    });
+    
+    return aiMessage.content;
+  }
+
+  /**
+   * 流式发送消息（支持工具调用）
+   */
+  async stream(userMessage, onProgress, onDone, options = {}) {
+    try {
+      // 触发事件：开始发送
+      this.emit('sending', { 
+        role: 'user', 
+        content: userMessage,
+        timestamp: new Date()
+      });
+      
+      // 添加用户消息
+      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,
+        (chunk) => {
+          // 流式进度回调
+          this.emit('stream-progress', chunk);
+          onProgress(chunk);
+        },
+        async (finalMessage) => {
+          // 流式完成回调
+          if (finalMessage.tool_calls && finalMessage.tool_calls.length > 0) {
+            // 处理流式中的工具调用
+            await this._handleStreamToolCalls(finalMessage, onProgress, onDone);
+          } else {
+            // 普通流式回复
+            this.messages.addAssistantMessage(finalMessage.content || '', {
+              reasoning_content: finalMessage.reasoning_content
+            });
+            
+            this.emit('stream-done', { message: finalMessage });
+            onDone(finalMessage);
+          }
+        }
+      );
+      
+      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,
+          (chunk) => {
+            this.emit('stream-progress', chunk);
+            onProgress(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;
+      }
+    }
+    
+    // 添加最终助手消息
+    this.messages.addAssistantMessage(currentMessage.content, {
+      reasoning_content: currentMessage.reasoning_content || '' // ✅ 新增：保存最终思考内容
+    });
+    
+    this.emit('stream-done', { 
+      message: currentMessage,
+      reasoning_content: currentMessage.reasoning_content, // ✅ 新增：包含思考内容
+      toolIterations: iteration
+    });
+    onDone(currentMessage);
+  }
+
+  /**
+   * 撤回消息
+   */
+  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
+};

package/src/utils/index.js

@@ -0,0 +1,21 @@
+// This file contains utility functions for the AI chat framework.
+// You can add common functions such as data formatting, error handling, and other helper methods here.
+
+export const formatDate = (date) => {
+  if (!(date instanceof Date)) {
+    throw new Error('Invalid date object');
+  }
+  return date.toISOString();
+};
+
+export const handleError = (error) => {
+  console.error('An error occurred:', error);
+  return {
+    message: error.message || 'An unknown error occurred',
+    stack: error.stack || null,
+  };
+};
+
+export const isEmpty = (value) => {
+  return value === null || value === undefined || value.trim() === '';
+};