@fudrouter/fsrouter 0.6.61 → 0.6.63

package/open-sse/services/codexQuotaFetcher.js

@@ -0,0 +1,312 @@
+import {
+  CODEX_SPARK_QUOTA_SESSION,
+  CODEX_SPARK_QUOTA_WEEKLY,
+  getCodexModelScope,
+  isCodexSparkLimitDescriptor
+} from "../config/codexQuotaScopes.js";
+import { registerQuotaFetcher, registerQuotaWindows } from "./quotaPreflight.js";
+import { registerMonitorFetcher } from "./quotaMonitor.js";
+import { throttleQuotaFetch } from "./quotaFetchThrottle.js";
+const CODEX_WINDOW_SESSION = "session";
+const CODEX_WINDOW_WEEKLY = "weekly";
+const CODEX_USAGE_URL = "https://chatgpt.com/backend-api/wham/usage";
+const CACHE_TTL_MS = 6e4;
+const quotaCache = /* @__PURE__ */ new Map();
+const _cacheCleanup = setInterval(() => {
+  const now = Date.now();
+  for (const [key, entry] of quotaCache) {
+    if (now - entry.fetchedAt > CACHE_TTL_MS * 5) {
+      quotaCache.delete(key);
+    }
+  }
+}, 5 * 6e4);
+if (typeof _cacheCleanup === "object" && "unref" in _cacheCleanup) {
+  _cacheCleanup.unref?.();
+}
+const MAX_CONNECTIONS = 100;
+const connectionRegistry = /* @__PURE__ */ new Map();
+const MAX_QUOTA_CACHE_ENTRIES = 200;
+function registerCodexConnection(connectionId, meta) {
+  if (!connectionRegistry.has(connectionId) && connectionRegistry.size >= MAX_CONNECTIONS) {
+    const oldestKey = connectionRegistry.keys().next().value;
+    if (oldestKey !== void 0) {
+      deleteQuotaCacheForConnection(oldestKey);
+      connectionRegistry.delete(oldestKey);
+    }
+  }
+  connectionRegistry.set(connectionId, meta);
+}
+function getQuotaCacheKey(connectionId, requestedModel) {
+  return `${connectionId}:${getCodexModelScope(requestedModel)}`;
+}
+function deleteQuotaCacheForConnection(connectionId) {
+  quotaCache.delete(connectionId);
+  const scopedKeys = Array.from(quotaCache.keys()).filter(
+    (key) => key.startsWith(`${connectionId}:`)
+  );
+  for (const key of scopedKeys) quotaCache.delete(key);
+}
+function unregisterCodexConnection(connectionId) {
+  deleteQuotaCacheForConnection(connectionId);
+  connectionRegistry.delete(connectionId);
+}
+function getRequestedModel(connection) {
+  if (!connection || typeof connection !== "object") return null;
+  const directModel = connection.requestedModel ?? connection.model;
+  return typeof directModel === "string" && directModel.trim().length > 0 ? directModel.trim() : null;
+}
+function getCodexConnectionMeta(connectionId, connection) {
+  if (connection && typeof connection === "object") {
+    const providerSpecificData = connection.providerSpecificData && typeof connection.providerSpecificData === "object" && !Array.isArray(connection.providerSpecificData) ? connection.providerSpecificData : {};
+    const accessToken = typeof connection.accessToken === "string" && connection.accessToken.trim().length > 0 ? connection.accessToken : null;
+    const workspaceId = typeof providerSpecificData.workspaceId === "string" && providerSpecificData.workspaceId.trim().length > 0 ? providerSpecificData.workspaceId : void 0;
+    if (accessToken) {
+      const meta = { accessToken, ...workspaceId ? { workspaceId } : {} };
+      if (!connectionRegistry.has(connectionId) && connectionRegistry.size >= MAX_CONNECTIONS) {
+        const oldestKey = connectionRegistry.keys().next().value;
+        if (oldestKey !== void 0) {
+          deleteQuotaCacheForConnection(oldestKey);
+          connectionRegistry.delete(oldestKey);
+        }
+      }
+      connectionRegistry.set(connectionId, meta);
+      return meta;
+    }
+  }
+  return connectionRegistry.get(connectionId) || null;
+}
+function getDominantResetAt(quota) {
+  if (quota.window7d.percentUsed > quota.window5h.percentUsed) {
+    return quota.window7d.resetAt || quota.window5h.resetAt;
+  }
+  if (quota.window5h.percentUsed > quota.window7d.percentUsed) {
+    return quota.window5h.resetAt || quota.window7d.resetAt;
+  }
+  return quota.window7d.resetAt || quota.window5h.resetAt;
+}
+async function fetchCodexQuota(connectionId, connection) {
+  const requestedModel = getRequestedModel(connection);
+  const cacheKey = getQuotaCacheKey(connectionId, requestedModel);
+  const cached = quotaCache.get(cacheKey);
+  if (cached && Date.now() - cached.fetchedAt < CACHE_TTL_MS) {
+    return cached.quota;
+  }
+  const meta = getCodexConnectionMeta(connectionId, connection);
+  if (!meta?.accessToken) {
+    return null;
+  }
+  try {
+    const headers = {
+      Authorization: `Bearer ${meta.accessToken}`,
+      "Content-Type": "application/json",
+      Accept: "application/json"
+    };
+    if (meta.workspaceId) {
+      headers["chatgpt-account-id"] = meta.workspaceId;
+    }
+    await throttleQuotaFetch();
+    const response = await fetch(CODEX_USAGE_URL, {
+      method: "GET",
+      headers,
+      signal: AbortSignal.timeout(8e3)
+    });
+    if (!response.ok) {
+      if (response.status === 401 || response.status === 403) {
+        deleteQuotaCacheForConnection(connectionId);
+        connectionRegistry.delete(connectionId);
+      }
+      return null;
+    }
+    const data = await response.json();
+    const quota = parseCodexUsageResponse(data, requestedModel);
+    if (!quota) return null;
+    if (!quotaCache.has(connectionId) && quotaCache.size >= MAX_QUOTA_CACHE_ENTRIES) {
+      const oldestCacheKey = quotaCache.keys().next().value;
+      if (oldestCacheKey !== void 0) quotaCache.delete(oldestCacheKey);
+    }
+    quotaCache.set(cacheKey, { quota, fetchedAt: Date.now() });
+    return quota;
+  } catch {
+    return null;
+  }
+}
+function toNumber(value, fallback = 0) {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "string") {
+    const parsed = parseFloat(value);
+    if (Number.isFinite(parsed)) return parsed;
+  }
+  return fallback;
+}
+function toRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function parseWindowReset(window) {
+  const resetAt = toNumber(window["reset_at"] ?? window["resetAt"], 0);
+  if (resetAt > 0) {
+    return new Date(resetAt * 1e3).toISOString();
+  }
+  const resetAfterSeconds = toNumber(
+    window["reset_after_seconds"] ?? window["resetAfterSeconds"],
+    0
+  );
+  if (resetAfterSeconds > 0) {
+    return new Date(Date.now() + resetAfterSeconds * 1e3).toISOString();
+  }
+  return null;
+}
+function parseCodexWindow(window) {
+  if (!window || Object.keys(window).length === 0) return null;
+  const percentUsed = toNumber(window["used_percent"] ?? window["usedPercent"], 0) / 100;
+  return { percentUsed, resetAt: parseWindowReset(window) };
+}
+function parseBankedResetCredits(data) {
+  const resetCredits = toRecord(data["rate_limit_reset_credits"] ?? data["rateLimitResetCredits"]);
+  const availableCount = resetCredits["available_count"] ?? resetCredits["availableCount"];
+  const count = toNumber(availableCount, NaN);
+  return Number.isFinite(count) ? count : void 0;
+}
+function parseRateLimitReachedType(data) {
+  const reachedType = data["rate_limit_reached_type"] ?? data["rateLimitReachedType"];
+  if (typeof reachedType === "string" && reachedType.trim().length > 0) return reachedType.trim();
+  const reachedTypeObj = toRecord(reachedType);
+  const type = reachedTypeObj["type"];
+  return typeof type === "string" && type.trim().length > 0 ? type.trim() : void 0;
+}
+function findSparkRateLimit(data) {
+  const additional = data["additional_rate_limits"] ?? data["additionalRateLimits"];
+  if (!Array.isArray(additional)) return null;
+  for (const entryValue of additional) {
+    const entry = toRecord(entryValue);
+    if (!isCodexSparkLimitDescriptor(
+      entry["limit_name"],
+      entry["limitName"],
+      entry["metered_feature"],
+      entry["meteredFeature"],
+      entry["limit_id"],
+      entry["limitId"],
+      entry["id"],
+      entry["name"],
+      entry["title"],
+      entry["model"],
+      entry["model_id"],
+      entry["modelId"]
+    )) {
+      continue;
+    }
+    return toRecord(entry["rate_limit"] ?? entry["rateLimit"]);
+  }
+  return null;
+}
+function getCodexRateLimitWindows(rateLimit) {
+  return {
+    primary: parseCodexWindow(toRecord(rateLimit["primary_window"] ?? rateLimit["primaryWindow"])),
+    secondary: parseCodexWindow(
+      toRecord(rateLimit["secondary_window"] ?? rateLimit["secondaryWindow"])
+    )
+  };
+}
+function assignCodexWindows(target, rateLimit, names) {
+  const { primary, secondary } = getCodexRateLimitWindows(rateLimit);
+  if (primary) target[names.primary] = primary;
+  if (secondary) target[names.secondary] = secondary;
+}
+function getSelectedCodexRateLimit(normalRateLimit, sparkRateLimit, useSparkWindows) {
+  if (useSparkWindows) return sparkRateLimit;
+  return normalRateLimit;
+}
+function parseCodexUsageResponse(data, requestedModel) {
+  const obj = toRecord(data);
+  const normalRateLimit = toRecord(obj["rate_limit"] ?? obj["rateLimit"]);
+  const sparkRateLimit = findSparkRateLimit(obj);
+  const useSparkWindows = getCodexModelScope(requestedModel) === "spark";
+  const selectedRateLimit = getSelectedCodexRateLimit(
+    normalRateLimit,
+    sparkRateLimit,
+    useSparkWindows
+  );
+  if (!selectedRateLimit) return null;
+  const { primary: parsedPrimary, secondary: parsedSecondary } = getCodexRateLimitWindows(selectedRateLimit);
+  if (!parsedPrimary && !parsedSecondary) return null;
+  const window5h = parsedPrimary ?? { percentUsed: 0, resetAt: null };
+  const window7d = parsedSecondary ?? { percentUsed: 0, resetAt: null };
+  const worstPercentUsed = Math.max(window5h.percentUsed, window7d.percentUsed);
+  const limitReached = Boolean(
+    selectedRateLimit["limit_reached"] ?? selectedRateLimit["limitReached"]
+  );
+  const windows = {};
+  assignCodexWindows(windows, selectedRateLimit, {
+    primary: useSparkWindows ? CODEX_SPARK_QUOTA_SESSION : CODEX_WINDOW_SESSION,
+    secondary: useSparkWindows ? CODEX_SPARK_QUOTA_WEEKLY : CODEX_WINDOW_WEEKLY
+  });
+  const allWindows = {
+    ...windows
+  };
+  if (sparkRateLimit) {
+    assignCodexWindows(allWindows, sparkRateLimit, {
+      primary: CODEX_SPARK_QUOTA_SESSION,
+      secondary: CODEX_SPARK_QUOTA_WEEKLY
+    });
+  }
+  assignCodexWindows(allWindows, normalRateLimit, {
+    primary: CODEX_WINDOW_SESSION,
+    secondary: CODEX_WINDOW_WEEKLY
+  });
+  const bankedResetCredits = parseBankedResetCredits(obj);
+  const rateLimitReachedType = parseRateLimitReachedType(obj);
+  return {
+    used: Math.round(worstPercentUsed * 100),
+    total: 100,
+    percentUsed: worstPercentUsed,
+    resetAt: getDominantResetAt({ window5h, window7d }),
+    // Per-window breakdown for the preflight evaluator. For Spark requests this
+    // intentionally contains ONLY Spark windows, so Spark exhaustion does not
+    // preflight-block normal Codex requests (and vice versa).
+    windows,
+    allWindows,
+    // Legacy fields preserved for existing consumers (quotaMonitor, cooldown
+    // computation in accountFallback). These mirror the selected scope entries
+    // but keep the historical names — do not remove without checking callers.
+    window5h,
+    window7d,
+    limitReached,
+    // Banked reset credits (display-only, eligibility-gated — issue #5199).
+    ...bankedResetCredits !== void 0 ? { bankedResetCredits } : {},
+    ...rateLimitReachedType !== void 0 ? { rateLimitReachedType } : {}
+  };
+}
+function getCodexQuotaCooldownMs(quota, threshold = 0.95) {
+  const now = Date.now();
+  if (quota.window7d.percentUsed >= threshold && quota.window7d.resetAt) {
+    const resetTime = new Date(quota.window7d.resetAt).getTime();
+    if (resetTime > now) return resetTime - now;
+  }
+  if (quota.window5h.percentUsed >= threshold && quota.window5h.resetAt) {
+    const resetTime = new Date(quota.window5h.resetAt).getTime();
+    if (resetTime > now) return resetTime - now;
+  }
+  return 0;
+}
+function invalidateCodexQuotaCache(connectionId) {
+  deleteQuotaCacheForConnection(connectionId);
+}
+function registerCodexQuotaFetcher() {
+  registerQuotaFetcher("codex", fetchCodexQuota);
+  registerMonitorFetcher("codex", fetchCodexQuota);
+  registerQuotaWindows("codex", [
+    CODEX_WINDOW_SESSION,
+    CODEX_WINDOW_WEEKLY,
+    CODEX_SPARK_QUOTA_SESSION,
+    CODEX_SPARK_QUOTA_WEEKLY
+  ]);
+}
+export {
+  CODEX_WINDOW_SESSION,
+  CODEX_WINDOW_WEEKLY,
+  fetchCodexQuota,
+  getCodexQuotaCooldownMs,
+  invalidateCodexQuotaCache,
+  registerCodexConnection,
+  registerCodexQuotaFetcher,
+  unregisterCodexConnection
+};

package/open-sse/services/codexVerbosity.js

@@ -0,0 +1,30 @@
+const VERBOSITY_LEVELS = /* @__PURE__ */ new Set(["low", "medium", "high"]);
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function normalizeLevel(value) {
+  if (typeof value !== "string") return void 0;
+  const level = value.toLowerCase();
+  return VERBOSITY_LEVELS.has(level) ? level : void 0;
+}
+function normalizeCodexVerbosity(body) {
+  const textRecord = asRecord(body.text);
+  let verbosity = textRecord ? normalizeLevel(textRecord.verbosity) : void 0;
+  const topLevel = normalizeLevel(body.verbosity);
+  if (topLevel) verbosity = topLevel;
+  delete body.verbosity;
+  const nextText = textRecord ? { ...textRecord } : {};
+  if (verbosity) {
+    nextText.verbosity = verbosity;
+  } else {
+    delete nextText.verbosity;
+  }
+  if (Object.keys(nextText).length > 0) {
+    body.text = nextText;
+  } else {
+    delete body.text;
+  }
+}
+export {
+  normalizeCodexVerbosity
+};

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

@@ -0,0 +1,12 @@
+function createComboContext(opts) {
+  return {
+    body: opts.body,
+    combo: opts.combo,
+    settings: opts.settings ?? null,
+    relayOptions: opts.relayOptions ?? null,
+    log: opts.log
+  };
+}
+export {
+  createComboContext
+};

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

@@ -0,0 +1,51 @@
+const FINGERPRINT_PROVIDERS = /* @__PURE__ */ new Set(["mimocode", "mcode", "opencode"]);
+function isFingerprintProvider(provider) {
+  return FINGERPRINT_PROVIDERS.has(provider);
+}
+function getConnectionFingerprints(connection) {
+  if (!connection || typeof connection !== "object") return [];
+  const psd = connection["providerSpecificData"];
+  if (!psd || typeof psd !== "object") return [];
+  const fps = psd["fingerprints"];
+  if (!Array.isArray(fps)) return [];
+  return fps.filter((fp) => typeof fp === "string" && fp.trim().length > 0);
+}
+function hasMultipleFingerprints(connection) {
+  return getConnectionFingerprints(connection).length > 1;
+}
+function buildFingerprintExecutionKey(originalKey, fingerprint, isFirst) {
+  if (isFirst) return originalKey;
+  return `${originalKey}@fp:${fingerprint}`;
+}
+function expandTargetsByFingerprints(targets, connectionById, getProvider) {
+  const result = [];
+  for (const target of targets) {
+    const provider = getProvider(target);
+    const { connectionId } = target;
+    if (!connectionId || !isFingerprintProvider(provider)) {
+      result.push(target);
+      continue;
+    }
+    const connection = connectionById.get(connectionId);
+    const fingerprints = getConnectionFingerprints(connection);
+    if (fingerprints.length <= 1) {
+      result.push(target);
+      continue;
+    }
+    for (let i = 0; i < fingerprints.length; i++) {
+      const isFirst = i === 0;
+      result.push({
+        ...target,
+        executionKey: buildFingerprintExecutionKey(target.executionKey, fingerprints[i], isFirst)
+      });
+    }
+  }
+  return result;
+}
+export {
+  buildFingerprintExecutionKey,
+  expandTargetsByFingerprints,
+  getConnectionFingerprints,
+  hasMultipleFingerprints,
+  isFingerprintProvider
+};

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

@@ -0,0 +1,28 @@
+function clampUtil(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) return 0;
+  if (value <= 0) return 0;
+  if (value >= 1) return 1;
+  return value;
+}
+function computeHeadroom(sat) {
+  const u5 = clampUtil(sat?.util5h);
+  const u7 = clampUtil(sat?.util7d);
+  return 1 - Math.max(u5, u7);
+}
+function rankByHeadroom(candidates, satByKey, keyOf) {
+  if (candidates.length <= 1) return candidates;
+  const decorated = candidates.map((candidate, index) => ({
+    candidate,
+    index,
+    headroom: computeHeadroom(satByKey.get(keyOf(candidate)))
+  }));
+  decorated.sort((a, b) => {
+    if (b.headroom !== a.headroom) return b.headroom - a.headroom;
+    return a.index - b.index;
+  });
+  return decorated.map((entry) => entry.candidate);
+}
+export {
+  computeHeadroom,
+  rankByHeadroom
+};

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

@@ -0,0 +1,87 @@
+import {
+  evaluateQuotaCutoff,
+  getQuotaFetcher
+} from "../quotaPreflight.ts";
+import { getProviderConnectionById } from '../../../dist/lib/db/providers.js';
+import {
+  resolveResilienceSettings
+} from '../../../dist/lib/resilience/settings.js';
+import { fetchResetAwareQuotaWithCache } from "./quotaStrategies.ts";
+function asThresholdMap(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+  const result = {};
+  for (const [key, raw] of Object.entries(value)) {
+    const numeric = Number(raw);
+    if (key && Number.isFinite(numeric)) result[key] = numeric;
+  }
+  return result;
+}
+function quotaWindowLookupNames(provider, windowName) {
+  const names = [windowName];
+  const lower = windowName.toLowerCase();
+  if (lower !== windowName) names.push(lower);
+  if (provider === "codex") {
+    if (lower.includes("session") || lower === "5h" || lower === "five_hour") names.push("session");
+    if (lower.includes("weekly") || lower === "7d" || lower === "seven_day") names.push("weekly");
+    if (lower.includes("monthly") || lower === "30d") names.push("monthly");
+  }
+  return [...new Set(names)];
+}
+function buildAutoQuotaThresholds(provider, connection, resilienceSettings) {
+  const quotaPreflight = (resilienceSettings ?? resolveResilienceSettings(null))?.quotaPreflight;
+  const defaultThresholdPercent = quotaPreflight?.defaultThresholdPercent ?? 2;
+  const warnThresholdPercent = quotaPreflight?.warnThresholdPercent ?? 20;
+  const providerWindowMap = asThresholdMap(quotaPreflight?.providerWindowDefaults?.[provider]);
+  const perConnectionWindowOverrides = asThresholdMap(connection?.quotaWindowThresholds);
+  return {
+    resolveMinRemainingPercent: (windowName) => {
+      if (windowName !== null) {
+        for (const lookupWindowName of quotaWindowLookupNames(provider, windowName)) {
+          const override = perConnectionWindowOverrides[lookupWindowName];
+          if (typeof override === "number") return override;
+          const providerDefault = providerWindowMap[lookupWindowName];
+          if (typeof providerDefault === "number") return providerDefault;
+        }
+      }
+      return defaultThresholdPercent;
+    },
+    resolveWarnRemainingPercent: () => warnThresholdPercent
+  };
+}
+async function resolveQuotaExhaustionCutoffForTarget(provider, connectionId, resilienceSettings, resetWindowConfig, comboName, log) {
+  const quotaCutoffEnabled = (resilienceSettings ?? resolveResilienceSettings(null))?.quotaPreflight?.enabled === true;
+  if (!quotaCutoffEnabled || !provider || !connectionId) return { blocked: false };
+  const fetcher = getQuotaFetcher(provider);
+  if (!fetcher) return { blocked: false };
+  let connection;
+  try {
+    connection = await getProviderConnectionById(connectionId);
+  } catch {
+    connection = void 0;
+  }
+  try {
+    const quota = await fetchResetAwareQuotaWithCache({
+      provider,
+      connectionId,
+      connection,
+      fetcher,
+      config: resetWindowConfig,
+      log,
+      comboName
+    });
+    const cutoffDecision = evaluateQuotaCutoff(
+      quota,
+      buildAutoQuotaThresholds(provider, connection, resilienceSettings)
+    );
+    if (!cutoffDecision.proceed) {
+      return { blocked: true, reason: cutoffDecision.reason || "quota_exhausted" };
+    }
+  } catch {
+    return { blocked: false };
+  }
+  return { blocked: false };
+}
+export {
+  buildAutoQuotaThresholds,
+  resolveQuotaExhaustionCutoffForTarget
+};