my-ai-chat-framework 1.0.2

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

@@ -0,0 +1,1381 @@
+"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 };
+    if (message.reasoning_content) {
+      standardMessage.reasoning_content = message.reasoning_content;
+    }
+    if (message.tool_calls) {
+      standardMessage.tool_calls = message.tool_calls;
+    }
+    if (message.tool_call_id) {
+      standardMessage.tool_call_id = message.tool_call_id;
+    }
+    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
+      }
+    };
+  }
+}
+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 (typeof content !== "string") {
+        throw new Error("消息内容必须是字符串");
+      }
+      if (content === void 0 || content === null) {
+        throw new Error("消息内容不能为undefined或null");
+      }
+    }
+    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" || !content.trim()) {
+      throw new Error("消息内容不能为空");
+    }
+    this.messages[index2].content = content.trim();
+    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;
+  }
+  // ========== 消息删除 ==========
+  /**
+   * 删除消息
+   */
+  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;
+  }
+}
+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;
+  }
+}
+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 request = {
+      model: this.model,
+      messages: formattedMessages,
+      ...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;
+  }
+}
+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 {
+      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 = {
+        content: "",
+        reasoning_content: "",
+        tool_calls: []
+        // 新增：收集工具调用
+      };
+      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 });
+            onDone({ ...message });
+            return;
+          }
+          try {
+            const obj = JSON.parse(cleanChunk);
+            console.log("🔍 收到流式chunk:", obj);
+            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 });
+            onProgress({ ...message });
+          } catch (e) {
+            console.error("🔍 解析chunk错误:", e, "原始数据:", cleanChunk);
+          }
+        }
+        if (!this.isGenerating) {
+          break;
+        }
+      }
+      this.emit("stream-done", { message });
+      onDone({ ...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("无法识别的聊天数据格式");
+  }
+}
+class ChatService extends EventEmitter {
+  constructor(apiKey, model = "deepseek-chat", config = {}) {
+    super();
+    this.messages = new Messages();
+    this.apiClient = new ApiClient(apiKey);
+    this.requestBuilder = new RequestBuilder(model, this.messages, config);
+    this.toolManager = new ToolManager();
+    this._setupDefaultListeners();
+  }
+  _setupDefaultListeners() {
+    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()
+      });
+      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 {
+        return await this._handleNormalResponse(aiMessage);
+      }
+    } catch (error) {
+      this.emit("error", {
+        error,
+        message: userMessage,
+        timestamp: /* @__PURE__ */ new Date()
+      });
+      throw error;
+    }
+  }
+  /**
+   * 处理工具调用（支持循环调用）
+   */
+  async _handleToolCalls(aiMessage, maxIterations = 5) {
+    console.log("🔍 处理工具调用，aiMessage:", aiMessage);
+    let iteration = 0;
+    let currentMessage = aiMessage;
+    while (iteration < maxIterations) {
+      iteration++;
+      console.log(`🔄 工具调用迭代 ${iteration}/${maxIterations}`);
+      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);
+      console.log("🔍 工具执行结果:", toolResults);
+      for (const result of toolResults) {
+        console.log("🔍 添加工具消息，result:", result);
+        this.messages.addToolMessage(
+          result.result || result.error || "",
+          result.tool_call_id
+        );
+      }
+      console.log("🔍 当前所有消息:", this.messages.getMessages());
+      const requestBody = this.requestBuilder.toJSON();
+      console.log("🔍 第", iteration, "次请求体:", requestBody);
+      const response = await this.apiClient.send(requestBody);
+      currentMessage = response.choices[0].message;
+      if (!currentMessage.tool_calls || currentMessage.tool_calls.length === 0) {
+        console.log("✅ 工具调用完成，AI给出最终回复");
+        break;
+      }
+      console.log("🔄 AI请求了新的工具调用，继续处理...");
+    }
+    this.messages.addAssistantMessage(currentMessage.content || "", {
+      reasoning_content: currentMessage.reasoning_content || ""
+      // ✅ 新增：保存最终思考内容
+    });
+    this.emit("message", {
+      role: "assistant",
+      content: currentMessage.content,
+      reasoning_content: currentMessage.reasoning_content,
+      // ✅ 新增：包含思考内容
+      timestamp: /* @__PURE__ */ new Date(),
+      response: { choices: [{ message: currentMessage }] },
+      toolIterations: iteration
+    });
+    return currentMessage.content;
+  }
+  /**
+   * 处理普通回复
+   */
+  async _handleNormalResponse(aiMessage) {
+    this.messages.addAssistantMessage(aiMessage.content || "", {
+      reasoning_content: aiMessage.reasoning_content
+    });
+    this.emit("message", {
+      role: "assistant",
+      content: aiMessage.content,
+      timestamp: /* @__PURE__ */ new Date(),
+      response: { choices: [{ message: aiMessage }] }
+    });
+    return aiMessage.content;
+  }
+  /**
+   * 流式发送消息（支持工具调用）
+   */
+  async stream(userMessage, onProgress, onDone, options = {}) {
+    try {
+      this.emit("sending", {
+        role: "user",
+        content: userMessage,
+        timestamp: /* @__PURE__ */ new Date()
+      });
+      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,
+        (chunk) => {
+          this.emit("stream-progress", chunk);
+          onProgress(chunk);
+        },
+        async (finalMessage) => {
+          if (finalMessage.tool_calls && finalMessage.tool_calls.length > 0) {
+            await this._handleStreamToolCalls(finalMessage, onProgress, onDone);
+          } else {
+            this.messages.addAssistantMessage(finalMessage.content || "", {
+              reasoning_content: finalMessage.reasoning_content
+            });
+            this.emit("stream-done", { message: finalMessage });
+            onDone(finalMessage);
+          }
+        }
+      );
+      return response;
+    } catch (error) {
+      this.emit("error", {
+        error,
+        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,
+          (chunk) => {
+            this.emit("stream-progress", chunk);
+            onProgress(chunk);
+          },
+          (finalMessage) => {
+            currentMessage = finalMessage;
+            if (!currentMessage.tool_calls || currentMessage.tool_calls.length === 0) {
+              resolve();
+            } else {
+              resolve();
+            }
+          }
+        ).catch(reject);
+      });
+      if (!currentMessage.tool_calls || currentMessage.tool_calls.length === 0) {
+        break;
+      }
+    }
+    this.messages.addAssistantMessage(currentMessage.content, {
+      reasoning_content: currentMessage.reasoning_content || ""
+      // ✅ 新增：保存最终思考内容
+    });
+    this.emit("stream-done", {
+      message: currentMessage,
+      reasoning_content: currentMessage.reasoning_content,
+      // ✅ 新增：包含思考内容
+      toolIterations: iteration
+    });
+    onDone(currentMessage);
+  }
+  /**
+   * 撤回消息
+   */
+  undo() {
+    const removed = this.messages.undoToAssistant();
+    if (removed.length > 0) {
+      this.emit("undo", {
+        removedMessages: removed,
+        timestamp: /* @__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;
+  }
+}
+const index = {
+  Messages,
+  RequestBuilder,
+  ApiClient,
+  EventEmitter,
+  MessageFormatter,
+  ToolManager,
+  ChatService
+};
+exports.ApiClient = ApiClient;
+exports.ChatService = ChatService;
+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