wyxrouter 0.4.71

package/open-sse/translator/response/claude-to-openai.js

@@ -0,0 +1,206 @@
+import { register } from "../index.js";
+import { FORMATS } from "../formats.js";
+
+// Create OpenAI chunk helper
+function createChunk(state, delta, finishReason = null) {
+  return {
+    id: `chatcmpl-${state.messageId}`,
+    object: "chat.completion.chunk",
+    created: Math.floor(Date.now() / 1000),
+    model: state.model,
+    choices: [{
+      index: 0,
+      delta,
+      finish_reason: finishReason
+    }]
+  };
+}
+
+// Convert Claude stream chunk to OpenAI format
+export function claudeToOpenAIResponse(chunk, state) {
+  if (!chunk) return null;
+
+  const results = [];
+  const event = chunk.type;
+
+  switch (event) {
+    case "message_start": {
+      state.messageId = chunk.message?.id || `msg_${Date.now()}`;
+      state.model = chunk.message?.model;
+      state.toolCallIndex = 0;
+      results.push(createChunk(state, { role: "assistant" }));
+      break;
+    }
+
+    case "content_block_start": {
+      const block = chunk.content_block;
+      if (block?.type === "server_tool_use") {
+        // Built-in tool (web search) - Claude handles internally, skip
+        state.serverToolBlockIndex = chunk.index;
+        break;
+      }
+      if (block?.type === "text") {
+        state.textBlockStarted = true;
+      } else if (block?.type === "thinking") {
+        state.inThinkingBlock = true;
+        state.currentBlockIndex = chunk.index;
+        results.push(createChunk(state, { content: "<think>" }));
+      } else if (block?.type === "tool_use") {
+        const toolCallIndex = state.toolCallIndex++;
+        // Restore original tool name from mapping (Claude OAuth)
+        const toolName = state.toolNameMap?.get(block.name) || block.name;
+        const toolCall = {
+          index: toolCallIndex,
+          id: block.id,
+          type: "function",
+          function: {
+            name: toolName,
+            arguments: ""
+          }
+        };
+        state.toolCalls.set(chunk.index, toolCall);
+        results.push(createChunk(state, { tool_calls: [toolCall] }));
+      }
+      break;
+    }
+
+    case "content_block_delta": {
+      // Skip deltas for built-in server tool blocks (web search)
+      if (chunk.index === state.serverToolBlockIndex) break;
+      const delta = chunk.delta;
+      if (delta?.type === "text_delta" && delta.text) {
+        results.push(createChunk(state, { content: delta.text }));
+      } else if (delta?.type === "thinking_delta" && delta.thinking) {
+        results.push(createChunk(state, { reasoning_content: delta.thinking }));
+      } else if (delta?.type === "input_json_delta" && delta.partial_json) {
+        const toolCall = state.toolCalls.get(chunk.index);
+        if (toolCall) {
+          toolCall.function.arguments += delta.partial_json;
+          results.push(createChunk(state, {
+            tool_calls: [{
+              index: toolCall.index,
+              id: toolCall.id,
+              function: { arguments: delta.partial_json }
+            }]
+          }));
+        }
+      }
+      break;
+    }
+
+    case "content_block_stop": {
+      // Skip stop for built-in server tool blocks (web search)
+      if (chunk.index === state.serverToolBlockIndex) {
+        state.serverToolBlockIndex = -1;
+        break;
+      }
+      if (state.inThinkingBlock && chunk.index === state.currentBlockIndex) {
+        results.push(createChunk(state, { content: "</think>" }));
+        state.inThinkingBlock = false;
+      }
+      state.textBlockStarted = false;
+      state.thinkingBlockStarted = false;
+      break;
+    }
+
+    case "message_delta": {
+      // Extract usage from message_delta event (Claude native format)
+      // Normalize to OpenAI format (prompt_tokens/completion_tokens) for consistent logging
+      if (chunk.usage && typeof chunk.usage === "object") {
+        const inputTokens = typeof chunk.usage.input_tokens === "number" ? chunk.usage.input_tokens : 0;
+        const outputTokens = typeof chunk.usage.output_tokens === "number" ? chunk.usage.output_tokens : 0;
+        const cacheReadTokens = typeof chunk.usage.cache_read_input_tokens === "number" ? chunk.usage.cache_read_input_tokens : 0;
+        const cacheCreationTokens = typeof chunk.usage.cache_creation_input_tokens === "number" ? chunk.usage.cache_creation_input_tokens : 0;
+
+        // prompt_tokens = input_tokens + cache_read + cache_creation (all prompt-side tokens)
+        const promptTokens = inputTokens + cacheReadTokens + cacheCreationTokens;
+
+        state.usage = {
+          prompt_tokens: promptTokens,
+          completion_tokens: outputTokens,
+          total_tokens: promptTokens + outputTokens,
+          input_tokens: inputTokens,
+          output_tokens: outputTokens
+        };
+
+        if (cacheReadTokens > 0) state.usage.cache_read_input_tokens = cacheReadTokens;
+        if (cacheCreationTokens > 0) state.usage.cache_creation_input_tokens = cacheCreationTokens;
+      }
+
+      if (chunk.delta?.stop_reason) {
+        state.finishReason = convertStopReason(chunk.delta.stop_reason);
+        const finalChunk = {
+          id: `chatcmpl-${state.messageId}`,
+          object: "chat.completion.chunk",
+          created: Math.floor(Date.now() / 1000),
+          model: state.model,
+          choices: [{ index: 0, delta: {}, finish_reason: state.finishReason }]
+        };
+
+        if (state.usage) {
+          finalChunk.usage = {
+            prompt_tokens: state.usage.prompt_tokens,
+            completion_tokens: state.usage.completion_tokens,
+            total_tokens: state.usage.total_tokens
+          };
+
+          const cacheRead = state.usage.cache_read_input_tokens;
+          const cacheCreate = state.usage.cache_creation_input_tokens;
+          if (cacheRead > 0 || cacheCreate > 0) {
+            finalChunk.usage.prompt_tokens_details = {};
+            if (cacheRead > 0) finalChunk.usage.prompt_tokens_details.cached_tokens = cacheRead;
+            if (cacheCreate > 0) finalChunk.usage.prompt_tokens_details.cache_creation_tokens = cacheCreate;
+          }
+        }
+
+        results.push(finalChunk);
+        state.finishReasonSent = true;
+      }
+      break;
+    }
+
+    case "message_stop": {
+      if (!state.finishReasonSent) {
+        const finishReason = state.finishReason || (state.toolCalls?.size > 0 ? "tool_calls" : "stop");
+        const usageObj = (state.usage && typeof state.usage === 'object') ? {
+          usage: {
+            prompt_tokens: state.usage.input_tokens || 0,
+            completion_tokens: state.usage.output_tokens || 0,
+            total_tokens: (state.usage.input_tokens || 0) + (state.usage.output_tokens || 0)
+          }
+        } : {};
+        results.push({
+          id: `chatcmpl-${state.messageId}`,
+          object: "chat.completion.chunk",
+          created: Math.floor(Date.now() / 1000),
+          model: state.model,
+          choices: [{
+            index: 0,
+            delta: {},
+            finish_reason: finishReason
+          }],
+          ...usageObj
+        });
+        state.finishReasonSent = true;
+      }
+      break;
+    }
+  }
+
+  return results.length > 0 ? results : null;
+}
+
+// Convert Claude stop_reason to OpenAI finish_reason
+function convertStopReason(reason) {
+  switch (reason) {
+    case "end_turn": return "stop";
+    case "max_tokens": return "length";
+    case "tool_use": return "tool_calls";
+    case "stop_sequence": return "stop";
+    default: return "stop";
+  }
+}
+
+// Register
+register(FORMATS.CLAUDE, FORMATS.OPENAI, null, claudeToOpenAIResponse);
+

package/open-sse/translator/response/commandcode-to-openai.js

@@ -0,0 +1,197 @@
+/**
+ * CommandCode → OpenAI response translator
+ *
+ * CommandCode upstream emits NDJSON-style AI SDK v5 stream events:
+ *   {"type":"start"} {"type":"start-step", ...}
+ *   {"type":"reasoning-start","id":"..."} {"type":"reasoning-delta","text":"..."}
+ *   {"type":"text-start","id":"..."}     {"type":"text-delta","text":"..."}
+ *   {"type":"tool-input-start","id","toolName"}
+ *   {"type":"tool-input-delta","id","delta"}
+ *   {"type":"tool-input-end","id"}
+ *   {"type":"tool-call","toolCallId","toolName","input"}
+ *   {"type":"finish-step","finishReason","usage": {...}, ...}
+ *   {"type":"finish",...}
+ *
+ * Each upstream "event" arrives as one JSON object per line — we receive it as a string chunk
+ * already split per line by the upstream SSE/JSON-line reader in 9router.
+ */
+import { register } from "../index.js";
+import { FORMATS } from "../formats.js";
+
+function ensureState(state, model) {
+  if (!state.responseId) {
+    state.responseId = `chatcmpl-${Date.now()}`;
+    state.created = Math.floor(Date.now() / 1000);
+    state.model = state.model || model || "commandcode";
+    state.chunkIndex = 0;
+    state.toolIndex = 0;
+    state.toolIndexById = new Map();
+    state.openTools = new Set();
+    state.openText = false;
+    state.finishReason = null;
+    state.usage = null;
+  }
+}
+
+function makeChunk(state, delta, finishReason = null) {
+  return {
+    id: state.responseId,
+    object: "chat.completion.chunk",
+    created: state.created,
+    model: state.model,
+    choices: [{ index: 0, delta, finish_reason: finishReason }],
+  };
+}
+
+function mapFinishReason(reason) {
+  switch (reason) {
+    case "stop": return "stop";
+    case "length": return "length";
+    case "tool-calls":
+    case "tool_use": return "tool_calls";
+    case "content-filter": return "content_filter";
+    case "error": return "stop";
+    default: return reason || "stop";
+  }
+}
+
+export function convertCommandCodeToOpenAI(chunk, state) {
+  if (!chunk) return null;
+
+  // Already-OpenAI chunk: pass through
+  if (chunk && typeof chunk === "object" && chunk.object === "chat.completion.chunk") {
+    return chunk;
+  }
+
+  // Parse string lines coming out of upstream
+  let event = chunk;
+  if (typeof chunk === "string") {
+    const line = chunk.trim();
+    if (!line) return null;
+    // Tolerate raw "data: {...}" framing if the upstream wrapper inserts it
+    const json = line.startsWith("data:") ? line.slice(5).trim() : line;
+    if (!json || json === "[DONE]") return null;
+    try {
+      event = JSON.parse(json);
+    } catch {
+      return null;
+    }
+  }
+
+  if (!event || typeof event !== "object" || !event.type) return null;
+
+  ensureState(state, event.model);
+  const out = [];
+
+  switch (event.type) {
+    case "text-delta": {
+      const text = event.text || event.delta || "";
+      if (!text) break;
+      const delta = state.chunkIndex === 0 ? { role: "assistant", content: text } : { content: text };
+      state.chunkIndex++;
+      state.openText = true;
+      out.push(makeChunk(state, delta));
+      break;
+    }
+    case "reasoning-delta": {
+      const text = event.text || "";
+      if (!text) break;
+      // Map reasoning to OpenAI "reasoning_content" field (used by deepseek-reasoner-style clients).
+      const delta = state.chunkIndex === 0
+        ? { role: "assistant", reasoning_content: text }
+        : { reasoning_content: text };
+      state.chunkIndex++;
+      out.push(makeChunk(state, delta));
+      break;
+    }
+    case "tool-input-start": {
+      const id = event.id || event.toolCallId || `call_${Date.now()}_${state.toolIndex}`;
+      let idx = state.toolIndexById.get(id);
+      if (idx == null) {
+        idx = state.toolIndex++;
+        state.toolIndexById.set(id, idx);
+      }
+      state.openTools.add(id);
+      const delta = {
+        ...(state.chunkIndex === 0 ? { role: "assistant" } : {}),
+        tool_calls: [{
+          index: idx,
+          id,
+          type: "function",
+          function: { name: event.toolName || "", arguments: "" },
+        }],
+      };
+      state.chunkIndex++;
+      out.push(makeChunk(state, delta));
+      break;
+    }
+    case "tool-input-delta": {
+      const id = event.id || event.toolCallId;
+      const idx = state.toolIndexById.get(id);
+      if (idx == null) break;
+      const delta = {
+        tool_calls: [{
+          index: idx,
+          function: { arguments: event.delta || event.inputTextDelta || "" },
+        }],
+      };
+      out.push(makeChunk(state, delta));
+      break;
+    }
+    case "tool-call": {
+      // Final consolidated tool call — only emit if we never saw tool-input-* deltas.
+      const id = event.toolCallId;
+      if (state.toolIndexById.has(id)) break;
+      const idx = state.toolIndex++;
+      state.toolIndexById.set(id, idx);
+      const argsStr = typeof event.input === "string" ? event.input : JSON.stringify(event.input ?? {});
+      const delta = {
+        ...(state.chunkIndex === 0 ? { role: "assistant" } : {}),
+        tool_calls: [{
+          index: idx,
+          id,
+          type: "function",
+          function: { name: event.toolName || "", arguments: argsStr },
+        }],
+      };
+      state.chunkIndex++;
+      out.push(makeChunk(state, delta));
+      break;
+    }
+    case "finish-step": {
+      state.finishReason = mapFinishReason(event.finishReason);
+      if (event.usage) state.usage = event.usage;
+      break;
+    }
+    case "finish": {
+      const finishReason = state.finishReason || mapFinishReason(event.finishReason || "stop");
+      const finalChunk = makeChunk(state, {}, finishReason);
+      const totalUsage = event.totalUsage || state.usage;
+      if (totalUsage) {
+        finalChunk.usage = {
+          prompt_tokens: totalUsage.inputTokens ?? 0,
+          completion_tokens: totalUsage.outputTokens ?? 0,
+          total_tokens: totalUsage.totalTokens ?? ((totalUsage.inputTokens ?? 0) + (totalUsage.outputTokens ?? 0)),
+        };
+      }
+      out.push(finalChunk);
+      break;
+    }
+    case "error": {
+      state.finishReason = "stop";
+      const errVal = event.error ?? event.message ?? "unknown";
+      const errStr = typeof errVal === "string" ? errVal : JSON.stringify(errVal);
+      out.push(makeChunk(state, { content: `\n\n[CommandCode error: ${errStr}]` }));
+      out.push(makeChunk(state, {}, "stop"));
+      break;
+    }
+    // Silently ignore: start, start-step, reasoning-start, reasoning-end, text-start, text-end,
+    // provider-metadata, message-metadata, etc. They carry no client-visible content.
+    default:
+      break;
+  }
+
+  return out.length ? out : null;
+}
+
+register(FORMATS.COMMANDCODE, FORMATS.OPENAI, null, convertCommandCodeToOpenAI);

package/open-sse/translator/response/cursor-to-openai.js

@@ -0,0 +1,30 @@
+/**
+ * Cursor to OpenAI Response Translator
+ * CursorExecutor already emits OpenAI format - this is a passthrough
+ */
+import { register } from "../index.js";
+import { FORMATS } from "../formats.js";
+
+/**
+ * Convert Cursor response to OpenAI format
+ * Since CursorExecutor.transformProtobufToSSE/JSON already emits OpenAI chunks,
+ * this is a passthrough translator (similar to Kiro pattern)
+ */
+export function convertCursorToOpenAI(chunk, state) {
+  if (!chunk) return null;
+
+  // If chunk is already in OpenAI format (from executor transform), return as-is
+  if (chunk.object === "chat.completion.chunk" && chunk.choices) {
+    return chunk;
+  }
+
+  // If chunk is a completion object (non-streaming), return as-is
+  if (chunk.object === "chat.completion" && chunk.choices) {
+    return chunk;
+  }
+
+  // Fallback: return chunk as-is (should not reach here)
+  return chunk;
+}
+
+register(FORMATS.CURSOR, FORMATS.OPENAI, null, convertCursorToOpenAI);

package/open-sse/translator/response/gemini-to-openai.js

@@ -0,0 +1,245 @@
+import { register } from "../index.js";
+import { FORMATS } from "../formats.js";
+
+// Convert Gemini response chunk to OpenAI format
+export function geminiToOpenAIResponse(chunk, state) {
+  if (!chunk) return null;
+  
+  // Handle Antigravity wrapper
+  const response = chunk.response || chunk;
+  if (!response || !response.candidates?.[0]) return null;
+
+  const results = [];
+  const candidate = response.candidates[0];
+  const content = candidate.content;
+
+  // Initialize state
+  if (!state.messageId) {
+    state.messageId = response.responseId || `msg_${Date.now()}`;
+    state.model = response.modelVersion || "gemini";
+    state.functionIndex = 0;
+    results.push({
+      id: `chatcmpl-${state.messageId}`,
+      object: "chat.completion.chunk",
+      created: Math.floor(Date.now() / 1000),
+      model: state.model,
+      choices: [{
+        index: 0,
+        delta: { role: "assistant" },
+        finish_reason: null
+      }]
+    });
+  }
+
+  // Process parts
+  if (content?.parts) {
+    for (const part of content.parts) {
+      const hasThoughtSig = part.thoughtSignature || part.thought_signature;
+      const isThought = part.thought === true;
+      
+      // Handle thought signature (thinking mode)
+      if (hasThoughtSig) {
+        const hasTextContent = part.text !== undefined && part.text !== "";
+        const hasFunctionCall = !!part.functionCall;
+        
+        if (hasTextContent) {
+          results.push({
+            id: `chatcmpl-${state.messageId}`,
+            object: "chat.completion.chunk",
+            created: Math.floor(Date.now() / 1000),
+            model: state.model,
+            choices: [{
+              index: 0,
+              delta: isThought 
+                ? { reasoning_content: part.text }
+                : { content: part.text },
+              finish_reason: null
+            }]
+          });
+        }
+        
+        if (hasFunctionCall) {
+          const rawName = part.functionCall.name;
+          // Restore original tool name from mapping (AG cloaking)
+          const fcName = state.toolNameMap?.get(rawName) || rawName;
+          const fcArgs = part.functionCall.args || {};
+          const toolCallIndex = state.functionIndex++;
+          
+          const toolCall = {
+            id: `${fcName}-${Date.now()}-${toolCallIndex}`,
+            index: toolCallIndex,
+            type: "function",
+            function: {
+              name: fcName,
+              arguments: JSON.stringify(fcArgs)
+            }
+          };
+          
+          state.toolCalls.set(toolCallIndex, toolCall);
+          
+          results.push({
+            id: `chatcmpl-${state.messageId}`,
+            object: "chat.completion.chunk",
+            created: Math.floor(Date.now() / 1000),
+            model: state.model,
+            choices: [{
+              index: 0,
+              delta: { tool_calls: [toolCall] },
+              finish_reason: null
+            }]
+          });
+        }
+        continue;
+      }
+
+      // Text content (non-thinking)
+      if (part.text !== undefined && part.text !== "") {
+        results.push({
+          id: `chatcmpl-${state.messageId}`,
+          object: "chat.completion.chunk",
+          created: Math.floor(Date.now() / 1000),
+          model: state.model,
+          choices: [{
+            index: 0,
+            delta: { content: part.text },
+            finish_reason: null
+          }]
+        });
+      }
+
+      // Function call
+      if (part.functionCall) {
+        const rawName = part.functionCall.name;
+        // Restore original tool name from mapping (AG cloaking)
+        const fcName = state.toolNameMap?.get(rawName) || rawName;
+        const fcArgs = part.functionCall.args || {};
+        const toolCallIndex = state.functionIndex++;
+        
+        const toolCall = {
+          id: `${fcName}-${Date.now()}-${toolCallIndex}`,
+          index: toolCallIndex,
+          type: "function",
+          function: {
+            name: fcName,
+            arguments: JSON.stringify(fcArgs)
+          }
+        };
+        
+        state.toolCalls.set(toolCallIndex, toolCall);
+        
+        results.push({
+          id: `chatcmpl-${state.messageId}`,
+          object: "chat.completion.chunk",
+          created: Math.floor(Date.now() / 1000),
+          model: state.model,
+          choices: [{
+            index: 0,
+            delta: { tool_calls: [toolCall] },
+            finish_reason: null
+          }]
+        });
+      }
+
+      // Inline data (images)
+      const inlineData = part.inlineData || part.inline_data;
+      if (inlineData?.data) {
+        const mimeType = inlineData.mimeType || inlineData.mime_type || "image/png";
+        results.push({
+          id: `chatcmpl-${state.messageId}`,
+          object: "chat.completion.chunk",
+          created: Math.floor(Date.now() / 1000),
+          model: state.model,
+          choices: [{
+            index: 0,
+            delta: {
+              images: [{
+                type: "image_url",
+                image_url: { url: `data:${mimeType};base64,${inlineData.data}` }
+              }]
+            },
+            finish_reason: null
+          }]
+        });
+      }
+    }
+  }
+
+  // Usage metadata - extract before finish reason so we can include it
+  const usageMeta = response.usageMetadata || chunk.usageMetadata;
+  if (usageMeta && typeof usageMeta === "object") {
+    const cachedTokens = typeof usageMeta.cachedContentTokenCount === "number" ? usageMeta.cachedContentTokenCount : 0;
+    const promptTokenCountRaw = typeof usageMeta.promptTokenCount === "number" ? usageMeta.promptTokenCount : 0;
+    const thoughtsTokens = typeof usageMeta.thoughtsTokenCount === "number" ? usageMeta.thoughtsTokenCount : 0;
+    let candidatesTokens = typeof usageMeta.candidatesTokenCount === "number" ? usageMeta.candidatesTokenCount : 0;
+    const totalTokens = typeof usageMeta.totalTokenCount === "number" ? usageMeta.totalTokenCount : 0;
+    
+    // prompt_tokens = promptTokenCount (includes cached tokens, matching claude-to-openai.js behavior)
+    const promptTokens = promptTokenCountRaw;
+    
+    // Fallback calculation if candidatesTokenCount is 0 but totalTokenCount exists
+    if (candidatesTokens === 0 && totalTokens > 0) {
+      candidatesTokens = totalTokens - promptTokenCountRaw - thoughtsTokens;
+      if (candidatesTokens < 0) candidatesTokens = 0;
+    }
+    
+    // completion_tokens = candidatesTokenCount + thoughtsTokenCount (match Go code)
+    const completionTokens = candidatesTokens + thoughtsTokens;
+    
+    state.usage = {
+      prompt_tokens: promptTokens,
+      completion_tokens: completionTokens,
+      total_tokens: totalTokens
+    };
+    
+    // Add prompt_tokens_details if cached tokens exist
+    if (cachedTokens > 0) {
+      state.usage.prompt_tokens_details = {
+        cached_tokens: cachedTokens
+      };
+    }
+    
+    // Add completion_tokens_details if reasoning tokens exist
+    if (thoughtsTokens > 0) {
+      state.usage.completion_tokens_details = {
+        reasoning_tokens: thoughtsTokens
+      };
+    }
+  }
+
+  // Finish reason - include usage in final chunk
+  if (candidate.finishReason) {
+    let finishReason = candidate.finishReason.toLowerCase();
+    if (finishReason === "stop" && state.toolCalls.size > 0) {
+      finishReason = "tool_calls";
+    }
+    
+    const finalChunk = {
+      id: `chatcmpl-${state.messageId}`,
+      object: "chat.completion.chunk",
+      created: Math.floor(Date.now() / 1000),
+      model: state.model,
+      choices: [{
+        index: 0,
+        delta: {},
+        finish_reason: finishReason
+      }]
+    };
+    
+    // Include usage in final chunk for downstream translators
+    if (state.usage) {
+      finalChunk.usage = state.usage;
+    }
+    
+    results.push(finalChunk);
+    state.finishReason = finishReason;
+  }
+
+  return results.length > 0 ? results : null;
+}
+
+// Register
+register(FORMATS.GEMINI, FORMATS.OPENAI, null, geminiToOpenAIResponse);
+register(FORMATS.GEMINI_CLI, FORMATS.OPENAI, null, geminiToOpenAIResponse);
+register(FORMATS.ANTIGRAVITY, FORMATS.OPENAI, null, geminiToOpenAIResponse);
+register(FORMATS.VERTEX, FORMATS.OPENAI, null, geminiToOpenAIResponse);
+