@fudrouter/fsrouter 0.6.63 → 0.6.64

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

@@ -1,195 +0,0 @@
-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

@@ -1,188 +0,0 @@
-/**
- * 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

@@ -1,30 +0,0 @@
-/**
- * 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

@@ -1,147 +0,0 @@
-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);
-