my-ai-chat-framework 1.0.2

package/dist/my-ai-chat-framework.browser.umd.js

@@ -0,0 +1,2634 @@
+(function(global, factory) {
+  typeof exports === "object" && typeof module !== "undefined" ? factory(exports) : typeof define === "function" && define.amd ? define(["exports"], factory) : (global = typeof globalThis !== "undefined" ? globalThis : global || self, factory(global.AIChatFramework = {}));
+})(this, (function(exports2) {
+  "use strict";
+  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;
+    }
+  }
+  function getDefaultExportFromCjs(x) {
+    return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
+  }
+  var axios$2 = { exports: {} };
+  var bind;
+  var hasRequiredBind;
+  function requireBind() {
+    if (hasRequiredBind) return bind;
+    hasRequiredBind = 1;
+    bind = function bind2(fn, thisArg) {
+      return function wrap() {
+        var args = new Array(arguments.length);
+        for (var i = 0; i < args.length; i++) {
+          args[i] = arguments[i];
+        }
+        return fn.apply(thisArg, args);
+      };
+    };
+    return bind;
+  }
+  var utils;
+  var hasRequiredUtils;
+  function requireUtils() {
+    if (hasRequiredUtils) return utils;
+    hasRequiredUtils = 1;
+    var bind2 = requireBind();
+    var toString = Object.prototype.toString;
+    function isArray(val) {
+      return toString.call(val) === "[object Array]";
+    }
+    function isUndefined(val) {
+      return typeof val === "undefined";
+    }
+    function isBuffer(val) {
+      return val !== null && !isUndefined(val) && val.constructor !== null && !isUndefined(val.constructor) && typeof val.constructor.isBuffer === "function" && val.constructor.isBuffer(val);
+    }
+    function isArrayBuffer(val) {
+      return toString.call(val) === "[object ArrayBuffer]";
+    }
+    function isFormData(val) {
+      return typeof FormData !== "undefined" && val instanceof FormData;
+    }
+    function isArrayBufferView(val) {
+      var result;
+      if (typeof ArrayBuffer !== "undefined" && ArrayBuffer.isView) {
+        result = ArrayBuffer.isView(val);
+      } else {
+        result = val && val.buffer && val.buffer instanceof ArrayBuffer;
+      }
+      return result;
+    }
+    function isString(val) {
+      return typeof val === "string";
+    }
+    function isNumber(val) {
+      return typeof val === "number";
+    }
+    function isObject(val) {
+      return val !== null && typeof val === "object";
+    }
+    function isPlainObject(val) {
+      if (toString.call(val) !== "[object Object]") {
+        return false;
+      }
+      var prototype = Object.getPrototypeOf(val);
+      return prototype === null || prototype === Object.prototype;
+    }
+    function isDate(val) {
+      return toString.call(val) === "[object Date]";
+    }
+    function isFile(val) {
+      return toString.call(val) === "[object File]";
+    }
+    function isBlob(val) {
+      return toString.call(val) === "[object Blob]";
+    }
+    function isFunction(val) {
+      return toString.call(val) === "[object Function]";
+    }
+    function isStream(val) {
+      return isObject(val) && isFunction(val.pipe);
+    }
+    function isURLSearchParams(val) {
+      return typeof URLSearchParams !== "undefined" && val instanceof URLSearchParams;
+    }
+    function trim(str) {
+      return str.trim ? str.trim() : str.replace(/^\s+|\s+$/g, "");
+    }
+    function isStandardBrowserEnv() {
+      if (typeof navigator !== "undefined" && (navigator.product === "ReactNative" || navigator.product === "NativeScript" || navigator.product === "NS")) {
+        return false;
+      }
+      return typeof window !== "undefined" && typeof document !== "undefined";
+    }
+    function forEach(obj, fn) {
+      if (obj === null || typeof obj === "undefined") {
+        return;
+      }
+      if (typeof obj !== "object") {
+        obj = [obj];
+      }
+      if (isArray(obj)) {
+        for (var i = 0, l = obj.length; i < l; i++) {
+          fn.call(null, obj[i], i, obj);
+        }
+      } else {
+        for (var key in obj) {
+          if (Object.prototype.hasOwnProperty.call(obj, key)) {
+            fn.call(null, obj[key], key, obj);
+          }
+        }
+      }
+    }
+    function merge() {
+      var result = {};
+      function assignValue(val, key) {
+        if (isPlainObject(result[key]) && isPlainObject(val)) {
+          result[key] = merge(result[key], val);
+        } else if (isPlainObject(val)) {
+          result[key] = merge({}, val);
+        } else if (isArray(val)) {
+          result[key] = val.slice();
+        } else {
+          result[key] = val;
+        }
+      }
+      for (var i = 0, l = arguments.length; i < l; i++) {
+        forEach(arguments[i], assignValue);
+      }
+      return result;
+    }
+    function extend(a, b, thisArg) {
+      forEach(b, function assignValue(val, key) {
+        if (thisArg && typeof val === "function") {
+          a[key] = bind2(val, thisArg);
+        } else {
+          a[key] = val;
+        }
+      });
+      return a;
+    }
+    function stripBOM(content) {
+      if (content.charCodeAt(0) === 65279) {
+        content = content.slice(1);
+      }
+      return content;
+    }
+    utils = {
+      isArray,
+      isArrayBuffer,
+      isBuffer,
+      isFormData,
+      isArrayBufferView,
+      isString,
+      isNumber,
+      isObject,
+      isPlainObject,
+      isUndefined,
+      isDate,
+      isFile,
+      isBlob,
+      isFunction,
+      isStream,
+      isURLSearchParams,
+      isStandardBrowserEnv,
+      forEach,
+      merge,
+      extend,
+      trim,
+      stripBOM
+    };
+    return utils;
+  }
+  var buildURL;
+  var hasRequiredBuildURL;
+  function requireBuildURL() {
+    if (hasRequiredBuildURL) return buildURL;
+    hasRequiredBuildURL = 1;
+    var utils2 = requireUtils();
+    function encode(val) {
+      return encodeURIComponent(val).replace(/%3A/gi, ":").replace(/%24/g, "$").replace(/%2C/gi, ",").replace(/%20/g, "+").replace(/%5B/gi, "[").replace(/%5D/gi, "]");
+    }
+    buildURL = function buildURL2(url, params, paramsSerializer) {
+      if (!params) {
+        return url;
+      }
+      var serializedParams;
+      if (paramsSerializer) {
+        serializedParams = paramsSerializer(params);
+      } else if (utils2.isURLSearchParams(params)) {
+        serializedParams = params.toString();
+      } else {
+        var parts = [];
+        utils2.forEach(params, function serialize(val, key) {
+          if (val === null || typeof val === "undefined") {
+            return;
+          }
+          if (utils2.isArray(val)) {
+            key = key + "[]";
+          } else {
+            val = [val];
+          }
+          utils2.forEach(val, function parseValue(v) {
+            if (utils2.isDate(v)) {
+              v = v.toISOString();
+            } else if (utils2.isObject(v)) {
+              v = JSON.stringify(v);
+            }
+            parts.push(encode(key) + "=" + encode(v));
+          });
+        });
+        serializedParams = parts.join("&");
+      }
+      if (serializedParams) {
+        var hashmarkIndex = url.indexOf("#");
+        if (hashmarkIndex !== -1) {
+          url = url.slice(0, hashmarkIndex);
+        }
+        url += (url.indexOf("?") === -1 ? "?" : "&") + serializedParams;
+      }
+      return url;
+    };
+    return buildURL;
+  }
+  var InterceptorManager_1;
+  var hasRequiredInterceptorManager;
+  function requireInterceptorManager() {
+    if (hasRequiredInterceptorManager) return InterceptorManager_1;
+    hasRequiredInterceptorManager = 1;
+    var utils2 = requireUtils();
+    function InterceptorManager() {
+      this.handlers = [];
+    }
+    InterceptorManager.prototype.use = function use(fulfilled, rejected, options) {
+      this.handlers.push({
+        fulfilled,
+        rejected,
+        synchronous: options ? options.synchronous : false,
+        runWhen: options ? options.runWhen : null
+      });
+      return this.handlers.length - 1;
+    };
+    InterceptorManager.prototype.eject = function eject(id) {
+      if (this.handlers[id]) {
+        this.handlers[id] = null;
+      }
+    };
+    InterceptorManager.prototype.forEach = function forEach(fn) {
+      utils2.forEach(this.handlers, function forEachHandler(h) {
+        if (h !== null) {
+          fn(h);
+        }
+      });
+    };
+    InterceptorManager_1 = InterceptorManager;
+    return InterceptorManager_1;
+  }
+  var normalizeHeaderName;
+  var hasRequiredNormalizeHeaderName;
+  function requireNormalizeHeaderName() {
+    if (hasRequiredNormalizeHeaderName) return normalizeHeaderName;
+    hasRequiredNormalizeHeaderName = 1;
+    var utils2 = requireUtils();
+    normalizeHeaderName = function normalizeHeaderName2(headers, normalizedName) {
+      utils2.forEach(headers, function processHeader(value, name) {
+        if (name !== normalizedName && name.toUpperCase() === normalizedName.toUpperCase()) {
+          headers[normalizedName] = value;
+          delete headers[name];
+        }
+      });
+    };
+    return normalizeHeaderName;
+  }
+  var enhanceError;
+  var hasRequiredEnhanceError;
+  function requireEnhanceError() {
+    if (hasRequiredEnhanceError) return enhanceError;
+    hasRequiredEnhanceError = 1;
+    enhanceError = function enhanceError2(error, config, code, request, response) {
+      error.config = config;
+      if (code) {
+        error.code = code;
+      }
+      error.request = request;
+      error.response = response;
+      error.isAxiosError = true;
+      error.toJSON = function toJSON() {
+        return {
+          // Standard
+          message: this.message,
+          name: this.name,
+          // Microsoft
+          description: this.description,
+          number: this.number,
+          // Mozilla
+          fileName: this.fileName,
+          lineNumber: this.lineNumber,
+          columnNumber: this.columnNumber,
+          stack: this.stack,
+          // Axios
+          config: this.config,
+          code: this.code
+        };
+      };
+      return error;
+    };
+    return enhanceError;
+  }
+  var createError;
+  var hasRequiredCreateError;
+  function requireCreateError() {
+    if (hasRequiredCreateError) return createError;
+    hasRequiredCreateError = 1;
+    var enhanceError2 = requireEnhanceError();
+    createError = function createError2(message, config, code, request, response) {
+      var error = new Error(message);
+      return enhanceError2(error, config, code, request, response);
+    };
+    return createError;
+  }
+  var settle;
+  var hasRequiredSettle;
+  function requireSettle() {
+    if (hasRequiredSettle) return settle;
+    hasRequiredSettle = 1;
+    var createError2 = requireCreateError();
+    settle = function settle2(resolve, reject, response) {
+      var validateStatus = response.config.validateStatus;
+      if (!response.status || !validateStatus || validateStatus(response.status)) {
+        resolve(response);
+      } else {
+        reject(createError2(
+          "Request failed with status code " + response.status,
+          response.config,
+          null,
+          response.request,
+          response
+        ));
+      }
+    };
+    return settle;
+  }
+  var cookies;
+  var hasRequiredCookies;
+  function requireCookies() {
+    if (hasRequiredCookies) return cookies;
+    hasRequiredCookies = 1;
+    var utils2 = requireUtils();
+    cookies = utils2.isStandardBrowserEnv() ? (
+      // Standard browser envs support document.cookie
+      /* @__PURE__ */ (function standardBrowserEnv() {
+        return {
+          write: function write(name, value, expires, path, domain, secure) {
+            var cookie = [];
+            cookie.push(name + "=" + encodeURIComponent(value));
+            if (utils2.isNumber(expires)) {
+              cookie.push("expires=" + new Date(expires).toGMTString());
+            }
+            if (utils2.isString(path)) {
+              cookie.push("path=" + path);
+            }
+            if (utils2.isString(domain)) {
+              cookie.push("domain=" + domain);
+            }
+            if (secure === true) {
+              cookie.push("secure");
+            }
+            document.cookie = cookie.join("; ");
+          },
+          read: function read(name) {
+            var match = document.cookie.match(new RegExp("(^|;\\s*)(" + name + ")=([^;]*)"));
+            return match ? decodeURIComponent(match[3]) : null;
+          },
+          remove: function remove(name) {
+            this.write(name, "", Date.now() - 864e5);
+          }
+        };
+      })()
+    ) : (
+      // Non standard browser env (web workers, react-native) lack needed support.
+      /* @__PURE__ */ (function nonStandardBrowserEnv() {
+        return {
+          write: function write() {
+          },
+          read: function read() {
+            return null;
+          },
+          remove: function remove() {
+          }
+        };
+      })()
+    );
+    return cookies;
+  }
+  var isAbsoluteURL;
+  var hasRequiredIsAbsoluteURL;
+  function requireIsAbsoluteURL() {
+    if (hasRequiredIsAbsoluteURL) return isAbsoluteURL;
+    hasRequiredIsAbsoluteURL = 1;
+    isAbsoluteURL = function isAbsoluteURL2(url) {
+      return /^([a-z][a-z\d\+\-\.]*:)?\/\//i.test(url);
+    };
+    return isAbsoluteURL;
+  }
+  var combineURLs;
+  var hasRequiredCombineURLs;
+  function requireCombineURLs() {
+    if (hasRequiredCombineURLs) return combineURLs;
+    hasRequiredCombineURLs = 1;
+    combineURLs = function combineURLs2(baseURL, relativeURL) {
+      return relativeURL ? baseURL.replace(/\/+$/, "") + "/" + relativeURL.replace(/^\/+/, "") : baseURL;
+    };
+    return combineURLs;
+  }
+  var buildFullPath;
+  var hasRequiredBuildFullPath;
+  function requireBuildFullPath() {
+    if (hasRequiredBuildFullPath) return buildFullPath;
+    hasRequiredBuildFullPath = 1;
+    var isAbsoluteURL2 = requireIsAbsoluteURL();
+    var combineURLs2 = requireCombineURLs();
+    buildFullPath = function buildFullPath2(baseURL, requestedURL) {
+      if (baseURL && !isAbsoluteURL2(requestedURL)) {
+        return combineURLs2(baseURL, requestedURL);
+      }
+      return requestedURL;
+    };
+    return buildFullPath;
+  }
+  var parseHeaders;
+  var hasRequiredParseHeaders;
+  function requireParseHeaders() {
+    if (hasRequiredParseHeaders) return parseHeaders;
+    hasRequiredParseHeaders = 1;
+    var utils2 = requireUtils();
+    var ignoreDuplicateOf = [
+      "age",
+      "authorization",
+      "content-length",
+      "content-type",
+      "etag",
+      "expires",
+      "from",
+      "host",
+      "if-modified-since",
+      "if-unmodified-since",
+      "last-modified",
+      "location",
+      "max-forwards",
+      "proxy-authorization",
+      "referer",
+      "retry-after",
+      "user-agent"
+    ];
+    parseHeaders = function parseHeaders2(headers) {
+      var parsed = {};
+      var key;
+      var val;
+      var i;
+      if (!headers) {
+        return parsed;
+      }
+      utils2.forEach(headers.split("\n"), function parser(line) {
+        i = line.indexOf(":");
+        key = utils2.trim(line.substr(0, i)).toLowerCase();
+        val = utils2.trim(line.substr(i + 1));
+        if (key) {
+          if (parsed[key] && ignoreDuplicateOf.indexOf(key) >= 0) {
+            return;
+          }
+          if (key === "set-cookie") {
+            parsed[key] = (parsed[key] ? parsed[key] : []).concat([val]);
+          } else {
+            parsed[key] = parsed[key] ? parsed[key] + ", " + val : val;
+          }
+        }
+      });
+      return parsed;
+    };
+    return parseHeaders;
+  }
+  var isURLSameOrigin;
+  var hasRequiredIsURLSameOrigin;
+  function requireIsURLSameOrigin() {
+    if (hasRequiredIsURLSameOrigin) return isURLSameOrigin;
+    hasRequiredIsURLSameOrigin = 1;
+    var utils2 = requireUtils();
+    isURLSameOrigin = utils2.isStandardBrowserEnv() ? (
+      // Standard browser envs have full support of the APIs needed to test
+      // whether the request URL is of the same origin as current location.
+      (function standardBrowserEnv() {
+        var msie = /(msie|trident)/i.test(navigator.userAgent);
+        var urlParsingNode = document.createElement("a");
+        var originURL;
+        function resolveURL(url) {
+          var href = url;
+          if (msie) {
+            urlParsingNode.setAttribute("href", href);
+            href = urlParsingNode.href;
+          }
+          urlParsingNode.setAttribute("href", href);
+          return {
+            href: urlParsingNode.href,
+            protocol: urlParsingNode.protocol ? urlParsingNode.protocol.replace(/:$/, "") : "",
+            host: urlParsingNode.host,
+            search: urlParsingNode.search ? urlParsingNode.search.replace(/^\?/, "") : "",
+            hash: urlParsingNode.hash ? urlParsingNode.hash.replace(/^#/, "") : "",
+            hostname: urlParsingNode.hostname,
+            port: urlParsingNode.port,
+            pathname: urlParsingNode.pathname.charAt(0) === "/" ? urlParsingNode.pathname : "/" + urlParsingNode.pathname
+          };
+        }
+        originURL = resolveURL(window.location.href);
+        return function isURLSameOrigin2(requestURL) {
+          var parsed = utils2.isString(requestURL) ? resolveURL(requestURL) : requestURL;
+          return parsed.protocol === originURL.protocol && parsed.host === originURL.host;
+        };
+      })()
+    ) : (
+      // Non standard browser envs (web workers, react-native) lack needed support.
+      /* @__PURE__ */ (function nonStandardBrowserEnv() {
+        return function isURLSameOrigin2() {
+          return true;
+        };
+      })()
+    );
+    return isURLSameOrigin;
+  }
+  var xhr;
+  var hasRequiredXhr;
+  function requireXhr() {
+    if (hasRequiredXhr) return xhr;
+    hasRequiredXhr = 1;
+    var utils2 = requireUtils();
+    var settle2 = requireSettle();
+    var cookies2 = requireCookies();
+    var buildURL2 = requireBuildURL();
+    var buildFullPath2 = requireBuildFullPath();
+    var parseHeaders2 = requireParseHeaders();
+    var isURLSameOrigin2 = requireIsURLSameOrigin();
+    var createError2 = requireCreateError();
+    xhr = function xhrAdapter(config) {
+      return new Promise(function dispatchXhrRequest(resolve, reject) {
+        var requestData = config.data;
+        var requestHeaders = config.headers;
+        var responseType = config.responseType;
+        if (utils2.isFormData(requestData)) {
+          delete requestHeaders["Content-Type"];
+        }
+        var request = new XMLHttpRequest();
+        if (config.auth) {
+          var username = config.auth.username || "";
+          var password = config.auth.password ? unescape(encodeURIComponent(config.auth.password)) : "";
+          requestHeaders.Authorization = "Basic " + btoa(username + ":" + password);
+        }
+        var fullPath = buildFullPath2(config.baseURL, config.url);
+        request.open(config.method.toUpperCase(), buildURL2(fullPath, config.params, config.paramsSerializer), true);
+        request.timeout = config.timeout;
+        function onloadend() {
+          if (!request) {
+            return;
+          }
+          var responseHeaders = "getAllResponseHeaders" in request ? parseHeaders2(request.getAllResponseHeaders()) : null;
+          var responseData = !responseType || responseType === "text" || responseType === "json" ? request.responseText : request.response;
+          var response = {
+            data: responseData,
+            status: request.status,
+            statusText: request.statusText,
+            headers: responseHeaders,
+            config,
+            request
+          };
+          settle2(resolve, reject, response);
+          request = null;
+        }
+        if ("onloadend" in request) {
+          request.onloadend = onloadend;
+        } else {
+          request.onreadystatechange = function handleLoad() {
+            if (!request || request.readyState !== 4) {
+              return;
+            }
+            if (request.status === 0 && !(request.responseURL && request.responseURL.indexOf("file:") === 0)) {
+              return;
+            }
+            setTimeout(onloadend);
+          };
+        }
+        request.onabort = function handleAbort() {
+          if (!request) {
+            return;
+          }
+          reject(createError2("Request aborted", config, "ECONNABORTED", request));
+          request = null;
+        };
+        request.onerror = function handleError() {
+          reject(createError2("Network Error", config, null, request));
+          request = null;
+        };
+        request.ontimeout = function handleTimeout() {
+          var timeoutErrorMessage = "timeout of " + config.timeout + "ms exceeded";
+          if (config.timeoutErrorMessage) {
+            timeoutErrorMessage = config.timeoutErrorMessage;
+          }
+          reject(createError2(
+            timeoutErrorMessage,
+            config,
+            config.transitional && config.transitional.clarifyTimeoutError ? "ETIMEDOUT" : "ECONNABORTED",
+            request
+          ));
+          request = null;
+        };
+        if (utils2.isStandardBrowserEnv()) {
+          var xsrfValue = (config.withCredentials || isURLSameOrigin2(fullPath)) && config.xsrfCookieName ? cookies2.read(config.xsrfCookieName) : void 0;
+          if (xsrfValue) {
+            requestHeaders[config.xsrfHeaderName] = xsrfValue;
+          }
+        }
+        if ("setRequestHeader" in request) {
+          utils2.forEach(requestHeaders, function setRequestHeader(val, key) {
+            if (typeof requestData === "undefined" && key.toLowerCase() === "content-type") {
+              delete requestHeaders[key];
+            } else {
+              request.setRequestHeader(key, val);
+            }
+          });
+        }
+        if (!utils2.isUndefined(config.withCredentials)) {
+          request.withCredentials = !!config.withCredentials;
+        }
+        if (responseType && responseType !== "json") {
+          request.responseType = config.responseType;
+        }
+        if (typeof config.onDownloadProgress === "function") {
+          request.addEventListener("progress", config.onDownloadProgress);
+        }
+        if (typeof config.onUploadProgress === "function" && request.upload) {
+          request.upload.addEventListener("progress", config.onUploadProgress);
+        }
+        if (config.cancelToken) {
+          config.cancelToken.promise.then(function onCanceled(cancel) {
+            if (!request) {
+              return;
+            }
+            request.abort();
+            reject(cancel);
+            request = null;
+          });
+        }
+        if (!requestData) {
+          requestData = null;
+        }
+        request.send(requestData);
+      });
+    };
+    return xhr;
+  }
+  var defaults_1;
+  var hasRequiredDefaults;
+  function requireDefaults() {
+    if (hasRequiredDefaults) return defaults_1;
+    hasRequiredDefaults = 1;
+    var utils2 = requireUtils();
+    var normalizeHeaderName2 = requireNormalizeHeaderName();
+    var enhanceError2 = requireEnhanceError();
+    var DEFAULT_CONTENT_TYPE = {
+      "Content-Type": "application/x-www-form-urlencoded"
+    };
+    function setContentTypeIfUnset(headers, value) {
+      if (!utils2.isUndefined(headers) && utils2.isUndefined(headers["Content-Type"])) {
+        headers["Content-Type"] = value;
+      }
+    }
+    function getDefaultAdapter() {
+      var adapter;
+      if (typeof XMLHttpRequest !== "undefined") {
+        adapter = requireXhr();
+      } else if (typeof process !== "undefined" && Object.prototype.toString.call(process) === "[object process]") {
+        adapter = requireXhr();
+      }
+      return adapter;
+    }
+    function stringifySafely(rawValue, parser, encoder) {
+      if (utils2.isString(rawValue)) {
+        try {
+          (parser || JSON.parse)(rawValue);
+          return utils2.trim(rawValue);
+        } catch (e) {
+          if (e.name !== "SyntaxError") {
+            throw e;
+          }
+        }
+      }
+      return (encoder || JSON.stringify)(rawValue);
+    }
+    var defaults = {
+      transitional: {
+        silentJSONParsing: true,
+        forcedJSONParsing: true,
+        clarifyTimeoutError: false
+      },
+      adapter: getDefaultAdapter(),
+      transformRequest: [function transformRequest(data, headers) {
+        normalizeHeaderName2(headers, "Accept");
+        normalizeHeaderName2(headers, "Content-Type");
+        if (utils2.isFormData(data) || utils2.isArrayBuffer(data) || utils2.isBuffer(data) || utils2.isStream(data) || utils2.isFile(data) || utils2.isBlob(data)) {
+          return data;
+        }
+        if (utils2.isArrayBufferView(data)) {
+          return data.buffer;
+        }
+        if (utils2.isURLSearchParams(data)) {
+          setContentTypeIfUnset(headers, "application/x-www-form-urlencoded;charset=utf-8");
+          return data.toString();
+        }
+        if (utils2.isObject(data) || headers && headers["Content-Type"] === "application/json") {
+          setContentTypeIfUnset(headers, "application/json");
+          return stringifySafely(data);
+        }
+        return data;
+      }],
+      transformResponse: [function transformResponse(data) {
+        var transitional = this.transitional;
+        var silentJSONParsing = transitional && transitional.silentJSONParsing;
+        var forcedJSONParsing = transitional && transitional.forcedJSONParsing;
+        var strictJSONParsing = !silentJSONParsing && this.responseType === "json";
+        if (strictJSONParsing || forcedJSONParsing && utils2.isString(data) && data.length) {
+          try {
+            return JSON.parse(data);
+          } catch (e) {
+            if (strictJSONParsing) {
+              if (e.name === "SyntaxError") {
+                throw enhanceError2(e, this, "E_JSON_PARSE");
+              }
+              throw e;
+            }
+          }
+        }
+        return data;
+      }],
+      /**
+       * A timeout in milliseconds to abort a request. If set to 0 (default) a
+       * timeout is not created.
+       */
+      timeout: 0,
+      xsrfCookieName: "XSRF-TOKEN",
+      xsrfHeaderName: "X-XSRF-TOKEN",
+      maxContentLength: -1,
+      maxBodyLength: -1,
+      validateStatus: function validateStatus(status) {
+        return status >= 200 && status < 300;
+      }
+    };
+    defaults.headers = {
+      common: {
+        "Accept": "application/json, text/plain, */*"
+      }
+    };
+    utils2.forEach(["delete", "get", "head"], function forEachMethodNoData(method) {
+      defaults.headers[method] = {};
+    });
+    utils2.forEach(["post", "put", "patch"], function forEachMethodWithData(method) {
+      defaults.headers[method] = utils2.merge(DEFAULT_CONTENT_TYPE);
+    });
+    defaults_1 = defaults;
+    return defaults_1;
+  }
+  var transformData;
+  var hasRequiredTransformData;
+  function requireTransformData() {
+    if (hasRequiredTransformData) return transformData;
+    hasRequiredTransformData = 1;
+    var utils2 = requireUtils();
+    var defaults = requireDefaults();
+    transformData = function transformData2(data, headers, fns) {
+      var context = this || defaults;
+      utils2.forEach(fns, function transform(fn) {
+        data = fn.call(context, data, headers);
+      });
+      return data;
+    };
+    return transformData;
+  }
+  var isCancel;
+  var hasRequiredIsCancel;
+  function requireIsCancel() {
+    if (hasRequiredIsCancel) return isCancel;
+    hasRequiredIsCancel = 1;
+    isCancel = function isCancel2(value) {
+      return !!(value && value.__CANCEL__);
+    };
+    return isCancel;
+  }
+  var dispatchRequest;
+  var hasRequiredDispatchRequest;
+  function requireDispatchRequest() {
+    if (hasRequiredDispatchRequest) return dispatchRequest;
+    hasRequiredDispatchRequest = 1;
+    var utils2 = requireUtils();
+    var transformData2 = requireTransformData();
+    var isCancel2 = requireIsCancel();
+    var defaults = requireDefaults();
+    function throwIfCancellationRequested(config) {
+      if (config.cancelToken) {
+        config.cancelToken.throwIfRequested();
+      }
+    }
+    dispatchRequest = function dispatchRequest2(config) {
+      throwIfCancellationRequested(config);
+      config.headers = config.headers || {};
+      config.data = transformData2.call(
+        config,
+        config.data,
+        config.headers,
+        config.transformRequest
+      );
+      config.headers = utils2.merge(
+        config.headers.common || {},
+        config.headers[config.method] || {},
+        config.headers
+      );
+      utils2.forEach(
+        ["delete", "get", "head", "post", "put", "patch", "common"],
+        function cleanHeaderConfig(method) {
+          delete config.headers[method];
+        }
+      );
+      var adapter = config.adapter || defaults.adapter;
+      return adapter(config).then(function onAdapterResolution(response) {
+        throwIfCancellationRequested(config);
+        response.data = transformData2.call(
+          config,
+          response.data,
+          response.headers,
+          config.transformResponse
+        );
+        return response;
+      }, function onAdapterRejection(reason) {
+        if (!isCancel2(reason)) {
+          throwIfCancellationRequested(config);
+          if (reason && reason.response) {
+            reason.response.data = transformData2.call(
+              config,
+              reason.response.data,
+              reason.response.headers,
+              config.transformResponse
+            );
+          }
+        }
+        return Promise.reject(reason);
+      });
+    };
+    return dispatchRequest;
+  }
+  var mergeConfig;
+  var hasRequiredMergeConfig;
+  function requireMergeConfig() {
+    if (hasRequiredMergeConfig) return mergeConfig;
+    hasRequiredMergeConfig = 1;
+    var utils2 = requireUtils();
+    mergeConfig = function mergeConfig2(config1, config2) {
+      config2 = config2 || {};
+      var config = {};
+      var valueFromConfig2Keys = ["url", "method", "data"];
+      var mergeDeepPropertiesKeys = ["headers", "auth", "proxy", "params"];
+      var defaultToConfig2Keys = [
+        "baseURL",
+        "transformRequest",
+        "transformResponse",
+        "paramsSerializer",
+        "timeout",
+        "timeoutMessage",
+        "withCredentials",
+        "adapter",
+        "responseType",
+        "xsrfCookieName",
+        "xsrfHeaderName",
+        "onUploadProgress",
+        "onDownloadProgress",
+        "decompress",
+        "maxContentLength",
+        "maxBodyLength",
+        "maxRedirects",
+        "transport",
+        "httpAgent",
+        "httpsAgent",
+        "cancelToken",
+        "socketPath",
+        "responseEncoding"
+      ];
+      var directMergeKeys = ["validateStatus"];
+      function getMergedValue(target, source) {
+        if (utils2.isPlainObject(target) && utils2.isPlainObject(source)) {
+          return utils2.merge(target, source);
+        } else if (utils2.isPlainObject(source)) {
+          return utils2.merge({}, source);
+        } else if (utils2.isArray(source)) {
+          return source.slice();
+        }
+        return source;
+      }
+      function mergeDeepProperties(prop) {
+        if (!utils2.isUndefined(config2[prop])) {
+          config[prop] = getMergedValue(config1[prop], config2[prop]);
+        } else if (!utils2.isUndefined(config1[prop])) {
+          config[prop] = getMergedValue(void 0, config1[prop]);
+        }
+      }
+      utils2.forEach(valueFromConfig2Keys, function valueFromConfig2(prop) {
+        if (!utils2.isUndefined(config2[prop])) {
+          config[prop] = getMergedValue(void 0, config2[prop]);
+        }
+      });
+      utils2.forEach(mergeDeepPropertiesKeys, mergeDeepProperties);
+      utils2.forEach(defaultToConfig2Keys, function defaultToConfig2(prop) {
+        if (!utils2.isUndefined(config2[prop])) {
+          config[prop] = getMergedValue(void 0, config2[prop]);
+        } else if (!utils2.isUndefined(config1[prop])) {
+          config[prop] = getMergedValue(void 0, config1[prop]);
+        }
+      });
+      utils2.forEach(directMergeKeys, function merge(prop) {
+        if (prop in config2) {
+          config[prop] = getMergedValue(config1[prop], config2[prop]);
+        } else if (prop in config1) {
+          config[prop] = getMergedValue(void 0, config1[prop]);
+        }
+      });
+      var axiosKeys = valueFromConfig2Keys.concat(mergeDeepPropertiesKeys).concat(defaultToConfig2Keys).concat(directMergeKeys);
+      var otherKeys = Object.keys(config1).concat(Object.keys(config2)).filter(function filterAxiosKeys(key) {
+        return axiosKeys.indexOf(key) === -1;
+      });
+      utils2.forEach(otherKeys, mergeDeepProperties);
+      return config;
+    };
+    return mergeConfig;
+  }
+  const version = "0.21.4";
+  const require$$0 = {
+    version
+  };
+  var validator;
+  var hasRequiredValidator;
+  function requireValidator() {
+    if (hasRequiredValidator) return validator;
+    hasRequiredValidator = 1;
+    var pkg = require$$0;
+    var validators = {};
+    ["object", "boolean", "number", "function", "string", "symbol"].forEach(function(type, i) {
+      validators[type] = function validator2(thing) {
+        return typeof thing === type || "a" + (i < 1 ? "n " : " ") + type;
+      };
+    });
+    var deprecatedWarnings = {};
+    var currentVerArr = pkg.version.split(".");
+    function isOlderVersion(version2, thanVersion) {
+      var pkgVersionArr = thanVersion ? thanVersion.split(".") : currentVerArr;
+      var destVer = version2.split(".");
+      for (var i = 0; i < 3; i++) {
+        if (pkgVersionArr[i] > destVer[i]) {
+          return true;
+        } else if (pkgVersionArr[i] < destVer[i]) {
+          return false;
+        }
+      }
+      return false;
+    }
+    validators.transitional = function transitional(validator2, version2, message) {
+      var isDeprecated = version2 && isOlderVersion(version2);
+      function formatMessage(opt, desc) {
+        return "[Axios v" + pkg.version + "] Transitional option '" + opt + "'" + desc + (message ? ". " + message : "");
+      }
+      return function(value, opt, opts) {
+        if (validator2 === false) {
+          throw new Error(formatMessage(opt, " has been removed in " + version2));
+        }
+        if (isDeprecated && !deprecatedWarnings[opt]) {
+          deprecatedWarnings[opt] = true;
+          console.warn(
+            formatMessage(
+              opt,
+              " has been deprecated since v" + version2 + " and will be removed in the near future"
+            )
+          );
+        }
+        return validator2 ? validator2(value, opt, opts) : true;
+      };
+    };
+    function assertOptions(options, schema, allowUnknown) {
+      if (typeof options !== "object") {
+        throw new TypeError("options must be an object");
+      }
+      var keys = Object.keys(options);
+      var i = keys.length;
+      while (i-- > 0) {
+        var opt = keys[i];
+        var validator2 = schema[opt];
+        if (validator2) {
+          var value = options[opt];
+          var result = value === void 0 || validator2(value, opt, options);
+          if (result !== true) {
+            throw new TypeError("option " + opt + " must be " + result);
+          }
+          continue;
+        }
+        if (allowUnknown !== true) {
+          throw Error("Unknown option " + opt);
+        }
+      }
+    }
+    validator = {
+      isOlderVersion,
+      assertOptions,
+      validators
+    };
+    return validator;
+  }
+  var Axios_1;
+  var hasRequiredAxios$2;
+  function requireAxios$2() {
+    if (hasRequiredAxios$2) return Axios_1;
+    hasRequiredAxios$2 = 1;
+    var utils2 = requireUtils();
+    var buildURL2 = requireBuildURL();
+    var InterceptorManager = requireInterceptorManager();
+    var dispatchRequest2 = requireDispatchRequest();
+    var mergeConfig2 = requireMergeConfig();
+    var validator2 = requireValidator();
+    var validators = validator2.validators;
+    function Axios(instanceConfig) {
+      this.defaults = instanceConfig;
+      this.interceptors = {
+        request: new InterceptorManager(),
+        response: new InterceptorManager()
+      };
+    }
+    Axios.prototype.request = function request(config) {
+      if (typeof config === "string") {
+        config = arguments[1] || {};
+        config.url = arguments[0];
+      } else {
+        config = config || {};
+      }
+      config = mergeConfig2(this.defaults, config);
+      if (config.method) {
+        config.method = config.method.toLowerCase();
+      } else if (this.defaults.method) {
+        config.method = this.defaults.method.toLowerCase();
+      } else {
+        config.method = "get";
+      }
+      var transitional = config.transitional;
+      if (transitional !== void 0) {
+        validator2.assertOptions(transitional, {
+          silentJSONParsing: validators.transitional(validators.boolean, "1.0.0"),
+          forcedJSONParsing: validators.transitional(validators.boolean, "1.0.0"),
+          clarifyTimeoutError: validators.transitional(validators.boolean, "1.0.0")
+        }, false);
+      }
+      var requestInterceptorChain = [];
+      var synchronousRequestInterceptors = true;
+      this.interceptors.request.forEach(function unshiftRequestInterceptors(interceptor) {
+        if (typeof interceptor.runWhen === "function" && interceptor.runWhen(config) === false) {
+          return;
+        }
+        synchronousRequestInterceptors = synchronousRequestInterceptors && interceptor.synchronous;
+        requestInterceptorChain.unshift(interceptor.fulfilled, interceptor.rejected);
+      });
+      var responseInterceptorChain = [];
+      this.interceptors.response.forEach(function pushResponseInterceptors(interceptor) {
+        responseInterceptorChain.push(interceptor.fulfilled, interceptor.rejected);
+      });
+      var promise;
+      if (!synchronousRequestInterceptors) {
+        var chain = [dispatchRequest2, void 0];
+        Array.prototype.unshift.apply(chain, requestInterceptorChain);
+        chain = chain.concat(responseInterceptorChain);
+        promise = Promise.resolve(config);
+        while (chain.length) {
+          promise = promise.then(chain.shift(), chain.shift());
+        }
+        return promise;
+      }
+      var newConfig = config;
+      while (requestInterceptorChain.length) {
+        var onFulfilled = requestInterceptorChain.shift();
+        var onRejected = requestInterceptorChain.shift();
+        try {
+          newConfig = onFulfilled(newConfig);
+        } catch (error) {
+          onRejected(error);
+          break;
+        }
+      }
+      try {
+        promise = dispatchRequest2(newConfig);
+      } catch (error) {
+        return Promise.reject(error);
+      }
+      while (responseInterceptorChain.length) {
+        promise = promise.then(responseInterceptorChain.shift(), responseInterceptorChain.shift());
+      }
+      return promise;
+    };
+    Axios.prototype.getUri = function getUri(config) {
+      config = mergeConfig2(this.defaults, config);
+      return buildURL2(config.url, config.params, config.paramsSerializer).replace(/^\?/, "");
+    };
+    utils2.forEach(["delete", "get", "head", "options"], function forEachMethodNoData(method) {
+      Axios.prototype[method] = function(url, config) {
+        return this.request(mergeConfig2(config || {}, {
+          method,
+          url,
+          data: (config || {}).data
+        }));
+      };
+    });
+    utils2.forEach(["post", "put", "patch"], function forEachMethodWithData(method) {
+      Axios.prototype[method] = function(url, data, config) {
+        return this.request(mergeConfig2(config || {}, {
+          method,
+          url,
+          data
+        }));
+      };
+    });
+    Axios_1 = Axios;
+    return Axios_1;
+  }
+  var Cancel_1;
+  var hasRequiredCancel;
+  function requireCancel() {
+    if (hasRequiredCancel) return Cancel_1;
+    hasRequiredCancel = 1;
+    function Cancel(message) {
+      this.message = message;
+    }
+    Cancel.prototype.toString = function toString() {
+      return "Cancel" + (this.message ? ": " + this.message : "");
+    };
+    Cancel.prototype.__CANCEL__ = true;
+    Cancel_1 = Cancel;
+    return Cancel_1;
+  }
+  var CancelToken_1;
+  var hasRequiredCancelToken;
+  function requireCancelToken() {
+    if (hasRequiredCancelToken) return CancelToken_1;
+    hasRequiredCancelToken = 1;
+    var Cancel = requireCancel();
+    function CancelToken(executor) {
+      if (typeof executor !== "function") {
+        throw new TypeError("executor must be a function.");
+      }
+      var resolvePromise;
+      this.promise = new Promise(function promiseExecutor(resolve) {
+        resolvePromise = resolve;
+      });
+      var token = this;
+      executor(function cancel(message) {
+        if (token.reason) {
+          return;
+        }
+        token.reason = new Cancel(message);
+        resolvePromise(token.reason);
+      });
+    }
+    CancelToken.prototype.throwIfRequested = function throwIfRequested() {
+      if (this.reason) {
+        throw this.reason;
+      }
+    };
+    CancelToken.source = function source() {
+      var cancel;
+      var token = new CancelToken(function executor(c) {
+        cancel = c;
+      });
+      return {
+        token,
+        cancel
+      };
+    };
+    CancelToken_1 = CancelToken;
+    return CancelToken_1;
+  }
+  var spread;
+  var hasRequiredSpread;
+  function requireSpread() {
+    if (hasRequiredSpread) return spread;
+    hasRequiredSpread = 1;
+    spread = function spread2(callback) {
+      return function wrap(arr) {
+        return callback.apply(null, arr);
+      };
+    };
+    return spread;
+  }
+  var isAxiosError;
+  var hasRequiredIsAxiosError;
+  function requireIsAxiosError() {
+    if (hasRequiredIsAxiosError) return isAxiosError;
+    hasRequiredIsAxiosError = 1;
+    isAxiosError = function isAxiosError2(payload) {
+      return typeof payload === "object" && payload.isAxiosError === true;
+    };
+    return isAxiosError;
+  }
+  var hasRequiredAxios$1;
+  function requireAxios$1() {
+    if (hasRequiredAxios$1) return axios$2.exports;
+    hasRequiredAxios$1 = 1;
+    var utils2 = requireUtils();
+    var bind2 = requireBind();
+    var Axios = requireAxios$2();
+    var mergeConfig2 = requireMergeConfig();
+    var defaults = requireDefaults();
+    function createInstance(defaultConfig) {
+      var context = new Axios(defaultConfig);
+      var instance = bind2(Axios.prototype.request, context);
+      utils2.extend(instance, Axios.prototype, context);
+      utils2.extend(instance, context);
+      return instance;
+    }
+    var axios2 = createInstance(defaults);
+    axios2.Axios = Axios;
+    axios2.create = function create(instanceConfig) {
+      return createInstance(mergeConfig2(axios2.defaults, instanceConfig));
+    };
+    axios2.Cancel = requireCancel();
+    axios2.CancelToken = requireCancelToken();
+    axios2.isCancel = requireIsCancel();
+    axios2.all = function all(promises) {
+      return Promise.all(promises);
+    };
+    axios2.spread = requireSpread();
+    axios2.isAxiosError = requireIsAxiosError();
+    axios$2.exports = axios2;
+    axios$2.exports.default = axios2;
+    return axios$2.exports;
+  }
+  var axios$1;
+  var hasRequiredAxios;
+  function requireAxios() {
+    if (hasRequiredAxios) return axios$1;
+    hasRequiredAxios = 1;
+    axios$1 = requireAxios$1();
+    return axios$1;
+  }
+  var axiosExports = requireAxios();
+  const axios = /* @__PURE__ */ getDefaultExportFromCjs(axiosExports);
+  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
+  };
+  exports2.ApiClient = ApiClient;
+  exports2.ChatService = ChatService;
+  exports2.EventEmitter = EventEmitter;
+  exports2.MessageFormatter = MessageFormatter;
+  exports2.Messages = Messages;
+  exports2.RequestBuilder = RequestBuilder;
+  exports2.ToolManager = ToolManager;
+  exports2.default = index;
+  Object.defineProperties(exports2, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+}));
+//# sourceMappingURL=my-ai-chat-framework.browser.umd.js.map