aicodeswitch 1.4.1 → 1.5.0

package/src/server/transformers/chunk-collector.ts

@@ -0,0 +1,202 @@
+import { Transform } from 'stream';
+
+/**
+ * SSEEvent - 表示一个完整的SSE事件
+ */
+export interface SSEEvent {
+  event?: string;
+  id?: string;
+  data?: string;
+  raw: string; // 原始字符串
+}
+
+/**
+ * ChunkCollectorTransform - 收集stream chunks用于日志记录
+ * 这个Transform会记录所有经过它的数据块,同时将数据原封不动地传递给下一个stream
+ */
+export class ChunkCollectorTransform extends Transform {
+  private chunks: string[] = [];
+
+  constructor() {
+    super();
+  }
+
+  _transform(chunk: Buffer, _encoding: BufferEncoding, callback: (error?: Error | null) => void) {
+    // 收集chunk数据
+    this.chunks.push(chunk.toString('utf8'));
+
+    // 将chunk传递给下一个stream
+    this.push(chunk);
+
+    callback();
+  }
+
+  /**
+   * 获取收集的所有chunks
+   */
+  getChunks(): string[] {
+    return this.chunks;
+  }
+
+  /**
+   * 清空已收集的chunks
+   */
+  clearChunks(): void {
+    this.chunks = [];
+  }
+}
+
+/**
+ * SSEEventCollectorTransform - 智能收集完整的SSE事件
+ * 这个Transform会解析SSE流并将每个完整的事件存储为一个单独的entry
+ * 确保每个chunk代表一条完整的消息,而不是随机的buffer片段
+ */
+export class SSEEventCollectorTransform extends Transform {
+  private buffer = '';
+  private currentEvent: { event?: string; id?: string; dataLines: string[]; rawLines: string[] } = {
+    dataLines: [],
+    rawLines: []
+  };
+  private events: SSEEvent[] = [];
+
+  constructor() {
+    super();
+  }
+
+  _transform(chunk: Buffer, _encoding: BufferEncoding, callback: (error?: Error | null) => void) {
+    this.buffer += chunk.toString('utf8');
+    this.processBuffer();
+    // 将chunk传递给下一个stream
+    this.push(chunk);
+    callback();
+  }
+
+  _flush(callback: (error?: Error | null) => void) {
+    // 处理剩余的buffer
+    if (this.buffer.trim()) {
+      this.processBuffer();
+    }
+    // 刷新最后一个事件
+    this.flushEvent();
+    callback();
+  }
+
+  private processBuffer() {
+    const lines = this.buffer.split('\n');
+    // 保留最后一行(可能不完整)
+    this.buffer = lines.pop() || '';
+
+    for (const line of lines) {
+      this.processLine(line);
+    }
+  }
+
+  private processLine(line: string) {
+    // 记录原始行
+    this.currentEvent.rawLines.push(line);
+
+    // 空行表示一个事件结束
+    if (!line.trim()) {
+      this.flushEvent();
+      return;
+    }
+
+    if (line.startsWith('event:')) {
+      this.currentEvent.event = line.slice(6).trim();
+      return;
+    }
+
+    if (line.startsWith('id:')) {
+      this.currentEvent.id = line.slice(3).trim();
+      return;
+    }
+
+    if (line.startsWith('data:')) {
+      this.currentEvent.dataLines.push(line.slice(5).trim());
+      return;
+    }
+  }
+
+  private flushEvent() {
+    // 只有当有内容时才创建事件
+    if (!this.currentEvent.event && this.currentEvent.dataLines.length === 0 && !this.currentEvent.id) {
+      this.currentEvent = { dataLines: [], rawLines: [] };
+      return;
+    }
+
+    const raw = this.currentEvent.rawLines.join('\n');
+    const event: SSEEvent = {
+      event: this.currentEvent.event,
+      id: this.currentEvent.id,
+      data: this.currentEvent.dataLines.length > 0 ? this.currentEvent.dataLines.join('\n') : undefined,
+      raw
+    };
+
+    this.events.push(event);
+    this.currentEvent = { dataLines: [], rawLines: [] };
+  }
+
+  /**
+   * 获取收集的所有SSE事件
+   * 每个事件都是一个完整的SSE消息
+   */
+  getEvents(): SSEEvent[] {
+    return this.events;
+  }
+
+  /**
+   * 获取原始chunks(兼容旧接口)
+   */
+  getChunks(): string[] {
+    return this.events.map(e => e.raw);
+  }
+
+  /**
+   * 清空已收集的事件
+   */
+  clearEvents(): void {
+    this.events = [];
+  }
+
+  /**
+   * 从events中提取usage信息
+   */
+  extractUsage(): { input_tokens?: number; output_tokens?: number; cache_read_input_tokens?: number } | null {
+    for (const event of this.events) {
+      if (!event.data) continue;
+
+      try {
+        const data = JSON.parse(event.data);
+
+        // 尝试从不同的位置提取usage
+        // 1. message_delta事件中的usage
+        if (event.event === 'message_delta' && data.usage) {
+          return data.usage;
+        }
+
+        // 2. 直接在data中的usage
+        if (data.usage) {
+          return data.usage;
+        }
+
+        // 3. OpenAI格式: choices数组中最后一个元素的usage
+        if (Array.isArray(data.choices) && data.choices.length > 0) {
+          const lastChoice = data.choices[data.choices.length - 1];
+          if (lastChoice?.usage) {
+            return lastChoice.usage;
+          }
+        }
+
+        // 4. 直接在顶级的usage字段
+        if (data.input_tokens !== undefined || data.output_tokens !== undefined ||
+            data.prompt_tokens !== undefined || data.completion_tokens !== undefined) {
+          return data;
+        }
+      } catch {
+        // JSON解析失败,跳过
+      }
+    }
+
+    return null;
+  }
+}

package/src/server/transformers/claude-openai.ts

@@ -0,0 +1,261 @@
+import type { TokenUsage } from '../../types';
+
+type ClaudeContentBlock =
+  | { type: 'text'; text: string }
+  | { type: 'tool_use'; id?: string; name: string; input?: unknown }
+  | { type: 'tool_result'; tool_use_id?: string; content?: unknown }
+  | { type: 'thinking'; thinking?: string }
+  | Record<string, any>;
+
+type ClaudeMessage = {
+  role: 'user' | 'assistant' | 'system' | 'tool';
+  content: string | ClaudeContentBlock[] | null;
+};
+
+type ClaudeRequest = {
+  model?: string;
+  messages?: ClaudeMessage[];
+  system?: string | ClaudeContentBlock[];
+  max_tokens?: number;
+  temperature?: number;
+  top_p?: number;
+  stream?: boolean;
+  tools?: Array<{ name: string; description?: string; input_schema?: unknown }>;
+  tool_choice?: unknown;
+  stop_sequences?: string[];
+  [key: string]: unknown;
+};
+
+const toTextContent = (content: unknown): string | null => {
+  if (typeof content === 'string') return content;
+  if (!Array.isArray(content)) return null;
+
+  const parts: string[] = [];
+  for (const item of content) {
+    if (item && typeof item === 'object' && (item as any).type === 'text' && typeof (item as any).text === 'string') {
+      parts.push((item as any).text);
+    }
+  }
+  return parts.length > 0 ? parts.join('') : null;
+};
+
+const mapClaudeToolChoiceToOpenAI = (toolChoice: unknown): unknown => {
+  if (toolChoice === 'auto' || toolChoice === 'none' || toolChoice === 'required') {
+    return toolChoice;
+  }
+  if (toolChoice && typeof toolChoice === 'object' && (toolChoice as any).name) {
+    return {
+      type: 'function',
+      function: { name: (toolChoice as any).name },
+    };
+  }
+  return toolChoice;
+};
+
+export const convertOpenAIUsageToClaude = (usage: any) => {
+  const cached = usage?.prompt_tokens_details?.cached_tokens || 0;
+  return {
+    input_tokens: (usage?.prompt_tokens || 0) - cached,
+    output_tokens: usage?.completion_tokens || 0,
+    cache_read_input_tokens: cached,
+  };
+};
+
+export const mapStopReason = (finishReason?: string | null): string => {
+  switch (finishReason) {
+    case 'stop':
+      return 'end_turn';
+    case 'length':
+      return 'max_tokens';
+    case 'tool_calls':
+      return 'tool_use';
+    case 'content_filter':
+      return 'content_filter';
+    default:
+      return 'end_turn';
+  }
+};
+
+export const transformClaudeRequestToOpenAIChat = (body: ClaudeRequest, targetModel?: string) => {
+  const messages: any[] = [];
+
+  if (body.system) {
+    const systemText = toTextContent(body.system);
+    if (systemText) {
+      messages.push({ role: 'system', content: systemText });
+    }
+  }
+
+  if (Array.isArray(body.messages)) {
+    for (const message of body.messages) {
+      if (typeof message.content === 'string' || message.content === null) {
+        messages.push({ role: message.role, content: message.content });
+        continue;
+      }
+
+      if (Array.isArray(message.content)) {
+        const textParts: string[] = [];
+        const toolCalls: any[] = [];
+        const toolResultMessages: any[] = [];
+
+        for (const block of message.content) {
+          if (block && typeof block === 'object') {
+            if (block.type === 'text' && typeof (block as any).text === 'string') {
+              textParts.push((block as any).text);
+            }
+            if (block.type === 'tool_use') {
+              const toolId = (block as any).id || `tool_${toolCalls.length + 1}`;
+              const toolName = (block as any).name || 'tool';
+              const input = (block as any).input ?? {};
+              toolCalls.push({
+                id: toolId,
+                type: 'function',
+                function: {
+                  name: toolName,
+                  arguments: JSON.stringify(input),
+                },
+              });
+            }
+            if (block.type === 'tool_result') {
+              const toolCallId = (block as any).tool_use_id || (block as any).id;
+              const toolContent = (block as any).content;
+              toolResultMessages.push({
+                role: 'tool',
+                tool_call_id: toolCallId,
+                content: typeof toolContent === 'string' ? toolContent : JSON.stringify(toolContent ?? {}),
+              });
+            }
+          }
+        }
+
+        const content = textParts.length > 0 ? textParts.join('') : null;
+        const openaiMessage: any = {
+          role: message.role,
+          content,
+        };
+
+        if (toolCalls.length > 0) {
+          openaiMessage.tool_calls = toolCalls;
+        }
+        messages.push(openaiMessage);
+        toolResultMessages.forEach((toolMessage) => messages.push(toolMessage));
+      }
+    }
+  }
+
+  const openaiBody: any = {
+    model: targetModel || body.model,
+    messages,
+  };
+
+  if (typeof body.temperature === 'number') openaiBody.temperature = body.temperature;
+  if (typeof body.top_p === 'number') openaiBody.top_p = body.top_p;
+  if (typeof body.max_tokens === 'number') openaiBody.max_tokens = body.max_tokens;
+  if (Array.isArray(body.stop_sequences)) openaiBody.stop = body.stop_sequences;
+
+  if (body.tools) {
+    openaiBody.tools = body.tools.map((tool) => ({
+      type: 'function',
+      function: {
+        name: tool.name,
+        description: tool.description,
+        parameters: tool.input_schema,
+      },
+    }));
+  }
+
+  if (body.tool_choice) {
+    openaiBody.tool_choice = mapClaudeToolChoiceToOpenAI(body.tool_choice);
+  }
+
+  if (body.stream === true) {
+    openaiBody.stream = true;
+    openaiBody.stream_options = { include_usage: true };
+  }
+
+  return openaiBody;
+};
+
+const extractOpenAIText = (content: unknown): string | null => {
+  if (typeof content === 'string') return content;
+  if (!Array.isArray(content)) return null;
+
+  const parts: string[] = [];
+  for (const item of content) {
+    if (item && typeof item === 'object' && typeof (item as any).text === 'string') {
+      parts.push((item as any).text);
+    }
+  }
+  return parts.length > 0 ? parts.join('') : null;
+};
+
+export const transformOpenAIChatResponseToClaude = (body: any) => {
+  const choice = Array.isArray(body?.choices) ? body.choices[0] : null;
+  const message = choice?.message || {};
+  const contentBlocks: any[] = [];
+
+  const contentText = extractOpenAIText(message.content);
+  if (contentText) {
+    contentBlocks.push({ type: 'text', text: contentText });
+  }
+
+  if (Array.isArray(message.tool_calls)) {
+    for (const toolCall of message.tool_calls) {
+      const toolName = toolCall?.function?.name || 'tool';
+      let input: unknown = {};
+      if (toolCall?.function?.arguments) {
+        try {
+          input = JSON.parse(toolCall.function.arguments);
+        } catch {
+          input = toolCall.function.arguments;
+        }
+      }
+      contentBlocks.push({
+        type: 'tool_use',
+        id: toolCall.id,
+        name: toolName,
+        input,
+      });
+    }
+  }
+
+  const usage = body?.usage ? convertOpenAIUsageToClaude(body.usage) : null;
+
+  return {
+    id: body?.id,
+    type: 'message',
+    role: 'assistant',
+    model: body?.model,
+    content: contentBlocks,
+    stop_reason: mapStopReason(choice?.finish_reason),
+    stop_sequence: null,
+    usage: usage || {
+      input_tokens: 0,
+      output_tokens: 0,
+      cache_read_input_tokens: 0,
+    },
+  };
+};
+
+export const extractTokenUsageFromOpenAIUsage = (usage: any): TokenUsage | undefined => {
+  if (!usage) return undefined;
+  const converted = convertOpenAIUsageToClaude(usage);
+  return {
+    inputTokens: converted.input_tokens,
+    outputTokens: converted.output_tokens,
+    totalTokens: usage.total_tokens,
+    cacheReadInputTokens: converted.cache_read_input_tokens,
+  };
+};
+
+export const extractTokenUsageFromClaudeUsage = (usage: any): TokenUsage | undefined => {
+  if (!usage) return undefined;
+  return {
+    inputTokens: usage.input_tokens ?? 0,
+    outputTokens: usage.output_tokens ?? 0,
+    totalTokens: usage.input_tokens !== undefined && usage.output_tokens !== undefined
+      ? usage.input_tokens + usage.output_tokens
+      : undefined,
+    cacheReadInputTokens: usage.cache_read_input_tokens,
+  };
+};