n9router 0.4.43 → 0.4.45

package/app/open-sse/utils/claudeCloaking.js

@@ -13,11 +13,18 @@ function generateBillingHeader(payload) {
   return `x-anthropic-billing-header: cc_version=${CLAUDE_VERSION}.${buildHash}; cc_entrypoint=${CC_ENTRYPOINT}; cch=${cch};`;
 }
 
+// Derive a deterministic UUID-v4-shaped string from a seed (stable per account)
+function deriveUuid(seed) {
+  const h = createHash("sha256").update(seed).digest("hex");
+  return `${h.slice(0, 8)}-${h.slice(8, 12)}-4${h.slice(13, 16)}-${((parseInt(h[16], 16) & 0x3) | 0x8).toString(16)}${h.slice(17, 20)}-${h.slice(20, 32)}`;
+}
+
 // Generate fake user ID in Claude Code 2.1.92+ JSON format:
 // {"device_id":"<64hex>","account_uuid":"<uuid>","session_id":"<uuid>"}
-function generateFakeUserID(sessionId) {
-  const deviceId = randomBytes(32).toString("hex");
-  const accountUuid = randomUUID();
+// device_id/account_uuid derive from apiKey (stable per account), session_id per-conversation
+function generateFakeUserID(sessionId, apiKey) {
+  const deviceId = apiKey ? createHash("sha256").update(`device:${apiKey}`).digest("hex") : randomBytes(32).toString("hex");
+  const accountUuid = apiKey ? deriveUuid(`account:${apiKey}`) : randomUUID();
   const sessionUuid = sessionId || randomUUID();
   return `{"device_id":"${deviceId}","account_uuid":"${accountUuid}","session_id":"${sessionUuid}"}`;
 }
@@ -35,13 +42,19 @@ export function cloakClaudeTools(body) {
   const tools = body.tools;
   if (!tools || tools.length === 0) return { body, toolNameMap: null };
 
+  const suffix = (name) => `${name}${CLAUDE_TOOL_SUFFIX}`;
   const toolNameMap = new Map();
+  const clientToolNames = new Set();
   const clientDeclarations = [];
 
-  // All client tools get renamed with suffix
+  // All client tools get renamed with suffix.
+  // Built-in server tools (web_search_20250305, etc.) carry a `type` and require
+  // an exact reserved `name` — never suffix those or Claude rejects the request.
   for (const tool of tools) {
-    const suffixed = `${tool.name}${CLAUDE_TOOL_SUFFIX}`;
+    if (tool.type) { clientDeclarations.push(tool); continue; }
+    const suffixed = suffix(tool.name);
     toolNameMap.set(suffixed, tool.name);
+    clientToolNames.add(tool.name);
     clientDeclarations.push({ ...tool, name: suffixed });
   }
 
@@ -51,17 +64,27 @@ export function cloakClaudeTools(body) {
   // Rename tool_use in message history (all client tools get suffix)
   const renamedMessages = body.messages?.map(msg => {
     if (!Array.isArray(msg.content)) return msg;
-    const renamedContent = msg.content.map(block => {
-      if (block.type === "tool_use") {
-        return { ...block, name: `${block.name}${CLAUDE_TOOL_SUFFIX}` };
-      }
-      return block;
-    });
+    const renamedContent = msg.content.map(block =>
+      block.type === "tool_use" ? { ...block, name: suffix(block.name) } : block
+    );
     return { ...msg, content: renamedContent };
   });
 
+  const cloakedBody = { ...body, tools: allTools, messages: renamedMessages || body.messages };
+
+  // A forced tool_choice ({ type: "tool", name }) must point at the suffixed
+  // tool name, otherwise Claude rejects it: "Tool '<name>' not found in provided tools".
+  // Only rewrite when the choice targets one of the client tools we actually
+  // renamed — never a decoy/built-in name (those are sent unsuffixed).
+  if (
+    body.tool_choice?.type === "tool" &&
+    clientToolNames.has(body.tool_choice.name)
+  ) {
+    cloakedBody.tool_choice = { ...body.tool_choice, name: suffix(body.tool_choice.name) };
+  }
+
   return {
-    body: { ...body, tools: allTools, messages: renamedMessages || body.messages },
+    body: cloakedBody,
     toolNameMap: toolNameMap.size > 0 ? toolNameMap : null
   };
 }
@@ -135,7 +158,7 @@ export function applyCloaking(body, apiKey, sessionId) {
   // Inject fake user ID into metadata (session_id must match X-Claude-Code-Session-Id)
   const existingUserId = result.metadata?.user_id;
   if (!existingUserId) {
-    result.metadata = { ...result.metadata, user_id: generateFakeUserID(sessionId) };
+    result.metadata = { ...result.metadata, user_id: generateFakeUserID(sessionId, apiKey) };
   }
 
   return result;

package/app/open-sse/utils/claudeSignature.js

@@ -0,0 +1,41 @@
+// Claude thinking signature validation (ported from CLIProxyAPI internal/signature).
+// E-form: single-layer base64, decoded[0] == 0x12 (Claude marker).
+// R-form: double-layer base64, outer decoded[0] == 'E', inner decoded[0] == 0x12.
+// Cache prefix "...#sig" stripped before validation.
+
+const MAX_CLAUDE_SIGNATURE_LEN = 32 * 1024 * 1024;
+const CLAUDE_SIGNATURE_MARKER = 0x12;
+
+function stripCachePrefix(rawSignature) {
+  const sig = (rawSignature || "").trim();
+  if (!sig) return "";
+  const idx = sig.indexOf("#");
+  return idx >= 0 ? sig.slice(idx + 1).trim() : sig;
+}
+
+export function hasClaudeSignaturePrefix(rawSignature) {
+  const sig = stripCachePrefix(rawSignature);
+  return sig.length > 0 && (sig[0] === "E" || sig[0] === "R");
+}
+
+// Strict-ish: validates base64 layers + Claude marker byte.
+export function isValidClaudeSignature(rawSignature) {
+  const sig = stripCachePrefix(rawSignature);
+  if (!sig || sig.length > MAX_CLAUDE_SIGNATURE_LEN) return false;
+
+  try {
+    if (sig[0] === "E") {
+      const decoded = Buffer.from(sig, "base64");
+      return decoded.length > 0 && decoded[0] === CLAUDE_SIGNATURE_MARKER;
+    }
+    if (sig[0] === "R") {
+      const outer = Buffer.from(sig, "base64");
+      if (!outer.length || outer[0] !== 0x45) return false; // 'E'
+      const inner = Buffer.from(outer.toString(), "base64");
+      return inner.length > 0 && inner[0] === CLAUDE_SIGNATURE_MARKER;
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}

package/app/open-sse/utils/reasoningContentInjector.js

@@ -1,13 +1,12 @@
-// Some thinking-mode providers (DeepSeek, Kimi, ...) require reasoning_content
+// Some thinking-mode providers (DeepSeek, Kimi, MiniMax, ...) require reasoning_content
 // to be echoed back on assistant messages. Clients in OpenAI format don't send it,
 // so we inject a non-empty placeholder to satisfy upstream validation.
+import { PROVIDERS } from "../config/providers.js";
 
 const PLACEHOLDER = " ";
 
-// Provider-level rules: keyed by executor.provider
-const PROVIDER_RULES = {
-  deepseek: { scope: "all" }
-};
+// Provider-level rules derive from registry transport.reasoningInject (single source)
+const providerRuleFor = (provider) => PROVIDERS[provider]?.reasoningInject;
 
 // Model-level rules: matched by predicate against model id
 const MODEL_RULES = [
@@ -69,7 +68,7 @@ function applyDeepSeekV4ProAlias({ provider, model, body }) {
 }
 
 export function injectReasoningContent({ provider, model, body }) {
-  const providerRule = PROVIDER_RULES[provider];
+  const providerRule = providerRuleFor(provider);
   const modelRule = MODEL_RULES.find(r => r.match(model));
   const rule = providerRule || modelRule;
   const nextBody = applyDeepSeekV4ProAlias({ provider, model, body });

package/app/open-sse/utils/responsesStreamHelpers.js

@@ -0,0 +1,50 @@
+// Helpers for OpenAI Responses API streaming termination + event framing
+import { FORMATS } from "../translator/formats.js";
+import { formatSSE } from "./streamHelpers.js";
+
+// Responses API events that signal the stream has reached a terminal state
+const OPENAI_RESPONSES_TERMINAL_EVENTS = new Set([
+  "response.completed",
+  "response.done",
+  "response.failed",
+  "error"
+]);
+
+export function getOpenAIResponsesEventName(eventName, chunk) {
+  if (eventName) return eventName;
+  if (chunk && typeof chunk.type === "string") return chunk.type;
+  return null;
+}
+
+export function isOpenAIResponsesTerminalEvent(eventName, chunk) {
+  const type = getOpenAIResponsesEventName(eventName, chunk);
+  if (OPENAI_RESPONSES_TERMINAL_EVENTS.has(type)) return true;
+  const status = chunk?.response?.status;
+  return status === "completed" || status === "failed";
+}
+
+const sharedEncoder = new TextEncoder();
+
+// Encoded response.failed + [DONE] payload for aborted/stalled Responses passthrough streams
+export function buildAbortedResponsesTerminalBytes() {
+  return sharedEncoder.encode(`${formatIncompleteOpenAIResponsesStreamFailure()}data: [DONE]\n\n`);
+}
+
+// Synthesize a response.failed event for streams that close without a terminal event
+export function formatIncompleteOpenAIResponsesStreamFailure() {
+  return formatSSE({
+    event: "response.failed",
+    data: {
+      type: "response.failed",
+      response: {
+        id: `resp_${Date.now()}`,
+        status: "failed",
+        error: {
+          type: "stream_error",
+          code: "stream_disconnected",
+          message: "stream closed before response.completed"
+        }
+      }
+    }
+  }, FORMATS.OPENAI_RESPONSES);
+}

package/app/open-sse/utils/sessionManager.js

@@ -79,4 +79,153 @@ export function generateBinaryStyleId() {
  */
 export function clearSessionStore() {
     runtimeSessionStore.clear();
+    assistantSessionStore.clear();
 }
+
+// Conversation-stable session store: Key = hash(scope+assistant text), Value = { sessionId, lastUsed }
+const assistantSessionStore = new Map();
+const ASSISTANT_MIN_LEN = 50;
+const ASSISTANT_CAP_LEN = 50;
+const MAX_ASSISTANT_SESSIONS = 5000;
+
+// Client headers/body fields that carry an upstream session id (priority order)
+const SESSION_HEADER_KEYS = ["x-session-id", "session-id", "session_id", "x-amp-thread-id", "x-client-request-id"];
+const CLAUDE_CODE_SESSION_RE = /_session_([a-f0-9-]+)$/;
+
+function sha16(text) {
+    return crypto.createHash("sha256").update(text).digest("hex").slice(0, 16);
+}
+
+// Normalize a session id candidate (trim, length cap)
+function normalizeSessionId(value) {
+    if (typeof value !== "string") return null;
+    const v = value.trim();
+    if (!v || v.length > 256) return null;
+    return v;
+}
+
+// Extract Claude Code session id from metadata.user_id (_session_{uuid} | JSON {session_id})
+function extractClaudeCodeSession(userId) {
+    if (typeof userId !== "string" || !userId) return null;
+    const m = userId.match(CLAUDE_CODE_SESSION_RE);
+    if (m) return m[1];
+    if (userId[0] === "{") {
+        try { return normalizeSessionId(JSON.parse(userId)?.session_id); } catch { /* noop */ }
+    }
+    return null;
+}
+
+// Lowercase-key lookup for raw client headers
+function headerValue(headers, key) {
+    if (!headers || typeof headers !== "object") return null;
+    return normalizeSessionId(headers[key] ?? headers[key.toLowerCase()]);
+}
+
+// Read client-provided session id from headers/body (no generation)
+// Antigravity envelope carries session in request.sessionId; requestId embeds conversation uuid
+const ANTIGRAVITY_CONV_RE = /^[a-z]+\/([0-9a-f-]{36})\//i;
+function extractAntigravitySession(body) {
+    const sid = body?.request?.sessionId;
+    if (sid != null && sid !== "") return normalizeSessionId(String(sid));
+    const m = typeof body?.requestId === "string" ? body.requestId.match(ANTIGRAVITY_CONV_RE) : null;
+    return m ? normalizeSessionId(m[1]) : null;
+}
+
+function extractClientSessionId(headers, body) {
+    const claude = extractClaudeCodeSession(body?.metadata?.user_id);
+    if (claude) return `claude:${claude}`;
+    const antigravity = extractAntigravitySession(body);
+    if (antigravity) return `antigravity:${antigravity}`;
+    for (const key of SESSION_HEADER_KEYS) {
+        const v = headerValue(headers, key);
+        if (v) return v;
+    }
+    const fromBody =
+        normalizeSessionId(body?.prompt_cache_key) ||
+        normalizeSessionId(body?.session_id) ||
+        normalizeSessionId(body?.conversation_id) ||
+        normalizeSessionId(body?.metadata?.user_id);
+    return fromBody || null;
+}
+
+// Accumulate assistant text from OpenAI/Responses-style input/messages (cap-limited)
+function accumulateAssistantText(body) {
+    const items = Array.isArray(body?.input) ? body.input
+        : Array.isArray(body?.messages) ? body.messages : null;
+    if (!items) return "";
+    let text = "";
+    for (const item of items) {
+        if (item?.role !== "assistant") continue;
+        if (typeof item.content === "string") text += item.content;
+        else if (Array.isArray(item.content)) {
+            for (const c of item.content) text += c?.text || c?.output || "";
+        }
+        if (text.length >= ASSISTANT_CAP_LEN) break;
+    }
+    return text;
+}
+
+// Stable session id keyed on accumulated assistant text (avoids collision on identical first user prompt)
+function assistantTextSessionId(scope, body) {
+    const text = accumulateAssistantText(body);
+    if (text.length < ASSISTANT_MIN_LEN) return null;
+    const hash = sha16(`${scope}:${text.slice(0, ASSISTANT_CAP_LEN)}`);
+    const existing = assistantSessionStore.get(hash);
+    if (existing) {
+        existing.lastUsed = Date.now();
+        return existing.sessionId;
+    }
+    if (assistantSessionStore.size >= MAX_ASSISTANT_SESSIONS) {
+        assistantSessionStore.delete(assistantSessionStore.keys().next().value);
+    }
+    const sessionId = generateBinaryStyleId();
+    assistantSessionStore.set(hash, { sessionId, lastUsed: Date.now() });
+    return sessionId;
+}
+
+/**
+ * Resolve a conversation-stable session id (generalizes Codex resolveCacheSessionId).
+ * Priority: client session → accumulated-assistant-text hash → workspaceId → per-connection.
+ *
+ * @param {object} opts
+ * @param {object} [opts.headers] - Raw client request headers (lowercase keys)
+ * @param {object} [opts.body] - Parsed request body
+ * @param {string} [opts.connectionId] - Connection identifier (fallback scope)
+ * @param {string} [opts.workspaceId] - Provider workspace id (account-wide fallback)
+ * @param {string} [opts.scope] - Provider scope to isolate cache keys across providers
+ * @returns {string} A stable session id
+ */
+export function resolveSessionId({ headers, body, connectionId, workspaceId, scope = "" } = {}) {
+    const client = extractClientSessionId(headers, body);
+    if (client) return client;
+    const fromAssistant = assistantTextSessionId(`${scope}:${connectionId || ""}`, body);
+    if (fromAssistant) return fromAssistant;
+    const ws = normalizeSessionId(workspaceId);
+    if (ws) return ws;
+    return deriveSessionId(connectionId);
+}
+
+// Capture session id from request body + credentials (envelope still intact here)
+export function captureSessionId(body, credentials, connectionId, scope = "") {
+    return resolveSessionId({ headers: credentials?.rawHeaders, body, connectionId, scope });
+}
+
+// Convert any session id to Antigravity numeric format "-<int64>" (matches real AG / CLIProxyAPI).
+// Already-numeric ids (native AG sessionId) pass through unchanged.
+export function toNumericSessionId(sessionId) {
+    const v = normalizeSessionId(sessionId);
+    if (!v) return null;
+    if (/^-?\d+$/.test(v)) return v;
+    const h = crypto.createHash("sha256").update(v).digest();
+    const n = h.readBigUInt64BE(0) & 0x7fffffffffffffffn;
+    return `-${n.toString()}`;
+}
+
+// Cleanup expired assistant-session entries
+const assistantCleanup = setInterval(() => {
+    const now = Date.now();
+    for (const [key, entry] of assistantSessionStore) {
+        if (now - entry.lastUsed > MEMORY_CONFIG.sessionTtlMs) assistantSessionStore.delete(key);
+    }
+}, MEMORY_CONFIG.sessionCleanupIntervalMs);
+if (assistantCleanup.unref) assistantCleanup.unref();

package/app/open-sse/utils/sse.js

@@ -0,0 +1,14 @@
+export function sseChunk(data) {
+  return `data: ${JSON.stringify(data)}\n\n`;
+}
+
+// Build OpenAI chat.completion.chunk SSE frame. Key order: id, object, created, model, choices.
+export function chatChunkSse({ id, created, model, delta, finishReason = null }) {
+  return sseChunk({
+    id,
+    object: "chat.completion.chunk",
+    created,
+    model,
+    choices: [{ index: 0, delta, finish_reason: finishReason }],
+  });
+}

package/app/open-sse/utils/sseConstants.js

@@ -0,0 +1,23 @@
+// Shared SSE primitives (no imports → safe for executors + stream.js)
+export const SSE_DONE = "data: [DONE]\n\n";
+
+export const SSE_HEADERS = {
+  "Content-Type": "text/event-stream",
+  "Cache-Control": "no-cache",
+  "Connection": "keep-alive"
+};
+
+// Variant for web-cookie executors behind nginx (disable proxy buffering)
+export const SSE_HEADERS_NO_BUFFER = {
+  "Content-Type": "text/event-stream",
+  "Cache-Control": "no-cache",
+  "X-Accel-Buffering": "no"
+};
+
+// Variant for client-facing SSE responses (adds permissive CORS)
+export const SSE_HEADERS_CORS = {
+  "Content-Type": "text/event-stream",
+  "Cache-Control": "no-cache",
+  "Connection": "keep-alive",
+  "Access-Control-Allow-Origin": "*"
+};

package/app/open-sse/utils/stream.js

@@ -1,11 +1,15 @@
 import { translateResponse, initState } from "../translator/index.js";
 import { FORMATS } from "../translator/formats.js";
 import { trackPendingRequest, appendRequestLog } from "@/lib/usageDb.js";
-import { extractUsage, hasValidUsage, estimateUsage, logUsage, addBufferToUsage, filterUsageForFormat, COLORS } from "./usageTracking.js";
+import { extractUsage, mergeUsage, hasValidUsage, estimateUsage, logUsage, addBufferToUsage, filterUsageForFormat, COLORS } from "./usageTracking.js";
 import { parseSSELine, hasValuableContent, fixInvalidId, formatSSE } from "./streamHelpers.js";
+import { getOpenAIResponsesEventName, isOpenAIResponsesTerminalEvent, formatIncompleteOpenAIResponsesStreamFailure } from "./responsesStreamHelpers.js";
 import { dbg, isDebugEnabled } from "./debugLog.js";
 
+import { SSE_DONE, SSE_HEADERS, SSE_HEADERS_NO_BUFFER } from "./sseConstants.js";
+
 export { COLORS, formatSSE };
+export { SSE_DONE, SSE_HEADERS, SSE_HEADERS_NO_BUFFER };
 
 // sharedEncoder is stateless — safe to share across streams
 const sharedEncoder = new TextEncoder();
@@ -63,6 +67,12 @@ export function createSSEStream(options = {}) {
   let sseEmittedCount = 0;
   const eventTypeCounts = {};
 
+  // Track Responses API event framing for same-format passthrough (codex)
+  let currentOpenAIResponsesEvent = null;
+  let openAIResponsesTerminalSeen = false;
+  let openAIResponsesDoneSent = false;
+  let streamDoneSent = false;  // track duplicate [DONE] across transform + flush
+
   return new TransformStream({
     transform(chunk, controller) {
       if (!ttftAt) ttftAt = Date.now();
@@ -83,6 +93,11 @@ export function createSSEStream(options = {}) {
           }
         }
 
+        // Capture Responses API event name to preserve framing in same-format passthrough
+        if (mode === STREAM_MODE.TRANSLATE && targetFormat === FORMATS.OPENAI_RESPONSES && trimmed.startsWith("event:")) {
+          currentOpenAIResponsesEvent = trimmed.slice(6).trim();
+        }
+
         // Passthrough mode: normalize and forward
         if (mode === STREAM_MODE.PASSTHROUGH) {
           let output;
@@ -115,6 +130,20 @@ export function createSSEStream(options = {}) {
                 }
               }
 
+              // Strip empty tool_calls arrays that break AI SDK reasoning tracking.
+              // Some providers (e.g. CodeBuddy CN) include `"tool_calls": []` in
+              // every streaming delta. @ai-sdk/openai-compatible checks
+              // `delta.tool_calls != null` — an empty array passes this check,
+              // causing premature `reasoning-end` on every chunk.
+              if (parsed?.choices) {
+                for (const choice of parsed.choices) {
+                  if (choice.delta?.tool_calls && Array.isArray(choice.delta.tool_calls) && choice.delta.tool_calls.length === 0) {
+                    delete choice.delta.tool_calls;
+                    fieldsInjected = true;
+                  }
+                }
+              }
+
               if (!hasValuableContent(parsed, FORMATS.OPENAI)) {
                 continue;
               }
@@ -133,16 +162,7 @@ export function createSSEStream(options = {}) {
 
               const extracted = extractUsage(parsed);
               if (extracted) {
-                // Merge instead of overwrite: Claude sends input_tokens in message_start
-                // and output_tokens in message_delta — both must be preserved.
-                usage = usage ? {
-                  prompt_tokens: Math.max(usage.prompt_tokens || 0, extracted.prompt_tokens || 0),
-                  completion_tokens: Math.max(usage.completion_tokens || 0, extracted.completion_tokens || 0),
-                  cache_read_input_tokens: extracted.cache_read_input_tokens ?? usage.cache_read_input_tokens,
-                  cache_creation_input_tokens: extracted.cache_creation_input_tokens ?? usage.cache_creation_input_tokens,
-                  cached_tokens: extracted.cached_tokens ?? usage.cached_tokens,
-                  reasoning_tokens: extracted.reasoning_tokens ?? usage.reasoning_tokens
-                } : extracted;
+                usage = mergeUsage(usage, extracted);
               }
 
               const isFinishChunk = parsed.choices?.[0]?.finish_reason;
@@ -161,7 +181,12 @@ export function createSSEStream(options = {}) {
                 output = `data: ${JSON.stringify(parsed)}\n`;
                 injectedUsage = true;
               }
-            } catch { }
+            } catch {
+              // Skip non-JSON data lines silently — don't forward garbage to clients.
+              // Upstream providers sometimes return plain-text errors (HTML, rate-limit
+              // messages) in the SSE stream that would break downstream JSON decoders.
+              continue;
+            }
           }
 
           if (!injectedUsage) {
@@ -183,12 +208,36 @@ export function createSSEStream(options = {}) {
         const parsed = parseSSELine(trimmed, targetFormat);
         if (!parsed) continue;
 
+        // Responses API same-format passthrough: preserve event framing + track terminal state
+        const isOpenAIResponsesStream = targetFormat === FORMATS.OPENAI_RESPONSES;
+        const keepsOpenAIResponsesFormat = isOpenAIResponsesStream && sourceFormat === FORMATS.OPENAI_RESPONSES;
+        const openAIResponsesEventName = isOpenAIResponsesStream
+          ? getOpenAIResponsesEventName(currentOpenAIResponsesEvent, parsed)
+          : null;
+
+        if (isOpenAIResponsesStream && isOpenAIResponsesTerminalEvent(openAIResponsesEventName, parsed)) {
+          openAIResponsesTerminalSeen = true;
+        }
+
         // For Ollama: done=true is the final chunk with finish_reason/usage, must translate
         // For other formats: done=true is the [DONE] sentinel, skip
         if (parsed && parsed.done && targetFormat !== FORMATS.OLLAMA) {
-          const output = "data: [DONE]\n\n";
-          reqLogger?.appendConvertedChunk?.(output);
-          controller.enqueue(sharedEncoder.encode(output));
+          // Synthesize response.failed if the Responses stream never sent a terminal event
+          if (keepsOpenAIResponsesFormat && !openAIResponsesTerminalSeen) {
+            const failedOutput = formatIncompleteOpenAIResponsesStreamFailure();
+            reqLogger?.appendConvertedChunk?.(failedOutput);
+            controller.enqueue(sharedEncoder.encode(failedOutput));
+            openAIResponsesTerminalSeen = true;
+            sseEmittedCount++;
+          }
+
+          if (keepsOpenAIResponsesFormat && !streamDoneSent) {
+            const doneOutput = "data: [DONE]\n\n";
+            reqLogger?.appendConvertedChunk?.(doneOutput);
+            controller.enqueue(sharedEncoder.encode(doneOutput));
+          }
+          streamDoneSent = true;
+          if (keepsOpenAIResponsesFormat) openAIResponsesDoneSent = true;
           continue;
         }
 
@@ -202,7 +251,7 @@ export function createSSEStream(options = {}) {
           totalContentLength += parsed.delta.thinking.length;
           accumulatedThinking += parsed.delta.thinking;
         }
-        
+
         // OpenAI format - content
         if (parsed.choices?.[0]?.delta?.content) {
           totalContentLength += parsed.choices[0].delta.content.length;
@@ -214,11 +263,6 @@ export function createSSEStream(options = {}) {
           accumulatedThinking += parsed.choices[0].delta.reasoning_content;
         }
 
-        if (parsed.type === "response.output_text.delta" && typeof parsed.delta === "string") {
-          totalContentLength += parsed.delta.length;
-          accumulatedContent += parsed.delta;
-        }
-
         // Gemini format
         if (parsed.candidates?.[0]?.content?.parts) {
           for (const part of parsed.candidates[0].content.parts) {
@@ -234,20 +278,22 @@ export function createSSEStream(options = {}) {
           }
         }
 
-        // Extract usage (accumulate across events — Claude sends input_tokens in message_start,
-        // output_tokens in message_delta; both must survive to produce correct totals).
+        // Extract usage
         const extracted = extractUsage(parsed);
-        if (extracted) {
-          state.usage = state.usage ? {
-            prompt_tokens: Math.max(state.usage.prompt_tokens || 0, extracted.prompt_tokens || 0),
-            completion_tokens: Math.max(state.usage.completion_tokens || 0, extracted.completion_tokens || 0),
-            cache_read_input_tokens: extracted.cache_read_input_tokens ?? state.usage.cache_read_input_tokens,
-            cache_creation_input_tokens: extracted.cache_creation_input_tokens ?? state.usage.cache_creation_input_tokens,
-            cached_tokens: extracted.cached_tokens ?? state.usage.cached_tokens,
-            reasoning_tokens: extracted.reasoning_tokens ?? state.usage.reasoning_tokens
-          } : extracted;
+        if (extracted) state.usage = mergeUsage(state.usage, extracted); // Keep original usage for logging
+
+        // Responses same-format passthrough: re-emit with original event framing
+        if (keepsOpenAIResponsesFormat && openAIResponsesEventName) {
+          const output = formatSSE({ event: openAIResponsesEventName, data: parsed }, sourceFormat);
+          reqLogger?.appendConvertedChunk?.(output);
+          controller.enqueue(sharedEncoder.encode(output));
+          currentOpenAIResponsesEvent = null;
+          sseEmittedCount++;
+          continue;
         }
 
+        currentOpenAIResponsesEvent = null;
+
         // Translate: targetFormat -> openai -> sourceFormat
         const translated = translateResponse(targetFormat, sourceFormat, parsed, state);
 
@@ -261,6 +307,7 @@ export function createSSEStream(options = {}) {
 
         if (translated?.length > 0) {
           for (const item of translated) {
+            if (item === null || item === undefined) continue;
             // Filter empty chunks
             if (!hasValuableContent(item, sourceFormat)) {
               continue; // Skip this empty chunk
@@ -314,14 +361,18 @@ export function createSSEStream(options = {}) {
           } else {
             appendRequestLog({ model, provider, connectionId, tokens: null, status: "200 OK" }).catch(() => { });
           }
-          
+
           // IMPORTANT: In passthrough mode we still must terminate the SSE stream.
           // Some clients (e.g. OpenClaw) expect the OpenAI-style sentinel:
           //   data: [DONE]\n\n
           // Without it they can hang until timeout and trigger failover.
-          const doneOutput = "data: [DONE]\n\n";
-          reqLogger?.appendConvertedChunk?.(doneOutput);
-          controller.enqueue(sharedEncoder.encode(doneOutput));
+          // Gemini-family clients (Antigravity, Vertex, Gemini) reject this sentinel with 400 syntax errors.
+          const isGeminiFamily = provider === "antigravity" || provider === "gemini" || provider === "vertex";
+          if (!streamDoneSent && !isGeminiFamily) {
+            const doneOutput = "data: [DONE]\n\n";
+            reqLogger?.appendConvertedChunk?.(doneOutput);
+            controller.enqueue(sharedEncoder.encode(doneOutput));
+          }
 
           if (onStreamComplete) {
             onStreamComplete({
@@ -346,6 +397,7 @@ export function createSSEStream(options = {}) {
 
             if (translated?.length > 0) {
               for (const item of translated) {
+                if (item === null || item === undefined) continue;
                 const output = formatSSE(item, sourceFormat);
                 reqLogger?.appendConvertedChunk?.(output);
                 controller.enqueue(sharedEncoder.encode(output));
@@ -365,15 +417,29 @@ export function createSSEStream(options = {}) {
 
         if (flushed?.length > 0) {
           for (const item of flushed) {
+            if (item === null || item === undefined) continue;
             const output = formatSSE(item, sourceFormat);
             reqLogger?.appendConvertedChunk?.(output);
             controller.enqueue(sharedEncoder.encode(output));
           }
         }
 
-        const doneOutput = "data: [DONE]\n\n";
-        reqLogger?.appendConvertedChunk?.(doneOutput);
-        controller.enqueue(sharedEncoder.encode(doneOutput));
+        // Synthesize response.failed if a Responses passthrough stream never reached a terminal event
+        const keepsOpenAIResponsesFormat = targetFormat === FORMATS.OPENAI_RESPONSES && sourceFormat === FORMATS.OPENAI_RESPONSES;
+        if (keepsOpenAIResponsesFormat && !openAIResponsesTerminalSeen) {
+          const failedOutput = formatIncompleteOpenAIResponsesStreamFailure();
+          reqLogger?.appendConvertedChunk?.(failedOutput);
+          controller.enqueue(sharedEncoder.encode(failedOutput));
+          openAIResponsesTerminalSeen = true;
+        }
+
+        if (keepsOpenAIResponsesFormat && !openAIResponsesDoneSent && !streamDoneSent) {
+          const doneOutput = "data: [DONE]\n\n";
+          reqLogger?.appendConvertedChunk?.(doneOutput);
+          controller.enqueue(sharedEncoder.encode(doneOutput));
+          openAIResponsesDoneSent = true;
+          streamDoneSent = true;
+        }
 
         if (!hasValidUsage(state?.usage) && totalContentLength > 0) {
           state.usage = estimateUsage(body, totalContentLength, sourceFormat);
@@ -384,7 +450,7 @@ export function createSSEStream(options = {}) {
         } else {
           appendRequestLog({ model, provider, connectionId, tokens: null, status: "200 OK" }).catch(() => { });
         }
-        
+
         if (onStreamComplete) {
           onStreamComplete({
             content: accumulatedContent,