@fudrouter/fsrouter 0.6.63 → 0.6.64

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

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

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