my-ai-chat-framework 1.1.0 → 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 [];
+  }
+}