@fudrouter/fsrouter 0.6.63 → 0.6.64

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

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

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

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

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

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