@fudrouter/fsrouter 0.6.62 → 0.6.63

package/open-sse/utils/streamHandler.js

@@ -0,0 +1,250 @@
+// Stream handler with disconnect detection - shared for all providers
+import { STREAM_STALL_TIMEOUT_MS } from "../config/runtimeConfig.js";
+import { dbg, isDebugEnabled } from "./debugLog.js";
+
+// Get HH:MM:SS timestamp
+function getTimeString() {
+  return new Date().toLocaleTimeString("en-US", { hour12: false, hour: "2-digit", minute: "2-digit", second: "2-digit" });
+}
+
+/**
+ * Create stream controller with abort and disconnect detection
+ * @param {object} options
+ * @param {function} options.onDisconnect - Callback when client disconnects
+ * @param {object} options.log - Logger instance
+ * @param {string} options.provider - Provider name
+ * @param {string} options.model - Model name
+ */
+export function createStreamController({ onDisconnect, onError, log, provider, model } = {}) {
+  const abortController = new AbortController();
+  const startTime = Date.now();
+  let disconnected = false;
+  let abortTimeout = null;
+
+  const logStream = (status) => {
+    const duration = Date.now() - startTime;
+    const p = provider?.toUpperCase() || "UNKNOWN";
+    console.log(`[${getTimeString()}] 🌊 [STREAM] ${p} | ${model || "unknown"} | ${duration}ms | ${status}`);
+  };
+
+  return {
+    signal: abortController.signal,
+    startTime,
+
+    isConnected: () => !disconnected,
+
+    // Call when client disconnects
+    handleDisconnect: (reason = "client_closed") => {
+      if (disconnected) return;
+      disconnected = true;
+
+      logStream(`disconnect: ${reason}`);
+      dbg("CTRL", `${provider}/${model} | disconnect=${reason} | dur=${Date.now() - startTime}ms`);
+
+      // Delay abort to allow cleanup
+      abortTimeout = setTimeout(() => {
+        abortController.abort();
+      }, 500);
+
+      onDisconnect?.({ reason, duration: Date.now() - startTime });
+    },
+
+    // Call when stream completes normally
+    handleComplete: () => {
+      if (disconnected) return;
+      disconnected = true;
+
+      logStream("complete");
+
+      if (abortTimeout) {
+        clearTimeout(abortTimeout);
+        abortTimeout = null;
+      }
+    },
+
+    // Call on error
+    handleError: (error) => {
+      if (disconnected) return;
+      disconnected = true;
+
+      if (abortTimeout) {
+        clearTimeout(abortTimeout);
+        abortTimeout = null;
+      }
+
+      if (error.name === "AbortError") {
+        logStream("aborted");
+        return;
+      }
+
+      logStream(`error: ${error.message}`);
+      onError?.(error);
+    },
+
+    abort: () => abortController.abort()
+  };
+}
+
+/**
+ * Create transform stream with disconnect detection
+ * Wraps existing transform stream and adds abort capability.
+ *
+ * Stall detection lives in pipeWithDisconnect (tied to upstream byte
+ * activity), not here — output of the transform stream may be silent
+ * for long periods while raw bytes still flow (e.g. Kiro EventStream
+ * binary frames buffering, Claude reasoning streams).
+ */
+export function createDisconnectAwareStream(transformStream, streamController, onAbortTerminal = null) {
+  const reader = transformStream.readable.getReader();
+  const writer = transformStream.writable.getWriter();
+  let terminalEmitted = false;
+
+  // Emit a synthesized terminal payload (e.g. Responses response.failed + [DONE]) once
+  const emitTerminal = (controller) => {
+    if (terminalEmitted || !onAbortTerminal) return;
+    terminalEmitted = true;
+    try {
+      const bytes = onAbortTerminal();
+      if (bytes) controller.enqueue(bytes);
+    } catch { /* best-effort terminal */ }
+  };
+
+  return new ReadableStream({
+    async pull(controller) {
+      if (!streamController.isConnected()) {
+        emitTerminal(controller);
+        controller.close();
+        return;
+      }
+
+      try {
+        const { done, value } = await reader.read();
+
+        if (done) {
+          streamController.handleComplete();
+          controller.close();
+          return;
+        }
+        controller.enqueue(value);
+      } catch (error) {
+        const wasConnected = streamController.isConnected();
+        streamController.handleError(error);
+        reader.cancel().catch(() => {});
+        writer.abort().catch(() => {});
+
+        // Treat network resets / socket hang up / abort as graceful close
+        const msg = error?.message || "";
+        const code = error?.code || error?.cause?.code || "";
+        const isNetworkClose =
+          error.name === "AbortError" ||
+          msg.includes("aborted") ||
+          msg.includes("socket hang up") ||
+          msg.includes("ECONNRESET") ||
+          msg.includes("ETIMEDOUT") ||
+          msg.includes("EPIPE") ||
+          code === "ECONNRESET" ||
+          code === "ETIMEDOUT" ||
+          code === "EPIPE" ||
+          code === "UND_ERR_SOCKET";
+
+        // Graceful close on network/abort, or when a structured terminal is available
+        // (Responses passthrough prefers response.failed + [DONE] over a raw transport error)
+        try {
+          if (!wasConnected || isNetworkClose || onAbortTerminal) {
+            emitTerminal(controller);
+            controller.close();
+          } else {
+            controller.error(error);
+          }
+        } catch (e) { /* already closed or cancelled */ }
+      }
+    },
+
+    cancel(reason) {
+      streamController.handleDisconnect(reason || "cancelled");
+      reader.cancel();
+      writer.abort();
+    }
+  });
+}
+
+/**
+ * Pipe provider response through transform with disconnect detection.
+ *
+ * Stall watchdog tracks raw upstream byte activity, not transform output.
+ * Reasoning models (Claude thinking via Kiro, etc.) can produce zero SSE
+ * output for long stretches while partial EventStream frames keep arriving.
+ * Measuring stall on the transform output caused false stalls and the
+ * "failed to pipe response" error in Next.
+ *
+ * Any upstream chunk resets the timer. If no bytes arrive for
+ * STREAM_STALL_TIMEOUT_MS, abort the underlying fetch via the controller.
+ *
+ * @param {Response} providerResponse - Response from provider
+ * @param {TransformStream} transformStream - Transform stream for SSE
+ * @param {object} streamController - Stream controller from createStreamController
+ */
+export function pipeWithDisconnect(providerResponse, transformStream, streamController, onAbortTerminal = null) {
+  let stallTimer = null;
+  let chunkCount = 0;
+  let totalBytes = 0;
+  let lastChunkAt = Date.now();
+  const t0 = Date.now();
+  const tag = "STREAM";
+  const clearStall = () => {
+    if (stallTimer) { clearTimeout(stallTimer); stallTimer = null; }
+  };
+  const armStall = () => {
+    clearStall();
+    stallTimer = setTimeout(() => {
+      stallTimer = null;
+      dbg(tag, `STALL TIMEOUT ${STREAM_STALL_TIMEOUT_MS}ms | chunks=${chunkCount} | bytes=${totalBytes} | sinceLast=${Date.now() - lastChunkAt}ms`);
+      streamController.handleError?.(new Error("stream stall timeout"));
+      streamController.abort?.();
+    }, STREAM_STALL_TIMEOUT_MS);
+  };
+
+  // Wrap controller so every termination path clears the stall timer.
+  // Without this, abort/cancel/downstream-error paths leave the timer armed
+  // and a stale abort could fire after the request has already ended.
+  const wrappedController = {
+    signal: streamController.signal,
+    startTime: streamController.startTime,
+    isConnected: () => streamController.isConnected(),
+    handleComplete: () => { dbg(tag, `complete | chunks=${chunkCount} | bytes=${totalBytes} | dur=${Date.now() - t0}ms`); clearStall(); streamController.handleComplete(); },
+    handleError: (e) => { dbg(tag, `error: ${e?.message} | chunks=${chunkCount} | bytes=${totalBytes} | dur=${Date.now() - t0}ms`); clearStall(); streamController.handleError(e); },
+    handleDisconnect: (r) => { dbg(tag, `disconnect: ${r} | chunks=${chunkCount} | bytes=${totalBytes} | dur=${Date.now() - t0}ms`); clearStall(); streamController.handleDisconnect(r); },
+    abort: () => { clearStall(); streamController.abort(); }
+  };
+
+  armStall();
+  dbg(tag, `pipe start | stallTimeout=${STREAM_STALL_TIMEOUT_MS}ms`);
+
+  const upstreamTap = new TransformStream({
+    transform(chunk, controller) {
+      chunkCount++;
+      const sz = chunk?.byteLength || chunk?.length || 0;
+      totalBytes += sz;
+      const now = Date.now();
+      const gap = now - lastChunkAt;
+      lastChunkAt = now;
+      if (isDebugEnabled && (chunkCount <= 5 || chunkCount % 20 === 0 || gap > 5000)) {
+        dbg(tag, `chunk #${chunkCount} | size=${sz}B | gap=${gap}ms | total=${totalBytes}B`);
+      }
+      armStall();
+      controller.enqueue(chunk);
+    },
+    flush() { dbg(tag, `upstream EOF | chunks=${chunkCount} | bytes=${totalBytes} | dur=${Date.now() - t0}ms`); clearStall(); }
+  });
+
+  const transformedBody = providerResponse.body
+    .pipeThrough(upstreamTap)
+    .pipeThrough(transformStream);
+
+  return createDisconnectAwareStream(
+    { readable: transformedBody, writable: { getWriter: () => ({ abort: () => Promise.resolve() }) } },
+    wrappedController,
+    onAbortTerminal
+  );
+}
+

package/open-sse/utils/streamHelpers.js

@@ -0,0 +1,137 @@
+import { FORMATS } from "../translator/formats.js";
+
+// Parse SSE data line
+export function parseSSELine(line, format = null) {
+  if (!line) return null;
+
+  // NDJSON format (Ollama): raw JSON lines without "data:" prefix
+  if (format === FORMATS.OLLAMA) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("{")) {
+      try {
+        return JSON.parse(trimmed);
+      } catch (error) {
+        return null;
+      }
+    }
+    return null;
+  }
+
+  // Handle raw JSON errors disguised as SSE
+  if (line.charCodeAt(0) === 123) { // '{' = 123
+    try {
+      const parsedJson = JSON.parse(line.trim());
+      // Check if it looks like an error payload
+      if (parsedJson && (parsedJson.error || parsedJson.code !== undefined || parsedJson.msg)) {
+        return { _isRawError: true, raw: parsedJson };
+      }
+    } catch (e) {
+      // Ignore parse errors, continue to normal SSE check
+    }
+  }
+
+  // Standard SSE format: "data: {...}"
+  if (line.charCodeAt(0) !== 100) return null; // 'd' = 100
+
+  const data = line.slice(5).trim();
+  if (data === "[DONE]") return { done: true };
+
+  try {
+    return JSON.parse(data);
+  } catch (error) {
+    if (data.length > 0 && data.length < 1000) {
+      console.log(`[WARN] Failed to parse SSE line (${data.length} chars): ${data.substring(0, 100)}...`);
+    }
+    return null;
+  }
+}
+
+// Check if chunk has valuable content (not empty)
+export function hasValuableContent(chunk, format) {
+  // OpenAI format
+  if (format === FORMATS.OPENAI && chunk.choices?.[0]?.delta) {
+    const delta = chunk.choices[0].delta;
+    return !!(delta.content && delta.content !== "" ||
+           delta.reasoning_content && delta.reasoning_content !== "" ||
+           delta.tool_calls && delta.tool_calls.length > 0 ||
+           delta.refusal && delta.refusal !== "" ||
+           chunk.choices[0].finish_reason ||
+           delta.role ||
+           chunk.usage);
+  }
+
+  // Claude format
+  if (format === FORMATS.CLAUDE) {
+    const isContentBlockDelta = chunk.type === "content_block_delta";
+    const hasText = chunk.delta?.text && chunk.delta.text !== "";
+    const hasThinking = chunk.delta?.thinking && chunk.delta.thinking !== "";
+    const hasInputJson = chunk.delta?.partial_json && chunk.delta.partial_json !== "";
+    
+    if (isContentBlockDelta && !hasText && !hasThinking && !hasInputJson) {
+      return false;
+    }
+    return true;
+  }
+
+  return true; // Other formats: keep all chunks
+}
+
+// Fix invalid id (generic or too short)
+export function fixInvalidId(parsed) {
+  if (parsed.id && (parsed.id === "chat" || parsed.id === "completion" || parsed.id.length < 8)) {
+    const fallbackId = parsed.extend_fields?.requestId || 
+                      parsed.extend_fields?.traceId || 
+                      Date.now().toString(36);
+    parsed.id = `chatcmpl-${fallbackId}`;
+    return true;
+  }
+  return false;
+}
+
+function cleanUsagePayload(payload) {
+  if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
+    return payload;
+  }
+
+  let cleaned = payload;
+
+  if ("usage" in cleaned) {
+    if (cleaned.usage === null) {
+      const { usage, ...payloadWithoutUsage } = cleaned;
+      cleaned = payloadWithoutUsage;
+    } else if (typeof cleaned.usage === "object" && cleaned.usage.perf_metrics === null) {
+      const { perf_metrics, ...usageWithoutPerf } = cleaned.usage;
+      cleaned = { ...cleaned, usage: usageWithoutPerf };
+    }
+  }
+
+  if (cleaned.response && typeof cleaned.response === "object" && !Array.isArray(cleaned.response)) {
+    const cleanedResponse = cleanUsagePayload(cleaned.response);
+    if (cleanedResponse !== cleaned.response) {
+      cleaned = { ...cleaned, response: cleanedResponse };
+    }
+  }
+
+  return cleaned;
+}
+
+// Format output as SSE
+export function formatSSE(data, sourceFormat) {
+  if (data === null || data === undefined) return "data: null\n\n";
+  if (data && data.done) return "data: [DONE]\n\n";
+
+  // OpenAI Responses API format
+  if (data && data.event && data.data) {
+    const cleanedEventData = cleanUsagePayload(data.data);
+    return `event: ${data.event}\ndata: ${JSON.stringify(cleanedEventData)}\n\n`;
+  }
+
+  data = cleanUsagePayload(data);
+
+  // Claude format
+  if (sourceFormat === FORMATS.CLAUDE && data && data.type) {
+    return `event: ${data.type}\ndata: ${JSON.stringify(data)}\n\n`;
+  }
+
+  return `data: ${JSON.stringify(data)}\n\n`;
+}

package/open-sse/utils/textualToolCall.js

@@ -0,0 +1,104 @@
+function stripZeroWidth(value) {
+  if (typeof value === "string") {
+    return value.replace(/[\u200B-\u200D\uFEFF]/g, "");
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => stripZeroWidth(item));
+  }
+  if (value && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).map(([key, item]) => [
+        key,
+        stripZeroWidth(item)
+      ])
+    );
+  }
+  return value;
+}
+function isValidToolCallHeaderPrefix(candidate) {
+  if (!candidate.startsWith("[Tool call:")) return false;
+  const bracketIndex = candidate.indexOf("]");
+  if (bracketIndex === -1) {
+    const namePart2 = candidate.slice("[Tool call:".length);
+    if (namePart2.includes("\n") || namePart2.includes("[")) return false;
+    return true;
+  }
+  const namePart = candidate.slice("[Tool call:".length, bracketIndex);
+  if (namePart.includes("\n") || namePart.trim().length === 0) return false;
+  const afterBracket = candidate.slice(bracketIndex + 1);
+  const leadingWhitespaceMatch = afterBracket.match(/^[\s\r\n]*/);
+  const leadingWhitespace = leadingWhitespaceMatch ? leadingWhitespaceMatch[0] : "";
+  const textAfterWhitespace = afterBracket.slice(leadingWhitespace.length);
+  if (textAfterWhitespace.length === 0) {
+    return true;
+  }
+  if (!leadingWhitespace.includes("\n")) {
+    return false;
+  }
+  const expectedText = "Arguments:";
+  if (expectedText.startsWith(textAfterWhitespace)) {
+    return true;
+  }
+  if (textAfterWhitespace.startsWith(expectedText)) {
+    return true;
+  }
+  return false;
+}
+function parseTextualToolCallCandidate(text) {
+  if (typeof text !== "string") return null;
+  const normalized = text.replace(/[\u200B-\u200D\uFEFF]/g, "");
+  const toolCallIndex = normalized.lastIndexOf("[Tool call:");
+  if (toolCallIndex < 0) {
+    const lastParen = normalized.lastIndexOf("(");
+    if (lastParen !== -1 && "(empty)[Tool call:".startsWith(normalized.slice(lastParen))) {
+      return { kind: "partial" };
+    }
+    const lastBracket = normalized.lastIndexOf("[");
+    if (lastBracket !== -1 && "[Tool call:".startsWith(normalized.slice(lastBracket))) {
+      return { kind: "partial" };
+    }
+    return null;
+  }
+  const candidate = normalized.slice(toolCallIndex);
+  if (!isValidToolCallHeaderPrefix(candidate)) {
+    return null;
+  }
+  const headerMatch = candidate.match(/^\[Tool call:\s*([^\]\n]+)\]\s*\nArguments:\s*/);
+  if (!headerMatch) return { kind: "partial" };
+  const name = headerMatch[1]?.trim();
+  const rawArgs = candidate.slice(headerMatch[0].length).trim();
+  if (!name || !rawArgs) return { kind: "partial" };
+  const decoders = [
+    (value) => value,
+    (value) => {
+      if (value.startsWith('"') && value.endsWith('"')) {
+        const decoded = JSON.parse(value);
+        return typeof decoded === "string" ? decoded : value;
+      }
+      return value;
+    }
+  ];
+  for (const decode of decoders) {
+    try {
+      const decoded = decode(rawArgs);
+      const parsed = JSON.parse(decoded);
+      return { kind: "complete", name, args: stripZeroWidth(parsed) };
+    } catch {
+    }
+  }
+  return { kind: "partial" };
+}
+function containsTextualToolCallMarker(text) {
+  if (typeof text !== "string") return false;
+  const normalized = text.replace(/[\u200B-\u200D\uFEFF]/g, "");
+  if (!normalized.includes("[Tool call:")) return false;
+  if (normalized.includes("Arguments:")) return true;
+  const trimmed = normalized.trim();
+  return trimmed.startsWith("[Tool call:") || trimmed.startsWith("(empty)[Tool call:");
+}
+export {
+  containsTextualToolCallMarker,
+  isValidToolCallHeaderPrefix,
+  parseTextualToolCallCandidate,
+  stripZeroWidth
+};

package/open-sse/utils/thinkCloseMarker.js

@@ -0,0 +1,72 @@
+/**
+ * `</think>` close-marker client policy.
+ *
+ * When OmniRoute translates a Claude-native streamed response to OpenAI Chat
+ * Completions shape (`claude-to-openai.ts`), it emits a single `</think>`
+ * close marker as `delta.content` so clients that scan content for the marker
+ * (Claude Code, Cursor) can split reasoning from the final answer — see #4633.
+ *
+ * Some OpenAI-compatible consumers do NOT parse that marker and render it
+ * verbatim, so a bare `</think>` leaks into the visible reply (#5245). OpenCode
+ * is one such client.
+ *
+ * Policy is conservative and opt-OUT by allowlist: the marker stays ON by
+ * default (preserving #4633 for Claude Code / Cursor and any unrecognized
+ * client), and is suppressed ONLY for known clients that render it literally.
+ * Detection is by inbound `User-Agent`.
+ *
+ * Clients that DO render the marker verbatim but are not in the UA allowlist
+ * (e.g. Cursor's reasoning_content-native OpenAI path — #5312 / #5245) can opt
+ * in explicitly with the request header `x-omniroute-thinking-marker: off`,
+ * which suppresses the marker regardless of User-Agent. `on` forces it kept
+ * (overriding the UA allowlist). The default (header absent) is byte-identical
+ * to the UA-only policy, so #4633 / #5123 are never regressed.
+ */
+
+/** Header clients send to explicitly opt in/out of the `</think>` close marker. */
+export const THINKING_MARKER_HEADER = "x-omniroute-thinking-marker";
+
+// Lowercased User-Agent substrings of clients that render the textual
+// `</think>` marker verbatim and therefore want it suppressed.
+// - `opencode` (#5245): renders the marker as literal text.
+// - `antigravity` (#1061): the Antigravity IDE client (UA
+//   `vscode/<v> (Antigravity/<v>)`) renders a bare `</think>` as the sole
+//   visible content on thinking-only turns, which trips its loop-detection.
+const SUPPRESS_THINK_CLOSE_UA_MARKERS = ["opencode", "antigravity"];
+
+/**
+ * Whether the streamed `</think>` close marker should be suppressed for the
+ * given inbound client. Returns false (emit the marker) for unknown clients and
+ * for Claude Code / Cursor, so #4633 is never regressed.
+ */
+export function shouldSuppressThinkCloseMarker(userAgent) {
+  if (!userAgent || typeof userAgent !== "string") return false;
+  const ua = userAgent.toLowerCase();
+  return SUPPRESS_THINK_CLOSE_UA_MARKERS.some((marker) => ua.includes(marker));
+}
+
+/**
+ * Interpret the explicit `x-omniroute-thinking-marker` request header.
+ * Returns `true` (suppress the marker), `false` (force-keep the marker), or
+ * `null` when the header is absent/unrecognized (defer to the UA policy).
+ */
+export function thinkingMarkerHeaderSignal(headerValue) {
+  if (typeof headerValue !== "string") return null;
+  const value = headerValue.trim().toLowerCase();
+  if (value === "off" || value === "false" || value === "0" || value === "suppress") return true;
+  if (value === "on" || value === "true" || value === "1" || value === "keep") return false;
+  return null;
+}
+
+/**
+ * Resolve whether the streamed `</think>` close marker should be suppressed for
+ * this request. An explicit `x-omniroute-thinking-marker` header wins; absent
+ * that, the conservative User-Agent allowlist policy applies. With no header and
+ * an unrecognized UA the result is `false` (marker kept), so #4633 / #5123 stay
+ * byte-identical by default.
+ */
+export function resolveSuppressThinkClose(opts) {
+  const headerSignal = thinkingMarkerHeaderSignal(opts.thinkingMarkerHeader);
+  if (headerSignal !== null) return headerSignal;
+  return shouldSuppressThinkCloseMarker(opts.userAgent);
+}