my-ai-chat-framework 1.1.0 → 2.7.0

package/src/core/EventEmitter.js

@@ -1,126 +1,51 @@
-/**
- * 简单的事件发射器类
- * 实现观察者模式，允许对象监听和触发事件
- */
-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
+/**
+ * 极简事件发射器
+ * 支持同步/异步事件，handler 返回 Promise 时自动 await
+ */
+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);
+      }
+    }
+  }
+
+  /**
+   * 异步触发事件，逐个 await handler
+   * handler 返回 Promise 时自动等待
+   */
+  async emitAsync(event, data) {
+    if (!this._events.has(event)) return;
+    for (const handler of this._events.get(event)) {
+      try {
+        await handler(data);
+      } catch (err) {
+        console.error(`事件 ${event} 处理出错:`, err);
+      }
+    }
+  }
+}

package/src/core/MessageStore.js

@@ -0,0 +1,112 @@
+/**
+ * 消息存储 - 极简实现
+ * 每条消息格式：
+ * {
+ *   id?: string,
+ *   role: 'user'|'assistant'|'system'|'tool',
+ *   content: string,
+ *   images?: Array<string>,   // 图片引用（URL / id），框架不存储图片数据
+ *   _ephemeral?: boolean,     // 临时消息：仅底部连续时参与请求，续写后转正
+ *   _complete?: boolean,      // 流式是否完成（false=未完成/中断）
+ *   prefix?: boolean,         // 前缀续写标记
+ *   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 });
+  }
+
+  /**
+   * 快速添加一次性的、带续写标记的 assistant 消息
+   * 适用于思维链引导、临时注入等场景
+   * @param {string} content  — 引导内容
+   * @param {Object} [options] — { reasoningContent, prefix }
+   * @returns {Object} 添加的消息
+   */
+  addOnceAssistant(content, options = {}) {
+    return this.add({
+      role: 'assistant',
+      content,
+      reasoningContent: options.reasoningContent,
+      prefix: options.prefix !== false,  // 默认开启续写
+      _ephemeral: true
+    });
+  }
+
+  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 [];
+  }
+
+  /**
+   * 更新消息：按 id 查找并合并 changes，不新增消息
+   * @param {string} id — 消息 id
+   * @param {Object} changes — 要合并的字段
+   * @returns {Object|null} 更新后的消息，未找到返回 null
+   */
+  update(id, changes) {
+    for (const msg of this._messages) {
+      if (msg.id === id) {
+        Object.assign(msg, changes);
+        // 更新 timestamp 便于排查
+        msg.timestamp = changes.timestamp || Date.now();
+        return msg;
+      }
+    }
+    return null;
+  }
+}

package/src/core/SystemPromptStore.js

@@ -0,0 +1,118 @@
+/**
+ * SystemPromptStore — 系统提示词存储
+ * 
+ * 职责：管理多条 system prompt 的增删改查与开关
+ * 与 MessageStore 分离，因为 system prompt 是"AI 行为准则"，不是对话事件
+ * 
+ * 每条记录格式：
+ * {
+ *   id: string,
+ *   content: string,
+ *   enabled: boolean,
+ *   timestamp: number
+ * }
+ */
+
+export class SystemPromptStore {
+  constructor() {
+    this._prompts = [];
+    this._idCounter = 0;
+  }
+
+  /**
+   * 添加一条 system prompt
+   * @param {string} content — 提示词内容
+   * @param {boolean} [enabled=true] — 是否启用
+   * @returns {Object} 添加的记录
+   */
+  add(content, enabled = true) {
+    if (!content || typeof content !== 'string' || !content.trim()) {
+      throw new Error('[SystemPromptStore] content 必须是非空字符串');
+    }
+    const record = {
+      id: `sys_${Date.now()}_${++this._idCounter}`,
+      content: content.trim(),
+      enabled: Boolean(enabled),
+      timestamp: Date.now()
+    };
+    this._prompts.push(record);
+    return record;
+  }
+
+  /**
+   * 删除指定索引的 system prompt
+   * @param {number} index
+   * @returns {Object} 被删除的记录
+   */
+  remove(index) {
+    if (index < 0 || index >= this._prompts.length) {
+      throw new Error(`[SystemPromptStore] 索引越界: ${index}`);
+    }
+    return this._prompts.splice(index, 1)[0];
+  }
+
+  /**
+   * 切换指定索引的启用/禁用状态
+   * @param {number} index
+   * @returns {boolean} 切换后的状态
+   */
+  toggle(index) {
+    if (index < 0 || index >= this._prompts.length) {
+      throw new Error(`[SystemPromptStore] 索引越界: ${index}`);
+    }
+    this._prompts[index].enabled = !this._prompts[index].enabled;
+    return this._prompts[index].enabled;
+  }
+
+  /**
+   * 更新指定索引的 content
+   * @param {number} index
+   * @param {string} content
+   */
+  update(index, content) {
+    if (index < 0 || index >= this._prompts.length) {
+      throw new Error(`[SystemPromptStore] 索引越界: ${index}`);
+    }
+    if (!content || typeof content !== 'string' || !content.trim()) {
+      throw new Error('[SystemPromptStore] content 必须是非空字符串');
+    }
+    this._prompts[index].content = content.trim();
+    this._prompts[index].timestamp = Date.now();
+  }
+
+  /**
+   * 清空并用一条 content 替换（便捷方法，常用于 config.system = '...'）
+   * @param {string} content
+   */
+  set(content) {
+    this._prompts = [];
+    if (content && typeof content === 'string' && content.trim()) {
+      this.add(content, true);
+    }
+  }
+
+  /**
+   * 按 enabled 筛选后，转为适配器可用的格式
+   * @returns {Array<{role:'system', content:string}>}
+   */
+  getEnabled() {
+    return this._prompts
+      .filter(p => p.enabled)
+      .map(p => ({ role: 'system', content: p.content }));
+  }
+
+  /**
+   * 返回所有记录（含 enabled 状态，用于 UI 展示）
+   * @returns {Array}
+   */
+  getAll() {
+    return [...this._prompts];
+  }
+
+  /**
+   * 清空所有 system prompt
+   */
+  clear() {
+    this._prompts = [];
+  }
+}