zevairouter 1.0.152 → 1.0.154

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

@@ -30,6 +30,314 @@ function pickAssistantMessageForChatCompletion(output) {
   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.
@@ -45,10 +353,11 @@ export function parseSSEToOpenAIResponse(rawSSE, fallbackModel) {
     if (!payload) continue;
     if (payload === "[DONE]") {
       terminated = true;
-      continue;
+      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;
   }
@@ -61,14 +370,16 @@ export function parseSSEToOpenAIResponse(rawSSE, fallbackModel) {
   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);
-    if (choice?.finish_reason) finishReason = choice.finish_reason;
-    if (chunk?.usage && typeof chunk.usage === "object") usage = chunk.usage;
 
     // Accumulate tool_calls from streaming deltas
     if (Array.isArray(delta.tool_calls)) {
@@ -83,6 +394,11 @@ export function parseSSEToOpenAIResponse(rawSSE, fallbackModel) {
         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 : "") };
@@ -106,7 +422,7 @@ export function parseSSEToOpenAIResponse(rawSSE, fallbackModel) {
  * 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, provider, model, body, stream, translatedBody, finalBody, requestStartTime, connectionId, apiKey, clientRawRequest, onRequestSuccess, trackDone, appendLog }) {
+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
@@ -120,11 +436,19 @@ export async function handleForcedSSEToJson({ providerResponse, sourceFormat, pr
   };
 
   // Codex/Responses API SSE path
-  const isCodexResponsesApi = provider === "codex" || sourceFormat === FORMATS.OPENAI_RESPONSES;
+  const isCodexResponsesApi = targetFormat === FORMATS.OPENAI_RESPONSES;
   if (isCodexResponsesApi) {
     try {
       const jsonResponse = await convertResponsesStreamToJson(providerResponse.body);
-      if (onRequestSuccess) await onRequestSuccess();
+      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" });
@@ -133,7 +457,7 @@ export async function handleForcedSSEToJson({ providerResponse, sourceFormat, pr
         latency: { ttft: 0, total: Date.now() - requestStartTime },
       });
 
-      const { msgItem, textContent } = pickAssistantMessageForChatCompletion(jsonResponse.output);
+      const { textContent } = pickAssistantMessageForChatCompletion(jsonResponse.output);
       const totalLatency = Date.now() - requestStartTime;
 
       saveRequestDetail(buildRequestDetail({
@@ -144,51 +468,16 @@ export async function handleForcedSSEToJson({ providerResponse, sourceFormat, pr
         status: "success"
       }, { endpoint: clientRawRequest?.endpoint || null })).catch(() => {});
 
-      // Client is Responses API → return as-is
-      if (sourceFormat === FORMATS.OPENAI_RESPONSES) {
+      // 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": "*" } }) };
       }
 
-      // Build client-format response
-      const inTokens = usage.input_tokens || 0;
-      const outTokens = usage.output_tokens || 0;
-      let finalResp;
-
-      // Extract tool calls from Responses API output (function_call items)
-      const funcCallItems = (jsonResponse.output || []).filter(item => item.type === "function_call");
-      const toolCalls = funcCallItems.map((item, idx) => ({
-        id: item.call_id || `call_${item.name}_${Date.now()}_${idx}`,
-        type: "function",
-        function: {
-          name: item.name,
-          arguments: typeof item.arguments === "string" ? item.arguments : JSON.stringify(item.arguments || {})
-        }
-      }));
-      const hasToolCalls = toolCalls.length > 0;
-
-      if (sourceFormat === FORMATS.ANTIGRAVITY || sourceFormat === FORMATS.GEMINI || sourceFormat === FORMATS.GEMINI_CLI) {
-        finalResp = {
-          response: {
-            candidates: [{ content: { role: "model", parts: [{ text: textContent || "" }] }, finishReason: "STOP", index: 0 }],
-            usageMetadata: { promptTokenCount: inTokens, candidatesTokenCount: outTokens, totalTokenCount: inTokens + outTokens },
-            modelVersion: model,
-            responseId: jsonResponse.id || `resp_${Date.now()}`
-          }
-        };
-      } else {
-        const message = { role: "assistant", content: textContent || (hasToolCalls ? null : "") };
-        if (hasToolCalls) message.tool_calls = toolCalls;
-        const responseDone = jsonResponse.status === "completed" || jsonResponse.status === "done";
-        const finishReason = hasToolCalls ? "tool_calls" : (responseDone ? "stop" : (jsonResponse.status || "stop"));
-        finalResp = {
-          id: jsonResponse.id || `chatcmpl-${Date.now()}`,
-          object: "chat.completion",
-          created: jsonResponse.created_at || Math.floor(Date.now() / 1000),
-          model: jsonResponse.model || model,
-          choices: [{ index: 0, message, finish_reason: finishReason }],
-          usage: { prompt_tokens: inTokens, completion_tokens: outTokens, total_tokens: inTokens + outTokens }
-        };
-      }
+      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) {
@@ -201,9 +490,14 @@ export async function handleForcedSSEToJson({ providerResponse, sourceFormat, pr
   try {
     const sseText = await providerResponse.text();
     const parsed = parseSSEToOpenAIResponse(sseText, model);
-    if (!parsed) return createErrorResult(HTTP_STATUS.BAD_GATEWAY, "Invalid SSE response for non-streaming request");
+    if (!parsed || parsed.error) {
+      return createErrorResult(
+        HTTP_STATUS.BAD_GATEWAY,
+        parsed?.error?.message || "Invalid SSE response for non-streaming request"
+      );
+    }
 
-    if (onRequestSuccess) await onRequestSuccess();
+    await notifyRequestSuccess(onRequestSuccess);
 
     const usage = parsed.usage || {};
     appendLog({ tokens: usage, status: "200 OK" });
@@ -229,7 +523,7 @@ export async function handleForcedSSEToJson({ providerResponse, sourceFormat, pr
     // 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 (parsed?.choices) {
+    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;
@@ -237,7 +531,8 @@ export async function handleForcedSSEToJson({ providerResponse, sourceFormat, pr
       }
     }
 
-    return { success: true, response: new Response(JSON.stringify(parsed), { headers: { "Content-Type": "application/json", "Access-Control-Allow-Origin": "*" } }) };
+    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

@@ -2,7 +2,7 @@ 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 { buildAbortedResponsesTerminalBytes } from "../../utils/responsesStreamHelpers.js";
+import { createAbortedResponsesTerminalHandler } from "../../utils/responsesStreamHelpers.js";
 import { buildRequestDetail, extractRequestConfig, saveUsageStats } from "./requestDetail.js";
 import { saveRequestDetail } from "@/lib/usageDb.js";
 
@@ -40,14 +40,33 @@ function buildTransformStream({ provider, sourceFormat, targetFormat, userAgent,
 /**
  * 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, reqLogger, toolNameMap, streamController, onStreamComplete, streamDetailId }) {
-  if (onRequestSuccess) onRequestSuccess();
+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, apiKey });
+  const transformStream = buildTransformStream({ provider, sourceFormat, targetFormat, userAgent, reqLogger, toolNameMap, model, connectionId, body, onStreamComplete: handleComplete, apiKey });
 
-  // Responses passthrough: synthesize response.failed + [DONE] if the stream aborts/stalls before a terminal event
-  const isResponsesPassthrough = sourceFormat === FORMATS.OPENAI_RESPONSES && targetFormat === FORMATS.OPENAI_RESPONSES;
-  const onAbortTerminal = isResponsesPassthrough ? buildAbortedResponsesTerminalBytes : null;
+  // 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({
@@ -58,7 +77,7 @@ export function handleStreamingResponse({ providerResponse, provider, model, sou
     providerRequest: finalBody || translatedBody || null,
     providerResponse: "[Streaming - raw response not captured]",
     response: { content: "[Streaming in progress...]", thinking: null, type: "streaming" },
-    status: "success"
+    status: "pending"
   }, { id: streamDetailId })).catch(err => {
     console.error("[RequestDetail] Failed to save streaming request:", err.message);
   });
@@ -75,7 +94,7 @@ export function handleStreamingResponse({ providerResponse, provider, model, sou
 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) => {
+  const onStreamComplete = (contentObj, usage, ttftAt, outcome = {}) => {
     const latency = {
       ttft: ttftAt ? ttftAt - requestStartTime : Date.now() - requestStartTime,
       total: Date.now() - requestStartTime
@@ -83,6 +102,7 @@ export function buildOnStreamComplete({ provider, model, connectionId, apiKey, r
     const safeContent = contentObj?.content || "[Empty streaming response]";
     const safeThinking = contentObj?.thinking || null;
 
+    const failed = outcome.failed === true;
     saveRequestDetail(buildRequestDetail({
       provider, model, connectionId,
       latency,
@@ -90,8 +110,10 @@ export function buildOnStreamComplete({ provider, model, connectionId, apiKey, r
       request: extractRequestConfig(body, stream),
       providerRequest: finalBody || translatedBody || null,
       providerResponse: safeContent,
-      response: { content: safeContent, thinking: safeThinking, type: "streaming" },
-      status: "success"
+      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);
     });

package/open-sse/handlers/chatCore.js

@@ -34,7 +34,7 @@ import { applyThinkingFromModelAndSettings, stripThinkingSuffix } from "../utils
  * @param {object} options.credentials - Provider credentials
  * @param {string} options.sourceFormatOverride - Override detected source format (e.g. "openai-responses")
  */
-export async function handleChatCore({ body, modelInfo, credentials, log, onCredentialsRefreshed, onRequestSuccess, onDisconnect, clientRawRequest, connectionId, userAgent, apiKey, ccFilterNaming, rtkEnabled, headroomEnabled, headroomUrl, headroomCompressUserMessages, cavemanEnabled, cavemanLevel, contextInjectionEnabled, ponytailEnabled, ponytailLevel, pxpipeEnabled, pxpipeMinChars, pxpipeTimeoutMs, pxpipeTransform, onPxpipeEvent, sourceFormatOverride, providerThinking, signal }) {
+export async function handleChatCore({ body, modelInfo, credentials, log, onCredentialsRefreshed, onRequestSuccess, onStreamFailure, onDisconnect, clientRawRequest, connectionId, userAgent, apiKey, ccFilterNaming, rtkEnabled, headroomEnabled, headroomUrl, headroomCompressUserMessages, cavemanEnabled, cavemanLevel, contextInjectionEnabled, ponytailEnabled, ponytailLevel, pxpipeEnabled, pxpipeMinChars, pxpipeTimeoutMs, pxpipeTransform, onPxpipeEvent, sourceFormatOverride, providerThinking, signal }) {
   const { provider } = modelInfo;
   const requestStartTime = Date.now();
 
@@ -57,9 +57,10 @@ export async function handleChatCore({ body, modelInfo, credentials, log, onCred
   const targetFormat = modelTargetFormat || getTargetFormat(provider);
   const stripList = getModelStrip(alias, model);
   const upstreamModel = stripThinkingSuffix(getModelUpstreamId(alias, model));
+  const executor = getExecutor(provider);
 
   const clientRequestedStreaming = body.stream === true || sourceFormat === FORMATS.ANTIGRAVITY || sourceFormat === FORMATS.GEMINI || sourceFormat === FORMATS.GEMINI_CLI;
-  const providerRequiresStreaming = provider === "openai" || provider === "codex" || provider === "commandcode";
+  const providerRequiresStreaming = requiresStreamingTransport(provider, executor.config);
   let stream = providerRequiresStreaming ? true : (body.stream !== false);
 
   // DeepSeek-TUI: interactive TUI panel sends stream:true and needs SSE.
@@ -198,7 +199,6 @@ export async function handleChatCore({ body, modelInfo, credentials, log, onCred
     }
   }
 
-  const executor = getExecutor(provider);
   trackPendingRequest(model, provider, connectionId, true);
   appendRequestLog({ model, provider, connectionId, status: "PENDING" }).catch(() => { });
 
@@ -323,7 +323,15 @@ export async function handleChatCore({ body, modelInfo, credentials, log, onCred
         }
         try {
           const retryResult = await executor.execute({ model, body: translatedBody, stream, credentials, signal: streamController.signal, log, proxyOptions });
-          if (retryResult.response.ok) { providerResponse = retryResult.response; providerUrl = retryResult.url; }
+          if (!retryResult?.response) throw new Error("Token refresh retry returned no response");
+          await cancelResponseBody(providerResponse);
+          providerResponse = retryResult.response;
+          providerUrl = retryResult.url;
+          providerHeaders = retryResult.headers;
+          finalBody = retryResult.transformedBody;
+          if (!providerResponse.ok) {
+            log?.warn?.("TOKEN", `${provider.toUpperCase()} | retry after refresh returned HTTP ${providerResponse.status}`);
+          }
         } catch { log?.warn?.("TOKEN", `${provider.toUpperCase()} | retry after refresh failed`); }
       } else {
         log?.warn?.("TOKEN", `${provider.toUpperCase()} | refresh failed`);
@@ -355,13 +363,13 @@ export async function handleChatCore({ body, modelInfo, credentials, log, onCred
     return createErrorResult(statusCode, errMsg, resetsAtMs);
   }
 
-  const sharedCtx = { provider, model, body, stream, translatedBody, finalBody, requestStartTime, connectionId, apiKey, clientRawRequest, onRequestSuccess };
+  const sharedCtx = { provider, model, body, stream, translatedBody, finalBody, requestStartTime, connectionId, apiKey, clientRawRequest, onRequestSuccess, onStreamFailure };
   const appendLog = (extra) => appendRequestLog({ model, provider, connectionId, ...extra }).catch(() => { });
   const trackDone = () => trackPendingRequest(model, provider, connectionId, false);
 
   // Provider forced streaming but client wants JSON
   if (!clientRequestedStreaming && providerRequiresStreaming) {
-    const result = await handleForcedSSEToJson({ ...sharedCtx, providerResponse, sourceFormat, trackDone, appendLog });
+    const result = await handleForcedSSEToJson({ ...sharedCtx, providerResponse, sourceFormat, targetFormat, trackDone, appendLog });
     if (result) { streamController.handleComplete(); return result; }
   }
 
@@ -381,3 +389,10 @@ export function isTokenExpiringSoon(expiresAt, bufferMs = 5 * 60 * 1000) {
   if (!expiresAt) return false;
   return new Date(expiresAt).getTime() - Date.now() < bufferMs;
 }
+
+export function requiresStreamingTransport(provider, executorConfig = null) {
+  return executorConfig?.forceStream === true ||
+    provider === "openai" ||
+    provider === "codex" ||
+    provider === "commandcode";
+}