@fudrouter/fsrouter 0.6.61 → 0.6.63

package/open-sse/services/emergencyFallback.js

@@ -0,0 +1,109 @@
+import { isFeatureFlagEnabled } from '../../dist/shared/utils/featureFlags.js';
+const EMERGENCY_FALLBACK_FLAG_KEY = "OMNIROUTE_EMERGENCY_FALLBACK";
+const EMERGENCY_FALLBACK_FLAG_CACHE_MS = 500;
+let emergencyFallbackFlagCache = null;
+let emergencyFallbackFeatureFlagResolver = isFeatureFlagEnabled;
+const EMERGENCY_FALLBACK_CONFIG = {
+  enabled: true,
+  provider: "nvidia",
+  model: "openai/gpt-oss-120b",
+  triggerOn402: true,
+  triggerOnBudgetKeywords: true,
+  budgetKeywords: [
+    "insufficient funds",
+    "insufficient_funds",
+    "budget exceeded",
+    "budget_exceeded",
+    "quota exceeded",
+    "quota_exceeded",
+    "billing",
+    "payment required",
+    "out of credits",
+    "no credits",
+    "credit limit",
+    "spending limit",
+    "saldo insuficiente",
+    "limite de gastos",
+    "cota excedida"
+  ],
+  skipForToolRequests: true,
+  maxOutputTokens: 4096
+};
+function isEmergencyFallbackRawEnvEnabled() {
+  const raw = process.env.OMNIROUTE_EMERGENCY_FALLBACK;
+  return raw !== "false" && raw !== "0";
+}
+function resetEmergencyFallbackEnvCache() {
+  emergencyFallbackFlagCache = null;
+}
+function setEmergencyFallbackFeatureFlagResolverForTest(resolver) {
+  emergencyFallbackFeatureFlagResolver = resolver ?? isFeatureFlagEnabled;
+  resetEmergencyFallbackEnvCache();
+}
+function isEmergencyFallbackEnvEnabled() {
+  const now = Date.now();
+  if (emergencyFallbackFlagCache && emergencyFallbackFlagCache.expiresAt > now) {
+    return emergencyFallbackFlagCache.value;
+  }
+  let value;
+  try {
+    value = emergencyFallbackFeatureFlagResolver(EMERGENCY_FALLBACK_FLAG_KEY);
+  } catch (error) {
+    console.warn(
+      "[emergencyFallback] Feature flag resolution failed; falling back to raw env:",
+      error instanceof Error ? error.message : error
+    );
+    value = isEmergencyFallbackRawEnvEnabled();
+  }
+  emergencyFallbackFlagCache = {
+    value,
+    expiresAt: now + EMERGENCY_FALLBACK_FLAG_CACHE_MS
+  };
+  return value;
+}
+function shouldUseFallback(status, errorBody, requestHasTools, config = EMERGENCY_FALLBACK_CONFIG) {
+  if (!config.enabled) return { shouldFallback: false, reason: "emergency fallback disabled" };
+  if (!isEmergencyFallbackEnvEnabled()) {
+    return {
+      shouldFallback: false,
+      reason: "emergency fallback disabled via OMNIROUTE_EMERGENCY_FALLBACK"
+    };
+  }
+  if (config.skipForToolRequests && requestHasTools) {
+    return { shouldFallback: false, reason: "skipped: request has tools" };
+  }
+  if (config.triggerOn402 && status === 402) {
+    return {
+      shouldFallback: true,
+      reason: `HTTP 402 \u2192 emergency fallback to ${config.provider}/${config.model}`,
+      provider: config.provider,
+      model: config.model,
+      maxOutputTokens: config.maxOutputTokens
+    };
+  }
+  if (config.triggerOnBudgetKeywords && errorBody) {
+    const lowerBody = errorBody.toLowerCase();
+    const matched = config.budgetKeywords.find((kw) => lowerBody.includes(kw.toLowerCase()));
+    if (matched) {
+      return {
+        shouldFallback: true,
+        reason: `Budget error detected ('${matched}') \u2192 emergency fallback to ${config.provider}/${config.model}`,
+        provider: config.provider,
+        model: config.model,
+        maxOutputTokens: config.maxOutputTokens
+      };
+    }
+  }
+  return { shouldFallback: false, reason: "no budget error detected" };
+}
+function isFallbackDecision(result) {
+  return result.shouldFallback === true;
+}
+export {
+  EMERGENCY_FALLBACK_CONFIG,
+  isEmergencyFallbackEnvEnabled,
+  isFallbackDecision,
+  resetEmergencyFallbackEnvCache,
+  setEmergencyFallbackFeatureFlagResolverForTest,
+  shouldUseFallback
+};

package/open-sse/services/errorClassifier.js

@@ -0,0 +1,190 @@
+/**
+ * errorClassifier.js — Classifies upstream errors for routing decisions.
+ * Handles: account deactivation, credits exhausted, daily quota, OAuth invalid, etc.
+ */
+
+import {
+  isAccountDeactivated,
+  isCreditsExhausted,
+  isDailyQuotaExhausted,
+  isOAuthInvalidToken,
+} from "./accountFallback.js";
+import { getProviderCategory } from "../config/providerRegistry.js";
+
+// Terminal stop signals where an empty content payload is still a legitimate,
+// successful completion (truncated at the token limit, or a tool-call turn) —
+// NOT a silent "fake success" failure. Used to avoid rewriting a valid HTTP 200
+// (e.g. a Claude Code `max_tokens: 1` connectivity ping) into a synthetic 502.
+const LEGIT_EMPTY_CLAUDE_STOP = new Set(["max_tokens", "tool_use"]);
+const LEGIT_EMPTY_OPENAI_FINISH = new Set(["length", "tool_calls"]);
+
+export function isEmptyContentResponse(responseBody) {
+  if (!responseBody || typeof responseBody !== "object") return false;
+
+  const body = responseBody;
+
+  if (Array.isArray(body.choices)) {
+    const firstChoice = body.choices[0];
+    if (!firstChoice) return true;
+
+    const message = firstChoice.message;
+    const delta = firstChoice.delta;
+
+    const content = message?.content ?? delta?.content;
+    const reasoningContent = message?.reasoning_content ?? delta?.reasoning_content;
+    const hasToolCalls =
+      (Array.isArray(message?.tool_calls) && message.tool_calls.length > 0) ||
+      (Array.isArray(delta?.tool_calls) && delta.tool_calls.length > 0);
+
+    const hasContent = content !== null && content !== undefined && content !== "";
+    const hasReasoning =
+      reasoningContent !== null && reasoningContent !== undefined && reasoningContent !== "";
+
+    // A response truncated at the token limit (finish_reason "length") is a valid,
+    // successful completion even with empty text — do not flag it as a fake success.
+    const finishReason =
+      typeof firstChoice.finish_reason === "string" ? firstChoice.finish_reason : "";
+    if (LEGIT_EMPTY_OPENAI_FINISH.has(finishReason)) return false;
+
+    return !hasContent && !hasReasoning && !hasToolCalls;
+  }
+
+  if (Array.isArray(body.content)) {
+    if (body.content.length > 0) return false;
+    // Empty content array: a response truncated at max_tokens (or one that stopped
+    // to emit a tool_use block) is a legitimate terminal state, not a silent
+    // failure. Only flag empty content when no such terminal stop_reason is present.
+    const stopReason = typeof body.stop_reason === "string" ? body.stop_reason : "";
+    return !LEGIT_EMPTY_CLAUDE_STOP.has(stopReason);
+  }
+
+  if (typeof body.text === "string") {
+    return body.text.trim() === "";
+  }
+
+  if ("content" in body) {
+    const content = body.content;
+    return content === null || content === undefined || content === "";
+  }
+
+  return false;
+}
+
+export const PROVIDER_ERROR_TYPES = {
+  RATE_LIMITED: "rate_limited",
+  UNAUTHORIZED: "unauthorized",
+  ACCOUNT_DEACTIVATED: "account_deactivated",
+  FORBIDDEN: "forbidden",
+  SERVER_ERROR: "server_error",
+  QUOTA_EXHAUSTED: "quota_exhausted",
+  PROJECT_ROUTE_ERROR: "project_route_error",
+  CONTEXT_OVERFLOW: "context_overflow",
+  OAUTH_INVALID_TOKEN: "oauth_invalid_token",
+  EMPTY_CONTENT: "empty_content",
+};
+
+export const CONTEXT_OVERFLOW_SIGNALS = [
+  "context overflow",
+  "prompt too large",
+  "context window",
+  "maximum context",
+  "exceeds context",
+  "input too long",
+  "token limit",
+  "too many tokens",
+  "context length",
+  "exceed.*context",
+  "messages exceed",
+];
+
+export const CONTEXT_OVERFLOW_REGEX = new RegExp(CONTEXT_OVERFLOW_SIGNALS.join("|"), "i");
+
+export function isContextOverflow(errorText) {
+  return CONTEXT_OVERFLOW_REGEX.test(String(errorText || ""));
+}
+
+function responseBodyToString(responseBody) {
+  if (typeof responseBody === "string") return responseBody;
+  if (responseBody !== null && typeof responseBody === "object") {
+    try {
+      return JSON.stringify(responseBody);
+    } catch {
+      return "";
+    }
+  }
+  return "";
+}
+
+function shouldPreserveQuotaSignalsFor429(provider) {
+  if (!provider) return true;
+  return getProviderCategory(provider) === "oauth";
+}
+
+export function classifyProviderError(statusCode, responseBody, provider) {
+  const bodyStr = responseBodyToString(responseBody);
+  const creditsExhausted = isCreditsExhausted(bodyStr);
+  const accountDeactivated = isAccountDeactivated(bodyStr);
+  const oauthInvalid = isOAuthInvalidToken(bodyStr);
+  const preserveQuota429 = shouldPreserveQuotaSignalsFor429(provider);
+
+  if (creditsExhausted && [400, 402, 403].includes(statusCode)) {
+    return PROVIDER_ERROR_TYPES.QUOTA_EXHAUSTED;
+  }
+
+  if (creditsExhausted && statusCode === 429 && preserveQuota429) {
+    return PROVIDER_ERROR_TYPES.QUOTA_EXHAUSTED;
+  }
+
+  // API-key providers route 429 cooldowns through the resilience-aware fallback layer.
+  // OAuth providers keep their existing quota semantics because some of them encode
+  // longer quota windows as 429 responses.
+  if (statusCode === 429) {
+    if (preserveQuota429 && isDailyQuotaExhausted(bodyStr)) {
+      return PROVIDER_ERROR_TYPES.QUOTA_EXHAUSTED;
+    }
+    return PROVIDER_ERROR_TYPES.RATE_LIMITED;
+  }
+
+  if (statusCode === 401) {
+    if (oauthInvalid) {
+      return PROVIDER_ERROR_TYPES.OAUTH_INVALID_TOKEN;
+    }
+    return accountDeactivated
+      ? PROVIDER_ERROR_TYPES.ACCOUNT_DEACTIVATED
+      : PROVIDER_ERROR_TYPES.UNAUTHORIZED;
+  }
+
+  if (statusCode === 402) return PROVIDER_ERROR_TYPES.QUOTA_EXHAUSTED;
+  if (statusCode === 403 && accountDeactivated) {
+    return PROVIDER_ERROR_TYPES.ACCOUNT_DEACTIVATED;
+  }
+  if (statusCode === 403) {
+    const p = (provider || "").toLowerCase();
+    const isCloudCodeProvider =
+      p === "antigravity" ||
+      p === "gemini-cli" ||
+      p.includes("cloudcode") ||
+      p.includes("cloud-code");
+    const recoverableProject403 =
+      bodyStr.includes("has not been used in project") ||
+      bodyStr.includes("SERVICE_DISABLED") ||
+      bodyStr.includes("accessNotConfigured") ||
+      bodyStr.includes("PERMISSION_DENIED") ||
+      /\bit is disabled\b/i.test(bodyStr) ||
+      isCloudCodeProvider;
+    if (recoverableProject403) {
+      return PROVIDER_ERROR_TYPES.PROJECT_ROUTE_ERROR;
+    }
+    if (provider && getProviderCategory(provider) === "apikey") {
+      return null;
+    }
+    return PROVIDER_ERROR_TYPES.FORBIDDEN;
+  }
+  if (statusCode >= 500) return PROVIDER_ERROR_TYPES.SERVER_ERROR;
+
+  if (statusCode === 400 && isContextOverflow(bodyStr)) {
+    return PROVIDER_ERROR_TYPES.CONTEXT_OVERFLOW;
+  }
+
+  return null;
+}

package/open-sse/services/evalRouting.js

@@ -0,0 +1,201 @@
+import { listModelEvalRunsForRouting } from "../../lib/db/evals.ts";
+import { parseModel } from "./model.ts";
+const DEFAULT_EVAL_ROUTING_CONFIG = {
+  enabled: false,
+  suiteIds: [],
+  maxAgeHours: 24 * 30,
+  minCases: 1,
+  qualityWeight: 0.85,
+  latencyWeight: 0.15,
+  cacheTtlMs: 6e4
+};
+const MAX_EVAL_ROUTING_CACHE_ENTRIES = 200;
+const evalRoutingCache = /* @__PURE__ */ new Map();
+function pruneEvalRoutingCache(now = Date.now()) {
+  for (const [key, entry] of evalRoutingCache) {
+    if (entry.expiresAt <= now) evalRoutingCache.delete(key);
+  }
+  while (evalRoutingCache.size > MAX_EVAL_ROUTING_CACHE_ENTRIES) {
+    const oldestKey = evalRoutingCache.keys().next().value;
+    if (!oldestKey) break;
+    evalRoutingCache.delete(oldestKey);
+  }
+}
+function isRecord(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function toStringList(value, maxItems) {
+  if (!Array.isArray(value)) return [];
+  return [...new Set(value.map((entry) => String(entry || "").trim()).filter(Boolean))].slice(
+    0,
+    maxItems
+  );
+}
+function clampNumber(value, fallback, min, max) {
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed)) return fallback;
+  return Math.min(max, Math.max(min, parsed));
+}
+function normalizeEvalRoutingConfig(rawConfig) {
+  const raw = isRecord(rawConfig) ? rawConfig : {};
+  const qualityWeight = clampNumber(
+    raw.qualityWeight,
+    DEFAULT_EVAL_ROUTING_CONFIG.qualityWeight,
+    0,
+    1
+  );
+  const latencyWeight = clampNumber(
+    raw.latencyWeight,
+    DEFAULT_EVAL_ROUTING_CONFIG.latencyWeight,
+    0,
+    1
+  );
+  const weightTotal = qualityWeight + latencyWeight;
+  return {
+    enabled: raw.enabled === true,
+    suiteIds: toStringList(raw.suiteIds, 50),
+    maxAgeHours: clampNumber(raw.maxAgeHours, DEFAULT_EVAL_ROUTING_CONFIG.maxAgeHours, 1, 24 * 365),
+    minCases: Math.floor(
+      clampNumber(raw.minCases, DEFAULT_EVAL_ROUTING_CONFIG.minCases, 1, 1e5)
+    ),
+    qualityWeight: weightTotal > 0 ? qualityWeight / weightTotal : 1,
+    latencyWeight: weightTotal > 0 ? latencyWeight / weightTotal : 0,
+    cacheTtlMs: Math.floor(
+      clampNumber(raw.cacheTtlMs, DEFAULT_EVAL_ROUTING_CONFIG.cacheTtlMs, 1e3, 3e5)
+    )
+  };
+}
+function getTargetAliases(modelStr) {
+  const parsed = parseModel(modelStr);
+  const modelId = typeof parsed.model === "string" ? parsed.model.trim() : "";
+  return [...new Set([modelStr.trim(), modelId].filter(Boolean))];
+}
+function buildCacheKey(targetIds, config) {
+  return JSON.stringify({
+    targetIds: [...targetIds].sort(),
+    suiteIds: [...config.suiteIds].sort(),
+    maxAgeHours: config.maxAgeHours,
+    minCases: config.minCases
+  });
+}
+function getEvalRuns(targetIds, config) {
+  const now = Date.now();
+  pruneEvalRoutingCache(now);
+  const cacheKey = buildCacheKey(targetIds, config);
+  const cached = evalRoutingCache.get(cacheKey);
+  if (cached && cached.expiresAt > now) return cached.runs;
+  const runs = listModelEvalRunsForRouting({
+    targetIds,
+    suiteIds: config.suiteIds,
+    maxAgeHours: config.maxAgeHours
+  });
+  evalRoutingCache.set(cacheKey, { expiresAt: now + config.cacheTtlMs, runs });
+  pruneEvalRoutingCache(now);
+  return runs;
+}
+function dedupeLatestRunsBySuite(runs) {
+  const latest = /* @__PURE__ */ new Map();
+  for (const run of runs) {
+    const key = run.suiteId;
+    const current = latest.get(key);
+    if (!current || new Date(run.createdAt).getTime() > new Date(current.createdAt).getTime()) {
+      latest.set(key, run);
+    }
+  }
+  return Array.from(latest.values());
+}
+function calculateTargetScore(runs, config, bestLatencyMs) {
+  const validRuns = dedupeLatestRunsBySuite(runs).filter(
+    (run) => run.summary.total >= config.minCases
+  );
+  if (validRuns.length === 0) return null;
+  const totalCases = validRuns.reduce((sum, run) => sum + run.summary.total, 0);
+  if (totalCases < config.minCases) return null;
+  const passRate = validRuns.reduce((sum, run) => sum + run.summary.passRate * run.summary.total, 0) / totalCases;
+  const latencyWeight = validRuns.reduce(
+    (sum, run) => sum + Math.max(0, run.avgLatencyMs) * run.summary.total,
+    0
+  );
+  const avgLatencyMs = latencyWeight / totalCases;
+  const qualityScore = Math.max(0, Math.min(1, passRate / 100));
+  const latencyScore = bestLatencyMs && avgLatencyMs > 0 ? Math.max(0, Math.min(1, bestLatencyMs / avgLatencyMs)) : 0.5;
+  const score = qualityScore * config.qualityWeight + latencyScore * config.latencyWeight;
+  return {
+    score,
+    passRate,
+    avgLatencyMs,
+    totalCases,
+    runs: validRuns.length
+  };
+}
+function orderTargetsByEvalScores(targets, rawConfig, log = {}) {
+  const config = normalizeEvalRoutingConfig(rawConfig);
+  if (!config.enabled || targets.length <= 1) return targets;
+  const aliasesByIndex = targets.map((target) => getTargetAliases(target.modelStr));
+  const targetIds = [...new Set(aliasesByIndex.flat())];
+  if (targetIds.length === 0) return targets;
+  let runs;
+  try {
+    runs = getEvalRuns(targetIds, config);
+  } catch (error) {
+    log.warn?.("COMBO", "Eval-driven routing skipped because eval history could not be loaded", {
+      error: error instanceof Error ? error.message : String(error)
+    });
+    return targets;
+  }
+  if (runs.length === 0) return targets;
+  const runsByTargetId = /* @__PURE__ */ new Map();
+  for (const run of runs) {
+    const targetId = run.target.id;
+    if (!targetId) continue;
+    const bucket = runsByTargetId.get(targetId) || [];
+    bucket.push(run);
+    runsByTargetId.set(targetId, bucket);
+  }
+  const runsByIndex = aliasesByIndex.map((aliases) => {
+    const byId = /* @__PURE__ */ new Map();
+    for (const alias of aliases) {
+      for (const run of runsByTargetId.get(alias) || []) {
+        byId.set(run.id, run);
+      }
+    }
+    return Array.from(byId.values());
+  });
+  const candidateLatencies = runsByIndex.flatMap((targetRuns) => dedupeLatestRunsBySuite(targetRuns)).filter((run) => run.summary.total >= config.minCases && run.avgLatencyMs > 0).map((run) => run.avgLatencyMs);
+  const bestLatencyMs = candidateLatencies.length > 0 ? Math.min(...candidateLatencies) : null;
+  const entries = targets.map((target, index) => ({
+    target,
+    index,
+    score: calculateTargetScore(runsByIndex[index] || [], config, bestLatencyMs)
+  }));
+  const scoredCount = entries.filter((entry) => entry.score).length;
+  if (scoredCount === 0) return targets;
+  entries.sort((left, right) => {
+    if (left.score && right.score) {
+      const delta = right.score.score - left.score.score;
+      if (Math.abs(delta) > 1e-4) return delta;
+      return left.index - right.index;
+    }
+    if (left.score) return -1;
+    if (right.score) return 1;
+    return left.index - right.index;
+  });
+  log.info?.(
+    "COMBO",
+    `Eval-driven routing: ranked ${scoredCount}/${targets.length} targets by eval history`
+  );
+  log.debug?.(
+    "COMBO",
+    `Eval-driven routing scores: ${entries.filter((entry) => entry.score).map(
+      (entry) => `${entry.target.modelStr}=${entry.score?.score.toFixed(3)} pass=${entry.score?.passRate.toFixed(1)} cases=${entry.score?.totalCases}`
+    ).join(", ")}`
+  );
+  return entries.map((entry) => entry.target);
+}
+function resetEvalRoutingCache() {
+  evalRoutingCache.clear();
+}
+export {
+  orderTargetsByEvalScores,
+  resetEvalRoutingCache
+};

package/open-sse/services/freeWebSearch.js

@@ -0,0 +1,4 @@
+// Stub: freeWebSearch - not implemented in AMRouter yet
+export async function freeWebSearch(query, options = {}) {
+  return { results: [], message: "Free web search not configured" };
+}