zevairouter 1.0.154 → 1.0.155

package/open-sse/handlers/chatCore/sseToJsonHandler.js

@@ -1,540 +0,0 @@
-import { convertResponsesStreamToJson } from "../../transformer/streamToJsonConverter.js";
-import { createErrorResult } from "../../utils/error.js";
-import { HTTP_STATUS } from "../../config/runtimeConfig.js";
-import { FORMATS } from "../../translator/formats.js";
-import { buildRequestDetail, extractRequestConfig, saveUsageStats } from "./requestDetail.js";
-import { saveRequestDetail, appendRequestLog } from "@/lib/usageDb.js";
-
-function textFromResponsesMessageItem(item) {
-  if (!item?.content || !Array.isArray(item.content)) return "";
-  const byType = item.content.find((c) => c.type === "output_text");
-  if (typeof byType?.text === "string") return byType.text;
-  const anyText = item.content.find((c) => typeof c.text === "string");
-  if (typeof anyText?.text === "string") return anyText.text;
-  return "";
-}
-
-/**
- * Codex / Responses API may emit many alternating reasoning + message items.
- * Early message blocks often have empty output_text; the user-visible answer is usually in the last non-empty message.
- */
-function pickAssistantMessageForChatCompletion(output) {
-  if (!Array.isArray(output)) return { msgItem: null, textContent: null };
-  const messages = output.filter((item) => item?.type === "message");
-  if (messages.length === 0) return { msgItem: null, textContent: null };
-  for (let i = messages.length - 1; i >= 0; i--) {
-    const text = textFromResponsesMessageItem(messages[i]);
-    if (text.length > 0) return { msgItem: messages[i], textContent: text };
-  }
-  const last = messages[messages.length - 1];
-  return { msgItem: last, textContent: textFromResponsesMessageItem(last) };
-}
-
-function reasoningFromResponsesOutput(output) {
-  if (!Array.isArray(output)) return "";
-  return output
-    .filter((item) => item?.type === "reasoning")
-    .flatMap((item) => Array.isArray(item.summary) ? item.summary : item.content || [])
-    .map((part) => typeof part?.text === "string" ? part.text : "")
-    .filter(Boolean)
-    .join("\n");
-}
-
-/** Convert a completed Responses object into a Chat Completions response. */
-export function responsesJsonToChatCompletion(jsonResponse, fallbackModel) {
-  const usage = jsonResponse?.usage || {};
-  const output = Array.isArray(jsonResponse?.output) ? jsonResponse.output : [];
-  const { textContent } = pickAssistantMessageForChatCompletion(output);
-  const reasoningContent = reasoningFromResponsesOutput(output);
-  const functionItems = output.filter((item) =>
-    item?.type === "function_call" || item?.type === "custom_tool_call"
-  );
-  const toolCalls = functionItems.map((item, index) => ({
-    id: item.call_id || `call_${item.name || "unknown"}_${index}`,
-    type: "function",
-    function: {
-      name: item.name || "_unknown",
-      arguments: typeof (item.arguments ?? item.input) === "string"
-        ? (item.arguments ?? item.input)
-        : JSON.stringify(item.arguments ?? item.input ?? {}),
-    },
-  }));
-
-  const message = {
-    role: "assistant",
-    content: textContent || (toolCalls.length > 0 ? null : ""),
-  };
-  if (reasoningContent) message.reasoning_content = reasoningContent;
-  if (toolCalls.length > 0) message.tool_calls = toolCalls;
-
-  const status = jsonResponse?.status;
-  const finishReason = toolCalls.length > 0
-    ? "tool_calls"
-    : status === "incomplete" ? "length" : "stop";
-  const inputTokens = usage.input_tokens ?? usage.prompt_tokens ?? 0;
-  const outputTokens = usage.output_tokens ?? usage.completion_tokens ?? 0;
-
-  return {
-    id: jsonResponse?.id || `chatcmpl-${Date.now()}`,
-    object: "chat.completion",
-    created: jsonResponse?.created_at || Math.floor(Date.now() / 1000),
-    model: jsonResponse?.model || fallbackModel || "unknown",
-    choices: [{ index: 0, message, finish_reason: finishReason }],
-    usage: {
-      prompt_tokens: inputTokens,
-      completion_tokens: outputTokens,
-      total_tokens: usage.total_tokens ?? inputTokens + outputTokens,
-      ...(usage.input_tokens_details && { prompt_tokens_details: usage.input_tokens_details }),
-      ...(usage.output_tokens_details && { completion_tokens_details: usage.output_tokens_details }),
-    },
-  };
-}
-
-/** Convert a completed Chat Completions response into a Responses object. */
-export function chatCompletionToResponsesJson(chatResponse, fallbackModel) {
-  const choice = chatResponse?.choices?.[0] || {};
-  const message = choice.message || {};
-  const output = [];
-
-  if (typeof message.reasoning_content === "string" && message.reasoning_content) {
-    output.push({
-      id: `rs_${chatResponse?.id || Date.now()}`,
-      type: "reasoning",
-      summary: [{ type: "summary_text", text: message.reasoning_content }],
-    });
-  }
-
-  const text = typeof message.content === "string"
-    ? message.content
-    : Array.isArray(message.content)
-      ? message.content.map((part) => part?.text || "").join("")
-      : "";
-  if (text || !Array.isArray(message.tool_calls) || message.tool_calls.length === 0) {
-    output.push({
-      id: `msg_${chatResponse?.id || Date.now()}`,
-      type: "message",
-      role: "assistant",
-      status: "completed",
-      content: [{ type: "output_text", text, annotations: [] }],
-    });
-  }
-
-  const toolCalls = Array.isArray(message.tool_calls) ? message.tool_calls : [];
-  for (const [index, toolCall] of toolCalls.entries()) {
-    output.push({
-      id: `fc_${toolCall.id || index}`,
-      type: "function_call",
-      call_id: toolCall.id || `call_${index}`,
-      name: toolCall.function?.name || "_unknown",
-      arguments: typeof toolCall.function?.arguments === "string"
-        ? toolCall.function.arguments
-        : JSON.stringify(toolCall.function?.arguments ?? {}),
-      status: "completed",
-    });
-  }
-
-  const usage = chatResponse?.usage || {};
-  const inputTokens = usage.prompt_tokens ?? usage.input_tokens ?? 0;
-  const outputTokens = usage.completion_tokens ?? usage.output_tokens ?? 0;
-  const incomplete = choice.finish_reason === "length";
-
-  return {
-    id: chatResponse?.id?.startsWith("resp_") ? chatResponse.id : `resp_${chatResponse?.id || Date.now()}`,
-    object: "response",
-    created_at: chatResponse?.created || Math.floor(Date.now() / 1000),
-    status: incomplete ? "incomplete" : "completed",
-    error: null,
-    incomplete_details: incomplete ? { reason: "max_output_tokens" } : null,
-    model: chatResponse?.model || fallbackModel || "unknown",
-    output,
-    usage: {
-      input_tokens: inputTokens,
-      output_tokens: outputTokens,
-      total_tokens: usage.total_tokens ?? inputTokens + outputTokens,
-      ...(usage.prompt_tokens_details && { input_tokens_details: usage.prompt_tokens_details }),
-      ...(usage.completion_tokens_details && { output_tokens_details: usage.completion_tokens_details }),
-    },
-  };
-}
-
-function parseToolInput(rawInput) {
-  if (rawInput && typeof rawInput === "object" && !Array.isArray(rawInput)) return rawInput;
-  if (typeof rawInput !== "string" || rawInput.length === 0) return {};
-
-  try {
-    const parsed = JSON.parse(rawInput);
-    return parsed && typeof parsed === "object" && !Array.isArray(parsed)
-      ? parsed
-      : { value: parsed };
-  } catch {
-    // Preserve malformed upstream arguments without returning an invalid Claude envelope.
-    return { raw: rawInput };
-  }
-}
-
-function chatMessageText(message) {
-  if (typeof message?.content === "string") return message.content;
-  if (!Array.isArray(message?.content)) return "";
-  return message.content
-    .map((part) => {
-      if (typeof part === "string") return part;
-      if (typeof part?.text === "string") return part.text;
-      if (typeof part?.refusal === "string") return part.refusal;
-      return "";
-    })
-    .join("");
-}
-
-function claudeStopReason(finishReason) {
-  switch (finishReason) {
-    case "length": return "max_tokens";
-    case "tool_calls": return "tool_use";
-    case "content_filter": return "refusal";
-    default: return "end_turn";
-  }
-}
-
-/** Convert a completed Chat Completions object into a Claude Messages object. */
-export function chatCompletionToClaudeJson(chatResponse, fallbackModel) {
-  const choice = chatResponse?.choices?.[0] || {};
-  const message = choice.message || {};
-  const content = [];
-
-  if (typeof message.reasoning_content === "string" && message.reasoning_content) {
-    content.push({ type: "thinking", thinking: message.reasoning_content });
-  }
-
-  const text = chatMessageText(message);
-  if (text || !Array.isArray(message.tool_calls) || message.tool_calls.length === 0) {
-    content.push({ type: "text", text });
-  }
-
-  const toolCalls = Array.isArray(message.tool_calls) ? message.tool_calls : [];
-  for (const [index, toolCall] of toolCalls.entries()) {
-    content.push({
-      type: "tool_use",
-      id: toolCall?.id || `call_${index}`,
-      name: toolCall?.function?.name || "_unknown",
-      input: parseToolInput(toolCall?.function?.arguments),
-    });
-  }
-
-  const usage = chatResponse?.usage || {};
-  const cachedTokens = usage.prompt_tokens_details?.cached_tokens || 0;
-  const cacheCreationTokens = usage.prompt_tokens_details?.cache_creation_tokens || 0;
-  const promptTokens = usage.prompt_tokens ?? usage.input_tokens ?? 0;
-  const outputTokens = usage.completion_tokens ?? usage.output_tokens ?? 0;
-  const rawId = chatResponse?.id || `${Date.now()}`;
-  const messageId = rawId.startsWith("msg_")
-    ? rawId
-    : `msg_${rawId.replace(/^chatcmpl[-_]?/, "")}`;
-
-  return {
-    id: messageId,
-    type: "message",
-    role: "assistant",
-    model: chatResponse?.model || fallbackModel || "unknown",
-    content,
-    stop_reason: claudeStopReason(choice.finish_reason),
-    stop_sequence: choice.stop_sequence ?? null,
-    usage: {
-      input_tokens: Math.max(0, promptTokens - cachedTokens - cacheCreationTokens),
-      output_tokens: outputTokens,
-      ...(cachedTokens > 0 && { cache_read_input_tokens: cachedTokens }),
-      ...(cacheCreationTokens > 0 && { cache_creation_input_tokens: cacheCreationTokens }),
-    },
-  };
-}
-
-function geminiFinishReason(finishReason) {
-  switch (finishReason) {
-    case "length": return "MAX_TOKENS";
-    case "content_filter": return "SAFETY";
-    default: return "STOP";
-  }
-}
-
-/** Convert a completed Chat Completions object into a Gemini response object. */
-export function chatCompletionToGeminiJson(chatResponse, fallbackModel) {
-  const choice = chatResponse?.choices?.[0] || {};
-  const message = choice.message || {};
-  const parts = [];
-
-  if (typeof message.reasoning_content === "string" && message.reasoning_content) {
-    parts.push({ text: message.reasoning_content, thought: true });
-  }
-
-  const text = chatMessageText(message);
-  if (text) parts.push({ text });
-
-  const toolCalls = Array.isArray(message.tool_calls) ? message.tool_calls : [];
-  for (const toolCall of toolCalls) {
-    parts.push({
-      functionCall: {
-        ...(toolCall?.id && { id: toolCall.id }),
-        name: toolCall?.function?.name || "_unknown",
-        args: parseToolInput(toolCall?.function?.arguments),
-      },
-    });
-  }
-
-  if (parts.length === 0) parts.push({ text: "" });
-
-  const usage = chatResponse?.usage || {};
-  const promptTokens = usage.prompt_tokens ?? usage.input_tokens ?? 0;
-  const completionTokens = usage.completion_tokens ?? usage.output_tokens ?? 0;
-  const reasoningTokens = usage.completion_tokens_details?.reasoning_tokens || 0;
-  const cachedTokens = usage.prompt_tokens_details?.cached_tokens || 0;
-  const response = {
-    candidates: [{
-      content: { role: "model", parts },
-      finishReason: geminiFinishReason(choice.finish_reason),
-      index: choice.index ?? 0,
-    }],
-    modelVersion: chatResponse?.model || fallbackModel || "unknown",
-    responseId: chatResponse?.id || `resp_${Date.now()}`,
-  };
-
-  if (chatResponse?.usage) {
-    response.usageMetadata = {
-      promptTokenCount: promptTokens,
-      candidatesTokenCount: Math.max(0, completionTokens - reasoningTokens),
-      totalTokenCount: usage.total_tokens ?? promptTokens + completionTokens,
-      ...(cachedTokens > 0 && { cachedContentTokenCount: cachedTokens }),
-      ...(reasoningTokens > 0 && { thoughtsTokenCount: reasoningTokens }),
-    };
-  }
-
-  return response;
-}
-
-/** Convert the OpenAI intermediate response into the original client's JSON envelope. */
-export function chatCompletionToClientJson(chatResponse, sourceFormat, fallbackModel) {
-  if (sourceFormat === FORMATS.OPENAI_RESPONSES || sourceFormat === FORMATS.OPENAI_RESPONSE) {
-    return chatCompletionToResponsesJson(chatResponse, fallbackModel);
-  }
-  if (sourceFormat === FORMATS.CLAUDE) {
-    return chatCompletionToClaudeJson(chatResponse, fallbackModel);
-  }
-  if (
-    sourceFormat === FORMATS.GEMINI ||
-    sourceFormat === FORMATS.GEMINI_CLI ||
-    sourceFormat === FORMATS.VERTEX ||
-    sourceFormat === FORMATS.ANTIGRAVITY
-  ) {
-    const geminiResponse = chatCompletionToGeminiJson(chatResponse, fallbackModel);
-    return sourceFormat === FORMATS.ANTIGRAVITY ? { response: geminiResponse } : geminiResponse;
-  }
-  return chatResponse;
-}
-
-export async function notifyRequestSuccess(onRequestSuccess) {
-  if (typeof onRequestSuccess !== "function") return;
-  try {
-    await onRequestSuccess();
-  } catch (error) {
-    // Bookkeeping failures must not discard a valid provider response.
-    console.error("[ChatCore] Request success callback failed:", error?.message || error);
-  }
-}
-
-/**
- * Parse OpenAI-style SSE text into a single chat completion JSON.
- * Used when provider forces streaming but client wants non-streaming.
- */
-export function parseSSEToOpenAIResponse(rawSSE, fallbackModel) {
-  const chunks = [];
-  let terminated = false;
-
-  for (const line of String(rawSSE || "").split("\n")) {
-    const trimmed = line.trim();
-    if (!trimmed.startsWith("data:")) continue;
-    const payload = trimmed.slice(5).trim();
-    if (!payload) continue;
-    if (payload === "[DONE]") {
-      terminated = true;
-      break;
-    }
-    let chunk;
-    try { chunk = JSON.parse(payload); } catch { return null; }
-    if (chunk?.error) return { error: chunk.error };
-    chunks.push(chunk);
-    if (chunk?.choices?.some((choice) => choice?.finish_reason)) terminated = true;
-  }
-
-  if (chunks.length === 0 || !terminated) return null;
-
-  const first = chunks[0];
-  const contentParts = [];
-  const reasoningParts = [];
-  const toolCallMap = new Map(); // index -> { id, type, function: { name, arguments } }
-  let finishReason = "stop";
-  let usage = null;
-  let completionFinished = false;
-
-  for (const chunk of chunks) {
-    const choice = chunk?.choices?.[0];
-    const delta = choice?.delta || {};
-    if (chunk?.usage && typeof chunk.usage === "object") usage = chunk.usage;
-
-    if (completionFinished) continue;
-    if (typeof delta.content === "string" && delta.content.length > 0) contentParts.push(delta.content);
-    if (typeof delta.reasoning_content === "string" && delta.reasoning_content.length > 0) reasoningParts.push(delta.reasoning_content);
-
-    // Accumulate tool_calls from streaming deltas
-    if (Array.isArray(delta.tool_calls)) {
-      for (const tc of delta.tool_calls) {
-        const idx = tc.index ?? 0;
-        if (!toolCallMap.has(idx)) {
-          toolCallMap.set(idx, { id: tc.id || "", type: "function", function: { name: "", arguments: "" } });
-        }
-        const existing = toolCallMap.get(idx);
-        if (tc.id) existing.id = tc.id;
-        if (tc.function?.name) existing.function.name += tc.function.name;
-        if (tc.function?.arguments) existing.function.arguments += tc.function.arguments;
-      }
-    }
-
-    if (choice?.finish_reason) {
-      finishReason = choice.finish_reason;
-      completionFinished = true;
-    }
-  }
-
-  const message = { role: "assistant", content: contentParts.join("") || (toolCallMap.size > 0 ? null : "") };
-  if (reasoningParts.length > 0) message.reasoning_content = reasoningParts.join("");
-  if (toolCallMap.size > 0) {
-    message.tool_calls = [...toolCallMap.entries()].sort((a, b) => a[0] - b[0]).map(([, tc]) => tc);
-  }
-
-  const result = {
-    id: first.id || `chatcmpl-${Date.now()}`,
-    object: "chat.completion",
-    created: first.created || Math.floor(Date.now() / 1000),
-    model: first.model || fallbackModel || "unknown",
-    choices: [{ index: 0, message, finish_reason: finishReason }]
-  };
-  if (usage) result.usage = usage;
-  return result;
-}
-
-/**
- * Handle case: provider forced streaming but client wants JSON.
- * Supports both Codex/Responses API SSE and standard Chat Completions SSE.
- */
-export async function handleForcedSSEToJson({ providerResponse, sourceFormat, targetFormat, provider, model, body, stream, translatedBody, finalBody, requestStartTime, connectionId, apiKey, clientRawRequest, onRequestSuccess, trackDone, appendLog }) {
-  const contentType = providerResponse.headers.get("content-type") || "";
-  const isSSE = contentType.includes("text/event-stream") || (contentType === "" && provider === "codex");
-  if (!isSSE) return null; // not handled here
-
-  trackDone();
-
-  const ctx = {
-    provider, model, connectionId,
-    request: extractRequestConfig(body, stream),
-    providerRequest: finalBody || translatedBody || null
-  };
-
-  // Codex/Responses API SSE path
-  const isCodexResponsesApi = targetFormat === FORMATS.OPENAI_RESPONSES;
-  if (isCodexResponsesApi) {
-    try {
-      const jsonResponse = await convertResponsesStreamToJson(providerResponse.body);
-      if (jsonResponse?.status === "failed" || jsonResponse?.error) {
-        const error = jsonResponse.error || jsonResponse;
-        const message = typeof error === "string"
-          ? error
-          : error?.message || error?.error?.message || "Provider returned a failed response";
-        appendLog({ status: `FAILED ${HTTP_STATUS.BAD_GATEWAY}` });
-        return createErrorResult(HTTP_STATUS.BAD_GATEWAY, message);
-      }
-      await notifyRequestSuccess(onRequestSuccess);
-
-      const usage = jsonResponse.usage || {};
-      appendLog({ tokens: usage, status: "200 OK" });
-      saveUsageStats({
-        provider, model, tokens: usage, connectionId, apiKey, endpoint: clientRawRequest?.endpoint,
-        latency: { ttft: 0, total: Date.now() - requestStartTime },
-      });
-
-      const { textContent } = pickAssistantMessageForChatCompletion(jsonResponse.output);
-      const totalLatency = Date.now() - requestStartTime;
-
-      saveRequestDetail(buildRequestDetail({
-        ...ctx,
-        latency: { ttft: totalLatency, total: totalLatency },
-        tokens: { prompt_tokens: usage.input_tokens || 0, completion_tokens: usage.output_tokens || 0 },
-        response: { content: textContent, thinking: null, finish_reason: jsonResponse.status || "unknown" },
-        status: "success"
-      }, { endpoint: clientRawRequest?.endpoint || null })).catch(() => {});
-
-      // Client is Responses API -> return the completed provider envelope as-is.
-      if (sourceFormat === FORMATS.OPENAI_RESPONSES || sourceFormat === FORMATS.OPENAI_RESPONSE) {
-        return { success: true, response: new Response(JSON.stringify(jsonResponse), { headers: { "Content-Type": "application/json", "Access-Control-Allow-Origin": "*" } }) };
-      }
-
-      const finalResp = chatCompletionToClientJson(
-        responsesJsonToChatCompletion(jsonResponse, model),
-        sourceFormat,
-        model
-      );
-
-      return { success: true, response: new Response(JSON.stringify(finalResp), { headers: { "Content-Type": "application/json", "Access-Control-Allow-Origin": "*" } }) };
-    } catch (err) {
-      console.error("[ChatCore] Responses API SSE→JSON failed:", err);
-      return createErrorResult(HTTP_STATUS.BAD_GATEWAY, "Failed to convert streaming response to JSON");
-    }
-  }
-
-  // Standard Chat Completions SSE path
-  try {
-    const sseText = await providerResponse.text();
-    const parsed = parseSSEToOpenAIResponse(sseText, model);
-    if (!parsed || parsed.error) {
-      return createErrorResult(
-        HTTP_STATUS.BAD_GATEWAY,
-        parsed?.error?.message || "Invalid SSE response for non-streaming request"
-      );
-    }
-
-    await notifyRequestSuccess(onRequestSuccess);
-
-    const usage = parsed.usage || {};
-    appendLog({ tokens: usage, status: "200 OK" });
-    saveUsageStats({
-      provider, model, tokens: usage, connectionId, apiKey, endpoint: clientRawRequest?.endpoint,
-      latency: { ttft: 0, total: Date.now() - requestStartTime },
-    });
-
-    const totalLatency = Date.now() - requestStartTime;
-    saveRequestDetail(buildRequestDetail({
-      ...ctx,
-      latency: { ttft: totalLatency, total: totalLatency },
-      tokens: usage,
-      response: {
-        content: parsed.choices?.[0]?.message?.content || null,
-        thinking: parsed.choices?.[0]?.message?.reasoning_content || null,
-        finish_reason: parsed.choices?.[0]?.finish_reason || "unknown"
-      },
-      status: "success"
-    }, { endpoint: clientRawRequest?.endpoint || null })).catch(() => {});
-
-    // Strip reasoning_content only when content is non-empty.
-    // When content is empty (e.g. thinking models that used all tokens for reasoning),
-    // reasoning_content is the only useful output and must be preserved.
-    // Previously this was unconditional, which broke Qwen3.5, Claude extended thinking, etc.
-    if (sourceFormat === FORMATS.OPENAI && parsed?.choices) {
-      for (const choice of parsed.choices) {
-        if (choice?.message?.reasoning_content && choice.message.content) {
-          delete choice.message.reasoning_content;
-        }
-      }
-    }
-
-    const clientResponse = chatCompletionToClientJson(parsed, sourceFormat, model);
-    return { success: true, response: new Response(JSON.stringify(clientResponse), { headers: { "Content-Type": "application/json", "Access-Control-Allow-Origin": "*" } }) };
-  } catch (err) {
-    console.error("[ChatCore] Chat Completions SSE→JSON failed:", err);
-    return createErrorResult(HTTP_STATUS.BAD_GATEWAY, "Failed to convert streaming response to JSON");
-  }
-}

package/open-sse/handlers/chatCore/streamingHandler.js

@@ -1,125 +0,0 @@
-import { FORMATS } from "../../translator/formats.js";
-import { needsTranslation } from "../../translator/index.js";
-import { createSSETransformStreamWithLogger, createPassthroughStreamWithLogger } from "../../utils/stream.js";
-import { pipeWithDisconnect } from "../../utils/streamHandler.js";
-import { createAbortedResponsesTerminalHandler } from "../../utils/responsesStreamHelpers.js";
-import { buildRequestDetail, extractRequestConfig, saveUsageStats } from "./requestDetail.js";
-import { saveRequestDetail } from "@/lib/usageDb.js";
-
-const SSE_HEADERS = {
-  "Content-Type": "text/event-stream",
-  "Cache-Control": "no-cache",
-  "Connection": "keep-alive",
-  "Access-Control-Allow-Origin": "*"
-};
-
-/**
- * Determine which SSE transform stream to use based on provider/format.
- */
-function buildTransformStream({ provider, sourceFormat, targetFormat, userAgent, reqLogger, toolNameMap, model, connectionId, body, onStreamComplete, apiKey }) {
-  const isDroidCLI = userAgent?.toLowerCase().includes("droid") || userAgent?.toLowerCase().includes("codex-cli");
-  const needsCodexTranslation = provider === "codex" && targetFormat === FORMATS.OPENAI_RESPONSES && !isDroidCLI;
-
-  if (needsCodexTranslation) {
-    // Codex returns Responses API SSE → translate to client format
-    let codexTarget;
-    if (sourceFormat === FORMATS.OPENAI_RESPONSES) codexTarget = FORMATS.OPENAI_RESPONSES;
-    else if (sourceFormat === FORMATS.CLAUDE) codexTarget = FORMATS.CLAUDE;
-    else if (sourceFormat === FORMATS.ANTIGRAVITY || sourceFormat === FORMATS.GEMINI || sourceFormat === FORMATS.GEMINI_CLI) codexTarget = FORMATS.ANTIGRAVITY;
-    else codexTarget = FORMATS.OPENAI;
-    return createSSETransformStreamWithLogger(FORMATS.OPENAI_RESPONSES, codexTarget, provider, reqLogger, toolNameMap, model, connectionId, body, onStreamComplete, apiKey);
-  }
-
-  if (needsTranslation(targetFormat, sourceFormat)) {
-    return createSSETransformStreamWithLogger(targetFormat, sourceFormat, provider, reqLogger, toolNameMap, model, connectionId, body, onStreamComplete, apiKey);
-  }
-
-  return createPassthroughStreamWithLogger(provider, reqLogger, model, connectionId, body, onStreamComplete, apiKey);
-}
-
-/**
- * Handle streaming response — pipe provider SSE through transform stream to client.
- */
-export function handleStreamingResponse({ providerResponse, provider, model, sourceFormat, targetFormat, userAgent, body, stream, translatedBody, finalBody, requestStartTime, connectionId, apiKey, clientRawRequest, onRequestSuccess, onStreamFailure, reqLogger, toolNameMap, streamController, onStreamComplete, streamDetailId }) {
-  let outcomeReported = false;
-  const runCallback = (callback, value, label) => {
-    if (typeof callback !== "function") return;
-    Promise.resolve()
-      .then(() => callback(value))
-      .catch((error) => {
-        console.error(`[ChatCore] Streaming ${label} callback failed:`, error?.message || error);
-      });
-  };
-
-  const handleComplete = (content, usage, ttftAt, outcome = {}) => {
-    if (!outcomeReported) {
-      outcomeReported = true;
-      if (outcome.failed) runCallback(onStreamFailure, outcome.error, "failure");
-      else runCallback(onRequestSuccess, undefined, "success");
-    }
-    onStreamComplete?.(content, usage, ttftAt, outcome);
-  };
-
-  const transformStream = buildTransformStream({ provider, sourceFormat, targetFormat, userAgent, reqLogger, toolNameMap, model, connectionId, body, onStreamComplete: handleComplete, apiKey });
-
-  // Any Responses client needs a structured terminal if translation or
-  // passthrough aborts before response.completed/failed/incomplete.
-  const onAbortTerminal = sourceFormat === FORMATS.OPENAI_RESPONSES
-    ? createAbortedResponsesTerminalHandler()
-    : null;
-  const transformedBody = pipeWithDisconnect(providerResponse, transformStream, streamController, onAbortTerminal);
-
-  saveRequestDetail(buildRequestDetail({
-    provider, model, connectionId,
-    latency: { ttft: 0, total: Date.now() - requestStartTime },
-    tokens: { prompt_tokens: 0, completion_tokens: 0 },
-    request: extractRequestConfig(body, stream),
-    providerRequest: finalBody || translatedBody || null,
-    providerResponse: "[Streaming - raw response not captured]",
-    response: { content: "[Streaming in progress...]", thinking: null, type: "streaming" },
-    status: "pending"
-  }, { id: streamDetailId })).catch(err => {
-    console.error("[RequestDetail] Failed to save streaming request:", err.message);
-  });
-
-  return {
-    success: true,
-    response: new Response(transformedBody, { headers: SSE_HEADERS })
-  };
-}
-
-/**
- * Build onStreamComplete callback for streaming usage tracking.
- */
-export function buildOnStreamComplete({ provider, model, connectionId, apiKey, requestStartTime, body, stream, finalBody, translatedBody, clientRawRequest }) {
-  const streamDetailId = `${Date.now()}-${Math.random().toString(36).slice(2, 11)}`;
-
-  const onStreamComplete = (contentObj, usage, ttftAt, outcome = {}) => {
-    const latency = {
-      ttft: ttftAt ? ttftAt - requestStartTime : Date.now() - requestStartTime,
-      total: Date.now() - requestStartTime
-    };
-    const safeContent = contentObj?.content || "[Empty streaming response]";
-    const safeThinking = contentObj?.thinking || null;
-
-    const failed = outcome.failed === true;
-    saveRequestDetail(buildRequestDetail({
-      provider, model, connectionId,
-      latency,
-      tokens: usage || { prompt_tokens: 0, completion_tokens: 0 },
-      request: extractRequestConfig(body, stream),
-      providerRequest: finalBody || translatedBody || null,
-      providerResponse: safeContent,
-      response: failed
-        ? { error: outcome.error?.message || "Provider stream failed", status: outcome.error?.status || 502, content: safeContent, thinking: safeThinking, type: "streaming" }
-        : { content: safeContent, thinking: safeThinking, type: "streaming" },
-      status: failed ? "error" : "success"
-    }, { id: streamDetailId })).catch(err => {
-      console.error("[RequestDetail] Failed to update streaming content:", err.message);
-    });
-
-    saveUsageStats({ provider, model, tokens: usage, connectionId, apiKey, endpoint: clientRawRequest?.endpoint, latency, label: "STREAM USAGE" });
-  };
-
-  return { onStreamComplete, streamDetailId };
-}