my-ai-chat-framework 1.1.0 → 2.7.0

package/dist/my-ai-chat-framework.node.cjs.js

@@ -1,1665 +1,1307 @@
-"use strict";
-Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
-const axios = require("axios");
-class MessageFormatter {
-  /**
-   * 将消息转换为标准格式（不再过滤自定义元数据，只确保必需字段）
-   */
-  static toStandardFormat(message) {
-    const { role, content } = message;
-    const standardMessage = { role, content };
-    for (const [key, value] of Object.entries(message)) {
-      if (key !== "role" && key !== "content" && value !== void 0) {
-        standardMessage[key] = value;
-      }
-    }
-    return standardMessage;
-  }
-  /**
-   * 批量转换消息为标准格式
-   */
-  static batchToStandardFormat(messages) {
-    return messages.map((msg) => this.toStandardFormat(msg));
-  }
-  /**
-   * 从Messages实例获取格式化后的消息数组
-   */
-  static formatMessages(messagesInstance, baseRounds, cycleRounds) {
-    const systems = messagesInstance.getEnabledSystemPrompts();
-    const hintSystem = {
-      role: "system",
-      content: `你的名字||标题是：${messagesInstance.getName() || "未知"}`
-    };
-    systems.unshift(hintSystem);
-    const recentMessages = messagesInstance.getRecentMessages(baseRounds, cycleRounds);
-    return [...systems, ...recentMessages];
-  }
-  /**
-   * 构造工具参数
-   */
-  static constructParameters(array) {
-    let paramsArray = [];
-    if (Array.isArray(array)) {
-      paramsArray = array;
-    } else if (typeof array === "object" && array !== null) {
-      paramsArray = [array];
-    } else {
-      throw new Error("[系统提示异常] 检测到无效的参数格式");
-    }
-    const parameters = {};
-    for (let i = 0; i < paramsArray.length; i++) {
-      const param = paramsArray[i];
-      if (!param?.name?.trim()) {
-        throw new Error(`[系统提示异常] 检测到空参数名称 位置: 第 ${i + 1} 个参数`);
-      }
-      if (!param?.type?.trim()) {
-        throw new Error(`[系统提示异常] 检测到空参数类型 位置: 参数 "${param.name}"`);
-      }
-      if (!param?.description?.trim()) {
-        throw new Error(`[系统提示异常] 检测到空参数描述 位置: 参数 "${param.name}"`);
-      }
-      parameters[param.name] = {
-        type: param.type,
-        description: param.description
-      };
-    }
-    return {
-      type: "object",
-      properties: parameters,
-      required: Object.keys(parameters)
-    };
-  }
-  /**
-   * 构造工具定义
-   */
-  static constructTool({ name, description, parameters }) {
-    if (!name?.trim()) {
-      throw new Error("[系统提示异常] 检测到空工具名称");
-    }
-    if (!description?.trim()) {
-      throw new Error("[系统提示异常] 检测到空工具描述");
-    }
-    let processedParameters;
-    try {
-      processedParameters = this.constructParameters(parameters);
-    } catch (error) {
-      throw new Error(`[系统提示异常] 工具参数验证失败 工具名称: ${name} 错误详情: ${error.message}`);
-    }
-    return {
-      type: "function",
-      function: {
-        name,
-        description,
-        parameters: processedParameters
-      }
-    };
-  }
-  /**
-   * 过滤消息以供API使用（只移除空content的消息，保留所有字段）
-   */
-  static filterForAPI(messages) {
-    return messages.filter((msg) => {
-      if (msg.role === "tool") {
-        return true;
-      }
-      return msg.content !== "" && msg.content !== void 0 && msg.content !== null;
-    });
-  }
-}
-class Messages {
-  constructor() {
-    this.messages = [];
-    this.systemPrompts = [];
-    this.tools = [];
-    this.metadata = {
-      name: "",
-      createdAt: /* @__PURE__ */ new Date(),
-      lastModified: /* @__PURE__ */ new Date()
-    };
-  }
-  // ========== 核心消息方法 ==========
-  /**
-   * 添加消息（通用方法）
-   * @param {string} role - 角色：user/assistant/system/tool
-   * @param {string} content - 消息内容（允许空字符串）
-   * @param {object} metadata - 额外元数据
-   * @returns {number} 新消息的索引
-   */
-  addMessage(role, content, metadata = {}) {
-    const validRoles = ["user", "assistant", "system", "tool"];
-    if (!validRoles.includes(role)) {
-      throw new Error(`无效的角色: ${role}，有效值: ${validRoles.join(", ")}`);
-    }
-    if (role === "tool") {
-      if (!metadata.tool_call_id) {
-        throw new Error("tool消息必须包含tool_call_id");
-      }
-    } else {
-      if (content === void 0 || content === null) {
-        throw new Error("消息内容不能为undefined或null");
-      }
-      if (typeof content !== "string") {
-        throw new Error("消息内容必须是字符串");
-      }
-    }
-    const message = {
-      role,
-      content: content ? content.trim() : "",
-      // 允许空字符串
-      timestamp: /* @__PURE__ */ new Date()
-    };
-    if (metadata && typeof metadata === "object") {
-      for (const [key, value] of Object.entries(metadata)) {
-        if (value !== void 0 && value !== null) {
-          message[key] = value;
-        }
-      }
-    }
-    return this.messages.push(message) - 1;
-  }
-  /**
-   * 添加用户消息（便捷方法）
-   */
-  addUserMessage(content, metadata = {}) {
-    return this.addMessage("user", content, metadata);
-  }
-  /**
-   * 添加助手消息（便捷方法）
-   */
-  addAssistantMessage(content, metadata = {}) {
-    return this.addMessage("assistant", content, metadata);
-  }
-  /**
-   * 添加系统消息（便捷方法）
-   */
-  addSystemMessage(content, metadata = {}) {
-    return this.addMessage("system", content, metadata);
-  }
-  /**
-   * 添加工具消息（便捷方法）
-   */
-  addToolMessage(content, toolCallId, metadata = {}) {
-    if (!toolCallId || typeof toolCallId !== "string") {
-      throw new Error("tool_call_id不能为空");
-    }
-    return this.addMessage("tool", content, {
-      tool_call_id: toolCallId,
-      ...metadata
-    });
-  }
-  /**
-   * 批量添加消息
-   */
-  addMessages(messagesArray) {
-    if (!Array.isArray(messagesArray)) {
-      throw new Error("参数必须是数组");
-    }
-    const indices = [];
-    for (const msg of messagesArray) {
-      if (!msg.role || !msg.content) {
-        throw new Error("消息必须包含role和content属性");
-      }
-      const { role, content, ...metadata } = msg;
-      const index2 = this.addMessage(role, content, metadata);
-      indices.push(index2);
-    }
-    return indices;
-  }
-  // ========== 消息查询 ==========
-  /**
-   * 获取所有消息
-   */
-  getMessages() {
-    return [...this.messages];
-  }
-  /**
-   * 按角色获取消息
-   */
-  getMessagesByRole(role) {
-    const validRoles = ["user", "assistant", "system", "tool"];
-    if (!validRoles.includes(role)) {
-      throw new Error(`无效的角色: ${role}`);
-    }
-    return this.messages.filter((msg) => msg.role === role);
-  }
-  /**
-   * 获取最后一条消息
-   */
-  getLastMessage() {
-    return this.messages.length > 0 ? { ...this.messages[this.messages.length - 1] } : null;
-  }
-  /**
-   * 获取最后一条用户消息
-   */
-  getLastUserMessage() {
-    for (let i = this.messages.length - 1; i >= 0; i--) {
-      if (this.messages[i].role === "user") {
-        return { ...this.messages[i] };
-      }
-    }
-    return null;
-  }
-  /**
-   * 获取最后一条助手消息
-   */
-  getLastAssistantMessage() {
-    for (let i = this.messages.length - 1; i >= 0; i--) {
-      if (this.messages[i].role === "assistant") {
-        return { ...this.messages[i] };
-      }
-    }
-    return null;
-  }
-  /**
-   * 获取消息数量
-   */
-  getMessageCount() {
-    return this.messages.length;
-  }
-  // ========== 消息修改 ==========
-  /**
-   * 更新消息内容（允许空字符串）
-   */
-  updateMessage(index2, content) {
-    if (!Number.isInteger(index2) || index2 < 0 || index2 >= this.messages.length) {
-      throw new Error(`无效的消息索引: ${index2}`);
-    }
-    if (typeof content !== "string") {
-      throw new Error("消息内容必须是字符串");
-    }
-    this.messages[index2].content = content;
-    this.messages[index2].lastModified = /* @__PURE__ */ new Date();
-    return this;
-  }
-  /**
-   * 更新最后一条消息
-   */
-  updateLastMessage(content) {
-    if (this.messages.length === 0) {
-      throw new Error("没有消息可以修改");
-    }
-    return this.updateMessage(this.messages.length - 1, content);
-  }
-  /**
-   * 设置消息字段
-   */
-  setMessageField(index2, field, value) {
-    if (!Number.isInteger(index2) || index2 < 0 || index2 >= this.messages.length) {
-      throw new Error(`无效的消息索引: ${index2}`);
-    }
-    this.messages[index2][field] = value;
-    this.messages[index2].lastModified = /* @__PURE__ */ new Date();
-    return this;
-  }
-  /**
-   * 批量设置消息字段
-   */
-  setMessageFields(index2, fields) {
-    if (!Number.isInteger(index2) || index2 < 0 || index2 >= this.messages.length) {
-      throw new Error(`无效的消息索引: ${index2}`);
-    }
-    for (const [field, value] of Object.entries(fields)) {
-      if (value !== void 0 && value !== null) {
-        this.messages[index2][field] = value;
-      }
-    }
-    this.messages[index2].lastModified = /* @__PURE__ */ new Date();
-    return this;
-  }
-  /**
-   * 批量更新最后一条消息的字段
-   */
-  updateLastMessageFields(fields) {
-    if (this.messages.length === 0) {
-      throw new Error("没有消息可以修改");
-    }
-    return this.setMessageFields(this.messages.length - 1, fields);
-  }
-  // ========== 消息删除 ==========
-  /**
-   * 删除消息
-   */
-  removeMessage(index2) {
-    if (!Number.isInteger(index2) || index2 < 0 || index2 >= this.messages.length) {
-      throw new Error(`无效的消息索引: ${index2}`);
-    }
-    return this.messages.splice(index2, 1)[0];
-  }
-  /**
-   * 删除最后一条消息
-   */
-  removeLastMessage() {
-    if (this.messages.length === 0) {
-      throw new Error("没有消息可以删除");
-    }
-    return this.removeMessage(this.messages.length - 1);
-  }
-  /**
-   * 撤回到上一条助手消息
-   */
-  undoToAssistant() {
-    if (this.messages.length === 0) {
-      return [];
-    }
-    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) {
-      return this.messages.splice(lastAssistantIndex + 1);
-    } else {
-      const removed = [...this.messages];
-      this.messages = [];
-      return removed;
-    }
-  }
-  /**
-   * 是否可以撤回
-   */
-  canUndo() {
-    return this.messages.some((msg) => msg.role === "assistant");
-  }
-  /**
-   * 清空所有消息
-   */
-  clearMessages() {
-    const removed = [...this.messages];
-    this.messages = [];
-    this.metadata.lastModified = /* @__PURE__ */ new Date();
-    return removed;
-  }
-  // ========== 系统提示管理 ==========
-  /**
-   * 添加系统提示
-   */
-  addSystemPrompt(content, enabled = true) {
-    if (typeof content !== "string" || !content.trim()) {
-      throw new Error("系统提示内容不能为空");
-    }
-    const prompt = {
-      role: "system",
-      content: content.trim(),
-      enabled: Boolean(enabled),
-      createdAt: /* @__PURE__ */ new Date()
-    };
-    return this.systemPrompts.push(prompt) - 1;
-  }
-  /**
-   * 获取启用的系统提示
-   */
-  getEnabledSystemPrompts() {
-    return this.systemPrompts.filter((prompt) => prompt.enabled).map((prompt) => ({ role: prompt.role, content: prompt.content }));
-  }
-  /**
-   * 切换系统提示状态
-   */
-  toggleSystemPrompt(index2) {
-    if (!Number.isInteger(index2) || index2 < 0 || index2 >= this.systemPrompts.length) {
-      throw new Error(`无效的系统提示索引: ${index2}`);
-    }
-    this.systemPrompts[index2].enabled = !this.systemPrompts[index2].enabled;
-    return this;
-  }
-  /**
-   * 更新系统提示内容
-   */
-  updateSystemPrompt(index2, content) {
-    if (!Number.isInteger(index2) || index2 < 0 || index2 >= this.systemPrompts.length) {
-      throw new Error(`无效的系统提示索引: ${index2}`);
-    }
-    if (typeof content !== "string" || !content.trim()) {
-      throw new Error("系统提示内容不能为空");
-    }
-    this.systemPrompts[index2].content = content.trim();
-    this.systemPrompts[index2].lastModified = /* @__PURE__ */ new Date();
-    return this;
-  }
-  /**
-   * 删除系统提示
-   */
-  removeSystemPrompt(index2) {
-    if (!Number.isInteger(index2) || index2 < 0 || index2 >= this.systemPrompts.length) {
-      throw new Error(`无效的系统提示索引: ${index2}`);
-    }
-    return this.systemPrompts.splice(index2, 1)[0];
-  }
-  // ========== 工具管理 ==========
-  /**
-   * 添加工具
-   */
-  addTool(toolDefinition) {
-    if (typeof toolDefinition === "object" && toolDefinition !== null) {
-      if (!toolDefinition.type || toolDefinition.type !== "function") {
-        throw new Error(`无效的工具类型，期望: 'function'，实际: '${toolDefinition.type || "undefined"}'`);
-      }
-      if (!toolDefinition.function?.name?.trim()) {
-        throw new Error("工具名称不能为空");
-      }
-      return this.tools.push(toolDefinition) - 1;
-    }
-    if (toolDefinition.name && toolDefinition.description && toolDefinition.parameters) {
-      const constructedTool = MessageFormatter.constructTool(toolDefinition);
-      return this.tools.push(constructedTool) - 1;
-    }
-    throw new Error("无效的工具格式");
-  }
-  /**
-   * 从定义添加工具
-   */
-  addToolFromDefinition(name, description, parameters) {
-    const tool = MessageFormatter.constructTool({ name, description, parameters });
-    return this.tools.push(tool) - 1;
-  }
-  /**
-   * 获取所有工具
-   */
-  getTools() {
-    return [...this.tools];
-  }
-  /**
-   * 删除工具
-   */
-  removeTool(index2) {
-    if (!Number.isInteger(index2) || index2 < 0 || index2 >= this.tools.length) {
-      throw new Error(`无效的工具索引: ${index2}`);
-    }
-    return this.tools.splice(index2, 1)[0];
-  }
-  /**
-   * 清空所有工具
-   */
-  clearTools() {
-    const removed = [...this.tools];
-    this.tools = [];
-    return removed;
-  }
-  // ========== 元数据管理 ==========
-  setName(name) {
-    if (typeof name !== "string" || !name.trim()) {
-      throw new Error("名称不能为空");
-    }
-    this.metadata.name = name.trim();
-    this.metadata.lastModified = /* @__PURE__ */ new Date();
-    return this;
-  }
-  getName() {
-    return this.metadata.name;
-  }
-  // ========== 兼容性方法 ==========
-  /**
-   * 获取最近的消息（兼容旧方法）
-   */
-  getRecentMessages(baseRounds, cycleRounds) {
-    const messages = this.messages.map((item) => {
-      return MessageFormatter.toStandardFormat(item);
-    });
-    const msgTotal = messages.length;
-    const totalRounds = msgTotal / 2;
-    if (!baseRounds || isNaN(baseRounds) || baseRounds <= 0) {
-      return messages;
-    }
-    const maxCycleRoundMultiple = cycleRounds > 0 ? Math.floor(totalRounds / cycleRounds) * cycleRounds : 0;
-    const actualRounds = baseRounds + (totalRounds - maxCycleRoundMultiple);
-    const actualMsgCount = actualRounds * 2;
-    const n = Math.max(msgTotal - actualMsgCount, 0);
-    return messages.slice(n);
-  }
-  /**
-   * 获取所有格式化消息（兼容旧方法）
-   */
-  getMessagesFormatted(baseRounds, cycleRounds) {
-    const systems = this.getEnabledSystemPrompts();
-    const hintSystem = {
-      role: "system",
-      content: `你的名字||标题是：${this.metadata.name || "未知"}`
-    };
-    systems.unshift(hintSystem);
-    const recentMessages = this.getRecentMessages(baseRounds, cycleRounds);
-    return [...systems, ...recentMessages];
-  }
-  // ========== 导入导出 ==========
-  export() {
-    return {
-      __format_version: 2,
-      exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      metadata: { ...this.metadata },
-      payload: {
-        messages: JSON.parse(JSON.stringify(this.messages)),
-        systemPrompts: JSON.parse(JSON.stringify(this.systemPrompts)),
-        tools: JSON.parse(JSON.stringify(this.tools))
-      }
-    };
-  }
-  import(data) {
-    const obj = typeof data === "string" ? JSON.parse(data) : data;
-    const parsed = Messages.parseCompatible(obj);
-    this.messages = parsed.messages || [];
-    this.systemPrompts = parsed.systemPrompts || [];
-    this.tools = parsed.tools || [];
-    this.metadata = parsed.metadata || {
-      name: "",
-      createdAt: /* @__PURE__ */ new Date(),
-      lastModified: /* @__PURE__ */ new Date()
-    };
-    this.metadata.lastModified = /* @__PURE__ */ new Date();
-    return this;
-  }
-  static parseCompatible(obj) {
-    if (obj?.__format_version === 2 && obj.payload) {
-      return {
-        messages: obj.payload.messages || [],
-        systemPrompts: obj.payload.systemPrompts || [],
-        tools: obj.payload.tools || [],
-        metadata: obj.metadata || {
-          name: "",
-          createdAt: /* @__PURE__ */ new Date(),
-          lastModified: /* @__PURE__ */ new Date()
-        }
-      };
-    }
-    if (obj?.__format_version === 1 && obj.payload) {
-      return {
-        messages: obj.payload.messages || [],
-        systemPrompts: obj.payload.systems || [],
-        tools: obj.payload.tools || [],
-        metadata: {
-          name: obj.payload.hintData?.name || "",
-          createdAt: /* @__PURE__ */ new Date(),
-          lastModified: /* @__PURE__ */ new Date()
-        }
-      };
-    }
-    if (obj?.messages && Array.isArray(obj.messages)) {
-      return {
-        messages: obj.messages || [],
-        systemPrompts: obj.systems || [],
-        tools: obj.tools || [],
-        metadata: {
-          name: obj.hintData?.name || "",
-          createdAt: /* @__PURE__ */ new Date(),
-          lastModified: /* @__PURE__ */ new Date()
-        }
-      };
-    }
-    throw new Error("无法识别的聊天数据格式");
-  }
-}
-class EventEmitter {
-  constructor() {
-    this.events = {};
-  }
-  /**
-   * 监听事件
-   * @param {string} eventName - 要注册的事件名称
-   * @param {Function} callback - 事件触发时执行的回调函数
-   */
-  //实现一个监听事件的方法
-  on(eventName, callback) {
-    if (!this.events[eventName]) {
-      this.events[eventName] = [];
-    }
-    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;
-    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;
-  }
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/core/EventEmitter.js
+/**
+* 极简事件发射器
+* 支持同步/异步事件，handler 返回 Promise 时自动 await
+*/
+var EventEmitter = class {
+	constructor() {
+		this._events = /* @__PURE__ */ 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);
+		}
+	}
+};
+//#endregion
+//#region src/core/MessageStore.js
+/**
+* 消息存储 - 极简实现
+* 每条消息格式：
+* {
+*   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
+* }
+*/
+var MessageStore = class {
+	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) return this._messages.splice(lastAssistantIndex + 1);
+		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);
+			msg.timestamp = changes.timestamp || Date.now();
+			return msg;
+		}
+		return null;
+	}
+};
+//#endregion
+//#region src/core/SystemPromptStore.js
+/**
+* SystemPromptStore — 系统提示词存储
+* 
+* 职责：管理多条 system prompt 的增删改查与开关
+* 与 MessageStore 分离，因为 system prompt 是"AI 行为准则"，不是对话事件
+* 
+* 每条记录格式：
+* {
+*   id: string,
+*   content: string,
+*   enabled: boolean,
+*   timestamp: number
+* }
+*/
+var SystemPromptStore = class {
+	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 = [];
+	}
+};
+//#endregion
+//#region src/core/Errors.js
+/**
+* 自定义错误类
+* 用于区分不同类型的错误，方便用户通过 `error.name` 或 `instanceof` 处理
+*/
+var APIError = class extends Error {
+	/**
+	* @param {string} message - 错误消息(通常来自 API 响应)
+	* @param {number} statusCode - HTTP 状态码
+	* @param {any} originalError - 原始错误对象或相关信息
+	* @param {string} responseText - 原始响应文本（如果有）
+	*/
+	constructor(message, statusCode, originalError, responseText) {
+		super(message);
+		this.name = "APIError";
+		this.statusCode = statusCode;
+		this.originalError = originalError;
+		this.responseText = responseText;
+	}
+};
+var NetworkError = class extends Error {
+	/**
+	* @param {string} message - 错误消息
+	* @param {any} originalError - 原始错误对象或相关信息
+	*/
+	constructor(message, originalError) {
+		super(message);
+		this.name = "NetworkError";
+		this.originalError = originalError;
+	}
+};
+var ConfigurationError = class extends Error {
+	/**
+	* @param {string} message - 错误消息
+	*/
+	constructor(message) {
+		super(message);
+		this.name = "ConfigurationError";
+	}
+};
+var ParsingError = class extends Error {
+	/**
+	* @param {string} message - 错误消息
+	* @param {any} originalError - 原始错误对象或相关信息  
+	* @param {string} responseText - 原始响应文本（如果有）
+	**/
+	constructor(message, originalError, responseText) {
+		super(message);
+		this.name = "ParsingError";
+		this.originalError = originalError;
+		this.responseText = responseText;
+	}
+};
+//#endregion
+//#region src/core/ChatService.js
+var ChatService = class extends EventEmitter {
+	constructor(config = {}) {
+		super();
+		this.config = { ...config };
+		this.messages = new MessageStore();
+		this.systemPrompts = new SystemPromptStore();
+		this._adapter = null;
+		this._abortController = null;
+		this._isGenerating = false;
+		this._hooks = new EventEmitter();
+		this._processResponse = null;
+		const model = this.config.model || this.config.modelParams?.model;
+		if (!model || typeof model !== "string" || !model.trim()) throw new ConfigurationError("缺少 model 配置");
+		const temperature = this.config.modelParams?.temperature ?? this.config.temperature;
+		if (temperature !== void 0 && (typeof temperature !== "number" || temperature < 0 || temperature > 2)) throw new ConfigurationError(`temperature 必须在 0-2 之间，当前值: ${temperature}`);
+		const maxTokens = this.config.modelParams?.maxTokens ?? this.config.maxTokens;
+		if (maxTokens !== void 0 && (typeof maxTokens !== "number" || maxTokens < 1 || !Number.isInteger(maxTokens))) throw new ConfigurationError(`maxTokens 必须为正整数，当前值: ${maxTokens}`);
+		if (typeof config.system === "string" && config.system.trim()) this.systemPrompts.set(config.system);
+	}
+	use(plugin) {
+		plugin.install(this);
+		return this;
+	}
+	setAdapter(adapter) {
+		this._adapter = adapter;
+	}
+	abort() {
+		if (this._abortController) this._abortController.abort();
+	}
+	get isGenerating() {
+		return this._isGenerating;
+	}
+	async continueLast() {
+		const target = this._prepareContinue();
+		this.messages.update(target.id, { prefix: true });
+		try {
+			await this._request({
+				addUser: false,
+				isStream: false,
+				mergeToEntry: target.id
+			});
+			this.messages.update(target.id, {
+				_complete: true,
+				prefix: void 0,
+				_ephemeral: void 0
+			});
+			return target;
+		} catch (err) {
+			this.messages.update(target.id, { prefix: void 0 });
+			throw err;
+		}
+	}
+	async continueLastStream(onProgress, onDone) {
+		const target = this._prepareContinue();
+		console.log("[DEBUG] continueLastStream target.id:", target.id);
+		this.messages.update(target.id, { prefix: true });
+		const baseLen = (target.content || "").length;
+		try {
+			await this._request({
+				addUser: false,
+				isStream: true,
+				mergeToEntry: target.id,
+				onProgress: (chunk) => {
+					if (onProgress) onProgress({
+						...chunk,
+						content: (chunk.content || "").slice(baseLen)
+					});
+				},
+				onDone: (final) => {
+					if (onDone) onDone(final);
+				}
+			});
+			this.messages.update(target.id, {
+				_complete: true,
+				prefix: void 0,
+				_ephemeral: void 0
+			});
+			return target;
+		} catch (err) {
+			this.messages.update(target.id, { prefix: void 0 });
+			throw err;
+		}
+	}
+	_prepareContinue() {
+		const msgs = this.messages.getAll();
+		const last = msgs[msgs.length - 1];
+		if (last && (last.role === "assistant" || last._ephemeral)) return last;
+		throw new Error("最后一条消息不是 assistant，无法续写");
+	}
+	updateConfig(partial) {
+		Object.assign(this.config, partial);
+		if (typeof partial.system === "string") this.systemPrompts.set(partial.system);
+		this.emit("config-updated", {
+			changes: partial,
+			timestamp: Date.now()
+		});
+	}
+	async _request(options) {
+		let { userInput, addUser = true, isStream = false, onProgress, onDone, mergeToEntry } = options;
+		this.emit("sending", {
+			addUser,
+			userInput,
+			timestamp: Date.now()
+		});
+		this._addUserMessage(userInput, addUser);
+		await this._hooks.emitAsync("beforeRequest", {
+			messages: this.messages,
+			config: this.config,
+			options
+		});
+		if (this.config.ephemeralContinue && !mergeToEntry) {
+			const msgs = this.messages.getAll();
+			const last = msgs[msgs.length - 1];
+			if (last && last.prefix && (last.role === "assistant" || last._ephemeral)) mergeToEntry = last.id;
+		}
+		const body = this._adapter.buildRequest(this.messages.getAll(), this.config, this.systemPrompts.getEnabled());
+		const retryCfg = this.config.retry || {};
+		try {
+			return await this._withRetry(body, {
+				isStream,
+				onProgress,
+				onDone,
+				mergeToEntry,
+				maxRetries: retryCfg.maxRetries ?? 0,
+				retryDelay: retryCfg.retryDelay ?? 1e3
+			});
+		} catch (error) {
+			this.emit("error", {
+				error,
+				timestamp: Date.now()
+			});
+			throw error;
+		}
+	}
+	_addUserMessage(userInput, addUser) {
+		if (addUser && userInput !== void 0) {
+			const msg = typeof userInput === "string" ? {
+				role: "user",
+				content: userInput
+			} : {
+				role: "user",
+				...userInput
+			};
+			this.messages.add(msg);
+		}
+	}
+	/** retry 循环，占位消息只 push 一次 */
+	async _withRetry(body, { isStream, onProgress, onDone, mergeToEntry, maxRetries, retryDelay }) {
+		let lastError = null;
+		const adapterOptions = { signal: this._abortController?.signal };
+		let placeholder = null;
+		let base = null;
+		if (isStream) {
+			if (mergeToEntry) {
+				placeholder = this.messages.getAll().find((m) => m.id === mergeToEntry);
+				if (placeholder) base = {
+					content: placeholder.content || "",
+					reasoning: placeholder.reasoningContent || ""
+				};
+			}
+			if (!placeholder) placeholder = this.messages.add({
+				role: "assistant",
+				content: "",
+				_complete: false
+			});
+		}
+		for (let attempt = 0; attempt <= maxRetries; attempt++) {
+			if (attempt > 0) {
+				this.emit("retry", {
+					attempt,
+					maxRetries,
+					lastError,
+					timestamp: Date.now()
+				});
+				await new Promise((r) => setTimeout(r, retryDelay));
+			}
+			try {
+				this._isGenerating = true;
+				if (isStream) return await this._stream(body, adapterOptions, {
+					placeholder,
+					base,
+					mergeToEntry,
+					onProgress,
+					onDone
+				});
+				else {
+					const resp = await this._adapter.send(body, this.config, adapterOptions);
+					let result = this._handleResult(this._adapter.parseResponse(resp), mergeToEntry);
+					if (this._processResponse && !mergeToEntry) result = await this._processResponse(result, { isStream: false });
+					return result;
+				}
+			} catch (error) {
+				lastError = error;
+				if (error.name === "AbortError" || this._abortController?.signal.aborted) {
+					this._isGenerating = false;
+					throw error;
+				}
+				if (error instanceof NetworkError && attempt < maxRetries) continue;
+				this._isGenerating = false;
+				throw error;
+			}
+		}
+		this._isGenerating = false;
+		throw lastError;
+	}
+	/** 流式：ChatService 维护占位，adapter 只管解析 */
+	async _stream(body, adapterOptions, { placeholder, base, mergeToEntry, onProgress, onDone }) {
+		let finalMsg = null;
+		await this._adapter.stream(body, this.config, (snap) => {
+			placeholder.content = snap.content || "";
+			if (snap.reasoningContent) placeholder.reasoningContent = snap.reasoningContent;
+			if (snap.toolCalls) placeholder.toolCalls = [...snap.toolCalls];
+			this.emit("stream-progress", snap);
+			if (onProgress) onProgress(snap);
+		}, async (final) => {
+			finalMsg = final;
+			if (this._processResponse && !mergeToEntry) finalMsg = await this._processResponse(finalMsg, {
+				isStream: true,
+				onProgress,
+				onDone
+			});
+			if (mergeToEntry && base) {
+				const changes = {
+					content: base.content + (final.content || ""),
+					_complete: true
+				};
+				if (final.reasoningContent) changes.reasoningContent = base.reasoning + final.reasoningContent;
+				if (final.toolCalls) changes.toolCalls = final.toolCalls;
+				this.messages.update(mergeToEntry, changes);
+				const updated = this.messages.getAll().find((m) => m.id === mergeToEntry);
+				this.emit("message", updated);
+				if (onDone) onDone(updated);
+			} else {
+				placeholder._complete = true;
+				this.emit("message", finalMsg);
+				if (onDone) onDone(finalMsg);
+			}
+		}, adapterOptions);
+		return mergeToEntry || finalMsg;
+	}
+	/** 非流式结果落位 */
+	_handleResult(assistantMsg, mergeToEntry) {
+		if (mergeToEntry) {
+			const entry = this.messages.getAll().find((m) => m.id === mergeToEntry);
+			if (!entry) {
+				this.messages.add(assistantMsg);
+				this.emit("message", assistantMsg);
+				return assistantMsg;
+			}
+			const changes = {
+				content: (entry.content || "") + (assistantMsg.content || ""),
+				_complete: true
+			};
+			if (assistantMsg.reasoningContent) changes.reasoningContent = (entry.reasoningContent || "") + assistantMsg.reasoningContent;
+			if (assistantMsg.toolCalls) changes.toolCalls = assistantMsg.toolCalls;
+			this.messages.update(mergeToEntry, changes);
+			const updated = this.messages.getAll().find((m) => m.id === mergeToEntry);
+			this.emit("message", updated);
+			return updated;
+		}
+		this.messages.add(assistantMsg);
+		this.emit("message", assistantMsg);
+		return assistantMsg;
+	}
+	async send(userInput) {
+		this._abortController = new AbortController();
+		try {
+			return await this._request({
+				userInput,
+				addUser: true,
+				isStream: false
+			});
+		} finally {
+			this._abortController = null;
+			this._isGenerating = false;
+		}
+	}
+	async stream(userInput, onProgress, onDone) {
+		this._abortController = new AbortController();
+		try {
+			return await this._request({
+				userInput,
+				addUser: true,
+				isStream: true,
+				onProgress,
+				onDone
+			});
+		} finally {
+			this._abortController = null;
+			this._isGenerating = false;
+		}
+	}
+	async sendExisting() {
+		this._abortController = new AbortController();
+		try {
+			return await this._request({
+				addUser: false,
+				isStream: false
+			});
+		} finally {
+			this._abortController = null;
+			this._isGenerating = false;
+		}
+	}
+	async sendExistingStream(onProgress, onDone) {
+		this._abortController = new AbortController();
+		try {
+			return await this._request({
+				addUser: false,
+				isStream: true,
+				onProgress,
+				onDone
+			});
+		} finally {
+			this._abortController = null;
+			this._isGenerating = false;
+		}
+	}
+};
+//#endregion
+//#region src/utils/url.js
+/**
+* URL 工具函数
+*/
+/**
+* 拼接 baseUrl 和 path
+* 注意：path 应以 '/' 开头，否则会替换 baseUrl 的最后一段
+* @param {string} baseUrl - 基础 URL（如 https://api.deepseek.com）
+* @param {string} path - 路径（如 /v1/chat/completions）
+* @returns {string} 完整的 URL
+*/
+function joinUrl(baseUrl, path) {
+	return baseUrl.replace(/\/$/, "") + (path.startsWith("/") ? path : "/" + path);
 }
-class ToolManager extends EventEmitter {
-  constructor() {
-    super();
-    this.tools = /* @__PURE__ */ 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
-    });
-    this.emit("tool-registered", { name, definition: toolDefinition });
-    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 });
-      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
-        });
-      }
-    }
-    return results;
-  }
+//#endregion
+//#region src/utils/typeCheck.js
+/**
+* 类型判断工具
+*/
+/**
+* 判断一个值是否为字符串
+* @param {any} value - 要检查的值
+* @returns {boolean} 如果是字符串则返回 true
+*/
+function isString(value) {
+	return typeof value === "string";
 }
-class RequestBuilder {
-  constructor(model, messagesInstance, config = {}) {
-    this.model = model;
-    this.messages = messagesInstance;
-    this.config = {
-      // temperature: 0.7,
-      // max_tokens: 2000,
-      // stream: false, // 默认关闭流式传输
-      ...config
-    };
-    this.toolManager = null;
-  }
-  /**
-   * 设置ToolManager引用
-   */
-  setToolManager(toolManager) {
-    this.toolManager = toolManager;
-    return this;
-  }
-  /**
-   * 构建OpenAI兼容格式的请求体
-   */
-  buildOpenAIFormat(baseRounds, cycleRounds) {
-    const formattedMessages = MessageFormatter.formatMessages(
-      this.messages,
-      baseRounds,
-      cycleRounds
-    );
-    const filteredMessages = MessageFormatter.filterForAPI(formattedMessages);
-    const request = {
-      model: this.model,
-      messages: filteredMessages,
-      ...this.config
-    };
-    let tools = [];
-    if (this.toolManager && this.toolManager.hasTools()) {
-      tools = this.toolManager.getToolDefinitions();
-    } else {
-      tools = this.messages.getTools();
-    }
-    if (tools && tools.length > 0) {
-      request.tools = tools;
-      request.tool_choice = "auto";
-    }
-    return request;
-  }
-  /**
-   * 构建请求体并返回JSON字符串
-   */
-  toJSON(baseRounds, cycleRounds) {
-    const request = this.buildOpenAIFormat(baseRounds, cycleRounds);
-    return JSON.stringify(request);
-  }
-  /**
-   * 构建请求体并返回对象
-   */
-  toObject(baseRounds, cycleRounds) {
-    return this.buildOpenAIFormat(baseRounds, cycleRounds);
-  }
-  /**
-   * 设置配置项
-   */
-  setConfig(key, value) {
-    this.config[key] = value;
-    return this;
-  }
-  /**
-   * 批量设置配置项
-   */
-  setConfigs(configs) {
-    Object.assign(this.config, configs);
-    return this;
-  }
+//#endregion
+//#region src/utils/MessageFormatter.js
+/**
+* MessageFormatter — 可注册的消息格式转换器
+*
+* 职责：
+* 1. 内置 OpenA I兼容格式的转换逻辑
+* 2. 支持 register(name, fn) 注册自定义格式（如 Anthropic、Gemini 等）
+* 3. 统一处理 capabilities 过滤（reasoning、vision 等）
+* 4. 所有适配器通过此工具获取 API 消息数组，消除重复代码
+*
+* 用法：
+*   import { MessageFormatter } from 'my-ai-chat-framework';
+*
+*   // 使用内置格式
+*   const msgs = MessageFormatter.format({
+*     messages, systemPrompts, capabilities, resolveImage
+*   });  // 默认 'openai'
+*
+*   // 注册自定义格式
+*   MessageFormatter.register('anthropic', ({ messages, systemPrompts, capabilities }) => {
+*     // 返回 Anthropic 格式的消息数组
+*   });
+*/
+var IS_URL = /^https?:\/\//i;
+function defaultResolveImage(imageId) {
+	if (IS_URL.test(imageId)) return { url: imageId };
+	return null;
 }
-class ApiClient extends EventEmitter {
-  constructor(apiKey, apiUrl = "https://api.deepseek.com/v1/chat/completions") {
-    super();
-    this.apiKey = apiKey;
-    this.url = apiUrl;
-    this.isGenerating = false;
-    this.cancelTokenSource = null;
-    this.axiosInstance = axios.create({
-      baseURL: apiUrl,
-      headers: {
-        "Authorization": `Bearer ${apiKey}`,
-        "Content-Type": "application/json"
-      },
-      timeout: 3e4
-      // 30秒超时
-    });
-  }
-  setApiKey(apiKey) {
-    if (!apiKey || typeof apiKey !== "string") {
-      throw new Error("无效的API Key");
-    }
-    this.apiKey = apiKey;
-    this.axiosInstance.defaults.headers["Authorization"] = `Bearer ${apiKey}`;
-  }
-  setApiUrl(apiUrl) {
-    if (!apiUrl || typeof apiUrl !== "string") {
-      throw new Error("无效的API URL");
-    }
-    this.url = apiUrl;
-    this.axiosInstance.defaults.baseURL = apiUrl;
-  }
-  async send(body) {
-    this.isGenerating = true;
-    this.cancelTokenSource = axios.CancelToken.source();
-    try {
-      this.emit("request-start", { body });
-      const requestBody = this._buildRequestBody(body);
-      const response = await this.axiosInstance.post("", requestBody, {
-        cancelToken: this.cancelTokenSource.token
-      });
-      this.emit("request-success", { response: response.data });
-      return response.data;
-    } catch (error) {
-      if (axios.isCancel(error)) {
-        const cancelError = new Error("请求被中断");
-        cancelError.name = "CancelError";
-        this.emit("request-cancel", { error: cancelError });
-        throw cancelError;
-      }
-      this.emit("request-error", { error });
-      throw this._handleAxiosError(error);
-    } finally {
-      this.isGenerating = false;
-      this.cancelTokenSource = null;
-    }
-  }
-  async strSend(body, onProgress, onDone) {
-    this.isGenerating = true;
-    this.cancelTokenSource = axios.CancelToken.source();
-    try {
-      const safeOnProgress = typeof onProgress === "function" ? onProgress : () => {
-      };
-      const safeOnDone = typeof onDone === "function" ? onDone : () => {
-      };
-      this.emit("stream-start", { body });
-      const requestBody = this._buildRequestBody(body);
-      const response = await fetch(this.url, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          "Authorization": `Bearer ${this.apiKey}`,
-          "Accept": "text/event-stream"
-        },
-        body: requestBody,
-        signal: this.cancelTokenSource.token ? new AbortController().signal : void 0
-      });
-      if (!response.ok) {
-        throw new Error(`HTTP错误: ${response.status}`);
-      }
-      const reader = response.body.getReader();
-      const decoder = new TextDecoder();
-      let buffer = "";
-      const message = {
-        // 基础信息（符合Messages格式）
-        role: "assistant",
-        content: "",
-        reasoning_content: "",
-        timestamp: /* @__PURE__ */ new Date(),
-        // 工具调用
-        tool_calls: [],
-        // 流式元数据
-        streamMetadata: {
-          chunkCount: 0,
-          firstChunkTime: Date.now(),
-          lastChunkTime: null,
-          isStreaming: true
-        }
-      };
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done) break;
-        buffer += decoder.decode(value, { stream: true });
-        let lines = buffer.split(/(\r?\n){2,}/);
-        buffer = lines.pop() || "";
-        for (let rawChunk of lines) {
-          const cleanChunk = rawChunk.trim().replace(/^data: /, "");
-          if (!cleanChunk) continue;
-          if (cleanChunk === "[DONE]") {
-            this.emit("stream-done", { message });
-            safeOnDone({ ...message });
-            return;
-          }
-          try {
-            const obj = JSON.parse(cleanChunk);
-            console.log("🔍 收到流式chunk:", obj);
-            message.streamMetadata.chunkCount++;
-            message.streamMetadata.lastChunkTime = Date.now();
-            if (obj.choices?.[0]?.delta?.content) {
-              message.content += obj.choices[0].delta.content;
-            }
-            if (obj.choices?.[0]?.delta?.reasoning_content) {
-              message.reasoning_content += obj.choices[0].delta.reasoning_content;
-            }
-            if (obj.choices?.[0]?.delta?.tool_calls) {
-              const deltaToolCalls = obj.choices[0].delta.tool_calls;
-              deltaToolCalls.forEach((toolCall) => {
-                const index2 = toolCall.index || 0;
-                if (!message.tool_calls) message.tool_calls = [];
-                if (!message.tool_calls[index2]) {
-                  message.tool_calls[index2] = {
-                    id: "",
-                    type: "function",
-                    function: { name: "", arguments: "" }
-                  };
-                }
-                if (toolCall.id) message.tool_calls[index2].id = toolCall.id;
-                if (toolCall.type) message.tool_calls[index2].type = toolCall.type;
-                if (toolCall.function?.name) {
-                  message.tool_calls[index2].function.name += toolCall.function.name;
-                }
-                if (toolCall.function?.arguments) {
-                  message.tool_calls[index2].function.arguments += toolCall.function.arguments;
-                }
-              });
-            }
-            this.emit("stream-chunk", {
-              chunk: obj,
-              message: { ...message }
-              // 发送副本
-            });
-            safeOnProgress({ ...message });
-          } catch (e) {
-            console.error("🔍 解析chunk错误:", e, "原始数据:", cleanChunk);
-          }
-        }
-        if (!this.isGenerating) {
-          break;
-        }
-      }
-      message.streamMetadata.isStreaming = false;
-      message.streamMetadata.completedAt = /* @__PURE__ */ new Date();
-      this.emit("stream-done", { message: { ...message } });
-      safeOnDone({ ...message });
-    } catch (error) {
-      if (error.name === "AbortError" || axios.isCancel(error)) {
-        const cancelError = new Error("请求被中断");
-        cancelError.name = "CancelError";
-        this.emit("stream-cancel", { error: cancelError });
-        throw cancelError;
-      }
-      this.emit("stream-error", { error });
-      throw error;
-    } finally {
-      this.isGenerating = false;
-      this.cancelTokenSource = null;
-    }
-  }
-  interrupt() {
-    if (this.isGenerating && this.cancelTokenSource) {
-      this.cancelTokenSource.cancel("用户中断请求");
-      this.isGenerating = false;
-    }
-  }
-  _buildRequestBody(body) {
-    if (typeof body?.toJSON === "function") {
-      return body.toJSON();
-    } else if (typeof body === "object" && body !== null) {
-      return JSON.stringify(body);
-    } else if (typeof body === "string") {
-      try {
-        JSON.parse(body);
-        return body;
-      } catch {
-        throw new Error("字符串不是有效的JSON格式");
-      }
-    } else {
-      throw new Error("无效的请求体类型，应传入对象或JSON字符串");
-    }
-  }
-  _handleAxiosError(error) {
-    if (error.response) {
-      const status = error.response.status;
-      const data = error.response.data;
-      let message = `API错误 ${status}`;
-      if (data?.error?.message) {
-        message += `: ${data.error.message}`;
-      }
-      return new Error(message);
-    } else if (error.request) {
-      return new Error("网络错误：无法连接到API服务器");
-    } else {
-      return error;
-    }
-  }
-  static parseCompatible(obj) {
-    if (obj?.__format_version === 1 && obj.payload) {
-      return {
-        messages: obj.payload.messages || [],
-        systems: obj.payload.systems || [],
-        hintData: obj.payload.hintData || {
-          name: "",
-          toolState: {
-            currentTime: "同步失败",
-            currentTime_TS: 0
-          }
-        },
-        tools: obj.payload.tools || []
-      };
-    }
-    if (obj?.messages && Array.isArray(obj.messages)) {
-      return {
-        messages: obj.messages || [],
-        systems: obj.systems || [],
-        hintData: obj.hintData || {
-          name: "",
-          toolState: {
-            currentTime: "同步失败",
-            currentTime_TS: 0
-          }
-        },
-        tools: obj.tools || []
-      };
-    }
-    throw new Error("无法识别的聊天数据格式");
-  }
+function buildMultimodalContent(textContent, images, resolveImage) {
+	const content = [{
+		type: "text",
+		text: textContent
+	}];
+	for (const ref of images) {
+		const resolved = resolveImage(ref);
+		if (!resolved) continue;
+		if (resolved.url) content.push({
+			type: "image_url",
+			image_url: { url: resolved.url }
+		});
+		else if (resolved.data) {
+			const mime = resolved.mimeType || "image/png";
+			content.push({
+				type: "image_url",
+				image_url: { url: `data:${mime};base64,${resolved.data}` }
+			});
+		}
+	}
+	return content;
 }
-class ConfigManager extends EventEmitter {
-  constructor(defaultConfig2 = {}) {
-    super();
-    this._config = JSON.parse(JSON.stringify(defaultConfig2));
-    this._handlers = /* @__PURE__ */ new Map();
-    this.config = this._createProxy(this._config);
-  }
-  /**
-   * 创建配置代理
-   */
-  _createProxy(target, path = "") {
-    return new Proxy(target, {
-      set: (obj, prop, value) => {
-        const oldValue = obj[prop];
-        const fullPath = path ? `${path}.${prop}` : prop;
-        if (value && typeof value === "object" && !Array.isArray(value)) {
-          value = this._createProxy(value, fullPath);
-        }
-        obj[prop] = value;
-        this._triggerChange(fullPath, oldValue, value);
-        return true;
-      },
-      deleteProperty: (obj, prop) => {
-        const oldValue = obj[prop];
-        const fullPath = path ? `${path}.${prop}` : prop;
-        delete obj[prop];
-        this.emit("config-deleted", {
-          path: fullPath,
-          oldValue,
-          timestamp: /* @__PURE__ */ new Date()
-        });
-        return true;
-      }
-    });
-  }
-  /**
-   * 注册配置处理器
-   */
-  registerHandler(path, handler) {
-    if (!this._handlers.has(path)) {
-      this._handlers.set(path, []);
-    }
-    this._handlers.get(path).push(handler);
-    return this;
-  }
-  /**
-   * 移除配置处理器
-   */
-  removeHandler(path, handler) {
-    const handlers = this._handlers.get(path);
-    if (handlers) {
-      const index2 = handlers.indexOf(handler);
-      if (index2 > -1) {
-        handlers.splice(index2, 1);
-      }
-    }
-    return this;
-  }
-  /**
-   * 触发配置变更
-   */
-  _triggerChange(path, oldValue, newValue) {
-    this.emit("config-changed", {
-      path,
-      oldValue,
-      newValue,
-      timestamp: /* @__PURE__ */ new Date()
-    });
-    this.emit(`config-changed:${path}`, {
-      oldValue,
-      newValue,
-      timestamp: /* @__PURE__ */ new Date()
-    });
-    const handlers = this._handlers.get(path);
-    if (handlers) {
-      handlers.forEach((handler) => {
-        try {
-          handler(newValue, oldValue, path);
-        } catch (error) {
-          console.error(`配置处理器执行失败 (${path}):`, error);
-        }
-      });
-    }
-    const pathParts = path.split(".");
-    for (let i = pathParts.length - 1; i >= 0; i--) {
-      const parentPath = pathParts.slice(0, i).join(".");
-      const wildcardPath = parentPath ? `${parentPath}.*` : "*";
-      const parentHandlers = this._handlers.get(wildcardPath);
-      if (parentHandlers) {
-        parentHandlers.forEach((handler) => {
-          try {
-            handler(newValue, oldValue, path);
-          } catch (error) {
-            console.error(`通配符处理器执行失败 (${wildcardPath}):`, error);
-          }
-        });
-      }
-    }
-  }
-  /**
-   * 获取配置快照（非代理版本）
-   */
-  getSnapshot() {
-    return JSON.parse(JSON.stringify(this._config));
-  }
-  /**
-   * 批量更新配置
-   */
-  update(newConfig) {
-    Object.keys(newConfig).forEach((key) => {
-      this.config[key] = newConfig[key];
-    });
-    return this;
-  }
-  /**
-   * 重置为默认值
-   */
-  reset() {
-    const oldConfig = this.getSnapshot();
-    this._config = JSON.parse(JSON.stringify(this._defaultConfig));
-    this.config = this._createProxy(this._config);
-    this.emit("config-reset", {
-      oldConfig,
-      newConfig: this.getSnapshot(),
-      timestamp: /* @__PURE__ */ new Date()
-    });
-    return this;
-  }
+/** OpenAI 兼容格式 */
+function toOpenAI({ messages, systemPrompts, capabilities, resolveImage }) {
+	const rImg = typeof resolveImage === "function" ? resolveImage : defaultResolveImage;
+	const result = [];
+	for (const sp of systemPrompts) if (sp?.content && isString(sp.content) && sp.content.trim()) result.push({
+		role: "system",
+		content: sp.content.trim()
+	});
+	let ephemEnd = messages.length;
+	for (let i = messages.length - 1; i >= 0; i--) if (messages[i]._ephemeral) ephemEnd = i;
+	else break;
+	for (let i = 0; i < messages.length; i++) {
+		const msg = messages[i];
+		if (msg._ephemeral) {
+			if (i < ephemEnd) continue;
+		}
+		if (msg.role === "system" && !msg._ephemeral) continue;
+		if (msg.role === "tool") {
+			result.push({
+				role: "tool",
+				content: msg.content || "",
+				tool_call_id: msg.toolCallId
+			});
+			continue;
+		}
+		if (msg.role === "assistant" && msg.toolCalls?.length) {
+			const entry = {
+				role: "assistant",
+				content: msg.content || "",
+				tool_calls: msg.toolCalls
+			};
+			if (msg.prefix) entry.prefix = true;
+			if (capabilities?.reasoning && msg.reasoningContent) entry.reasoning_content = msg.reasoningContent;
+			result.push(entry);
+			continue;
+		}
+		const hasText = msg.content && isString(msg.content) && msg.content.trim();
+		const hasImages = msg.images && Array.isArray(msg.images) && msg.images.length > 0;
+		if (!hasText && !hasImages) {
+			if (msg.role === "assistant" && msg.prefix) {
+				const prefixEntry = {
+					role: "assistant",
+					content: "",
+					prefix: true
+				};
+				if (capabilities?.reasoning && msg.reasoningContent) prefixEntry.reasoning_content = msg.reasoningContent;
+				result.push(prefixEntry);
+			}
+			continue;
+		}
+		const entry = { role: msg.role };
+		if (hasImages) {
+			if (!capabilities?.vision) throw new Error("[MessageFormatter] 消息包含图片但模型不支持视觉（capabilities.vision=false）。请切换模型或移除图片。");
+			entry.content = buildMultimodalContent(msg.content || "", msg.images, rImg);
+		} else entry.content = msg.content;
+		if (msg.prefix) entry.prefix = true;
+		result.push(entry);
+	}
+	return result;
 }
-const defaultConfig = {
-  api: {
-    key: "",
-    url: "https://api.deepseek.com/v1/chat/completions",
-    timeout: 3e4
-  },
-  model: {
-    name: "deepseek-chat",
-    temperature: 0.7,
-    // maxTokens: 2000,
-    stream: false,
-    reasoningEffort: "medium"
-  },
-  conversation: {
-    baseRounds: 10,
-    cycleRounds: 5
-  },
-  debug: false
+var MessageFormatter = {
+	_formats: new Map([["openai", toOpenAI]]),
+	register(name, fn) {
+		if (!name || typeof name !== "string" || !name.trim()) throw new Error("[MessageFormatter] 格式名称必须是非空字符串");
+		if (typeof fn !== "function") throw new Error("[MessageFormatter] 转换函数必须是 function");
+		this._formats.set(name.trim(), fn);
+	},
+	unregister(name) {
+		if (name === "openai") throw new Error("[MessageFormatter] 内置格式 \"openai\" 不可移除");
+		this._formats.delete(name);
+	},
+	listFormats() {
+		return [...this._formats.keys()];
+	},
+	format(options = {}) {
+		const formatName = options.format || "openai";
+		const fn = this._formats.get(formatName);
+		if (!fn) throw new Error(`[MessageFormatter] 未知格式 "${formatName}"。可用格式: ${[...this._formats.keys()].join(", ")}`);
+		return fn({
+			messages: options.messages || [],
+			systemPrompts: options.systemPrompts || [],
+			capabilities: options.capabilities || {},
+			resolveImage: options.resolveImage
+		});
+	}
 };
-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() {
-    this.configManager.registerHandler("api.key", (newValue) => {
-      this.apiClient.setApiKey(newValue);
-    });
-    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() {
-    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) {
-    this.toolManager.registerTool(name, definition, executor);
-    this.messages.addTool(definition);
-    return this;
-  }
-  /**
-   * 发送消息（支持工具调用）
-   */
-  async send(userMessage, options = {}) {
-    try {
-      this.emit("sending", {
-        role: "user",
-        content: userMessage,
-        timestamp: /* @__PURE__ */ new Date(),
-        eventType: "sending"
-      });
-      this.messages.addUserMessage(userMessage);
-      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,
-        message: userMessage,
-        timestamp: /* @__PURE__ */ new Date()
-      });
-      throw error;
-    }
-  }
-  /**
-   * 处理工具调用（支持循环调用）
-   */
-  async _handleToolCalls(aiMessage, maxIterations = 5) {
-    let iteration = 0;
-    let currentMessage = aiMessage;
-    while (iteration < maxIterations) {
-      iteration++;
-      this.messages.addAssistantMessage(currentMessage.content || "", {
-        tool_calls: currentMessage.tool_calls,
-        reasoning_content: currentMessage.reasoning_content || ""
-        // ✅ 新增：保存思考内容
-      });
-      this.emit("tool-call-requested", {
-        tool_calls: currentMessage.tool_calls,
-        reasoning_content: currentMessage.reasoning_content,
-        // ✅ 新增：包含思考内容
-        timestamp: /* @__PURE__ */ new Date(),
-        iteration
-      });
-      const toolResults = await this.toolManager.executeToolCalls(currentMessage.tool_calls);
-      for (const result of toolResults) {
-        this.messages.addToolMessage(
-          result.result || result.error || "",
-          result.tool_call_id
-        );
-      }
-      const requestBody = this.requestBuilder.toJSON();
-      const response = await this.apiClient.send(requestBody);
-      currentMessage = response.choices[0].message;
-      if (!currentMessage.tool_calls || currentMessage.tool_calls.length === 0) {
-        break;
-      }
-    }
-    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
-      });
-    }
-    const eventData = {
-      // 基础字段（Messages格式）
-      role: "assistant",
-      content: aiMessage.content || "",
-      timestamp: /* @__PURE__ */ 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 }] }
-      }
-    };
-    this.emit("message", eventData);
-    return eventData;
-  }
-  /**
-   * 处理普通回复
-   */
-  async _handleNormalResponse(aiMessage) {
-    return await this._handleAssistantResponse(aiMessage);
-  }
-  /**
-   * 流式发送消息（支持工具调用）
-   */
-  async stream(userMessage, onProgress, onDone, options = {}) {
-    try {
-      this.emit("sending", {
-        role: "user",
-        content: userMessage,
-        timestamp: /* @__PURE__ */ new Date(),
-        eventType: "sending"
-      });
-      this.messages.addUserMessage(userMessage);
-      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,
-        message: userMessage,
-        timestamp: /* @__PURE__ */ new Date()
-      });
-      throw error;
-    }
-  }
-  /**
-   * 处理流式传输中的工具调用（支持循环调用）
-   */
-  async _handleStreamToolCalls(aiMessage, onProgress, onDone, maxIterations = 5) {
-    let iteration = 0;
-    let currentMessage = aiMessage;
-    while (iteration < maxIterations) {
-      iteration++;
-      this.messages.addAssistantMessage(currentMessage.content || "", {
-        tool_calls: currentMessage.tool_calls,
-        reasoning_content: currentMessage.reasoning_content || ""
-        // ✅ 新增：保存思考内容
-      });
-      this.emit("tool-call-requested", {
-        tool_calls: currentMessage.tool_calls,
-        reasoning_content: currentMessage.reasoning_content,
-        // ✅ 新增：包含思考内容
-        timestamp: /* @__PURE__ */ new Date(),
-        iteration
-      });
-      const toolResults = await this.toolManager.executeToolCalls(currentMessage.tool_calls);
-      for (const result of toolResults) {
-        this.messages.addToolMessage(result.result || result.error, result.tool_call_id);
-      }
-      const requestBody = this.requestBuilder.toJSON();
-      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
-    });
-    if (typeof onDone === "function") {
-      onDone(eventData);
-    }
-  }
-  /**
-   * 撤回消息
-   */
-  undo() {
-    const removed = this.messages.undoToAssistant();
-    if (removed.length > 0) {
-      this.emit("undo", {
-        removedMessages: removed,
-        timestamp: /* @__PURE__ */ new Date()
-      });
-    }
-    return removed;
-  }
-  /**
-   * 清空消息
-   */
-  clear() {
-    const removed = this.messages.clearMessages();
-    this.emit("clear", {
-      removedMessages: removed,
-      timestamp: /* @__PURE__ */ new Date()
-    });
-    return removed;
-  }
-  /**
-   * 导出对话数据
-   */
-  export() {
-    const data = this.messages.export();
-    this.emit("export", {
-      data,
-      timestamp: /* @__PURE__ */ new Date()
-    });
-    return data;
-  }
-  /**
-   * 导入对话数据
-   */
-  import(data) {
-    this.messages.import(data);
-    this.emit("import", {
-      data,
-      timestamp: /* @__PURE__ */ new Date()
-    });
-    return this;
-  }
+function assembleMessages(options = {}) {
+	return MessageFormatter.format({
+		...options,
+		format: "openai"
+	});
 }
-const index = {
-  Messages,
-  RequestBuilder,
-  ApiClient,
-  EventEmitter,
-  MessageFormatter,
-  ToolManager,
-  ChatService,
-  defaultConfig
+//#endregion
+//#region src/adapters/openai.js
+/**
+* OpenAI 兼容 API 适配器
+* 支持 DeepSeek 等完全兼容 OpenAI 接口的服务
+*/
+var openaiAdapter = {
+	name: "openai",
+	install(chatService) {
+		chatService.setAdapter(this);
+	},
+	buildRequest(messages, config, systemPrompts = []) {
+		const model = config.model || config.modelParams?.model;
+		if (!model) throw new Error("Missing required config: model (either at top level or in modelParams)");
+		const temperature = config.modelParams?.temperature ?? config.temperature ?? .7;
+		const maxTokens = config.modelParams?.maxTokens ?? config.maxTokens ?? 2e3;
+		const reasoningEffort = config.modelParams?.reasoningEffort ?? config.reasoningEffort;
+		const requestBody = {
+			model,
+			messages: MessageFormatter.format({
+				messages,
+				systemPrompts,
+				capabilities: config.capabilities || {},
+				resolveImage: config.resolveImage,
+				format: config.messageFormat
+			}),
+			temperature,
+			max_tokens: maxTokens,
+			stream: false
+		};
+		if (config.tools && Array.isArray(config.tools) && config.tools.length > 0) {
+			requestBody.tools = config.tools;
+			requestBody.tool_choice = "auto";
+		}
+		if (reasoningEffort && model === "deepseek-reasoner") requestBody.reasoning_effort = reasoningEffort;
+		return requestBody;
+	},
+	_getUrl(config) {
+		config = config || {};
+		const { apiUrl, baseUrl, path } = config;
+		const defaultPath = "/chat/completions";
+		if (apiUrl && isString(apiUrl)) return apiUrl;
+		if (baseUrl && isString(baseUrl)) return joinUrl(baseUrl, path && isString(path) ? path : defaultPath);
+		return "https://api.openai.com/v1/chat/completions";
+	},
+	async send(requestBody, config, options = {}) {
+		try {
+			const url = this._getUrl(config);
+			const headers = {
+				"Content-Type": "application/json",
+				"Authorization": `Bearer ${config.apiKey}`,
+				...config.headers || {},
+				...options.headers || {}
+			};
+			const response = await fetch(url, {
+				method: "POST",
+				headers,
+				body: JSON.stringify(requestBody),
+				signal: options.signal
+			});
+			if (!response.ok) await this.handleErrorResponse(response);
+			return await response.json();
+		} catch (error) {
+			if (error instanceof APIError) throw error;
+			if (error.name === "AbortError") throw error;
+			if (error.name === "TypeError" && error.message.includes("fetch")) throw new NetworkError(`Request failed: ${error.message}`, error);
+			throw error;
+		}
+	},
+	parseResponse(apiResponse) {
+		if (!apiResponse || !apiResponse.choices || !apiResponse.choices[0] || !apiResponse.choices[0].message) throw new ParsingError("Invalid API response: missing choices or message", apiResponse, JSON.stringify(apiResponse));
+		const msg = apiResponse.choices[0].message;
+		const internal = {
+			role: msg.role,
+			content: msg.content || ""
+		};
+		if (msg.tool_calls) internal.toolCalls = msg.tool_calls;
+		if (msg.reasoning_content) internal.reasoningContent = msg.reasoning_content;
+		return internal;
+	},
+	async stream(requestBody, config, onProgress, onDone, options = {}) {
+		const streamBody = {
+			...requestBody,
+			stream: true
+		};
+		const url = this._getUrl(config);
+		let response;
+		const headers = {
+			"Content-Type": "application/json",
+			"Authorization": `Bearer ${config.apiKey}`,
+			"Accept": "text/event-stream",
+			...config.headers || {},
+			...options.headers || {}
+		};
+		try {
+			response = await fetch(url, {
+				method: "POST",
+				headers,
+				body: JSON.stringify(streamBody),
+				signal: options.signal
+			});
+		} catch (error) {
+			if (error.name === "AbortError") throw error;
+			if (error.name === "TypeError" && error.message.includes("fetch")) throw new NetworkError(`Stream request failed: ${error.message}`, error);
+			throw error;
+		}
+		if (!response.ok) await this.handleErrorResponse(response);
+		const reader = response.body.getReader();
+		const decoder = new TextDecoder();
+		let buffer = "";
+		let accumulated = {
+			role: "assistant",
+			content: "",
+			reasoningContent: ""
+		};
+		while (true) {
+			if (options.signal?.aborted) break;
+			const { done, value } = await reader.read();
+			if (done) break;
+			buffer += decoder.decode(value, { stream: true });
+			const lines = buffer.split(/\n\n/);
+			buffer = lines.pop();
+			for (const line of lines) {
+				const dataLine = line.replace(/^data: /, "").trim();
+				if (!dataLine) continue;
+				if (dataLine === "[DONE]") break;
+				try {
+					const delta = JSON.parse(dataLine).choices?.[0]?.delta;
+					if (!delta) continue;
+					if (delta.content) accumulated.content += delta.content;
+					if (delta.tool_calls) {
+						if (!accumulated.toolCalls) accumulated.toolCalls = [];
+						for (const toolCallDelta of delta.tool_calls) {
+							const index = toolCallDelta.index;
+							if (!accumulated.toolCalls[index]) accumulated.toolCalls[index] = {
+								id: "",
+								type: "function",
+								function: {
+									name: "",
+									arguments: ""
+								}
+							};
+							if (toolCallDelta.id) accumulated.toolCalls[index].id = toolCallDelta.id;
+							if (toolCallDelta.type) accumulated.toolCalls[index].type = toolCallDelta.type;
+							if (toolCallDelta.function?.name) accumulated.toolCalls[index].function.name += toolCallDelta.function.name;
+							if (toolCallDelta.function?.arguments) accumulated.toolCalls[index].function.arguments += toolCallDelta.function.arguments;
+						}
+					}
+					if (delta.reasoning_content) accumulated.reasoningContent += delta.reasoning_content;
+					onProgress({ ...accumulated });
+				} catch (e) {
+					console.warn("stream parsing failed :", e, dataLine);
+				}
+			}
+		}
+		onDone({
+			role: "assistant",
+			content: accumulated.content,
+			toolCalls: accumulated.toolCalls,
+			reasoningContent: accumulated.reasoningContent
+		});
+	},
+	async handleErrorResponse(response) {
+		let errorText = await response.text();
+		let errorMessage = `HTTP ${response.status}`;
+		try {
+			const errorJson = JSON.parse(errorText);
+			errorMessage = errorJson.error?.message || errorJson.message || errorText.slice(0, 200);
+		} catch (e) {
+			errorMessage = errorText.length > 200 ? errorText.slice(0, 200) + "..." : errorText;
+		}
+		throw new APIError(errorMessage, response.status, null, errorText);
+	}
+};
+//#endregion
+//#region src/plugins/tool-calling.js
+/**
+* 工具调用插件
+* 功能：拦截助手消息中的 tool_calls，执行对应的工具，将结果作为 tool 消息加入对话，
+*       然后自动继续对话（通过 sendExisting / sendExistingStream），直到没有新的工具调用。
+* 
+* 设计要点：
+* - 支持普通请求和流式请求（通过 isStream 标志区分）
+* - 支持多次工具调用循环（maxIterations 防止无限循环）
+* - 串行执行工具（可后续升级为并行）
+* - 工具执行失败时，仍然返回错误信息给 AI，而不是中断整个流程
+* - 触发 tool-error 事件，方便用户监听工具执行异常
+*/
+var toolCallingPlugin = {
+	name: "tool-calling",
+	maxIterations: 5,
+	install(chatService) {
+		this.chatService = chatService;
+		this._tools = /* @__PURE__ */ new Map();
+		if (!chatService.config.tools) chatService.config.tools = [];
+		/**
+		* 注册工具
+		* @param {string} name - 工具名称（唯一标识）
+		* @param {string} description - 工具描述（告诉 AI 何时调用）
+		* @param {Function} executor - 异步执行函数，接收参数对象，返回结果（字符串或对象）
+		* @param {Object} parameters - JSON Schema 参数定义（可选，默认为空对象）
+		* @returns {ChatService} 返回 chatService 实例，支持链式调用
+		*/
+		chatService.registerTool = (name, description, executor, parameters = {}) => {
+			this._tools.set(name, {
+				executor,
+				description
+			});
+			const toolDefinition = {
+				type: "function",
+				function: {
+					name,
+					description,
+					parameters: {
+						type: "object",
+						properties: parameters,
+						required: Object.keys(parameters).filter((key) => parameters[key]?.required)
+					}
+				}
+			};
+			if (!chatService.config.tools.find((t) => t.function.name === name)) chatService.config.tools.push(toolDefinition);
+			return chatService;
+		};
+		chatService._processResponse = async (response, { isStream, onProgress, onDone }) => {
+			return this._handleWithTools(response, isStream, onProgress, onDone);
+		};
+	},
+	async _handleWithTools(initialResponse, isStream, onProgress, onDone) {
+		const self = this;
+		const chat = this.chatService;
+		let iteration = 0;
+		/**
+		* 递归处理工具调用
+		* @param {Object} initialResponse - 初始 AI 响应（可能是第一次请求的响应）
+		* @returns {Promise<Object>} 最终 AI 响应（不含 tool_calls）
+		*/
+		async function processResponse(initialResponse) {
+			let lastResponse = initialResponse;
+			while (iteration < self.maxIterations) {
+				const toolCalls = lastResponse?.toolCalls;
+				if (!toolCalls || toolCalls.length === 0) break;
+				iteration++;
+				const toolResults = await Promise.all(toolCalls.map(async (call) => {
+					const toolName = call.function?.name;
+					let args;
+					try {
+						args = JSON.parse(call.function?.arguments || "{}");
+					} catch (parseErr) {
+						chat.emit("tool-error", {
+							toolName: toolName || "unknown",
+							error: parseErr,
+							toolCallId: call.id,
+							stage: "parse",
+							timestamp: Date.now()
+						});
+						return {
+							tool_call_id: call.id,
+							error: `参数解析失败: ${parseErr.message}`,
+							success: false
+						};
+					}
+					const tool = self._tools.get(toolName);
+					if (!tool) {
+						chat.emit("tool-error", {
+							toolName,
+							error: /* @__PURE__ */ new Error(`Tool not registered: ${toolName}`),
+							toolCallId: call.id,
+							stage: "lookup",
+							timestamp: Date.now()
+						});
+						return {
+							tool_call_id: call.id,
+							error: `工具 ${toolName} 未注册`,
+							success: false
+						};
+					}
+					try {
+						const toolTimeout = chat.config.toolTimeout;
+						let execPromise = tool.executor(args);
+						if (toolTimeout && typeof toolTimeout === "number" && toolTimeout > 0) {
+							const timeoutErr = /* @__PURE__ */ new Error(`工具 ${toolName} 执行超时 (${toolTimeout}ms)`);
+							timeoutErr.name = "ToolTimeoutError";
+							const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(timeoutErr), toolTimeout));
+							execPromise = Promise.race([execPromise, timeoutPromise]);
+						}
+						const result = await execPromise;
+						chat.emit("tool-success", {
+							toolName,
+							result,
+							toolCallId: call.id,
+							timestamp: Date.now()
+						});
+						return {
+							tool_call_id: call.id,
+							content: typeof result === "string" ? result : JSON.stringify(result),
+							success: true
+						};
+					} catch (err) {
+						const stage = err.name === "ToolTimeoutError" ? "timeout" : "execute";
+						chat.emit("tool-error", {
+							toolName,
+							error: err,
+							toolCallId: call.id,
+							stage,
+							timestamp: Date.now()
+						});
+						return {
+							tool_call_id: call.id,
+							error: err.message,
+							success: false
+						};
+					}
+				}));
+				for (const tr of toolResults) {
+					const content = tr.success ? tr.content : tr.error || "工具执行失败";
+					chat.messages.addTool(content, tr.tool_call_id);
+				}
+				if (isStream) await new Promise((resolve) => {
+					chat.sendExistingStream((chunk) => {
+						if (onProgress) onProgress(chunk);
+						lastResponse = chunk;
+					}, (final) => {
+						lastResponse = final;
+						resolve();
+					});
+				});
+				else lastResponse = await chat.sendExisting();
+			}
+			return lastResponse;
+		}
+		return await processResponse(initialResponse);
+	}
+};
+//#endregion
+//#region src/plugins/model-registry.js
+/**
+* model-registry 插件
+* 
+* 职责：
+* 1. 内置常用模型的能力标签表（model → capabilities 映射）
+* 2. 安装时自动根据 config.model 查表，写入 config.capabilities
+* 3. 监听 config-updated 事件，切换模型时自动同步能力
+* 4. 提供 chat.registerModel()，允许用户追加/覆盖自定义模型
+* 
+* 能力标签字段（全部可选，缺失视为 false / 未知）：
+* {
+*   reasoning:    boolean — 是否返回 reasoning_content（思维链）
+*   vision:       boolean — 是否支持图片输入
+*   toolCalling:  boolean — 是否支持 function calling
+*   streaming:    boolean — 是否支持流式传输
+*   maxInputTokens:  number — 最大输入 token 数
+*   maxOutputTokens: number — 最大输出 token 数
+* }
+* 
+* 使用：
+*   chat.use(modelRegistryPlugin);
+*   // config.capabilities 现在已自动填充
+*   chat.registerModel('my-custom-model', { toolCalling: true });
+*/
+var BUILTIN_MODELS = {
+	"deepseek-chat": {
+		reasoning: false,
+		vision: false,
+		toolCalling: true,
+		streaming: true,
+		maxInputTokens: 128e3,
+		maxOutputTokens: 8192
+	},
+	"deepseek-reasoner": {
+		reasoning: true,
+		vision: false,
+		toolCalling: true,
+		streaming: true,
+		maxInputTokens: 128e3,
+		maxOutputTokens: 8192
+	},
+	"gpt-4o": {
+		reasoning: false,
+		vision: true,
+		toolCalling: true,
+		streaming: true,
+		maxInputTokens: 128e3,
+		maxOutputTokens: 16384
+	},
+	"gpt-4o-mini": {
+		reasoning: false,
+		vision: true,
+		toolCalling: true,
+		streaming: true,
+		maxInputTokens: 128e3,
+		maxOutputTokens: 16384
+	},
+	"gpt-3.5-turbo": {
+		reasoning: false,
+		vision: false,
+		toolCalling: true,
+		streaming: true,
+		maxInputTokens: 16385,
+		maxOutputTokens: 4096
+	},
+	"o1": {
+		reasoning: true,
+		vision: false,
+		toolCalling: false,
+		streaming: false,
+		maxInputTokens: 2e5,
+		maxOutputTokens: 1e5
+	},
+	"o3-mini": {
+		reasoning: true,
+		vision: false,
+		toolCalling: true,
+		streaming: true,
+		maxInputTokens: 2e5,
+		maxOutputTokens: 1e5
+	},
+	"claude-3.5-sonnet": {
+		reasoning: false,
+		vision: true,
+		toolCalling: true,
+		streaming: true,
+		maxInputTokens: 2e5,
+		maxOutputTokens: 8192
+	},
+	"claude-3.5-haiku": {
+		reasoning: false,
+		vision: true,
+		toolCalling: true,
+		streaming: true,
+		maxInputTokens: 2e5,
+		maxOutputTokens: 8192
+	}
+};
+var DEFAULT_CAPABILITIES = {
+	streaming: true,
+	toolCalling: false,
+	reasoning: false,
+	vision: false
+};
+var modelRegistryPlugin = {
+	name: "model-registry",
+	install(chatService) {
+		this.chat = chatService;
+		this._registry = new Map(Object.entries(BUILTIN_MODELS));
+		/**
+		* 注册/覆盖一个模型的能力标签
+		* @param {string} name — 模型名称
+		* @param {Object} capabilities — 能力标签对象（部分字段即可，未提供的取默认值）
+		* @returns {ChatService}
+		*/
+		chatService.registerModel = (name, capabilities = {}) => {
+			if (!name || typeof name !== "string" || !name.trim()) throw new Error("[model-registry] 模型名称必须是非空字符串");
+			const merged = {
+				...DEFAULT_CAPABILITIES,
+				...capabilities
+			};
+			this._registry.set(name.trim(), merged);
+			if (chatService.config.model === name.trim()) this._syncCapabilities();
+			return chatService;
+		};
+		/**
+		* 列出所有已注册的模型名称
+		* @returns {Array<string>}
+		*/
+		chatService.listModels = () => {
+			return [...this._registry.keys()];
+		};
+		this._syncCapabilities();
+		chatService.on("config-updated", ({ changes }) => {
+			if ("model" in changes) this._syncCapabilities();
+			if ("capabilities" in changes && !("model" in changes)) {
+				const current = this._lookupCapabilities();
+				if (current) chatService.config.capabilities = {
+					...current,
+					...changes.capabilities
+				};
+			}
+		});
+	},
+	_lookupCapabilities() {
+		const model = this.chat.config.model;
+		if (!model) return null;
+		return this._registry.get(model) || null;
+	},
+	_syncCapabilities() {
+		const caps = this._lookupCapabilities();
+		if (caps) this.chat.config.capabilities = { ...caps };
+	}
 };
-exports.ApiClient = ApiClient;
+//#endregion
+exports.APIError = APIError;
 exports.ChatService = ChatService;
+exports.ConfigurationError = ConfigurationError;
 exports.EventEmitter = EventEmitter;
 exports.MessageFormatter = MessageFormatter;
-exports.Messages = Messages;
-exports.RequestBuilder = RequestBuilder;
-exports.ToolManager = ToolManager;
-exports.default = index;
-//# sourceMappingURL=my-ai-chat-framework.node.cjs.js.map
+exports.MessageStore = MessageStore;
+exports.NetworkError = NetworkError;
+exports.ParsingError = ParsingError;
+exports.SystemPromptStore = SystemPromptStore;
+exports.assembleMessages = assembleMessages;
+exports.modelRegistryPlugin = modelRegistryPlugin;
+exports.openaiAdapter = openaiAdapter;
+exports.toolCallingPlugin = toolCallingPlugin;
+
+//# sourceMappingURL=my-ai-chat-framework.node.cjs.js.map