@fudrouter/fsrouter 0.6.58 → 0.6.60

package/open-sse/utils/streamHandler.js

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

@@ -1,137 +0,0 @@
-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

@@ -1,104 +0,0 @@
-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

@@ -1,72 +0,0 @@
-/**
- * `</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);
-}