@fudrouter/fsrouter 0.6.62 → 0.6.63

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

@@ -0,0 +1,195 @@
+import { register } from "../index.js";
+import { FORMATS } from "../formats.js";
+import { ROLE, OPENAI_BLOCK, CLAUDE_BLOCK, OPENAI_FINISH } from "../schema/index.js";
+import { buildChunk } from "../concerns/chunk.js";
+import { toOpenAIUsage } from "../concerns/usage.js";
+import { reasoningDelta } from "../concerns/reasoning.js";
+import { toOpenAIFinish } from "../concerns/finishReason.js";
+
+// Create OpenAI chunk helper
+function createChunk(state, delta, finishReason = null) {
+  return buildChunk(
+    { id: `chatcmpl-${state.messageId}`, created: Math.floor(Date.now() / 1000), model: state.model },
+    delta,
+    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;
+      // Claude sends input_tokens + cache_read + cache_creation here; message_delta
+      // later carries only the final output_tokens. Capture cache now so the
+      // delta (output-only) doesn't reset it to zero.
+      const startUsage = chunk.message?.usage;
+      if (startUsage && typeof startUsage === "object") {
+        const inputTokens = typeof startUsage.input_tokens === "number" ? startUsage.input_tokens : 0;
+        const cacheReadTokens = typeof startUsage.cache_read_input_tokens === "number" ? startUsage.cache_read_input_tokens : 0;
+        const cacheCreationTokens = typeof startUsage.cache_creation_input_tokens === "number" ? startUsage.cache_creation_input_tokens : 0;
+        const promptTokens = inputTokens + cacheReadTokens + cacheCreationTokens;
+        state.usage = {
+          prompt_tokens: promptTokens,
+          completion_tokens: 0,
+          total_tokens: promptTokens,
+          input_tokens: inputTokens,
+          output_tokens: 0
+        };
+        if (cacheReadTokens > 0) state.usage.cache_read_input_tokens = cacheReadTokens;
+        if (cacheCreationTokens > 0) state.usage.cache_creation_input_tokens = cacheCreationTokens;
+      }
+      results.push(createChunk(state, { role: 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 === CLAUDE_BLOCK.TEXT) {
+        state.textBlockStarted = true;
+      } else if (block?.type === CLAUDE_BLOCK.THINKING) {
+        state.inThinkingBlock = true;
+        state.currentBlockIndex = chunk.index;
+        results.push(createChunk(state, { content: "<think>" }));
+      } else if (block?.type === CLAUDE_BLOCK.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: OPENAI_BLOCK.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, reasoningDelta(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).
+      // Anthropic sends input/cache in message_start and only output here, so
+      // fall back to cache captured in message_start when the delta omits it.
+      if (chunk.usage && typeof chunk.usage === "object") {
+        const prev = state.usage || {};
+        const inputTokens = typeof chunk.usage.input_tokens === "number" ? chunk.usage.input_tokens : (prev.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 : (prev.cache_read_input_tokens || 0);
+        const cacheCreationTokens = typeof chunk.usage.cache_creation_input_tokens === "number" ? chunk.usage.cache_creation_input_tokens : (prev.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 = createChunk(state, {}, state.finishReason);
+
+        if (state.usage) {
+          // Build OpenAI usage from the merged state (cache from message_start +
+          // output from message_delta), not the delta chunk alone.
+          finalChunk.usage = toOpenAIUsage({
+            input_tokens: state.usage.input_tokens || 0,
+            output_tokens: state.usage.output_tokens || 0,
+            cache_read_input_tokens: state.usage.cache_read_input_tokens,
+            cache_creation_input_tokens: state.usage.cache_creation_input_tokens
+          }, "claude");
+        }
+
+        results.push(finalChunk);
+        state.finishReasonSent = true;
+      }
+      break;
+    }
+
+    case "message_stop": {
+      if (!state.finishReasonSent) {
+        const finishReason = state.finishReason || (state.toolCalls?.size > 0 ? OPENAI_FINISH.TOOL_CALLS : OPENAI_FINISH.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({ ...createChunk(state, {}, finishReason), ...usageObj });
+        state.finishReasonSent = true;
+      }
+      break;
+    }
+  }
+
+  return results.length > 0 ? results : null;
+}
+
+const convertStopReason = (reason) => toOpenAIFinish(reason, "claude");
+
+// Register
+register(FORMATS.CLAUDE, FORMATS.OPENAI, null, claudeToOpenAIResponse);
+

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

@@ -0,0 +1,188 @@
+/**
+ * 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";
+import { ROLE, OPENAI_BLOCK, OPENAI_FINISH } from "../schema/index.js";
+import { buildChunk } from "../concerns/chunk.js";
+import { toOpenAIUsage } from "../concerns/usage.js";
+import { reasoningDelta } from "../concerns/reasoning.js";
+import { fallbackToolCallId } from "../concerns/toolCall.js";
+import { toOpenAIFinish } from "../concerns/finishReason.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 buildChunk(
+    { id: state.responseId, created: state.created, model: state.model },
+    delta,
+    finishReason
+  );
+}
+
+const mapFinishReason = (reason) => toOpenAIFinish(reason, "commandcode");
+
+export function commandCodeToOpenAIResponse(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: 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 = reasoningDelta(text, state.chunkIndex === 0);
+      state.chunkIndex++;
+      out.push(makeChunk(state, delta));
+      break;
+    }
+    case "tool-input-start": {
+      const id = event.id || event.toolCallId || fallbackToolCallId(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: ROLE.ASSISTANT } : {}),
+        tool_calls: [{
+          index: idx,
+          id,
+          type: OPENAI_BLOCK.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: ROLE.ASSISTANT } : {}),
+        tool_calls: [{
+          index: idx,
+          id,
+          type: OPENAI_BLOCK.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;
+      const usage = toOpenAIUsage(totalUsage, "commandcode");
+      if (usage) finalChunk.usage = usage;
+      out.push(finalChunk);
+      break;
+    }
+    case "error": {
+      state.finishReason = OPENAI_FINISH.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, {}, OPENAI_FINISH.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, commandCodeToOpenAIResponse);
+
+// Backwards-compatible alias (executor expects this name)
+export const convertCommandCodeToOpenAI = commandCodeToOpenAIResponse;
+

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 cursorToOpenAIResponse(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, cursorToOpenAIResponse);

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

@@ -0,0 +1,147 @@
+import { register } from "../index.js";
+import { FORMATS } from "../formats.js";
+import { ROLE, OPENAI_BLOCK, OPENAI_FINISH, DEFAULT_IMAGE_MIME } from "../schema/index.js";
+import { buildChunk } from "../concerns/chunk.js";
+import { toOpenAIUsage } from "../concerns/usage.js";
+import { reasoningDelta } from "../concerns/reasoning.js";
+import { encodeDataUri } from "../concerns/image.js";
+import { toOpenAIFinish } from "../concerns/finishReason.js";
+
+// Build chunk meta for current gemini state
+function chunkMeta(state) {
+  return { id: `chatcmpl-${state.messageId}`, created: Math.floor(Date.now() / 1000), model: state.model };
+}
+
+// Build a tool_call chunk from a gemini functionCall part (shared by sig/non-sig branches)
+function emitFunctionCall(functionCall, state) {
+  const rawName = functionCall.name;
+  // Restore original tool name from mapping (AG cloaking)
+  const fcName = state.toolNameMap?.get(rawName) || rawName;
+  const fcArgs = functionCall.args || {};
+  const toolCallIndex = state.functionIndex++;
+  const toolCall = {
+    id: `${fcName}-${Date.now()}-${toolCallIndex}`,
+    index: toolCallIndex,
+    type: OPENAI_BLOCK.FUNCTION,
+    function: { name: fcName, arguments: JSON.stringify(fcArgs) },
+  };
+  // Keep Gemini bookkeeping separate from the shared translator state.toolCalls map.
+  // The downstream OpenAI→Claude translator uses state.toolCalls for Claude block
+  // metadata; pre-populating it here makes Anthropic tool deltas lose index.
+  state.geminiToolCallCount = (state.geminiToolCallCount || 0) + 1;
+  return buildChunk(chunkMeta(state), { tool_calls: [toolCall] }, null);
+}
+
+// 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;
+    state.geminiToolCallCount = 0;
+    results.push(buildChunk(chunkMeta(state), { role: ROLE.ASSISTANT }, 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(buildChunk(
+            chunkMeta(state),
+            isThought ? reasoningDelta(part.text) : { content: part.text },
+            null
+          ));
+        }
+        
+        if (hasFunctionCall) {
+          results.push(emitFunctionCall(part.functionCall, state));
+        }
+        continue;
+      }
+
+      // Text content. Gemini marks model-internal thinking with `thought: true`.
+      // Some responses include a thoughtSignature, but Google AI Studio/Gemini API
+      // can also stream thought parts without a signature; those must not be
+      // surfaced as normal assistant content in OpenAI-compatible clients.
+      if (part.text !== undefined && part.text !== "") {
+        results.push(buildChunk(
+          chunkMeta(state),
+          isThought ? reasoningDelta(part.text) : { content: part.text },
+          null
+        ));
+      }
+
+      // Function call
+      if (part.functionCall) {
+        results.push(emitFunctionCall(part.functionCall, state));
+      }
+
+      // Inline data (images)
+      const inlineData = part.inlineData || part.inline_data;
+      if (inlineData?.data) {
+        const mimeType = inlineData.mimeType || inlineData.mime_type || DEFAULT_IMAGE_MIME;
+        results.push(buildChunk(
+          chunkMeta(state),
+          {
+            images: [{
+              type: OPENAI_BLOCK.IMAGE_URL,
+              image_url: { url: encodeDataUri(mimeType, inlineData.data) }
+            }]
+          },
+          null
+        ));
+      }
+    }
+  }
+
+  // Usage metadata - extract before finish reason so we can include it
+  const usageMeta = response.usageMetadata || chunk.usageMetadata;
+  const geminiUsage = toOpenAIUsage(usageMeta, "gemini");
+  if (geminiUsage) state.usage = geminiUsage;
+
+  // Finish reason - include usage in final chunk
+  if (candidate.finishReason) {
+    let finishReason = toOpenAIFinish(candidate.finishReason, "gemini");
+    if (finishReason === OPENAI_FINISH.STOP && state.geminiToolCallCount > 0) {
+      finishReason = OPENAI_FINISH.TOOL_CALLS;
+    }
+    
+    const finalChunk = buildChunk(chunkMeta(state), {}, 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);
+