@fudrouter/fsrouter 0.6.59 → 0.6.61

package/open-sse/utils/jsonToSse.js

@@ -1,125 +0,0 @@
-/**
- * #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

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

@@ -1,104 +0,0 @@
-import { getAppLogFormat, getAppLogLevel } from "../../src/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

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

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

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

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

@@ -1,81 +0,0 @@
-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
-};