my-ai-chat-framework 1.0.2 → 2.0.0

package/src/core/EventEmitter.js

@@ -1,126 +1,32 @@
-/**
- * 简单的事件发射器类
- * 实现观察者模式，允许对象监听和触发事件
- */
-class EventEmitter {
-  constructor() {
-    //存储事件和对应的回调数组
-    //结构: 
-    // { 'event_name': [ callback1, callback2 ] }
-    this.events = {}
-  }
-
-  /**
-   * 监听事件
-   * @param {string} eventName - 要注册的事件名称
-   * @param {Function} callback - 事件触发时执行的回调函数
-   */
-  //实现一个监听事件的方法
-  on(eventName, callback) {
-    //1.如果没有事件数组，先创建
-    if (!this.events[eventName]) {
-      this.events[eventName] = []
-    }
-
-    //2.给数组添加（push）事件
-    this.events[eventName].push(callback)
-
-    //返回一个取消键听得函数（方便实用）
-    return () => this.off(eventName, callback)
-  }
-
-  /**
-   * 触发事件
-   * @param {string} eventName --要触发的事件名称
-   * @param {any} data --传递给回调函数的数据
-   */
-  emit(eventName, data) {
-    //获取这个事件的所有回调函数
-    const callbacks = this.events[eventName]
-
-    //仅在有回调函数时调用他们，否则提前退出（可以这么写吧？少一层嵌套）
-    if (!callbacks) return
-
-    //使用slice()创建副本，放置在循环中修改数组导致问题
-    const callbakesCopy = callbacks.slice()
-
-    for (let i = 0; i < callbakesCopy.length; i++) {
-      try {
-        //执行回调函数，并传入数据
-        callbakesCopy[i](data)
-      } catch (error) {
-        // 如果某个回调出错，不影响其他回调
-        console.error(`事件 ${eventName} 的回调函数执行出错:`, error)
-      }
-    }
-  }
-
-  /**
-   * 取消监听事件
-   * @param {string} eventName --要取消的事件名称
-   * @param {Function} callback --要移除的回调函数
-   */
-  off(eventName, callback) {
-    const callbacks = this.events[eventName]
-
-    //判断一下防止报错
-    if (!callbacks) return
-
-    //过滤掉要移除的回调函数
-    this.events[eventName] = callbacks.filter(item => item !== callback)
-
-    // 如果这个事件没有监听器了，删除这个事件
-    if (this.events[eventName].length === 0) {
-      delete this.events[eventName]
-    }
-  }
-
-  /**
-   * 只监听一次事件（触发后自动取消）
-   * @param {string} eventName - 事件名称
-   * @param {Function} callback - 回调函数
-   */
-  once(evenName, callback) {
-    // 创建一个包装函数，执行完成后自动取消
-    const onceCallback = (data) => {
-      //先取消监听
-      this.off(evenName, onceCallback)
-      //在执行原回调
-      callback(data)
-    }
-
-    //监听包装后的函数
-    this.on(evenName, onceCallback)
-
-    //返回取消函数
-    return () => this.off(evenName, onceCallback)
-  }
-
-  /**
- * 移除某个事件的所有监听器
- * @param {string} eventName - 事件名称
- */
-  removeAllListeners(eventName) {
-    if (eventName) {
-      // 移除指定事件的所有监听器
-      delete this.events[eventName]
-    } else {
-      // 如果没有指定事件名，移除所有事件的监听器
-      this.events = {}
-    }
-  }
-
-  /**
- * 获取某个事件的所有监听器数量
- * @param {string} eventName - 事件名称
- * @returns {number} 监听器数量
- */
-  listenerCount(eventName) {
-    const callbacks = this.events[eventName]
-    return callbacks ? callbacks.length : 0
-  }
-
-}
-
-//导出EventEmiter类
-export default EventEmitter
+/**
+ * 极简事件发射器
+ */
+export class EventEmitter {
+  constructor() {
+    this._events = new Map();
+  }
+
+  on(event, handler) {
+    if (!this._events.has(event)) this._events.set(event, []);
+    this._events.get(event).push(handler);
+    return () => this.off(event, handler);
+  }
+
+  off(event, handler) {
+    if (!this._events.has(event)) return;
+    const handlers = this._events.get(event).filter(h => h !== handler);
+    if (handlers.length) this._events.set(event, handlers);
+    else this._events.delete(event);
+  }
+
+  emit(event, data) {
+    if (!this._events.has(event)) return;
+    for (const handler of this._events.get(event)) {
+      try {
+        handler(data);
+      } catch (err) {
+        console.error(`事件 ${event} 处理出错:`, err);
+      }
+    }
+  }
+}

package/src/core/MessageStore.js

@@ -0,0 +1,73 @@
+/**
+ * 消息存储 - 极简实现
+ * 每条消息格式：
+ * {
+ *   id?: string,
+ *   role: 'user'|'assistant'|'system'|'tool',
+ *   content: string,
+ *   toolCalls?: Array,
+ *   toolCallId?: string,
+ *   timestamp?: number,
+ *   metadata?: any
+ * }
+ */
+export class MessageStore {
+  constructor() {
+    this._messages = [];
+    this._idCounter = 0;
+  }
+
+  add(message) {
+    const msg = {
+      id: message.id || `msg_${Date.now()}_${++this._idCounter}`,
+      timestamp: message.timestamp || Date.now(),
+      ...message
+    };
+    this._messages.push(msg);
+    return msg;
+  }
+
+  addUser(content, metadata = {}) {
+    return this.add({ role: 'user', content, metadata });
+  }
+
+  addAssistant(content, metadata = {}) {
+    return this.add({ role: 'assistant', content, metadata });
+  }
+
+  addSystem(content, metadata = {}) {
+    return this.add({ role: 'system', content, metadata });
+  }
+
+  addTool(content, toolCallId, metadata = {}) {
+    return this.add({ role: 'tool', content, toolCallId, metadata });
+  }
+
+  getLast() {
+    return this._messages[this._messages.length - 1] || null;
+  }
+
+  getAll() {
+    return [...this._messages];
+  }
+
+  clear() {
+    this._messages = [];
+  }
+
+  // 撤回最后一条助手消息及其后的所有消息（用于工具调用循环）
+  undoToLastAssistant() {
+    let lastAssistantIndex = -1;
+    for (let i = this._messages.length - 1; i >= 0; i--) {
+      if (this._messages[i].role === 'assistant') {
+        lastAssistantIndex = i;
+        break;
+      }
+    }
+    if (lastAssistantIndex >= 0) {
+      const removed = this._messages.splice(lastAssistantIndex + 1);
+      return removed;
+    }
+    return [];
+  }
+}

package/src/index.js

@@ -1,419 +1,15 @@
-// 这是 AI 聊天框架的入口文件
-// 导出所有核心组件供外部使用
+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';
 
-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 { ChatService, MessageStore, EventEmitter, openaiAdapter, toolCallingPlugin };
 
-// 导出所有核心类
-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,
+  ChatService,
+  MessageStore,
   EventEmitter,
-  MessageFormatter,
-  ToolManager,
-  ChatService
+  openaiAdapter,
+  toolCallingPlugin
 };