@fudrouter/fsrouter 0.6.62 → 0.6.63

package/open-sse/services/modelDeprecation.js

@@ -0,0 +1,101 @@
+const BUILT_IN_ALIASES = {
+  // Gemini legacy → current
+  "gemini-pro": "gemini-2.5-pro",
+  "gemini-pro-vision": "gemini-2.5-pro",
+  "gemini-1.5-pro": "gemini-2.5-pro",
+  "gemini-1.5-flash": "gemini-2.5-flash",
+  "gemini-1.0-pro": "gemini-2.5-pro",
+  "gemini-2.0-flash": "gemini-2.5-flash",
+  "gemini-2.0-flash-lite": "gemini-3.1-flash-lite",
+  "gemini-3.1-flash-lite-preview": "gemini-3.1-flash-lite",
+  "gemini-3-pro-high": "gemini-3.1-pro-high",
+  "gemini-3-pro-low": "gemini-3.1-pro-low",
+  // Retired free Gemma (was in the gemini-free pool) → current gemini-free model
+  "gemma-4": "gemini-3.1-flash-lite",
+  // Claude legacy → current
+  "claude-3-opus-20240229": "claude-opus-4-20250514",
+  "claude-3-sonnet-20240229": "claude-sonnet-4-20250514",
+  "claude-3-haiku-20240307": "claude-3-5-sonnet-20241022",
+  "claude-3-5-sonnet-latest": "claude-sonnet-4-20250514",
+  "claude-3-5-haiku-latest": "claude-3-5-sonnet-20241022",
+  // OpenAI legacy → current
+  "gpt-4-turbo-preview": "gpt-4-turbo",
+  "gpt-4-0125-preview": "gpt-4-turbo",
+  "gpt-4-1106-preview": "gpt-4-turbo",
+  "gpt-3.5-turbo-0125": "gpt-3.5-turbo",
+  // Kimi/Moonshot — Fireworks long-path aliases (#265)
+  "accounts/fireworks/models/kimi-k2p5": "moonshotai/Kimi-K2.5",
+  "fireworks/accounts/fireworks/models/kimi-k2p5": "moonshotai/Kimi-K2.5",
+  "kimi-k2p5": "moonshotai/Kimi-K2.5",
+  "accounts/fireworks/models/kimi-k2": "moonshotai/Kimi-K2",
+  "fireworks/accounts/fireworks/models/kimi-k2": "moonshotai/Kimi-K2",
+  "kimi-k2": "moonshotai/Kimi-K2",
+  // Mistral short aliases
+  "mistral-large": "mistral-large-latest",
+  "mistral-small": "mistral-small-latest",
+  codestral: "codestral-latest",
+  // Sweep 2026-06-19: codestral-2405 retired 2025-06-16 — forward to the current stable.
+  "codestral-2405": "codestral-2508",
+  // Llama short aliases
+  "llama-3.3": "llama-3.3-70b-versatile",
+  "llama-3-70b": "llama-3.3-70b-versatile",
+  "llama-3-8b": "llama3-8b-8192"
+};
+const CUSTOM_ALIASES_GLOBAL_KEY = "__omniroute_customAliases__";
+const _aliasStore = globalThis;
+function customAliases() {
+  if (!_aliasStore[CUSTOM_ALIASES_GLOBAL_KEY]) {
+    _aliasStore[CUSTOM_ALIASES_GLOBAL_KEY] = {};
+  }
+  return _aliasStore[CUSTOM_ALIASES_GLOBAL_KEY];
+}
+function setCustomAliases(aliases) {
+  _aliasStore[CUSTOM_ALIASES_GLOBAL_KEY] = { ...aliases };
+}
+function getCustomAliases() {
+  return { ...customAliases() };
+}
+function getAllAliases() {
+  return { ...BUILT_IN_ALIASES, ...customAliases() };
+}
+function resolveModelAlias(modelId) {
+  if (!modelId) return modelId;
+  const custom = customAliases();
+  if (custom[modelId]) return custom[modelId];
+  if (BUILT_IN_ALIASES[modelId]) return BUILT_IN_ALIASES[modelId];
+  return modelId;
+}
+function getDeprecationNotice(modelId) {
+  if (!modelId) return null;
+  const resolved = resolveModelAlias(modelId);
+  if (resolved === modelId) return null;
+  return `Model "${modelId}" is deprecated. Forwarding to "${resolved}".`;
+}
+function isDeprecated(modelId) {
+  return getDeprecationNotice(modelId) !== null;
+}
+function addCustomAlias(from, to) {
+  customAliases()[from] = to;
+}
+function removeCustomAlias(from) {
+  const custom = customAliases();
+  if (custom[from]) {
+    delete custom[from];
+    return true;
+  }
+  return false;
+}
+function getBuiltInAliases() {
+  return { ...BUILT_IN_ALIASES };
+}
+export {
+  addCustomAlias,
+  getAllAliases,
+  getBuiltInAliases,
+  getCustomAliases,
+  getDeprecationNotice,
+  isDeprecated,
+  removeCustomAlias,
+  resolveModelAlias,
+  setCustomAliases
+};

package/open-sse/services/modelFamilyFallback.js

@@ -0,0 +1,166 @@
+import { getModelContextLimit } from "../../lib/modelCapabilities";
+import { parseModel } from "./model.js";
+import { CONTEXT_OVERFLOW_REGEX } from "./errorClassifier.js";
+import { getRegistryEntry } from "../config/providerRegistry.js";
+const MODEL_FAMILIES = {
+  // Gemini 3 / 3.1 Pro family — ordered by preference
+  "gemini-3-pro": [
+    "gemini-3.1-pro-preview",
+    "gemini-3-pro-preview",
+    "gemini-3.1-pro-high",
+    "gemini-3-pro-high",
+    "gemini-3.1-pro-low",
+    "gemini-3-pro-low"
+  ],
+  "gemini-3.1-pro": [
+    "gemini-3.1-pro-preview",
+    "gemini-3-pro-preview",
+    "gemini-3.1-pro-high",
+    "gemini-3-pro-high",
+    "gemini-3.1-pro-low",
+    "gemini-3-pro-low"
+  ],
+  "gemini-3-pro-preview": [
+    "gemini-3.1-pro-preview",
+    "gemini-3-pro-high",
+    "gemini-3.1-pro-high",
+    "gemini-3-pro-low",
+    "gemini-3.1-pro-low"
+  ],
+  "gemini-3.1-pro-preview": [
+    "gemini-3-pro-preview",
+    "gemini-3.1-pro-high",
+    "gemini-3-pro-high",
+    "gemini-3.1-pro-low",
+    "gemini-3-pro-low"
+  ],
+  "gemini-3-pro-high": [
+    "gemini-3.1-pro-high",
+    "gemini-3-pro-preview",
+    "gemini-3.1-pro-preview",
+    "gemini-3-pro-low",
+    "gemini-3.1-pro-low"
+  ],
+  "gemini-3.1-pro-high": [
+    "gemini-3-pro-high",
+    "gemini-3.1-pro-preview",
+    "gemini-3-pro-preview",
+    "gemini-3.1-pro-low",
+    "gemini-3-pro-low"
+  ],
+  // Gemini 2.5 Pro family
+  "gemini-2.5-pro": ["gemini-2.5-pro-preview-06-05", "gemini-2.5-pro-exp-03-25"],
+  "gemini-2.5-pro-preview-06-05": ["gemini-2.5-pro", "gemini-2.5-pro-exp-03-25"],
+  // Claude Mythos family (Fable 5) — flagship falls to the next-best Opus
+  // tiers before the cheaper Sonnet, matching the Opus family ordering.
+  "claude-fable-5": ["claude-opus-4-8", "claude-opus-4-7", "claude-sonnet-5"],
+  // Claude Opus family
+  "claude-opus-4-8": ["claude-opus-4-7", "claude-opus-4-6", "claude-sonnet-5"],
+  "claude-opus-4-7": ["claude-opus-4-6", "claude-opus-4-5-20251101", "claude-sonnet-5"],
+  "claude-opus-4-6": ["claude-opus-4-6-thinking", "claude-opus-4-5-20251101", "claude-sonnet-5"],
+  "claude-opus-4-6-thinking": ["claude-opus-4-6", "claude-opus-4-5-20251101"],
+  // Claude Sonnet family — Sonnet 5 is the newest tier; degrade to 4.6 → 4.5 → 4.
+  "claude-sonnet-5": [
+    "claude-sonnet-4-6",
+    "claude-sonnet-4-5-20250929",
+    "claude-sonnet-4-20250514"
+  ],
+  "claude-sonnet-4-6": ["claude-sonnet-4-5-20250929", "claude-sonnet-4-20250514"],
+  "claude-sonnet-4-5-20250929": ["claude-sonnet-4-6", "claude-sonnet-4-20250514"],
+  // GPT-5 family
+  "gpt-5": ["gpt-5-mini", "gpt-4o"],
+  "gpt-5.1": ["gpt-5.1-mini", "gpt-5", "gpt-4o"]
+};
+const MODEL_UNAVAILABLE_FRAGMENTS = [
+  "model not found",
+  "model_not_found",
+  "model not available",
+  "model is not available",
+  "no such model",
+  "unsupported model",
+  "unknown model",
+  "this model does not exist",
+  "invalid model",
+  "model not supported",
+  "does not support",
+  "not enabled for",
+  "access to model",
+  "improperly formed request"
+  // Kiro 400 (model unavailable)
+];
+function isModelUnavailableError(status, errorMessage) {
+  if (status === 404) return true;
+  if (status !== 400 && status !== 403) return false;
+  const msg = errorMessage.toLowerCase();
+  return MODEL_UNAVAILABLE_FRAGMENTS.some((fragment) => msg.includes(fragment));
+}
+function isContextOverflowError(status, errorMessage) {
+  if (status !== 400) return false;
+  return CONTEXT_OVERFLOW_REGEX.test(errorMessage);
+}
+function getNextFamilyFallback(currentModel, triedModels) {
+  const parsed = parseModel(currentModel);
+  const bareModel = parsed.model || currentModel;
+  const provider = parsed.provider || parsed.providerAlias || "";
+  const prefix = provider ? `${provider}/` : "";
+  const lookupKey = bareModel.replace(/\./g, "-");
+  const family = MODEL_FAMILIES[lookupKey] ?? MODEL_FAMILIES[bareModel];
+  if (!family) return null;
+  const registryEntry = provider ? getRegistryEntry(provider) : null;
+  const supportedIds = registryEntry ? new Set(registryEntry.models.map((m) => m.id)) : null;
+  for (const candidate of family) {
+    let resolvedCandidate = candidate;
+    if (supportedIds && !supportedIds.has(candidate)) {
+      const dotVariant = candidate.replace(/-(\d+)-(\d+)$/, "-$1.$2");
+      const dotVariant2 = candidate.replace(/-(\d+)-(\d+)-/, "-$1.$2-");
+      if (supportedIds.has(dotVariant)) resolvedCandidate = dotVariant;
+      else if (supportedIds.has(dotVariant2)) resolvedCandidate = dotVariant2;
+    }
+    const fullCandidate = `${prefix}${resolvedCandidate}`;
+    if (!triedModels.has(fullCandidate)) {
+      return fullCandidate;
+    }
+  }
+  return null;
+}
+function isInModelFamily(model) {
+  const parsed = parseModel(model);
+  const bareModel = parsed.model || model;
+  return bareModel in MODEL_FAMILIES;
+}
+function getModelFamily(model) {
+  const parsed = parseModel(model);
+  const bareModel = parsed.model || model;
+  const prefix = parsed.provider || parsed.providerAlias ? `${parsed.provider || parsed.providerAlias}/` : "";
+  const family = MODEL_FAMILIES[bareModel];
+  if (!family) return [model];
+  return [model, ...family.map((c) => `${prefix}${c}`)];
+}
+function findLargerContextModel(currentModel, availableModels) {
+  const currentParsed = parseModel(currentModel);
+  const currentProvider = currentParsed.provider || currentParsed.providerAlias || "unknown";
+  const currentModelId = currentParsed.model || currentModel;
+  const currentLimit = getModelContextLimit(currentProvider, currentModelId) ?? 0;
+  let bestModel = null;
+  let bestLimit = currentLimit;
+  for (const candidate of availableModels) {
+    if (candidate === currentModel) continue;
+    const parsed = parseModel(candidate);
+    const provider = parsed.provider || parsed.providerAlias || "unknown";
+    const modelId = parsed.model || candidate;
+    const limit = getModelContextLimit(provider, modelId) ?? 0;
+    if (limit > bestLimit) {
+      bestLimit = limit;
+      bestModel = candidate;
+    }
+  }
+  return bestModel;
+}
+export {
+  findLargerContextModel,
+  getModelFamily,
+  getNextFamilyFallback,
+  isContextOverflowError,
+  isInModelFamily,
+  isModelUnavailableError
+};

package/open-sse/services/oauthCredentialManager.js

@@ -0,0 +1,156 @@
+import {
+  getRefreshLeadMs,
+  isUnrecoverableRefreshError,
+  refreshTokenByProvider,
+} from "./tokenRefresh.js";
+import { PROVIDER_OAUTH } from "../providers/index.js";
+
+// Single source: codex.oauth.maxRefreshAgeMs (8 days) — proactive refresh window
+export const CODEX_MAX_REFRESH_AGE_MS = PROVIDER_OAUTH["codex"]?.maxRefreshAgeMs;
+
+const refreshLocks = new Map();
+
+function parseTimeMs(value) {
+  if (value === undefined || value === null || value === "") return null;
+  if (typeof value === "number") {
+    return value < 1e12 ? value * 1000 : value;
+  }
+
+  const parsed = new Date(value).getTime();
+  return Number.isFinite(parsed) ? parsed : null;
+}
+
+function toExpiresAt(expiresIn, nowMs = Date.now()) {
+  if (!expiresIn) return null;
+  return new Date(nowMs + expiresIn * 1000).toISOString();
+}
+
+export function getCredentialExpiryMs(credentials) {
+  return parseTimeMs(credentials?.expiresAt ?? credentials?.tokenExpiresAt);
+}
+
+export function getCredentialLastRefreshMs(credentials) {
+  return parseTimeMs(
+    credentials?.lastRefreshAt ??
+    credentials?.lastRefresh ??
+    credentials?.providerSpecificData?.lastRefreshAt
+  );
+}
+
+export function isCodexRefreshStale(credentials, nowMs = Date.now(), maxAgeMs = CODEX_MAX_REFRESH_AGE_MS) {
+  const lastRefreshMs = getCredentialLastRefreshMs(credentials);
+  return !lastRefreshMs || nowMs - lastRefreshMs >= maxAgeMs;
+}
+
+export function shouldRefreshCredentials(provider, credentials, nowMs = Date.now()) {
+  if (!credentials) return false;
+
+  const expiresAtMs = getCredentialExpiryMs(credentials);
+  if (expiresAtMs !== null && expiresAtMs - nowMs < getRefreshLeadMs(provider)) {
+    return true;
+  }
+
+  // Proactive stale refresh for providers declaring oauth.maxRefreshAgeMs (e.g. codex)
+  const maxAgeMs = PROVIDER_OAUTH[provider]?.maxRefreshAgeMs;
+  if (maxAgeMs && credentials.refreshToken && isCodexRefreshStale(credentials, nowMs, maxAgeMs)) {
+    return true;
+  }
+
+  return false;
+}
+
+export function mergeProviderSpecificData(existing, next) {
+  if (!next || typeof next !== "object") return existing;
+  return {
+    ...(existing || {}),
+    ...next,
+  };
+}
+
+export function mergeRefreshedCredentials(provider, currentCredentials, refreshedCredentials, nowMs = Date.now()) {
+  if (!refreshedCredentials) return null;
+  if (isUnrecoverableRefreshError(refreshedCredentials)) return refreshedCredentials;
+
+  const next = {};
+  const nowIso = new Date(nowMs).toISOString();
+
+  if (refreshedCredentials.accessToken) next.accessToken = refreshedCredentials.accessToken;
+  if (refreshedCredentials.apiKey) next.apiKey = refreshedCredentials.apiKey;
+  if (refreshedCredentials.token) next.token = refreshedCredentials.token;
+
+  const refreshToken = refreshedCredentials.refreshToken ?? currentCredentials?.refreshToken;
+  if (refreshToken) next.refreshToken = refreshToken;
+
+  const idToken = refreshedCredentials.idToken ?? currentCredentials?.idToken;
+  if (idToken) next.idToken = idToken;
+
+  if (refreshedCredentials.expiresIn) {
+    next.expiresIn = refreshedCredentials.expiresIn;
+    next.expiresAt = toExpiresAt(refreshedCredentials.expiresIn, nowMs);
+  } else if (refreshedCredentials.expiresAt) {
+    next.expiresAt = refreshedCredentials.expiresAt;
+  }
+
+  if (refreshedCredentials.projectId) next.projectId = refreshedCredentials.projectId;
+
+  if (refreshedCredentials.providerSpecificData) {
+    next.providerSpecificData = mergeProviderSpecificData(
+      currentCredentials?.providerSpecificData,
+      refreshedCredentials.providerSpecificData
+    );
+  }
+
+  if (refreshedCredentials.copilotToken) next.copilotToken = refreshedCredentials.copilotToken;
+  if (refreshedCredentials.copilotTokenExpiresAt) {
+    next.copilotTokenExpiresAt = refreshedCredentials.copilotTokenExpiresAt;
+  }
+
+  // trackRefreshAt providers (e.g. codex) always stamp lastRefreshAt for staleness tracking
+  if (
+    PROVIDER_OAUTH[provider]?.trackRefreshAt ||
+    next.accessToken ||
+    next.apiKey ||
+    next.token ||
+    next.refreshToken ||
+    next.copilotToken
+  ) {
+    next.lastRefreshAt = refreshedCredentials.lastRefreshAt || nowIso;
+  }
+
+  return next;
+}
+
+function getRefreshLockKey(provider, credentials) {
+  const stableId =
+    credentials?.connectionId ||
+    credentials?.id ||
+    credentials?.email ||
+    credentials?.name ||
+    credentials?.refreshToken?.slice?.(-16) ||
+    "default";
+  return `${provider}:${stableId}`;
+}
+
+export async function withCredentialRefreshLock(provider, credentials, refreshFn) {
+  const key = getRefreshLockKey(provider, credentials);
+  const existing = refreshLocks.get(key);
+  if (existing) return existing;
+
+  const pending = Promise.resolve()
+    .then(refreshFn)
+    .finally(() => {
+      refreshLocks.delete(key);
+    });
+
+  refreshLocks.set(key, pending);
+  return pending;
+}
+
+export async function refreshProviderCredentials(provider, credentials, log) {
+  if (!credentials) return null;
+
+  return withCredentialRefreshLock(provider, credentials, async () => {
+    const refreshed = await refreshTokenByProvider(provider, credentials, log);
+    return mergeRefreshedCredentials(provider, credentials, refreshed);
+  });
+}

package/open-sse/services/pipeline.js

@@ -0,0 +1,107 @@
+import { errorResponse } from "../utils/error.ts";
+import { extractPanelText } from "./fusion.ts";
+function prependSystemInstruction(body, prompt) {
+  const sys = typeof prompt === "string" && prompt.trim() ? prompt.trim() : null;
+  const next = { ...body };
+  if (!sys) return next;
+  if (Array.isArray(body.input)) {
+    next.input = [{ role: "system", content: sys }, ...body.input];
+  } else if (Array.isArray(body.contents)) {
+    next.contents = [{ role: "user", parts: [{ text: sys }] }, ...body.contents];
+  } else if (Array.isArray(body.messages)) {
+    next.messages = [{ role: "system", content: sys }, ...body.messages];
+  } else {
+    next.messages = [{ role: "system", content: sys }];
+  }
+  return next;
+}
+function buildTransformBody(body, prompt, input) {
+  const next = { ...body };
+  const sys = typeof prompt === "string" && prompt.trim() ? prompt.trim() : null;
+  if (Array.isArray(body.input)) {
+    const turns = [];
+    if (sys) turns.push({ role: "system", content: sys });
+    turns.push({ role: "user", content: input });
+    next.input = turns;
+    delete next.messages;
+    delete next.contents;
+  } else if (Array.isArray(body.contents)) {
+    const text = sys ? `${sys}
+
+${input}` : input;
+    next.contents = [{ role: "user", parts: [{ text }] }];
+    delete next.messages;
+    delete next.input;
+  } else {
+    const turns = [];
+    if (sys) turns.push({ role: "system", content: sys });
+    turns.push({ role: "user", content: input });
+    next.messages = turns;
+  }
+  return next;
+}
+function stripStreaming(body) {
+  const { tools: _tools, tool_choice: _tc, ...rest } = body;
+  void _tools;
+  void _tc;
+  return { ...rest, stream: false };
+}
+async function handlePipelineChat({
+  body,
+  steps,
+  handleSingleModel,
+  log,
+  comboName
+}) {
+  const chain = (Array.isArray(steps) ? steps : []).filter((s) => s && s.model);
+  if (chain.length === 0) {
+    return errorResponse(400, "Pipeline combo has no models");
+  }
+  log.info(
+    "PIPELINE",
+    `Combo "${comboName ?? ""}" | steps=${chain.length} [${chain.map((s) => s.model).join(" -> ")}]`
+  );
+  if (chain.length === 1) {
+    return handleSingleModel(prependSystemInstruction(body, chain[0].prompt), chain[0].model);
+  }
+  let prevOutput = "";
+  for (let i = 0; i < chain.length; i++) {
+    const step = chain[i];
+    const isFinal = i === chain.length - 1;
+    const isFirst = i === 0;
+    let stepBody = isFirst ? prependSystemInstruction(body, step.prompt) : buildTransformBody(body, step.prompt, prevOutput);
+    if (!isFinal) stepBody = stripStreaming(stepBody);
+    const t0 = Date.now();
+    const res = await handleSingleModel(stepBody, step.model);
+    if (isFinal) {
+      log.info("PIPELINE", `Final step ${step.model} responded (${Date.now() - t0}ms)`);
+      return res;
+    }
+    if (!res.ok) {
+      log.warn("PIPELINE", `Step ${i + 1} (${step.model}) failed`, { status: res.status });
+      const status = res.status >= 400 && res.status <= 599 ? res.status : 502;
+      return errorResponse(status, `Pipeline step ${i + 1} (${step.model}) failed`);
+    }
+    try {
+      const json = await res.clone().json();
+      prevOutput = extractPanelText(json);
+    } catch {
+      log.warn("PIPELINE", `Step ${i + 1} (${step.model}) returned an unparseable body`);
+      return errorResponse(502, `Pipeline step ${i + 1} (${step.model}) returned an unparseable body`);
+    }
+    if (!prevOutput.trim()) {
+      log.warn("PIPELINE", `Step ${i + 1} (${step.model}) returned empty output`);
+      return errorResponse(502, `Pipeline step ${i + 1} (${step.model}) returned empty output`);
+    }
+    log.info(
+      "PIPELINE",
+      `Step ${i + 1} ${step.model} ok (${prevOutput.length} chars, ${Date.now() - t0}ms)`
+    );
+  }
+  return errorResponse(500, "Pipeline produced no final response");
+}
+export {
+  buildTransformBody,
+  handlePipelineChat,
+  prependSystemInstruction
+};