@fudrouter/fsrouter 0.6.64 → 0.6.65

package/open-sse/services/combo/quotaScoring.js

@@ -0,0 +1,226 @@
+import { clamp01 } from "../../utils/number.ts";
+import { isRecord } from "./comboData.ts";
+import { RESET_WINDOW_NAMES } from "./types.ts";
+const RESET_AWARE_SESSION_WINDOW_MS = 5 * 60 * 60 * 1e3;
+const RESET_AWARE_WEEKLY_WINDOW_MS = 7 * 24 * 60 * 60 * 1e3;
+const RESET_AWARE_SESSION_REMAINING_WEIGHT = 0.45;
+const RESET_AWARE_SESSION_RESET_PRESSURE_WEIGHT = 0.55;
+const RESET_AWARE_WEEKLY_REMAINING_WEIGHT = 0.25;
+const RESET_AWARE_WEEKLY_RESET_PRESSURE_WEIGHT = 0.75;
+const RESET_AWARE_DEFAULTS = {
+  sessionWeight: 0.35,
+  weeklyWeight: 0.65,
+  tieBandPercent: 5,
+  exhaustionGuardPercent: 10
+};
+const RESET_WINDOW_DEFAULT_TIE_BAND_MS = 6e4;
+function finiteNumberOrNull(value) {
+  const numericValue = Number(value);
+  return Number.isFinite(numericValue) ? numericValue : null;
+}
+function getPercentConfig(value, fallback) {
+  const numericValue = finiteNumberOrNull(value);
+  if (numericValue === null) return fallback;
+  return Math.max(0, Math.min(100, numericValue));
+}
+function getWeightConfig(value, fallback) {
+  const numericValue = finiteNumberOrNull(value);
+  if (numericValue === null || numericValue < 0) return fallback;
+  return numericValue;
+}
+function getDurationConfig(value, fallback, max) {
+  const numericValue = finiteNumberOrNull(value);
+  if (numericValue === null || numericValue < 0) return fallback;
+  return Math.min(max, Math.floor(numericValue));
+}
+function resolveResetAwareConfig(config) {
+  const sessionWeight = getWeightConfig(
+    config?.resetAwareSessionWeight,
+    RESET_AWARE_DEFAULTS.sessionWeight
+  );
+  const weeklyWeight = getWeightConfig(
+    config?.resetAwareWeeklyWeight,
+    RESET_AWARE_DEFAULTS.weeklyWeight
+  );
+  const totalWeight = sessionWeight + weeklyWeight;
+  const normalizedSessionWeight = totalWeight > 0 ? sessionWeight / totalWeight : RESET_AWARE_DEFAULTS.sessionWeight;
+  return {
+    sessionWeight: normalizedSessionWeight,
+    weeklyWeight: 1 - normalizedSessionWeight,
+    tieBand: getPercentConfig(config?.resetAwareTieBandPercent, RESET_AWARE_DEFAULTS.tieBandPercent) / 100,
+    exhaustionGuard: getPercentConfig(
+      config?.resetAwareExhaustionGuardPercent,
+      RESET_AWARE_DEFAULTS.exhaustionGuardPercent
+    ) / 100,
+    quotaCacheTtlMs: getDurationConfig(config?.resetAwareQuotaCacheTtlMs, 0, 3e5),
+    quotaCacheMaxStaleMs: getDurationConfig(config?.resetAwareQuotaCacheMaxStaleMs, 0, 36e5)
+  };
+}
+function resolveResetWindowConfig(config) {
+  const rawWindows = Array.isArray(config?.resetWindowWindows) ? config.resetWindowWindows : null;
+  const windows = rawWindows?.filter(
+    (windowName) => RESET_WINDOW_NAMES.includes(String(windowName))
+  ).filter((windowName, index, array) => array.indexOf(windowName) === index);
+  const effectiveWindows = windows && windows.length > 0 ? windows : config?.resetWindowIncludeSession === true ? ["weekly", "session"] : ["weekly"];
+  return {
+    windows: effectiveWindows,
+    tieBandMs: Math.max(
+      0,
+      finiteNumberOrNull(config?.resetWindowTieBandMs) ?? RESET_WINDOW_DEFAULT_TIE_BAND_MS
+    ),
+    quotaCacheTtlMs: getDurationConfig(config?.resetWindowQuotaCacheTtlMs, 0, 3e5),
+    quotaCacheMaxStaleMs: getDurationConfig(config?.resetWindowQuotaCacheMaxStaleMs, 0, 36e5)
+  };
+}
+function resolveSlaRoutingPolicy(config) {
+  if (!config) return void 0;
+  const nestedSla = isRecord(config.sla) ? config.sla : {};
+  const targetP95Ms = finiteNumberOrNull(config.slaTargetP95Ms ?? nestedSla.targetP95Ms);
+  const maxErrorRate = finiteNumberOrNull(config.slaMaxErrorRate ?? nestedSla.maxErrorRate);
+  const maxCostPer1MTokens = finiteNumberOrNull(
+    config.slaMaxCostPer1MTokens ?? nestedSla.maxCostPer1MTokens
+  );
+  const hardConstraints = config.slaHardConstraints ?? nestedSla.hardConstraints;
+  const policy = {};
+  if (targetP95Ms !== null && targetP95Ms > 0) policy.targetP95Ms = targetP95Ms;
+  if (maxErrorRate !== null && maxErrorRate >= 0) policy.maxErrorRate = clamp01(maxErrorRate);
+  if (maxCostPer1MTokens !== null && maxCostPer1MTokens > 0) {
+    policy.maxCostPer1MTokens = maxCostPer1MTokens;
+  }
+  if (typeof hardConstraints === "boolean") policy.hardConstraints = hardConstraints;
+  return Object.keys(policy).length > 0 ? policy : void 0;
+}
+function getResetAwareProvider(target) {
+  const provider = (target.providerId || target.provider || "").toLowerCase();
+  return provider || null;
+}
+function normalizeResetAt(value) {
+  if (typeof value === "string" && value.trim().length > 0) return value.trim();
+  if (typeof value === "number" && Number.isFinite(value)) return String(value);
+  return null;
+}
+function parseResetTimeMs(resetAt) {
+  if (!resetAt) return NaN;
+  const resetTime = Date.parse(resetAt);
+  if (Number.isFinite(resetTime)) return resetTime;
+  if (!/^\d+(?:\.\d+)?$/.test(resetAt)) return NaN;
+  const numericResetAt = Number(resetAt);
+  if (!Number.isFinite(numericResetAt)) return NaN;
+  return numericResetAt < 1e10 ? numericResetAt * 1e3 : numericResetAt;
+}
+function getQuotaWindow(quota, key) {
+  if (!isRecord(quota)) return null;
+  const window = quota[key];
+  if (!isRecord(window)) return null;
+  const percentUsed = finiteNumberOrNull(window.percentUsed);
+  const resetAt = normalizeResetAt(window.resetAt);
+  return { percentUsed, resetAt };
+}
+function normalizeWindowPercentUsed(value) {
+  const numericValue = finiteNumberOrNull(value);
+  if (numericValue === null) return null;
+  if (numericValue > 1) return clamp01(numericValue / 100);
+  return clamp01(numericValue);
+}
+function getNamedQuotaWindow(quota, windowName) {
+  if (!quota || !isRecord(quota)) return null;
+  if (windowName === "session") return getQuotaWindow(quota, "window5h");
+  if (windowName === "weekly") {
+    return getQuotaWindow(quota, "window7d") || getQuotaWindow(quota, "windowWeekly");
+  }
+  if (windowName === "monthly") return getQuotaWindow(quota, "windowMonthly");
+  return null;
+}
+function getWindowsMapQuotaWindow(quota, windowName) {
+  if (!quota || !isRecord(quota) || !isRecord(quota.windows)) return null;
+  const candidates = Object.entries(quota.windows).map(([key, value]) => ({ key: key.toLowerCase(), value })).filter(({ key }) => key === windowName || key.startsWith(`${windowName} `));
+  if (candidates.length === 0) return null;
+  candidates.sort((a, b) => a.key.localeCompare(b.key));
+  const window = candidates[0].value;
+  if (!isRecord(window)) return null;
+  return {
+    percentUsed: normalizeWindowPercentUsed(window.percentUsed),
+    resetAt: normalizeResetAt(window.resetAt)
+  };
+}
+function resolveQuotaWindowByName(quota, windowName) {
+  return getNamedQuotaWindow(quota, windowName) || getWindowsMapQuotaWindow(quota, windowName);
+}
+function getResetUrgency(resetAt, windowMs) {
+  if (!resetAt) return 0.5;
+  const resetTime = parseResetTimeMs(resetAt);
+  if (!Number.isFinite(resetTime)) return 0.5;
+  const msUntilReset = resetTime - Date.now();
+  if (msUntilReset <= 0) return 1;
+  return clamp01(1 - msUntilReset / windowMs);
+}
+function scoreQuotaWindow(remaining, resetAt, windowMs, remainingWeight, resetPressureWeight) {
+  const normalizedRemaining = clamp01(remaining);
+  const resetUrgency = getResetUrgency(resetAt, windowMs);
+  const resetPressure = resetUrgency * (1 - normalizedRemaining);
+  return remainingWeight * normalizedRemaining + resetPressureWeight * resetPressure;
+}
+function scoreResetAwareQuota(quota, config) {
+  if (!quota || !isRecord(quota)) return { score: 0.5 };
+  if (quota.limitReached === true) return { score: -Infinity };
+  const overallPercentUsed = clamp01(finiteNumberOrNull(quota.percentUsed) ?? 0.5);
+  const sessionWindow = getQuotaWindow(quota, "window5h");
+  const weeklyWindow = getQuotaWindow(quota, "window7d") || getQuotaWindow(quota, "windowWeekly");
+  const sessionRemaining = clamp01(1 - (sessionWindow?.percentUsed ?? overallPercentUsed));
+  const weeklyRemaining = clamp01(1 - (weeklyWindow?.percentUsed ?? overallPercentUsed));
+  const sessionScore = scoreQuotaWindow(
+    sessionRemaining,
+    sessionWindow?.resetAt,
+    RESET_AWARE_SESSION_WINDOW_MS,
+    RESET_AWARE_SESSION_REMAINING_WEIGHT,
+    RESET_AWARE_SESSION_RESET_PRESSURE_WEIGHT
+  );
+  const weeklyScore = scoreQuotaWindow(
+    weeklyRemaining,
+    weeklyWindow?.resetAt ?? normalizeResetAt(quota.resetAt),
+    RESET_AWARE_WEEKLY_WINDOW_MS,
+    RESET_AWARE_WEEKLY_REMAINING_WEIGHT,
+    RESET_AWARE_WEEKLY_RESET_PRESSURE_WEIGHT
+  );
+  let score = config.sessionWeight * sessionScore + config.weeklyWeight * weeklyScore;
+  if (config.exhaustionGuard > 0 && sessionRemaining < config.exhaustionGuard) {
+    score *= Math.max(0.05, sessionRemaining / config.exhaustionGuard);
+  }
+  return { score };
+}
+function getResetWindowTimestampMs(quota, windows) {
+  if (!quota || !isRecord(quota) || quota.limitReached === true) return Infinity;
+  let selectedResetMs = Infinity;
+  for (const windowName of windows) {
+    const window = resolveQuotaWindowByName(quota, windowName);
+    const resetMs = parseResetTimeMs(window?.resetAt ?? null);
+    if (Number.isFinite(resetMs)) {
+      selectedResetMs = Math.min(selectedResetMs, resetMs);
+    }
+  }
+  if (!Number.isFinite(selectedResetMs)) {
+    selectedResetMs = parseResetTimeMs(normalizeResetAt(quota.resetAt));
+  }
+  return Number.isFinite(selectedResetMs) ? selectedResetMs : Infinity;
+}
+function getResetWindowHorizonMs(windows) {
+  if (windows.includes("monthly")) return 30 * 24 * 60 * 60 * 1e3;
+  if (windows.includes("weekly")) return RESET_AWARE_WEEKLY_WINDOW_MS;
+  return RESET_AWARE_SESSION_WINDOW_MS;
+}
+function calculateResetWindowAffinity(quota, config) {
+  const resetMs = getResetWindowTimestampMs(quota, config.windows);
+  if (!Number.isFinite(resetMs)) return 0.5;
+  const msUntilReset = resetMs - Date.now();
+  if (msUntilReset <= 0) return 1;
+  return clamp01(1 - msUntilReset / getResetWindowHorizonMs(config.windows));
+}
+export {
+  calculateResetWindowAffinity,
+  getResetAwareProvider,
+  getResetWindowTimestampMs,
+  resolveResetAwareConfig,
+  resolveResetWindowConfig,
+  resolveSlaRoutingPolicy,
+  scoreResetAwareQuota
+};

package/open-sse/services/combo/quotaShareConcurrency.js

@@ -0,0 +1,25 @@
+import * as semaphore from "../rateLimitSemaphore.ts";
+function quotaShareConcurrencyKey(connectionId) {
+  return `qsconn:${connectionId}`;
+}
+async function acquireQuotaShareConcurrencySlot(target, cap, opts, log) {
+  const connectionId = target?.connectionId ?? "";
+  if (!connectionId || cap === null || cap <= 0) return null;
+  try {
+    return await semaphore.acquire(quotaShareConcurrencyKey(connectionId), {
+      maxConcurrency: cap,
+      timeoutMs: opts.queueTimeoutMs,
+      maxQueueSize: opts.maxQueueSize
+    });
+  } catch {
+    log.warn(
+      "COMBO",
+      `Quota-share concurrency: connection ${connectionId} gate saturated (cap=${cap}) \u2014 proceeding without a slot`
+    );
+    return null;
+  }
+}
+export {
+  acquireQuotaShareConcurrencySlot,
+  quotaShareConcurrencyKey
+};

package/open-sse/services/combo/quotaShareInflight.js

@@ -0,0 +1,50 @@
+const DEFAULT_LEASE_MS = 12e4;
+const _inflightMap = /* @__PURE__ */ new Map();
+function incrementInflight(connectionId, leaseMs = DEFAULT_LEASE_MS, nowMs = Date.now()) {
+  if (!connectionId) return 0;
+  pruneExpired(nowMs);
+  const slot = _inflightMap.get(connectionId);
+  const base = slot && slot.expiresAtMs > nowMs ? slot.count : 0;
+  const newCount = base + 1;
+  _inflightMap.set(connectionId, { count: newCount, expiresAtMs: nowMs + leaseMs });
+  return newCount;
+}
+function decrementInflight(connectionId, nowMs = Date.now()) {
+  if (!connectionId) return;
+  const slot = _inflightMap.get(connectionId);
+  if (!slot || slot.expiresAtMs <= nowMs) {
+    _inflightMap.delete(connectionId);
+    return;
+  }
+  const newCount = Math.max(0, slot.count - 1);
+  if (newCount === 0) {
+    _inflightMap.delete(connectionId);
+  } else {
+    _inflightMap.set(connectionId, { count: newCount, expiresAtMs: slot.expiresAtMs });
+  }
+}
+function getInflight(connectionId, nowMs = Date.now()) {
+  if (!connectionId) return 0;
+  const slot = _inflightMap.get(connectionId);
+  if (!slot || slot.expiresAtMs <= nowMs) return 0;
+  return slot.count;
+}
+function pruneExpired(nowMs) {
+  for (const [key, slot] of _inflightMap) {
+    if (slot.expiresAtMs <= nowMs) _inflightMap.delete(key);
+  }
+}
+function _clearInflightForTest() {
+  _inflightMap.clear();
+}
+function _inflightSizeForTest() {
+  return _inflightMap.size;
+}
+export {
+  DEFAULT_LEASE_MS,
+  _clearInflightForTest,
+  _inflightSizeForTest,
+  decrementInflight,
+  getInflight,
+  incrementInflight
+};

package/open-sse/services/combo/quotaShareStrategy.js

@@ -0,0 +1,130 @@
+import { isBucketSaturated } from '../../../dist/lib/quota/accountBuckets.ts.js';
+import { incrementInflight, decrementInflight, getInflight } from "./quotaShareInflight.ts";
+const MAX_DRR_COMBOS = 200;
+const _drrState = /* @__PURE__ */ new Map();
+function getDrrDeficits(comboName) {
+  let deficits = _drrState.get(comboName);
+  if (!deficits) {
+    if (_drrState.size >= MAX_DRR_COMBOS) {
+      const oldestKey = _drrState.keys().next().value;
+      if (oldestKey !== void 0) _drrState.delete(oldestKey);
+    }
+    deficits = /* @__PURE__ */ new Map();
+    _drrState.set(comboName, deficits);
+  }
+  return deficits;
+}
+function bareModelName(modelStr) {
+  const slash = modelStr.indexOf("/");
+  return slash >= 0 ? modelStr.slice(slash + 1) : modelStr;
+}
+function filterEligibleBySaturation(targets, modelStr, nowMs) {
+  const modelName = bareModelName(modelStr);
+  const eligible = targets.filter((target) => {
+    const connId = target.connectionId ?? "";
+    if (connId === "") return true;
+    const saturated = isBucketSaturated(connId, "5h", nowMs) || isBucketSaturated(connId, "7d", nowMs) || modelName !== "" && isBucketSaturated(connId, `7d:${modelName}`, nowMs);
+    return !saturated;
+  });
+  return eligible.length > 0 ? eligible : targets;
+}
+function resolveConnectionCap(connectionId, caps) {
+  if (!connectionId || !caps) return null;
+  const cap = caps.get(connectionId);
+  if (typeof cap !== "number" || !Number.isFinite(cap) || cap <= 0) return null;
+  return cap;
+}
+function partitionByConcurrencyCap(targets, caps, nowMs) {
+  if (!caps || caps.size === 0) return { withRoom: targets, atCap: [] };
+  const withRoom = [];
+  const atCap = [];
+  for (const target of targets) {
+    const connId = target.connectionId ?? "";
+    const cap = resolveConnectionCap(connId, caps);
+    if (cap === null) {
+      withRoom.push(target);
+      continue;
+    }
+    if (getInflight(connId, nowMs) >= cap) {
+      atCap.push(target);
+    } else {
+      withRoom.push(target);
+    }
+  }
+  if (withRoom.length === 0) return { withRoom: targets, atCap: [] };
+  return { withRoom, atCap };
+}
+function applyDrr(targets, comboName) {
+  if (targets.length <= 1) return targets.slice();
+  const deficits = getDrrDeficits(comboName);
+  const totalWeight = targets.reduce((sum, t) => sum + normalizeWeight(t.weight), 0);
+  for (const target of targets) {
+    const quantum = normalizeWeight(target.weight) / totalWeight;
+    deficits.set(target.executionKey, (deficits.get(target.executionKey) ?? 0) + quantum);
+  }
+  let winner = targets[0];
+  let bestDeficit = deficits.get(winner.executionKey) ?? 0;
+  for (let i = 1; i < targets.length; i++) {
+    const d = deficits.get(targets[i].executionKey) ?? 0;
+    if (d > bestDeficit) {
+      bestDeficit = d;
+      winner = targets[i];
+    }
+  }
+  deficits.set(winner.executionKey, bestDeficit - 1);
+  const rest = targets.filter((t) => t.executionKey !== winner.executionKey);
+  return [winner, ...rest];
+}
+function normalizeWeight(weight) {
+  return Number.isFinite(weight) && weight > 0 ? weight : 1;
+}
+function pickByInflightP2C(first, second, nowMs) {
+  const loadFirst = getInflight(first.connectionId ?? "", nowMs);
+  const loadSecond = getInflight(second.connectionId ?? "", nowMs);
+  return loadSecond < loadFirst ? 1 : 0;
+}
+function selectQuotaShareTarget(targets, comboName, modelStr, nowMs = Date.now(), options) {
+  const noOp = () => {
+  };
+  if (targets.length === 0) {
+    return { target: null, orderedTargets: [], decrementInflight: noOp };
+  }
+  const eligible = filterEligibleBySaturation(targets, modelStr, nowMs);
+  const saturatedDeprioritized = targets.filter((t) => !eligible.includes(t));
+  const { withRoom, atCap } = partitionByConcurrencyCap(
+    eligible,
+    options?.maxConcurrentByConnection,
+    nowMs
+  );
+  const ordered = applyDrr(withRoom, comboName);
+  let winner;
+  let rest;
+  if (ordered.length >= 2 && pickByInflightP2C(ordered[0], ordered[1], nowMs) === 1) {
+    winner = ordered[1];
+    rest = [ordered[0], ...ordered.slice(2)];
+  } else {
+    winner = ordered[0];
+    rest = ordered.slice(1);
+  }
+  const winnerConnectionId = winner.connectionId ?? "";
+  if (winnerConnectionId) incrementInflight(winnerConnectionId, void 0, nowMs);
+  const orderedTargets = [winner, ...rest, ...atCap, ...saturatedDeprioritized];
+  let released = false;
+  const release = () => {
+    if (released) return;
+    released = true;
+    if (winnerConnectionId) decrementInflight(winnerConnectionId, nowMs);
+  };
+  return { target: winner, orderedTargets, decrementInflight: release };
+}
+function _clearDrrStateForTest() {
+  _drrState.clear();
+}
+function _getDrrDeficitForTest(comboName, executionKey) {
+  return _drrState.get(comboName)?.get(executionKey) ?? 0;
+}
+export {
+  _clearDrrStateForTest,
+  _getDrrDeficitForTest,
+  selectQuotaShareTarget
+};

package/open-sse/services/combo/resolveAutoStrategy.js

@@ -0,0 +1,231 @@
+import { unavailableResponse } from "../../utils/error.ts";
+import { selectProvider as selectAutoProvider } from "../autoCombo/engine.ts";
+import {
+  resolveRequestModePack,
+  parseRequestBudgetCap
+} from "../autoCombo/requestControls.ts";
+import { selectWithStrategy } from "../autoCombo/routerStrategy.ts";
+import { buildComplexityRoutingHint } from "../autoCombo/complexityRouter";
+import { recordComboIntent } from "../comboMetrics.ts";
+import { estimateTokens } from "../contextManager.ts";
+import { classifyWithConfig } from "../intentClassifier.ts";
+import { parseModel } from "../model.ts";
+import { supportsToolCalling } from "../modelCapabilities.ts";
+import { parseAutoConfig } from "./autoConfig.ts";
+import { dedupeTargetsByExecutionKey } from "./comboData.ts";
+import { getModelContextLimitForModelString } from "./comboStructure.ts";
+import {
+  _registerExecutionCandidates,
+  expandAutoComboCandidatePool,
+  extractPromptForIntent,
+  getIntentConfig,
+  mapIntentToTaskType,
+  scoreAutoTargets
+} from "./autoStrategy.ts";
+async function resolveAutoStrategyOrder(deps) {
+  const {
+    body,
+    combo,
+    settings,
+    config,
+    relayOptions,
+    resilienceSettings,
+    log,
+    buildAutoCandidates
+  } = deps;
+  let orderedTargets = deps.orderedTargets;
+  let autoUsedExplicitRouter = false;
+  const requestHasTools = Array.isArray(body?.tools) && body.tools.length > 0;
+  let eligibleTargets = [...orderedTargets];
+  if (requestHasTools) {
+    const filtered = eligibleTargets.filter((target) => supportsToolCalling(target.modelStr));
+    if (filtered.length > 0) {
+      eligibleTargets = filtered;
+    } else {
+      log.warn(
+        "COMBO",
+        "Auto strategy: all candidates filtered by tool-calling policy, falling back to full pool"
+      );
+    }
+  }
+  const requestMessages = body.messages;
+  const estimatedInputTokens = estimateTokens(
+    typeof requestMessages === "string" || requestMessages !== null && typeof requestMessages === "object" ? requestMessages : []
+  );
+  if (estimatedInputTokens > 0) {
+    const filteredByContext = eligibleTargets.filter((target) => {
+      const limit = getModelContextLimitForModelString(target.modelStr);
+      if (limit === null || limit === void 0) return true;
+      return limit >= estimatedInputTokens;
+    });
+    if (filteredByContext.length > 0) {
+      log.debug?.(
+        "COMBO",
+        `Auto strategy: context-window filter kept ${filteredByContext.length}/${eligibleTargets.length} candidates (est. ${estimatedInputTokens} tokens)`
+      );
+      eligibleTargets = filteredByContext;
+    } else {
+      log.warn(
+        "COMBO",
+        `Auto strategy: all candidates filtered by context-window policy (est. ${estimatedInputTokens} tokens), falling back to full pool`
+      );
+    }
+    eligibleTargets = await expandAutoComboCandidatePool(eligibleTargets, combo);
+  }
+  const prompt = extractPromptForIntent(body);
+  const systemPrompt = typeof combo?.system_message === "string" ? combo.system_message : void 0;
+  const intentConfig = getIntentConfig(settings, combo);
+  const intent = classifyWithConfig(prompt, intentConfig, systemPrompt);
+  recordComboIntent(combo.name, intent);
+  const taskType = mapIntentToTaskType(intent);
+  const {
+    routingStrategy,
+    candidatePool,
+    weights,
+    explorationRate,
+    budgetCap: configBudgetCap,
+    modePack: configModePack,
+    resetWindowConfig,
+    slaPolicy
+  } = parseAutoConfig(combo, eligibleTargets);
+  const requestBudgetCap = parseRequestBudgetCap(relayOptions?.budgetCap);
+  const budgetCap = requestBudgetCap ?? configBudgetCap;
+  const requestModePack = resolveRequestModePack(relayOptions?.mode);
+  const modePack = requestModePack.override ? requestModePack.modePack : configModePack;
+  if (requestModePack.override || requestBudgetCap !== void 0) {
+    log.debug?.(
+      "COMBO",
+      `Auto strategy: per-request controls applied (mode=${requestModePack.override ? requestModePack.modePack ?? "balanced" : "\u2014"}, budgetCap=${requestBudgetCap ?? "\u2014"})`
+    );
+  }
+  let lastKnownGoodProvider;
+  try {
+    const { getLKGP } = await import('../../../dist/lib/localDb.js');
+    const lkgp = await getLKGP(combo.name, combo.id || combo.name);
+    if (lkgp) lastKnownGoodProvider = lkgp.provider;
+  } catch (err) {
+    log.warn("COMBO", "Failed to retrieve Last Known Good Provider. This is non-fatal.", { err });
+  }
+  const autoCandidateResilienceSettings = relayOptions?.bypassProviderQuotaPolicy === true ? {
+    ...resilienceSettings,
+    quotaPreflight: {
+      ...resilienceSettings.quotaPreflight,
+      enabled: false
+    }
+  } : resilienceSettings;
+  const candidates = await buildAutoCandidates(
+    eligibleTargets,
+    combo.name,
+    relayOptions?.sessionId,
+    resetWindowConfig,
+    autoCandidateResilienceSettings
+  );
+  const routableCandidates = candidates.filter(
+    (candidate) => candidate.quotaCutoffBlocked !== true
+  );
+  const quotaBlockedCount = candidates.length - routableCandidates.length;
+  if (quotaBlockedCount > 0) {
+    log.info(
+      "COMBO",
+      `Auto strategy: quota cutoff skipped ${quotaBlockedCount}/${candidates.length} account candidates`
+    );
+  }
+  _registerExecutionCandidates(routableCandidates);
+  if (candidates.length > 0 && routableCandidates.length === 0) {
+    return {
+      earlyResponse: unavailableResponse(
+        429,
+        "All auto strategy candidates are below configured quota cutoffs"
+      )
+    };
+  }
+  if (routableCandidates.length > 0) {
+    let selectedProvider = null;
+    let selectedModel = null;
+    let selectionReason = "";
+    if (routingStrategy !== "rules") {
+      try {
+        const decision = selectWithStrategy(
+          routableCandidates,
+          {
+            taskType,
+            requestHasTools,
+            lastKnownGoodProvider,
+            estimatedInputTokens,
+            sla: slaPolicy
+          },
+          routingStrategy
+        );
+        selectedProvider = decision.provider;
+        selectedModel = decision.model;
+        selectionReason = decision.reason;
+        autoUsedExplicitRouter = true;
+      } catch (err) {
+        log.warn(
+          "COMBO",
+          `Auto strategy '${routingStrategy}' failed (${err?.message || "unknown"}), falling back to rules`
+        );
+      }
+    }
+    if (!selectedProvider || !selectedModel) {
+      const selection = selectAutoProvider(
+        {
+          id: combo.id || combo.name,
+          name: combo.name,
+          type: "auto",
+          candidatePool,
+          weights,
+          modePack,
+          budgetCap,
+          explorationRate
+        },
+        routableCandidates,
+        taskType
+      );
+      selectedProvider = selection.provider;
+      selectedModel = selection.model;
+      selectionReason = `score=${selection.score.toFixed(3)}${selection.isExploration ? " (exploration)" : ""}`;
+    }
+    const autoManifestHint = config.complexityAwareRouting === true ? buildComplexityRoutingHint(
+      eligibleTargets.filter((t) => t.kind === "model"),
+      body,
+      log
+    ) : null;
+    const scoredTargets = scoreAutoTargets(
+      eligibleTargets,
+      routableCandidates,
+      taskType,
+      weights,
+      autoManifestHint
+    );
+    const rankedTargets = scoredTargets.map((entry) => entry.target);
+    const selectedTarget = scoredTargets.find((entry) => {
+      const parsed = parseModel(entry.target.modelStr);
+      const modelId = parsed.model || entry.target.modelStr;
+      return entry.target.provider === selectedProvider && modelId === selectedModel;
+    })?.target || rankedTargets[0] || eligibleTargets[0];
+    if (!selectedTarget) {
+      return {
+        earlyResponse: unavailableResponse(
+          429,
+          "No auto strategy targets remained after quota cutoff filtering"
+        )
+      };
+    }
+    orderedTargets = dedupeTargetsByExecutionKey(
+      [selectedTarget, ...rankedTargets, ...eligibleTargets].filter(
+        (entry) => entry !== void 0 && entry !== null
+      )
+    );
+    log.info(
+      "COMBO",
+      `Auto selection: ${selectedTarget?.modelStr || `${selectedProvider}/${selectedModel}`} | intent=${intent} task=${taskType} | strategy=${routingStrategy} | ${selectionReason}`
+    );
+  } else {
+    log.warn("COMBO", "Auto strategy has no candidates, keeping default ordering");
+  }
+  return { orderedTargets, autoUsedExplicitRouter };
+}
+export {
+  resolveAutoStrategyOrder
+};