my-ai-chat-framework 1.0.2

package/src/core/ApiClient.js

@@ -0,0 +1,288 @@
+import axios from 'axios';
+import EventEmitter from './EventEmitter.js';
+
+/**
+ * API客户端（使用axios）
+ * 支持浏览器和Node.js环境
+ */
+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;
+    
+    // 创建axios实例
+    this.axiosInstance = axios.create({
+      baseURL: apiUrl,
+      headers: {
+        'Authorization': `Bearer ${apiKey}`,
+        'Content-Type': 'application/json'
+      },
+      timeout: 30000 // 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 : undefined
+      });
+
+      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 index = toolCall.index || 0;
+                
+                // 确保数组存在
+                if (!message.tool_calls) message.tool_calls = [];
+                
+                // 初始化或更新
+                if (!message.tool_calls[index]) {
+                  message.tool_calls[index] = {
+                    id: '',
+                    type: 'function',
+                    function: { name: '', arguments: '' }
+                  };
+                }
+                
+                // 只更新非空字段
+                if (toolCall.id) message.tool_calls[index].id = toolCall.id;
+                if (toolCall.type) message.tool_calls[index].type = toolCall.type;
+                if (toolCall.function?.name) {
+                  message.tool_calls[index].function.name += toolCall.function.name;
+                }
+                if (toolCall.function?.arguments) {
+                  message.tool_calls[index].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('无法识别的聊天数据格式');
+  }
+}
+
+export default ApiClient;

package/src/core/EventEmitter.js

@@ -0,0 +1,126 @@
+/**
+ * 简单的事件发射器类
+ * 实现观察者模式，允许对象监听和触发事件
+ */
+class EventEmitter {
+  constructor() {
+    //存储事件和对应的回调数组
+    //结构: 
+    // { 'event_name': [ callback1, callback2 ] }
+    this.events = {}
+  }
+
+  /**
+   * 监听事件
+   * @param {string} eventName - 要注册的事件名称
+   * @param {Function} callback - 事件触发时执行的回调函数
+   */
+  //实现一个监听事件的方法
+  on(eventName, callback) {
+    //1.如果没有事件数组，先创建
+    if (!this.events[eventName]) {
+      this.events[eventName] = []
+    }
+
+    //2.给数组添加（push）事件
+    this.events[eventName].push(callback)
+
+    //返回一个取消键听得函数（方便实用）
+    return () => this.off(eventName, callback)
+  }
+
+  /**
+   * 触发事件
+   * @param {string} eventName --要触发的事件名称
+   * @param {any} data --传递给回调函数的数据
+   */
+  emit(eventName, data) {
+    //获取这个事件的所有回调函数
+    const callbacks = this.events[eventName]
+
+    //仅在有回调函数时调用他们，否则提前退出（可以这么写吧？少一层嵌套）
+    if (!callbacks) return
+
+    //使用slice()创建副本，放置在循环中修改数组导致问题
+    const callbakesCopy = callbacks.slice()
+
+    for (let i = 0; i < callbakesCopy.length; i++) {
+      try {
+        //执行回调函数，并传入数据
+        callbakesCopy[i](data)
+      } catch (error) {
+        // 如果某个回调出错，不影响其他回调
+        console.error(`事件 ${eventName} 的回调函数执行出错:`, error)
+      }
+    }
+  }
+
+  /**
+   * 取消监听事件
+   * @param {string} eventName --要取消的事件名称
+   * @param {Function} callback --要移除的回调函数
+   */
+  off(eventName, callback) {
+    const callbacks = this.events[eventName]
+
+    //判断一下防止报错
+    if (!callbacks) return
+
+    //过滤掉要移除的回调函数
+    this.events[eventName] = callbacks.filter(item => item !== callback)
+
+    // 如果这个事件没有监听器了，删除这个事件
+    if (this.events[eventName].length === 0) {
+      delete this.events[eventName]
+    }
+  }
+
+  /**
+   * 只监听一次事件（触发后自动取消）
+   * @param {string} eventName - 事件名称
+   * @param {Function} callback - 回调函数
+   */
+  once(evenName, callback) {
+    // 创建一个包装函数，执行完成后自动取消
+    const onceCallback = (data) => {
+      //先取消监听
+      this.off(evenName, onceCallback)
+      //在执行原回调
+      callback(data)
+    }
+
+    //监听包装后的函数
+    this.on(evenName, onceCallback)
+
+    //返回取消函数
+    return () => this.off(evenName, onceCallback)
+  }
+
+  /**
+ * 移除某个事件的所有监听器
+ * @param {string} eventName - 事件名称
+ */
+  removeAllListeners(eventName) {
+    if (eventName) {
+      // 移除指定事件的所有监听器
+      delete this.events[eventName]
+    } else {
+      // 如果没有指定事件名，移除所有事件的监听器
+      this.events = {}
+    }
+  }
+
+  /**
+ * 获取某个事件的所有监听器数量
+ * @param {string} eventName - 事件名称
+ * @returns {number} 监听器数量
+ */
+  listenerCount(eventName) {
+    const callbacks = this.events[eventName]
+    return callbacks ? callbacks.length : 0
+  }
+
+}
+
+//导出EventEmiter类
+export default EventEmitter

package/src/core/MessageFormatter.js

@@ -0,0 +1,126 @@
+/**
+ * 消息格式转换器
+ * 负责将Messages的状态转换为不同格式
+ */
+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;  // ✅ 修复：保留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,
+      },
+    };
+  }
+}
+
+export default MessageFormatter;