@fudrouter/fsrouter 0.6.62 → 0.6.63

package/open-sse/translator/response/openai-responses.js

@@ -0,0 +1,535 @@
+/**
+ * Translator: OpenAI Chat Completions → OpenAI Responses API (response)
+ * Converts streaming chunks from Chat Completions to Responses API events
+ */
+import { register } from "../index.js";
+import { FORMATS } from "../formats.js";
+import { buildChunk } from "../concerns/chunk.js";
+import { buildUsage } from "../concerns/usage.js";
+import { fallbackToolCallId } from "../concerns/toolCall.js";
+import { reasoningDelta, extractReasoningText } from "../concerns/reasoning.js";
+import { ROLE, OPENAI_BLOCK, RESPONSES_ITEM, OPENAI_FINISH, MODEL_FALLBACK } from "../schema/index.js";
+
+/**
+ * Translate OpenAI chunk to Responses API events
+ * @returns {Array} Array of events with { event, data } structure
+ */
+export function openaiToOpenAIResponsesResponse(chunk, state) {
+  if (!chunk) {
+    return flushEvents(state);
+  }
+  
+  if (!chunk.choices?.length) return [];
+  
+  const events = [];
+  const nextSeq = () => ++state.seq;
+  
+  const emit = (eventType, data) => {
+    data.sequence_number = nextSeq();
+    events.push({ event: eventType, data });
+  };
+
+  const choice = chunk.choices[0];
+  const idx = choice.index || 0;
+  const delta = choice.delta || {};
+
+  // Emit initial events
+  if (!state.started) {
+    state.started = true;
+    state.responseId = chunk.id ? `resp_${chunk.id}` : state.responseId;
+    
+    emit("response.created", {
+      type: "response.created",
+      response: {
+        id: state.responseId,
+        object: "response",
+        created_at: state.created,
+        status: "in_progress",
+        background: false,
+        error: null,
+        output: []
+      }
+    });
+
+    emit("response.in_progress", {
+      type: "response.in_progress",
+      response: {
+        id: state.responseId,
+        object: "response",
+        created_at: state.created,
+        status: "in_progress"
+      }
+    });
+  }
+
+  // Handle reasoning across vendor shapes (reasoning_content / reasoning / reasoning_details)
+  const reasoningText = extractReasoningText(delta);
+  if (reasoningText) {
+    startReasoning(state, emit, idx);
+    emitReasoningDelta(state, emit, reasoningText);
+  }
+
+  // Handle text content
+  if (delta.content) {
+    let content = delta.content;
+
+    if (content.includes("<think>")) {
+      state.inThinking = true;
+      content = content.replace("<think>", "");
+      startReasoning(state, emit, idx);
+    }
+
+    if (content.includes("</think>")) {
+      const parts = content.split("</think>");
+      const thinkPart = parts[0];
+      const textPart = parts.slice(1).join("</think>");
+      if (thinkPart) emitReasoningDelta(state, emit, thinkPart);
+      closeReasoning(state, emit);
+      state.inThinking = false;
+      content = textPart;
+    }
+
+    if (state.inThinking && content) {
+      emitReasoningDelta(state, emit, content);
+      return events;
+    }
+
+    if (content) {
+      emitTextContent(state, emit, idx, content);
+    }
+  }
+
+  // Handle tool_calls
+  if (delta.tool_calls) {
+    closeMessage(state, emit, idx);
+    for (const tc of delta.tool_calls) {
+      emitToolCall(state, emit, tc);
+    }
+  }
+
+  // Handle finish_reason
+  if (choice.finish_reason) {
+    for (const i in state.msgItemAdded) closeMessage(state, emit, i);
+    closeReasoning(state, emit);
+    for (const i in state.funcCallIds) closeToolCall(state, emit, i);
+    sendCompleted(state, emit);
+  }
+
+  return events;
+}
+
+// Helper functions
+function startReasoning(state, emit, idx) {
+  if (!state.reasoningId) {
+    state.reasoningId = `rs_${state.responseId}_${idx}`;
+    state.reasoningIndex = idx;
+    
+    emit("response.output_item.added", {
+      type: "response.output_item.added",
+      output_index: idx,
+      item: { id: state.reasoningId, type: RESPONSES_ITEM.REASONING, summary: [] }
+    });
+
+    emit("response.reasoning_summary_part.added", {
+      type: "response.reasoning_summary_part.added",
+      item_id: state.reasoningId,
+      output_index: idx,
+      summary_index: 0,
+      part: { type: RESPONSES_ITEM.SUMMARY_TEXT, text: "" }
+    });
+    state.reasoningPartAdded = true;
+  }
+}
+
+function emitReasoningDelta(state, emit, text) {
+  if (!text) return;
+  state.reasoningBuf += text;
+  emit("response.reasoning_summary_text.delta", {
+    type: "response.reasoning_summary_text.delta",
+    item_id: state.reasoningId,
+    output_index: state.reasoningIndex,
+    summary_index: 0,
+    delta: text
+  });
+}
+
+function closeReasoning(state, emit) {
+  if (state.reasoningId && !state.reasoningDone) {
+    state.reasoningDone = true;
+    
+    emit("response.reasoning_summary_text.done", {
+      type: "response.reasoning_summary_text.done",
+      item_id: state.reasoningId,
+      output_index: state.reasoningIndex,
+      summary_index: 0,
+      text: state.reasoningBuf
+    });
+
+    emit("response.reasoning_summary_part.done", {
+      type: "response.reasoning_summary_part.done",
+      item_id: state.reasoningId,
+      output_index: state.reasoningIndex,
+      summary_index: 0,
+      part: { type: RESPONSES_ITEM.SUMMARY_TEXT, text: state.reasoningBuf }
+    });
+
+    emit("response.output_item.done", {
+      type: "response.output_item.done",
+      output_index: state.reasoningIndex,
+      item: {
+        id: state.reasoningId,
+        type: RESPONSES_ITEM.REASONING,
+        summary: [{ type: RESPONSES_ITEM.SUMMARY_TEXT, text: state.reasoningBuf }]
+      }
+    });
+  }
+}
+
+function emitTextContent(state, emit, idx, content) {
+  if (!state.msgItemAdded[idx]) {
+    state.msgItemAdded[idx] = true;
+    const msgId = `msg_${state.responseId}_${idx}`;
+    
+    emit("response.output_item.added", {
+      type: "response.output_item.added",
+      output_index: idx,
+      item: { id: msgId, type: RESPONSES_ITEM.MESSAGE, content: [], role: ROLE.ASSISTANT }
+    });
+  }
+
+  if (!state.msgContentAdded[idx]) {
+    state.msgContentAdded[idx] = true;
+    
+    emit("response.content_part.added", {
+      type: "response.content_part.added",
+      item_id: `msg_${state.responseId}_${idx}`,
+      output_index: idx,
+      content_index: 0,
+      part: { type: RESPONSES_ITEM.OUTPUT_TEXT, annotations: [], logprobs: [], text: "" }
+    });
+  }
+
+  emit("response.output_text.delta", {
+    type: "response.output_text.delta",
+    item_id: `msg_${state.responseId}_${idx}`,
+    output_index: idx,
+    content_index: 0,
+    delta: content,
+    logprobs: []
+  });
+
+  if (!state.msgTextBuf[idx]) state.msgTextBuf[idx] = "";
+  state.msgTextBuf[idx] += content;
+}
+
+function closeMessage(state, emit, idx) {
+  if (state.msgItemAdded[idx] && !state.msgItemDone[idx]) {
+    state.msgItemDone[idx] = true;
+    const fullText = state.msgTextBuf[idx] || "";
+    const msgId = `msg_${state.responseId}_${idx}`;
+
+    emit("response.output_text.done", {
+      type: "response.output_text.done",
+      item_id: msgId,
+      output_index: parseInt(idx),
+      content_index: 0,
+      text: fullText,
+      logprobs: []
+    });
+
+    emit("response.content_part.done", {
+      type: "response.content_part.done",
+      item_id: msgId,
+      output_index: parseInt(idx),
+      content_index: 0,
+      part: { type: RESPONSES_ITEM.OUTPUT_TEXT, annotations: [], logprobs: [], text: fullText }
+    });
+
+    emit("response.output_item.done", {
+      type: "response.output_item.done",
+      output_index: parseInt(idx),
+      item: {
+        id: msgId,
+        type: RESPONSES_ITEM.MESSAGE,
+        content: [{ type: RESPONSES_ITEM.OUTPUT_TEXT, annotations: [], logprobs: [], text: fullText }],
+        role: ROLE.ASSISTANT
+      }
+    });
+  }
+}
+
+function emitToolCall(state, emit, tc) {
+  const tcIdx = tc.index ?? 0;
+  const newCallId = tc.id;
+  const funcName = tc.function?.name;
+
+  if (funcName) state.funcNames[tcIdx] = funcName;
+
+  if (!state.funcCallIds[tcIdx] && newCallId) {
+    state.funcCallIds[tcIdx] = newCallId;
+    
+    emit("response.output_item.added", {
+      type: "response.output_item.added",
+      output_index: tcIdx,
+      item: {
+        id: `fc_${newCallId}`,
+        type: RESPONSES_ITEM.FUNCTION_CALL,
+        arguments: "",
+        call_id: newCallId,
+        name: state.funcNames[tcIdx] || ""
+      }
+    });
+  }
+
+  if (!state.funcArgsBuf[tcIdx]) state.funcArgsBuf[tcIdx] = "";
+
+  if (tc.function?.arguments) {
+    const refCallId = state.funcCallIds[tcIdx] || newCallId;
+    if (refCallId) {
+      emit("response.function_call_arguments.delta", {
+        type: "response.function_call_arguments.delta",
+        item_id: `fc_${refCallId}`,
+        output_index: tcIdx,
+        delta: tc.function.arguments
+      });
+    }
+    state.funcArgsBuf[tcIdx] += tc.function.arguments;
+  }
+}
+
+function closeToolCall(state, emit, idx) {
+  const callId = state.funcCallIds[idx];
+  if (callId && !state.funcItemDone[idx]) {
+    const args = state.funcArgsBuf[idx] || "{}";
+    
+    emit("response.function_call_arguments.done", {
+      type: "response.function_call_arguments.done",
+      item_id: `fc_${callId}`,
+      output_index: parseInt(idx),
+      arguments: args
+    });
+
+    emit("response.output_item.done", {
+      type: "response.output_item.done",
+      output_index: parseInt(idx),
+      item: {
+        id: `fc_${callId}`,
+        type: RESPONSES_ITEM.FUNCTION_CALL,
+        arguments: args,
+        call_id: callId,
+        name: state.funcNames[idx] || ""
+      }
+    });
+
+    state.funcItemDone[idx] = true;
+    state.funcArgsDone[idx] = true;
+  }
+}
+
+function sendCompleted(state, emit) {
+  if (!state.completedSent) {
+    state.completedSent = true;
+    emit("response.completed", {
+      type: "response.completed",
+      response: {
+        id: state.responseId,
+        object: "response",
+        created_at: state.created,
+        status: "completed",
+        background: false,
+        error: null
+      }
+    });
+  }
+}
+
+function flushEvents(state) {
+  if (state.completedSent) return [];
+  
+  const events = [];
+  const nextSeq = () => ++state.seq;
+  const emit = (eventType, data) => {
+    data.sequence_number = nextSeq();
+    events.push({ event: eventType, data });
+  };
+
+  for (const i in state.msgItemAdded) closeMessage(state, emit, i);
+  closeReasoning(state, emit);
+  for (const i in state.funcCallIds) closeToolCall(state, emit, i);
+  sendCompleted(state, emit);
+  
+  return events;
+}
+
+// currentToolCallId is intentionally sticky for the current turn so flush/completion
+  // can still finalize as tool_calls even if the tool call was emitted before stream end.
+function computeFinishReason(state) {
+   return state.toolCallIndex > 0 || state.currentToolCallId
+    ? OPENAI_FINISH.TOOL_CALLS
+    : OPENAI_FINISH.STOP;
+}
+
+/**
+ * Translate OpenAI Responses API chunk to OpenAI Chat Completions format
+ * This is for when Codex returns data and we need to send it to an OpenAI-compatible client
+ */
+export function openaiResponsesToOpenAIResponse(chunk, state) {
+  if (!chunk) {
+    // Flush: send final chunk with finish_reason
+    if (state.finishReasonSent || !state.started) return null;
+
+    const finishReason = computeFinishReason(state);
+
+    state.finishReasonSent = true;
+    state.finishReason = finishReason;
+
+    const finalChunk = buildChunk(
+      { id: state.chatId || `chatcmpl-${Date.now()}`, created: state.created || Math.floor(Date.now() / 1000), model: state.model || MODEL_FALLBACK },
+      {},
+      finishReason
+    );
+
+    if (state.usage && typeof state.usage === "object") {
+      finalChunk.usage = state.usage;
+    }
+
+    return finalChunk;
+  }
+
+  // Handle different event types from Responses API
+  const eventType = chunk.type || chunk.event;
+  const data = chunk.data || chunk;
+
+  // Initialize state
+  if (!state.started) {
+    state.started = true;
+    state.chatId = `chatcmpl-${Date.now()}`;
+    state.created = Math.floor(Date.now() / 1000);
+    state.toolCallIndex = 0;
+    state.currentToolCallId = null;
+  }
+
+  // Text content delta
+  if (eventType === "response.output_text.delta") {
+    const delta = data.delta || "";
+    if (!delta) return null;
+
+    return buildChunk(
+      { id: state.chatId, created: state.created, model: state.model || MODEL_FALLBACK },
+      { content: delta }
+    );
+  }
+
+  // Text content done (ignore, we handle via delta)
+  if (eventType === "response.output_text.done") {
+    return null;
+  }
+
+  // Function call started (standard function_call or custom_tool_call)
+  if (eventType === "response.output_item.added" && (data.item?.type === RESPONSES_ITEM.FUNCTION_CALL || data.item?.type === "custom_tool_call")) {
+    const item = data.item;
+    state.currentToolCallId = item.call_id || fallbackToolCallId();
+
+    return buildChunk(
+      { id: state.chatId, created: state.created, model: state.model || MODEL_FALLBACK },
+      {
+        tool_calls: [{
+          index: state.toolCallIndex,
+          id: state.currentToolCallId,
+          type: OPENAI_BLOCK.FUNCTION,
+          function: { name: item.name || "", arguments: "" }
+        }]
+      }
+    );
+  }
+
+  // Function call arguments delta (standard or custom_tool_call variant)
+  if (eventType === "response.function_call_arguments.delta" || eventType === "response.custom_tool_call_input.delta") {
+    const argsDelta = data.delta || "";
+    if (!argsDelta) return null;
+
+    return buildChunk(
+      { id: state.chatId, created: state.created, model: state.model || MODEL_FALLBACK },
+      { tool_calls: [{ index: state.toolCallIndex, function: { arguments: argsDelta } }] }
+    );
+  }
+
+  // Function call done (standard or custom_tool_call variant)
+  if (eventType === "response.output_item.done" && (data.item?.type === RESPONSES_ITEM.FUNCTION_CALL || data.item?.type === "custom_tool_call")) {
+    state.toolCallIndex++;
+    return null;
+  }
+
+  // Response completed
+  if (eventType === "response.completed" || eventType === "response.done") {
+    // Extract usage from response.completed event
+    const responseUsage = data.response?.usage;
+    if (responseUsage && typeof responseUsage === "object") {
+      const inputTokens = responseUsage.input_tokens || responseUsage.prompt_tokens || 0;
+      const outputTokens = responseUsage.output_tokens || responseUsage.completion_tokens || 0;
+      // OpenAI Responses API: input_tokens already includes cached_tokens
+      // Cache info is in input_tokens_details.cached_tokens
+      const cacheReadTokens = responseUsage.input_tokens_details?.cached_tokens || responseUsage.cache_read_input_tokens || 0;
+      
+      state.usage = buildUsage({ promptTokens: inputTokens, completionTokens: outputTokens, totalTokens: inputTokens + outputTokens, cachedTokens: cacheReadTokens });
+    }
+    
+    if (!state.finishReasonSent) {
+      const finishReason = computeFinishReason(state);
+
+      state.finishReasonSent = true;
+      state.finishReason = finishReason; // Mark for usage injection in stream.js
+      
+      const finalChunk = buildChunk(
+        { id: state.chatId, created: state.created, model: state.model || MODEL_FALLBACK },
+        {},
+        finishReason
+      );
+
+      // Include usage in final chunk if available
+      if (state.usage && typeof state.usage === "object") {
+        finalChunk.usage = state.usage;
+      }
+      
+      return finalChunk;
+    }
+    return null;
+  }
+
+  // Error events from Responses API (e.g. model_not_found)
+  if (eventType === "error" || eventType === "response.failed") {
+    // Avoid emitting duplicate errors (error + response.failed arrive back-to-back)
+    if (state.finishReasonSent) return null;
+
+    const error = data.error || data.response?.error;
+    if (error) {
+      state.error = error;
+      state.finishReasonSent = true;
+
+      // Surface the error as an OpenAI-compatible error chunk
+      return buildChunk(
+        { id: state.chatId || `chatcmpl-${Date.now()}`, created: state.created || Math.floor(Date.now() / 1000), model: state.model || MODEL_FALLBACK },
+        { content: `[Error] ${error.message || JSON.stringify(error)}` },
+        OPENAI_FINISH.STOP
+      );
+    }
+    return null;
+  }
+
+  // Reasoning summary delta → emit as reasoning_content for client thinking display
+  if (eventType === "response.reasoning_summary_text.delta") {
+    const delta = data.delta || "";
+    if (!delta) return null;
+    return buildChunk(
+      { id: state.chatId, created: state.created, model: state.model || MODEL_FALLBACK },
+      reasoningDelta(delta)
+    );
+  }
+
+  // Ignore other events
+  return null;
+}
+
+// Register both directions
+register(FORMATS.OPENAI, FORMATS.OPENAI_RESPONSES, null, openaiToOpenAIResponsesResponse);
+register(FORMATS.OPENAI_RESPONSES, FORMATS.OPENAI, null, openaiResponsesToOpenAIResponse);

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

@@ -0,0 +1,123 @@
+import { register } from "../index.js";
+import { FORMATS } from "../formats.js";
+import { GEMINI_ROLE, OPENAI_FINISH, GEMINI_FINISH } from "../schema/index.js";
+
+// Convert OpenAI SSE chunk to Antigravity SSE format
+// Real Antigravity format:
+//   data: {"response":{"candidates":[{"content":{"role":"model","parts":[...]}, "finishReason":"STOP"}], "usageMetadata":{...}, "modelVersion":"...", "responseId":"..."}}
+// Tool calls: OpenAI sends incremental args across chunks → accumulate and emit ONCE at finish
+export function openaiToAntigravityResponse(chunk, state) {
+  if (!chunk) return null;
+
+  const choice = chunk.choices?.[0];
+  if (!choice) {
+    if (chunk.usage) {
+      state._usage = chunk.usage;
+    }
+    return null;
+  }
+
+  const delta = choice.delta || {};
+  const finishReason = choice.finish_reason;
+
+  // Init state
+  if (!state._toolCallAccum) state._toolCallAccum = {};
+  if (!state._responseId) state._responseId = chunk.id || `resp_${Date.now()}`;
+  if (!state._modelVersion) state._modelVersion = chunk.model || "";
+
+  const parts = [];
+
+  // Thinking/reasoning → thought part
+  if (delta.reasoning_content) {
+    parts.push({ thought: true, text: delta.reasoning_content });
+  }
+
+  // Text content
+  if (delta.content) {
+    parts.push({ text: delta.content });
+  }
+
+  // Accumulate tool calls silently (no emit until finish)
+  if (delta.tool_calls) {
+    for (const tc of delta.tool_calls) {
+      const idx = tc.index ?? 0;
+      if (!state._toolCallAccum[idx]) {
+        state._toolCallAccum[idx] = { id: "", name: "", arguments: "" };
+      }
+      const accum = state._toolCallAccum[idx];
+      if (tc.id) accum.id = tc.id;
+      if (tc.function?.name) accum.name += tc.function.name;
+      if (tc.function?.arguments) accum.arguments += tc.function.arguments;
+    }
+    // Skip emit — wait for finish_reason
+    if (parts.length === 0 && !finishReason) return null;
+  }
+
+  // On finish, emit accumulated tool calls as complete functionCall parts
+  if (finishReason) {
+    const indices = Object.keys(state._toolCallAccum);
+    for (const idx of indices) {
+      const accum = state._toolCallAccum[idx];
+      let args = {};
+      try { args = JSON.parse(accum.arguments); } catch { /* empty */ }
+      // Restore original tool name if it was prefixed during cloaking
+      const originalName = state.toolNameMap?.get(accum.name) || accum.name;
+      parts.push({
+        functionCall: {
+          name: originalName,
+          args
+        }
+      });
+    }
+  }
+
+  // Skip empty non-finish chunks
+  if (parts.length === 0 && !finishReason) return null;
+
+  // Ensure at least empty text part on finish with no content
+  if (parts.length === 0 && finishReason) {
+    parts.push({ text: "" });
+  }
+
+  // Build candidate
+  const candidate = { content: { role: GEMINI_ROLE.MODEL, parts } };
+
+  // Finish reason mapping
+  if (finishReason) {
+    const reasonMap = {
+      [OPENAI_FINISH.STOP]: GEMINI_FINISH.STOP,
+      [OPENAI_FINISH.LENGTH]: GEMINI_FINISH.MAX_TOKENS,
+      [OPENAI_FINISH.TOOL_CALLS]: GEMINI_FINISH.STOP,
+      [OPENAI_FINISH.CONTENT_FILTER]: GEMINI_FINISH.SAFETY
+    };
+    candidate.finishReason = reasonMap[finishReason] || GEMINI_FINISH.STOP;
+  }
+
+  // Build response
+  const response = {
+    candidates: [candidate],
+    modelVersion: state._modelVersion,
+    responseId: state._responseId
+  };
+
+  // Usage metadata
+  const usage = chunk.usage || state._usage;
+  if (usage) {
+    response.usageMetadata = {
+      promptTokenCount: usage.prompt_tokens || 0,
+      candidatesTokenCount: usage.completion_tokens || 0,
+      totalTokenCount: usage.total_tokens || 0
+    };
+    if (usage.completion_tokens_details?.reasoning_tokens) {
+      response.usageMetadata.thoughtsTokenCount = usage.completion_tokens_details.reasoning_tokens;
+    }
+    if (usage.prompt_tokens_details?.cached_tokens) {
+      response.usageMetadata.cachedContentTokenCount = usage.prompt_tokens_details.cached_tokens;
+    }
+  }
+
+  return { response };
+}
+
+// Register
+register(FORMATS.OPENAI, FORMATS.ANTIGRAVITY, null, openaiToAntigravityResponse);