@fudrouter/fsrouter 0.6.59 → 0.6.60

package/open-sse/services/emergencyFallback.js

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

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

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

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