my-ai-chat-framework 1.0.2 → 2.0.0

package/src/core/ApiClient.js

@@ -1,288 +0,0 @@
-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/MessageFormatter.js

@@ -1,126 +0,0 @@
-/**
- * 消息格式转换器
- * 负责将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;