@fudrouter/fsrouter 0.6.61 → 0.6.63

package/open-sse/utils/jsonToSse.js

@@ -0,0 +1,125 @@
+/**
+ * #3089 — Convert a complete OpenAI-style chat-completion JSON body into an
+ * equivalent OpenAI SSE (`chat.completion.chunk`) stream.
+ *
+ * Some "reasoning" openai-compatible upstreams ignore a `stream: true` request
+ * and reply with a single `application/json` chat-completion body instead of an
+ * SSE stream. OmniRoute's streaming readiness check only recognizes SSE `data:`
+ * frames, so such a body produced a spurious `STREAM_EARLY_EOF` / HTTP 502 even
+ * though it carried valid `content` / `reasoning_content`. Synthesizing an SSE
+ * stream from that JSON lets the normal streaming pipeline (and the client) get
+ * a valid stream that preserves both `content` and `reasoning_content`.
+ *
+ * Returns "" when the text is not a parseable chat-completion object with at
+ * least one choice — callers then fall back to the original (error) handling.
+ */
+import { normalizeOpenAICompatibleFinishReasonString } from "./finishReason.js";
+import { getUnsupportedReasoningValue } from "./reasoningFields.js";
+
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function nonEmptyString(value) {
+  return typeof value === "string" && value.length > 0 ? value : "";
+}
+
+function addReadableReasoning(message, delta) {
+  const reasoningContent = nonEmptyString(message.reasoning_content);
+  if (reasoningContent) {
+    delta.reasoning_content = reasoningContent;
+    return true;
+  }
+
+  const reasoning = nonEmptyString(message.reasoning);
+  if (reasoning) {
+    delta.reasoning = reasoning;
+    return true;
+  }
+
+  return false;
+}
+
+function addUnsupportedReasoning(message, delta) {
+  const reasoningContent = getUnsupportedReasoningValue(message);
+  if (reasoningContent) {
+    delta.reasoning_content = reasoningContent;
+  }
+}
+
+function buildReasoningDelta(message) {
+  const delta = {};
+  if (Array.isArray(message.reasoning_details)) {
+    delta.reasoning_details = message.reasoning_details;
+  }
+
+  if (!addReadableReasoning(message, delta)) {
+    addUnsupportedReasoning(message, delta);
+  }
+
+  return Object.keys(delta).length > 0 ? delta : null;
+}
+
+function sseEvent(payload) {
+  return `data: ${JSON.stringify(payload)}\n\n`;
+}
+
+export function synthesizeOpenAiSseFromJson(jsonText) {
+  let parsed;
+  try {
+    parsed = JSON.parse(jsonText);
+  } catch {
+    return "";
+  }
+  if (!isRecord(parsed)) return "";
+
+  const choices = parsed.choices;
+  if (!Array.isArray(choices) || choices.length === 0) return "";
+
+  const id = typeof parsed.id === "string" && parsed.id ? parsed.id : "chatcmpl-omniroute-sse";
+  const created = typeof parsed.created === "number" ? parsed.created : 0;
+  const model = typeof parsed.model === "string" ? parsed.model : "";
+  const base = { id, object: "chat.completion.chunk", created, model };
+
+  let out = "";
+  let emittedAny = false;
+
+  choices.forEach((choice, fallbackIndex) => {
+    if (!isRecord(choice)) return;
+    const index = typeof choice.index === "number" ? choice.index : fallbackIndex;
+    const message = isRecord(choice.message) ? choice.message : {};
+
+    // Emit role, reasoning_content, content and tool_calls as SEPARATE sequential
+    // deltas — the same shape a real reasoning model streams (reasoning first,
+    // then content). Combining them in one delta caused the openai→openai
+    // translator to re-split and DUPLICATE reasoning_content across chunks
+    // (#3089 follow-up); separate deltas pass through cleanly with no duplication.
+    const role = typeof message.role === "string" ? message.role : "assistant";
+    const emitDelta = (delta) => {
+      out += sseEvent({ ...base, choices: [{ index, delta, finish_reason: null }] });
+    };
+
+    emitDelta({ role });
+    const reasoningDelta = buildReasoningDelta(message);
+    if (reasoningDelta) {
+      emitDelta(reasoningDelta);
+    }
+    if (typeof message.content === "string" && message.content.length > 0) {
+      emitDelta({ content: message.content });
+    }
+    if (Array.isArray(message.tool_calls) && message.tool_calls.length > 0) {
+      emitDelta({ tool_calls: message.tool_calls });
+    }
+
+    const finishReason = normalizeOpenAICompatibleFinishReasonString(choice.finish_reason);
+    const finalChoice = { index, delta: {}, finish_reason: finishReason };
+    const finalChunk = { ...base, choices: [finalChoice] };
+    if (isRecord(parsed.usage)) finalChunk.usage = parsed.usage;
+    out += sseEvent(finalChunk);
+    emittedAny = true;
+  });
+
+  if (!emittedAny) return "";
+  out += "data: [DONE]\n\n";
+  return out;
+}

package/open-sse/utils/keepaliveThreshold.js

@@ -0,0 +1,40 @@
+import { NOAUTH_PROVIDERS } from '../../dist/shared/constants/providers.js';
+import { APIKEY_PROVIDERS } from '../../dist/shared/constants/providers.js';
+import { WEB_COOKIE_PROVIDERS } from '../../dist/shared/constants/providers.js';
+import { WEB_SESSION_CREDENTIAL_REQUIREMENTS } from '../../dist/shared/providers/webSessionCredentials.js';
+const DEFAULT_THRESHOLD_MS = 2e3;
+const SLOW_THRESHOLD_MS = 15e3;
+const SLOW_PROVIDER_IDS = /* @__PURE__ */ new Set();
+function addSlowProvider(id, alias) {
+  SLOW_PROVIDER_IDS.add(id);
+  if (typeof alias === "string" && alias) SLOW_PROVIDER_IDS.add(alias);
+}
+for (const [id, def] of Object.entries(NOAUTH_PROVIDERS)) {
+  if (def.noAuth === true) {
+    addSlowProvider(id, def.alias);
+  }
+}
+for (const [id, def] of Object.entries(APIKEY_PROVIDERS)) {
+  if (def.anonymousFallback === true) {
+    addSlowProvider(id, def.alias);
+  }
+}
+for (const [id, def] of Object.entries(WEB_COOKIE_PROVIDERS)) {
+  addSlowProvider(id, def.alias);
+}
+for (const id of Object.keys(WEB_SESSION_CREDENTIAL_REQUIREMENTS)) {
+  SLOW_PROVIDER_IDS.add(id);
+}
+const SLOW_KEEPALIVE_PROVIDERS = SLOW_PROVIDER_IDS;
+function resolveKeepaliveThreshold(model) {
+  if (!model || typeof model !== "string") return DEFAULT_THRESHOLD_MS;
+  const slashIndex = model.indexOf("/");
+  if (slashIndex <= 0) return DEFAULT_THRESHOLD_MS;
+  const prefix = model.slice(0, slashIndex);
+  if (SLOW_PROVIDER_IDS.has(prefix)) return SLOW_THRESHOLD_MS;
+  return DEFAULT_THRESHOLD_MS;
+}
+export {
+  SLOW_KEEPALIVE_PROVIDERS,
+  resolveKeepaliveThreshold
+};

package/open-sse/utils/logger.js

@@ -0,0 +1,104 @@
+import { getAppLogFormat, getAppLogLevel } from "../../lib/logEnv";
+const LEVELS = { debug: 0, info: 1, warn: 2, error: 3 };
+function isLogLevel(value) {
+  return Object.prototype.hasOwnProperty.call(LEVELS, value);
+}
+const configuredLevel = getAppLogLevel("info").toLowerCase();
+const currentLevel = isLogLevel(configuredLevel) ? LEVELS[configuredLevel] : LEVELS.info;
+const jsonFormat = getAppLogFormat("text") === "json";
+let requestCounter = 0;
+function generateRequestId() {
+  return `req_${Date.now()}_${++requestCounter}`;
+}
+function maskKey(key) {
+  if (!key || key.length < 12) return "(redacted)";
+  return `${key.slice(0, 6)}...${key.slice(-4)}`;
+}
+function getConsoleFn(level) {
+  switch (level) {
+    case "debug":
+      return console.debug;
+    case "warn":
+      return console.warn;
+    case "error":
+      return console.error;
+    default:
+      return console.log;
+  }
+}
+function formatMeta(meta) {
+  if (!meta || typeof meta !== "object") return "";
+  const cleaned = {};
+  for (const [k, v] of Object.entries(meta)) {
+    if (v !== void 0 && v !== null) cleaned[k] = v;
+  }
+  return Object.keys(cleaned).length > 0 ? ` ${JSON.stringify(cleaned)}` : "";
+}
+function logger(tag) {
+  const emit = (level, message, meta) => {
+    if (LEVELS[level] < currentLevel) return;
+    const consoleFn = getConsoleFn(level);
+    if (jsonFormat) {
+      const entry = {
+        ts: (/* @__PURE__ */ new Date()).toISOString(),
+        level,
+        tag,
+        msg: message
+      };
+      if (meta && typeof meta === "object" && Object.keys(meta).length > 0) {
+        entry.data = meta;
+      }
+      consoleFn(JSON.stringify(entry));
+    } else {
+      consoleFn(`[${level.toUpperCase()}] [${tag}] ${message}${formatMeta(meta)}`);
+    }
+  };
+  return {
+    debug: (message, meta) => emit("debug", message, meta),
+    info: (message, meta) => emit("info", message, meta),
+    warn: (message, meta) => emit("warn", message, meta),
+    error: (message, meta) => emit("error", message, meta)
+  };
+}
+function createLogger(requestId = null) {
+  const emit = (level, tag, message, data) => {
+    if (LEVELS[level] < currentLevel) return;
+    const consoleFn = getConsoleFn(level);
+    if (jsonFormat) {
+      const entry = {
+        ts: (/* @__PURE__ */ new Date()).toISOString(),
+        level,
+        tag,
+        msg: message
+      };
+      if (requestId) entry.reqId = requestId;
+      if (data && typeof data === "object" && Object.keys(data).length > 0) {
+        entry.data = data;
+      }
+      consoleFn(JSON.stringify(entry));
+    } else {
+      const ts = (/* @__PURE__ */ new Date()).toISOString().slice(11, 23);
+      const prefix = requestId ? `[${requestId}]` : "";
+      const dataStr = formatMeta(data);
+      consoleFn(`${ts} ${prefix}[${tag}] ${message}${dataStr}`);
+    }
+  };
+  return {
+    debug: (tag, msg, data) => emit("debug", tag, msg, data),
+    info: (tag, msg, data) => emit("info", tag, msg, data),
+    warn: (tag, msg, data) => emit("warn", tag, msg, data),
+    error: (tag, msg, data) => emit("error", tag, msg, data)
+  };
+}
+const defaultLogger = createLogger();
+const log = defaultLogger;
+var logger_default = logger;
+export {
+  createLogger,
+  logger_default as default,
+  defaultLogger,
+  generateRequestId,
+  log,
+  logger,
+  maskKey
+};

package/open-sse/utils/noThinkingAlias.js

@@ -0,0 +1,74 @@
+import { getModelSpec } from '../../dist/shared/constants/modelSpecs.js';
+const NO_THINKING_PREFIX = "no-think/";
+function isNoThinkingAlias(modelId) {
+  return typeof modelId === "string" && modelId.startsWith(NO_THINKING_PREFIX);
+}
+function stripNoThinkingAlias(modelId) {
+  return isNoThinkingAlias(modelId) ? modelId.slice(NO_THINKING_PREFIX.length) : modelId;
+}
+function toNoThinkingAlias(qualifiedModelId) {
+  return `${NO_THINKING_PREFIX}${qualifiedModelId}`;
+}
+function applyNoThinkingAlias(body, opts = {}) {
+  if (!body || typeof body !== "object") return { applied: false };
+  const model = body.model;
+  if (!isNoThinkingAlias(model)) return { applied: false };
+  const realModel = stripNoThinkingAlias(model);
+  if (!realModel) return { applied: false };
+  body.model = realModel;
+  if (opts.claudeFormat === true) {
+    body.thinking = { type: "disabled" };
+  }
+  delete body.reasoning_effort;
+  delete body.reasoning;
+  return { applied: true, realModel };
+}
+function bareModelName(id) {
+  const slash = id.lastIndexOf("/");
+  return slash >= 0 ? id.slice(slash + 1) : id;
+}
+function shouldExposeNoThinkingAlias(model) {
+  if (!model || typeof model !== "object") return false;
+  const id = model.id;
+  if (typeof id !== "string" || id.length === 0) return false;
+  if (model.owned_by === "combo") return false;
+  if (isNoThinkingAlias(id)) return false;
+  const name = bareModelName(id);
+  const spec = getModelSpec(name);
+  if (!spec) return false;
+  if (spec.noThinkingAlias === true) return true;
+  if (spec.noThinkingAlias === false) return false;
+  return spec.supportsThinking === true && spec.rejectsThinkingDisabled !== true && /claude/i.test(name);
+}
+function normalizeProviderPrefix(qualifiedId, aliasToCanonical) {
+  const slash = qualifiedId.indexOf("/");
+  if (slash < 0) return qualifiedId;
+  const prefix = qualifiedId.slice(0, slash);
+  const canonical = aliasToCanonical[prefix];
+  return canonical && canonical !== prefix ? `${canonical}${qualifiedId.slice(slash)}` : qualifiedId;
+}
+function appendNoThinkingVariants(models, aliasToCanonical) {
+  if (!Array.isArray(models)) return models;
+  const variants = [];
+  for (const model of models) {
+    if (!shouldExposeNoThinkingAlias(model)) continue;
+    const rawId = model.id;
+    const qualifiedId = aliasToCanonical ? normalizeProviderPrefix(rawId, aliasToCanonical) : rawId;
+    const aliasId = toNoThinkingAlias(qualifiedId);
+    const variant = { ...model, id: aliasId, root: aliasId };
+    if (typeof model.name === "string" && model.name) {
+      variant.name = `${model.name} (no thinking)`;
+    }
+    variants.push(variant);
+  }
+  return variants.length > 0 ? [...models, ...variants] : models;
+}
+export {
+  NO_THINKING_PREFIX,
+  appendNoThinkingVariants,
+  applyNoThinkingAlias,
+  isNoThinkingAlias,
+  shouldExposeNoThinkingAlias,
+  stripNoThinkingAlias,
+  toNoThinkingAlias
+};

package/open-sse/utils/number.js

@@ -0,0 +1,7 @@
+function clamp01(value) {
+  if (!Number.isFinite(value)) return 0;
+  return Math.min(1, Math.max(0, value));
+}
+export {
+  clamp01
+};

package/open-sse/utils/ollamaTransform.js

@@ -0,0 +1,85 @@
+// Transform OpenAI SSE stream to Ollama JSON lines format
+export function transformToOllama(response, model) {
+  let buffer = "";
+  let pendingToolCalls = {};
+  
+  const transform = new TransformStream({
+    transform(chunk, controller) {
+      const text = new TextDecoder().decode(chunk);
+      buffer += text;
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+
+      for (const line of lines) {
+        if (!line.startsWith("data:")) continue;
+        const data = line.slice(5).trim();
+        
+        if (data === "[DONE]") {
+          const ollamaEnd = JSON.stringify({ model, message: { role: "assistant", content: "" }, done: true }) + "\n";
+          controller.enqueue(new TextEncoder().encode(ollamaEnd));
+          return;
+        }
+
+        try {
+          const parsed = JSON.parse(data);
+          const delta = parsed.choices?.[0]?.delta || {};
+          const content = delta.content || "";
+          const toolCalls = delta.tool_calls;
+
+          if (toolCalls) {
+            for (const tc of toolCalls) {
+              const idx = tc.index;
+              if (!pendingToolCalls[idx]) {
+                pendingToolCalls[idx] = { id: tc.id, function: { name: "", arguments: "" } };
+              }
+              if (tc.function?.name) pendingToolCalls[idx].function.name += tc.function.name;
+              if (tc.function?.arguments) pendingToolCalls[idx].function.arguments += tc.function.arguments;
+            }
+          }
+
+          if (content) {
+            const ollama = JSON.stringify({ model, message: { role: "assistant", content }, done: false }) + "\n";
+            controller.enqueue(new TextEncoder().encode(ollama));
+          }
+
+          const finishReason = parsed.choices?.[0]?.finish_reason;
+          if (finishReason === "tool_calls" || finishReason === "stop") {
+            const toolCallsArr = Object.values(pendingToolCalls);
+            if (toolCallsArr.length > 0) {
+              const formattedCalls = toolCallsArr.map(tc => ({
+                function: {
+                  name: tc.function.name,
+                  arguments: (() => { try { return JSON.parse(tc.function.arguments || "{}"); } catch { return {}; } })()
+                }
+              }));
+              const ollama = JSON.stringify({ 
+                model, 
+                message: { role: "assistant", content: "", tool_calls: formattedCalls }, 
+                done: true
+              }) + "\n";
+              controller.enqueue(new TextEncoder().encode(ollama));
+              pendingToolCalls = {};
+            } else if (finishReason === "stop") {
+              const ollamaEnd = JSON.stringify({ model, message: { role: "assistant", content: "" }, done: true }) + "\n";
+              controller.enqueue(new TextEncoder().encode(ollamaEnd));
+            }
+          }
+        } catch (e) {
+          // Silently ignore parse errors
+        }
+      }
+    },
+    flush(controller) {
+      const ollamaEnd = JSON.stringify({ model, message: { role: "assistant", content: "" }, done: true }) + "\n";
+      controller.enqueue(new TextEncoder().encode(ollamaEnd));
+    }
+  });
+
+  if (!response.body) {
+    return new Response("", { status: response.status, headers: { "Content-Type": "application/x-ndjson" } });
+  }
+  return new Response(response.body.pipeThrough(transform), {
+    headers: { "Content-Type": "application/x-ndjson", "Access-Control-Allow-Origin": "*" }
+  });
+}
+

package/open-sse/utils/opencodeHeaders.js

@@ -0,0 +1,47 @@
+import { randomUUID } from "crypto";
+import { setUserAgentHeader } from "../executors/base.ts";
+const OPENCODE_HEADER_KEYS = [
+  "x-opencode-session",
+  "x-opencode-request",
+  "x-opencode-project",
+  "x-opencode-client"
+];
+function findHeader(headers, name) {
+  return Object.entries(headers).find(([key]) => key.toLowerCase() === name.toLowerCase())?.[1];
+}
+function forwardOpencodeClientHeaders(headers, clientHeaders, options) {
+  const clientUA = clientHeaders["User-Agent"] || clientHeaders["user-agent"];
+  if (clientUA) {
+    setUserAgentHeader(headers, clientUA);
+  }
+  for (const headerName of OPENCODE_HEADER_KEYS) {
+    const value = findHeader(clientHeaders, headerName);
+    if (value) {
+      headers[headerName] = value;
+    }
+  }
+  if (options?.synthesizeRequestId && !headers["x-opencode-session"]) {
+    const sessionAffinity = findHeader(clientHeaders, "x-session-affinity") || findHeader(clientHeaders, "x-session-id");
+    if (sessionAffinity) {
+      headers["x-opencode-session"] = sessionAffinity;
+      if (!headers["x-opencode-request"]) {
+        headers["x-opencode-request"] = randomUUID();
+      }
+    }
+  }
+  if (options?.cliDefaults) {
+    applyCliDefaults(headers, options.cliDefaults);
+  }
+}
+function applyCliDefaults(headers, cliDefaults) {
+  if (!headers["User-Agent"] && !headers["user-agent"]) {
+    setUserAgentHeader(headers, cliDefaults.userAgent);
+  }
+  headers["x-opencode-client"] ||= cliDefaults.client;
+  headers["x-opencode-project"] ||= cliDefaults.project;
+  headers["x-opencode-request"] ||= randomUUID();
+  headers["x-opencode-session"] ||= randomUUID();
+}
+export {
+  forwardOpencodeClientHeaders
+};

package/open-sse/utils/progressTracker.js

@@ -0,0 +1,81 @@
+const DEFAULT_INTERVAL_MS = 2e3;
+function createProgressTransform({
+  intervalMs = DEFAULT_INTERVAL_MS,
+  signal
+} = {}) {
+  let tokenCount = 0;
+  let startTime = Date.now();
+  let intervalId;
+  let writer;
+  const encoder = new TextEncoder();
+  return new TransformStream(
+    {
+      start(controller) {
+        writer = controller;
+        startTime = Date.now();
+        intervalId = setInterval(() => {
+          if (signal?.aborted) {
+            clearInterval(intervalId);
+            return;
+          }
+          const progressEvent = `event: progress
+data: ${JSON.stringify({
+            tokens_generated: tokenCount,
+            elapsed_ms: Date.now() - startTime
+          })}
+
+`;
+          try {
+            controller.enqueue(encoder.encode(progressEvent));
+          } catch {
+            clearInterval(intervalId);
+          }
+        }, intervalMs);
+        signal?.addEventListener(
+          "abort",
+          () => {
+            clearInterval(intervalId);
+          },
+          { once: true }
+        );
+      },
+      transform(chunk, controller) {
+        const text = typeof chunk === "string" ? chunk : new TextDecoder().decode(chunk);
+        const dataLines = text.split("\n").filter((l) => l.startsWith("data: "));
+        tokenCount += dataLines.length;
+        controller.enqueue(chunk);
+      },
+      flush() {
+        clearInterval(intervalId);
+        if (writer) {
+          try {
+            const finalEvent = `event: progress
+data: ${JSON.stringify({
+              tokens_generated: tokenCount,
+              elapsed_ms: Date.now() - startTime,
+              done: true
+            })}
+
+`;
+            writer.enqueue(encoder.encode(finalEvent));
+          } catch {
+          }
+        }
+      },
+      cancel() {
+        clearInterval(intervalId);
+      }
+    },
+    { highWaterMark: 16384 },
+    { highWaterMark: 16384 }
+  );
+}
+function wantsProgress(headers) {
+  if (!headers) return false;
+  const get = typeof headers.get === "function" ? (k) => headers.get(k) : (k) => headers[k];
+  return get("x-omniroute-progress") === "true";
+}
+export {
+  createProgressTransform,
+  wantsProgress
+};