@huyooo/ai-chat-core 0.2.45 → 0.3.2

package/src/providers/protocols/openai.ts

@@ -1,420 +0,0 @@
-/**
- * OpenAI Protocol（通过 OpenRouter 访问 OpenAI/GPT 模型）
- * 
- * 特点：
- * - GPT-5.x 支持 reasoning（思考模式）
- * - 支持工具调用
- */
-
-import type {
-  Protocol,
-  ProtocolConfig,
-  ProtocolMessage,
-  ProtocolToolDefinition,
-  ProtocolRequestOptions,
-  RawEvent,
-  RawToolCall,
-  RawSearchResult,
-} from './types';
-import { DEFAULT_OPENROUTER_URL } from '../../constants';
-import { DebugLogger } from '../../utils';
-import { friendlyHttpError } from './error-utils';
-
-const logger = DebugLogger.module('OpenAIProtocol');
-
-/**
- * OpenAI Protocol 实现（通过 OpenRouter）
- */
-export class OpenAIProtocol implements Protocol {
-  readonly name = 'openai';
-  
-  private apiKey: string;
-  private apiUrl: string;
-  
-  constructor(config: ProtocolConfig) {
-    this.apiKey = config.apiKey;
-    this.apiUrl = config.apiUrl ?? DEFAULT_OPENROUTER_URL;
-  }
-  
-  async *stream(
-    messages: ProtocolMessage[],
-    tools: ProtocolToolDefinition[],
-    options: ProtocolRequestOptions
-  ): AsyncGenerator<RawEvent> {
-    const requestBody = this.buildRequestBody(messages, tools, options);
-    const url = `${this.apiUrl}/responses`;
-    
-    logger.debug('发送 OpenAI 请求', {
-      url,
-      model: options.model,
-      toolsCount: tools.length,
-    });
-    
-    const response = await fetch(url, {
-      method: 'POST',
-      headers: {
-        'Authorization': `Bearer ${this.apiKey}`,
-        'Content-Type': 'application/json',
-        'HTTP-Referer': 'https://ai-chat.local',
-        'X-Title': 'AI Chat',
-      },
-      body: JSON.stringify(requestBody),
-      signal: options.signal,
-    });
-    
-    if (!response.ok) {
-      const errorText = await response.text();
-      logger.error('OpenAI API 错误', { status: response.status, body: errorText.slice(0, 500) });
-      yield { type: 'error', error: friendlyHttpError(response.status, errorText, 'OpenAI') };
-      return;
-    }
-    
-    const reader = response.body?.getReader();
-    if (!reader) {
-      yield { type: 'error', error: '无法获取响应流' };
-      return;
-    }
-    
-    yield* this.parseSSE(reader, options.enableThinking);
-  }
-  
-  /**
-   * 构建请求体（OpenAI/GPT 专用）
-   */
-  private buildRequestBody(
-    messages: ProtocolMessage[],
-    tools: ProtocolToolDefinition[],
-    options: ProtocolRequestOptions
-  ): Record<string, unknown> {
-    const input = this.convertMessages(messages);
-    
-    const body: Record<string, unknown> = {
-      model: options.model,
-      stream: true,
-      input,
-      // OpenRouter Responses API 的 include 仅支持 file_search_call.results 等，不含 usage；
-      // usage 由服务端在 response.done / response.completed 中自动返回，无需传 include。
-    };
-    
-    // GPT-5.x 支持 reasoning
-    if (options.enableThinking) {
-      body.reasoning = { effort: 'high' };
-    }
-    
-    // 构建工具列表
-    if (tools.length > 0) {
-      body.tools = tools.map(t => ({
-        type: 'function',
-        name: t.name,
-        description: t.description,
-        parameters: t.parameters,
-      }));
-    }
-    
-    return body;
-  }
-  
-  private convertMessages(messages: ProtocolMessage[]): unknown[] {
-    const input: unknown[] = [];
-    
-    for (const msg of messages) {
-      switch (msg.role) {
-        case 'system':
-          input.push({ role: 'system', content: msg.content });
-          break;
-          
-        case 'user': {
-          // 当只有图片没有文字时提供默认提示
-          const textContent = msg.content || (msg.images?.length ? '请分析这张图片' : '');
-          const content: unknown[] = [{ type: 'input_text', text: textContent }];
-          if (msg.images?.length) {
-            for (const img of msg.images) {
-              content.push({
-                type: 'input_image',
-                image_url: img.startsWith('data:') ? img : `data:image/jpeg;base64,${img}`,
-                detail: 'auto',
-              });
-            }
-          }
-          input.push({ role: 'user', content });
-          break;
-        }
-        
-        case 'assistant':
-          if (msg.toolCalls?.length) {
-            for (const tc of msg.toolCalls) {
-              input.push({
-                type: 'function_call',
-                call_id: tc.id,
-                name: tc.name,
-                arguments: tc.arguments,
-              });
-            }
-          } else {
-            input.push({
-              role: 'developer',
-              content: `[上一轮AI回复]: ${msg.content}`,
-            });
-          }
-          break;
-          
-        case 'tool':
-          input.push({
-            type: 'function_call_output',
-            call_id: msg.toolCallId,
-            output: msg.content,
-          });
-          break;
-      }
-    }
-    
-    return input;
-  }
-  
-  /**
-   * 解析 SSE 流（OpenAI/GPT 专用）
-   */
-  private async *parseSSE(
-    reader: ReadableStreamDefaultReader<Uint8Array>,
-    enableThinking: boolean
-  ): AsyncGenerator<RawEvent> {
-    const decoder = new TextDecoder();
-    let buffer = '';
-    const pendingToolCalls = new Map<string, RawToolCall>();
-    let currentFunctionCallId: string | null = null;
-    const searchResults: RawSearchResult[] = [];
-    let streamDone = false;
-    let thinkingDone = false;
-    let textStarted = false;
-    // Token 使用统计（从 response.completed 或最后一个 chunk 提取）
-    let lastUsage: import('./types').RawTokenUsage | undefined;
-    
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) break;
-      
-      buffer += decoder.decode(value, { stream: true });
-      const lines = buffer.split('\n');
-      buffer = lines.pop() || '';
-      
-      for (const line of lines) {
-        if (streamDone) continue;
-        if (!line.startsWith('data:')) continue;
-        
-        const data = line.slice(5).trim();
-        if (data === '[DONE]') {
-          streamDone = true;
-          
-          if (pendingToolCalls.size > 0) {
-            for (const tc of pendingToolCalls.values()) {
-              yield { type: 'tool_call_done', toolCall: tc };
-            }
-            yield { type: 'done', finishReason: 'tool_calls', usage: lastUsage };
-          } else {
-            yield { type: 'done', finishReason: 'stop', usage: lastUsage };
-          }
-          return;
-        }
-        
-        try {
-          const event = JSON.parse(data);
-          logger.debug('SSE 事件', { type: event.type, event: JSON.stringify(event).slice(0, 200) });
-          
-          // 通用 usage 提取（兼容 response.done / response.completed 及任意带 usage 的事件，取最新以保留完整用量）
-          const eventUsage = event.response?.usage || event.usage;
-          if (eventUsage) {
-            lastUsage = {
-              promptTokens: eventUsage.input_tokens ?? eventUsage.prompt_tokens ?? 0,
-              completionTokens: eventUsage.output_tokens ?? eventUsage.completion_tokens ?? 0,
-              totalTokens: (eventUsage.input_tokens ?? eventUsage.prompt_tokens ?? 0) + (eventUsage.output_tokens ?? eventUsage.completion_tokens ?? 0),
-              reasoningTokens: eventUsage.output_tokens_details?.reasoning_tokens ?? 0,
-              cachedTokens: eventUsage.input_tokens_details?.cached_tokens ?? eventUsage.prompt_tokens_details?.cached_tokens ?? 0,
-            };
-          }
-          
-          switch (event.type) {
-            // ========== Responses API 格式 ==========
-            case 'response.output_item.added': {
-              const item = event.item;
-              // 兼容 call_id 和 id 两种格式
-              const callId = item?.call_id || item?.id;
-              if (item?.type === 'function_call' && callId) {
-                currentFunctionCallId = callId;
-                // 兼容多种参数格式：arguments 可能是字符串或对象，也可能叫 input
-                let args = item.arguments || item.input || '';
-                if (typeof args === 'object') {
-                  args = JSON.stringify(args);
-                }
-                pendingToolCalls.set(callId, {
-                  id: callId,
-                  name: item.name || item.function?.name || '',
-                  arguments: args,
-                });
-                logger.debug('工具调用开始', { id: callId, name: item.name, args: args.slice(0, 100) });
-                yield { type: 'tool_call_start', toolCall: { id: callId, name: item.name || item.function?.name || '' } };
-              }
-              break;
-            }
-            
-            case 'response.function_call_arguments.delta': {
-              const delta = event.delta as string | undefined;
-              if (currentFunctionCallId && delta) {
-                const call = pendingToolCalls.get(currentFunctionCallId);
-                if (call) {
-                  call.arguments += delta;
-                  yield { type: 'tool_call_delta', toolCall: { id: currentFunctionCallId, arguments: delta } };
-                }
-              }
-              break;
-            }
-            
-            case 'response.function_call_arguments.done': {
-              // 兼容 item_id 和 call_id
-              const callId = event.item_id || event.call_id || currentFunctionCallId;
-              if (callId) {
-                const existing = pendingToolCalls.get(callId);
-                if (existing) {
-                  // 如果 event 中有完整的 arguments，使用它
-                  if (event.arguments) {
-                    existing.arguments = event.arguments;
-                  }
-                  try {
-                    JSON.parse(existing.arguments);
-                  } catch {
-                    logger.warn('工具参数解析失败，使用空对象', { args: existing.arguments.slice(0, 100) });
-                    existing.arguments = '{}';
-                  }
-                }
-              }
-              break;
-            }
-            
-            case 'response.output_item.done': {
-              const item = event.item;
-              const callId = item?.call_id || item?.id;
-              if (item?.type === 'function_call' && callId) {
-                const existing = pendingToolCalls.get(callId);
-                // 兼容多种参数格式
-                let args = item.arguments || item.input || existing?.arguments || '{}';
-                if (typeof args === 'object') {
-                  args = JSON.stringify(args);
-                }
-                pendingToolCalls.set(callId, {
-                  id: callId,
-                  name: item.name || item.function?.name || existing?.name || '',
-                  arguments: args,
-                });
-                logger.debug('工具调用完成', { id: callId, name: item.name, args: args.slice(0, 100) });
-              }
-              break;
-            }
-            
-            case 'response.output_text.annotation.added': {
-              const annotation = event.annotation;
-              if (annotation?.url) {
-                const exists = searchResults.some(r => r.url === annotation.url);
-                if (!exists) {
-                  searchResults.push({
-                    title: annotation.title || annotation.text || '',
-                    url: annotation.url,
-                    snippet: annotation.summary || annotation.snippet || '',
-                  });
-                  yield { type: 'search_result', searchResults: [...searchResults] };
-                }
-              }
-              break;
-            }
-            
-            case 'response.output_text.delta':
-              if (event.delta) {
-                // 首次收到 text 时，结束 thinking
-                if (!textStarted) {
-                  textStarted = true;
-                  if (enableThinking && !thinkingDone) {
-                    thinkingDone = true;
-                    yield { type: 'thinking_done' };
-                  }
-                }
-                yield { type: 'text_delta', delta: event.delta };
-              }
-              break;
-              
-            // GPT-5.x 支持 reasoning
-            case 'response.reasoning_summary_text.delta':
-              if (enableThinking && event.delta && !thinkingDone) {
-                yield { type: 'thinking_delta', delta: event.delta };
-              }
-              break;
-              
-            // response.done（OpenRouter）/ response.completed（含工具参数 + Token 使用统计）
-            case 'response.done':
-            case 'response.completed': {
-              const response = event.response;
-              if (response?.output?.length) {
-                for (const item of response.output) {
-                  if (item.type === 'function_call' && item.call_id) {
-                    const existing = pendingToolCalls.get(item.call_id);
-                    // 从 response.completed 中获取完整参数
-                    let args = item.arguments || existing?.arguments || '{}';
-                    if (typeof args === 'object') {
-                      args = JSON.stringify(args);
-                    }
-                    pendingToolCalls.set(item.call_id, {
-                      id: item.call_id,
-                      name: item.name || existing?.name || '',
-                      arguments: args,
-                    });
-                    logger.debug('response.completed: 更新工具参数', { id: item.call_id, args: args.slice(0, 100) });
-                  }
-                }
-              }
-              
-              // 提取 Token 使用统计
-              const responseUsage = response?.usage;
-              const usage = responseUsage ? {
-                promptTokens: responseUsage.input_tokens || responseUsage.prompt_tokens || 0,
-                completionTokens: responseUsage.output_tokens || responseUsage.completion_tokens || 0,
-                totalTokens: (responseUsage.input_tokens || responseUsage.prompt_tokens || 0) + (responseUsage.output_tokens || responseUsage.completion_tokens || 0),
-                reasoningTokens: responseUsage.output_tokens_details?.reasoning_tokens || 0,
-                cachedTokens: responseUsage.input_tokens_details?.cached_tokens || responseUsage.prompt_tokens_details?.cached_tokens || 0,
-              } : undefined;
-              lastUsage = usage;
-              
-              streamDone = true;
-              if (pendingToolCalls.size > 0) {
-                for (const tc of pendingToolCalls.values()) {
-                  logger.debug('response.completed: 发出 tool_call_done', tc);
-                  yield { type: 'tool_call_done', toolCall: tc };
-                }
-                yield { type: 'done', finishReason: 'tool_calls', usage };
-              } else {
-                yield { type: 'done', finishReason: 'stop', usage };
-              }
-              return;
-            }
-          }
-        } catch (e) {
-          logger.warn('SSE 解析错误', { line: line.slice(0, 100), error: String(e) });
-        }
-      }
-    }
-    
-    // 兜底
-    if (!streamDone) {
-      logger.debug('流结束，执行兜底逻辑', { pendingToolCalls: pendingToolCalls.size });
-      if (pendingToolCalls.size > 0) {
-        for (const tc of pendingToolCalls.values()) {
-          yield { type: 'tool_call_done', toolCall: tc };
-        }
-        yield { type: 'done', finishReason: 'tool_calls', usage: lastUsage };
-      } else {
-        yield { type: 'done', finishReason: 'stop', usage: lastUsage };
-      }
-    }
-  }
-}
-
-export function createOpenAIProtocol(config: ProtocolConfig): OpenAIProtocol {
-  return new OpenAIProtocol(config);
-}
-