@huyooo/ai-chat-core 0.2.19 → 0.2.21

package/src/providers/protocols/openai.ts

@@ -0,0 +1,420 @@
+/**
+ * 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);
+}
+