@fudrouter/fsrouter 0.6.62 → 0.6.63

package/open-sse/services/qoderModels.js

@@ -0,0 +1,214 @@
+/**
+ * Qoder model catalog fetcher.
+ *
+ * Calls /algo/api/v2/model/list (COSY-signed) on the inference host to get
+ * the live catalog for an authenticated Qoder account, then caches the
+ * per-model `model_config` blocks by key. Chat requests later look up the
+ * exact server-published metadata for the model they want — Qoder's chat
+ * endpoint silently downgrades to a different model when the wrong
+ * model_config is sent.
+ *
+ * On any error the live cache stays empty and chatExecuteCall surfaces the
+ * problem to the user as "model config not yet fetched, retry shortly".
+ */
+
+import { createHash } from "crypto";
+
+import { proxyAwareFetch } from "../utils/proxyFetch.js";
+import { buildCosyHeaders } from "../shared/qoder/cosy.js";
+import {
+  QODER_MODEL_LIST_URL,
+} from "../shared/qoder/constants.js";
+
+const FETCH_TIMEOUT_MS = 15_000;
+const CACHE_TTL_MS = 60 * 60 * 1000; // 1h, same as the Kiro catalog
+
+/** @type {Map<string, { expiresAt: number, models: any[], rawConfigs: Map<string, object>, fetched: boolean }>} */
+const catalogCache = new Map();
+
+/**
+ * In-flight fetch promises keyed by cacheKey. Concurrent first-time
+ * callers (parallel chat windows) all observe the same Promise so we
+ * fan-out exactly one upstream request per credential per miss.
+ * @type {Map<string, Promise<{ expiresAt: number, models: any[], rawConfigs: Map<string, object>, fetched: boolean } | null>>}
+ */
+const inflight = new Map();
+
+/**
+ * Stable cache key per credential (so different login sessions for the same
+ * account share an entry).
+ */
+function cacheKey(credentials) {
+  const psd = credentials?.providerSpecificData || {};
+  const seed = psd.userId || credentials?.refreshToken || credentials?.accessToken || "anonymous";
+  return createHash("sha256").update(`qoder:${seed}`).digest("hex");
+}
+
+/**
+ * Strip credential -> COSY creds for buildCosyHeaders.
+ */
+function cosyCredsFromConnection(credentials) {
+  const psd = credentials?.providerSpecificData || {};
+  return {
+    userId: psd.userId,
+    authToken: credentials.accessToken,
+    name: credentials.displayName || "",
+    email: credentials.email || "",
+    machineId: psd.machineId || "",
+  };
+}
+
+/**
+ * Fetch the live model list for this credential. Returns:
+ *   { models: [{ id, name, contextLength, isVL, isReasoning, ... }, ...],
+ *     rawConfigs: Map<modelKey, modelConfigObject> }
+ * or `null` on any error.
+ */
+async function fetchQoderCatalogRaw(credentials, signal, proxyOptions = null) {
+  const creds = cosyCredsFromConnection(credentials);
+  if (!creds.userId || !creds.authToken) return null;
+
+  const headers = {
+    Accept: "application/json",
+    "Accept-Encoding": "identity",
+    ...buildCosyHeaders(Buffer.alloc(0), QODER_MODEL_LIST_URL, creds),
+  };
+
+  const controller = new AbortController();
+  let timer = null;
+  let abortListener = null;
+  let response;
+  try {
+    timer = setTimeout(() => controller.abort("timeout"), FETCH_TIMEOUT_MS);
+    if (signal && typeof signal.addEventListener === "function") {
+      // If the parent signal already aborted before we got here, the
+      // 'abort' event has already fired and addEventListener won't
+      // re-trigger it. Propagate the cancellation immediately.
+      if (signal.aborted) {
+        controller.abort(signal.reason);
+      } else {
+        abortListener = () => controller.abort(signal.reason);
+        signal.addEventListener("abort", abortListener);
+      }
+    }
+    response = await proxyAwareFetch(
+      QODER_MODEL_LIST_URL,
+      {
+        method: "GET",
+        headers,
+        signal: controller.signal,
+      },
+      proxyOptions,
+    );
+  } finally {
+    if (timer) clearTimeout(timer);
+    if (signal && abortListener) signal.removeEventListener("abort", abortListener);
+  }
+
+  if (!response.ok) return null;
+
+  const body = await response.json().catch(() => null);
+  if (!body || !Array.isArray(body.chat)) return null;
+
+  const models = [];
+  const rawConfigs = new Map();
+  for (const entry of body.chat) {
+    if (!entry || typeof entry !== "object") continue;
+    const key = entry.key;
+    if (!key) continue;
+
+    // Always cache the config — chat needs model_config even for UI-hidden
+    // models (enable:false). Upstream still accepts chat for these keys.
+    rawConfigs.set(key, entry);
+    if (entry.enable === false) continue;
+
+    const display = entry.display_name || key;
+    const ctx = Number(entry.max_input_tokens) || 131_072;
+    models.push({
+      id: key,
+      name: `${display}`,
+      contextLength: ctx,
+      isVL: !!entry.is_vl,
+      isReasoning: !!entry.is_reasoning,
+      maxOutputTokens: Number(entry.max_output_tokens) || 0,
+      description: entry.description || "",
+    });
+  }
+
+  return { models, rawConfigs };
+}
+
+/**
+ * Get the cached model_config block for a given model key, fetching the
+ * catalog first if needed. Returns null when the catalog can't be fetched
+ * (so callers can fall back to the static registry).
+ */
+export async function getQoderModelConfig(credentials, modelKey, options = {}) {
+  const cached = await resolveQoderModels(credentials, options);
+  if (!cached) return null;
+  const config = cached.rawConfigs.get(modelKey);
+  if (!config) return null;
+  // Defensive copy — chat code may mutate `key` to align with the alias path.
+  return { ...config, key: modelKey };
+}
+
+/**
+ * Resolve the live model catalog + raw configs for a credential. Caches
+ * results for CACHE_TTL_MS so repeated chat requests don't re-fetch, and
+ * deduplicates concurrent misses so parallel chat windows fan-out exactly
+ * one upstream request per credential.
+ */
+export async function resolveQoderModels(credentials, options = {}) {
+  if (!credentials?.accessToken) return null;
+  const psd = credentials.providerSpecificData || {};
+  if (!psd.userId) return null;
+
+  const key = cacheKey(credentials);
+  const now = Date.now();
+  if (!options.forceRefresh) {
+    const cached = catalogCache.get(key);
+    if (cached && cached.expiresAt > now) {
+      return cached;
+    }
+  }
+
+  // Coalesce concurrent misses on the same credential into one upstream call.
+  // forceRefresh callers still get their own fetch (they wanted fresh data).
+  const existing = inflight.get(key);
+  if (existing && !options.forceRefresh) {
+    return existing;
+  }
+
+  const fetchPromise = (async () => {
+    const fetched = await fetchQoderCatalogRaw(credentials, options.signal, options.proxyOptions);
+    if (!fetched) return null;
+    const entry = {
+      expiresAt: Date.now() + CACHE_TTL_MS,
+      models: fetched.models,
+      rawConfigs: fetched.rawConfigs,
+      fetched: true,
+    };
+    catalogCache.set(key, entry);
+    return entry;
+  })();
+
+  inflight.set(key, fetchPromise);
+  try {
+    return await fetchPromise;
+  } finally {
+    // Clear only if this is still the in-flight entry — a forceRefresh
+    // call that started later may have replaced it.
+    if (inflight.get(key) === fetchPromise) {
+      inflight.delete(key);
+    }
+  }
+}
+
+export function invalidateQoderCatalog(credentials) {
+  if (!credentials) return;
+  catalogCache.delete(cacheKey(credentials));
+}
+
+export function clearQoderCatalog() {
+  catalogCache.clear();
+}

package/open-sse/services/quotaFetchThrottle.js

@@ -0,0 +1,103 @@
+/**
+ * quotaFetchThrottle.js — global min-interval throttle for upstream quota fetches (#6009).
+ *
+ * Problem: when many accounts on one IP fetch provider quota, firing all the
+ * network calls in the same second looks like automation to the upstream and
+ * can get an OAuth token revoked.
+ *
+ * Solution: serialize the *actual network calls* through a single gate that
+ * spaces each fetch start at least `minIntervalMs` (+ optional jitter) after the
+ * previous one. Cache hits never reach the gate (the fetcher returns early), so
+ * this only paces genuine upstream requests, and it is fail-open: `acquire()`
+ * only ever awaits a timer, it cannot throw the quota fetch off its fail-open path.
+ *
+ * `minIntervalMs = 0` disables throttling entirely (byte-identical to before).
+ */
+
+const DEFAULT_MIN_INTERVAL_MS = 250;
+const MAX_MIN_INTERVAL_MS = 5000;
+const DEFAULT_JITTER_MS = 120;
+
+const realClock = {
+  now: () => Date.now(),
+  sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+};
+
+/**
+ * Serializes callers so each `acquire()` resolves at least `minIntervalMs`
+ * (plus up to `jitterMs`) after the previous one. Concurrent callers queue in
+ * arrival order; the first through the gate is never delayed.
+ */
+export class MinIntervalThrottle {
+  #minIntervalMs;
+  #jitterMs;
+  #clock;
+  #rand;
+  #lastStart = 0;
+  #chain = Promise.resolve();
+
+  constructor(options) {
+    this.#minIntervalMs = Math.max(0, options.minIntervalMs);
+    this.#jitterMs = Math.max(0, options.jitterMs ?? 0);
+    this.#clock = options.clock ?? realClock;
+    this.#rand = options.rand ?? Math.random;
+  }
+
+  async acquire() {
+    if (this.#minIntervalMs <= 0) return; // throttling disabled — no serialization cost
+    const prev = this.#chain;
+    let release;
+    this.#chain = new Promise((resolve) => {
+      release = resolve;
+    });
+    try {
+      await prev;
+      const now = this.#clock.now();
+      if (this.#lastStart !== 0) {
+        const jitter = this.#jitterMs > 0 ? Math.floor(this.#rand() * this.#jitterMs) : 0;
+        const wait = this.#lastStart + this.#minIntervalMs + jitter - now;
+        if (wait > 0) await this.#clock.sleep(wait);
+      }
+      this.#lastStart = this.#clock.now();
+    } finally {
+      release();
+    }
+  }
+}
+
+/**
+ * Resolve the configured min interval (ms) from the environment, clamped to a
+ * sane range. Garbage / negative → default; above the ceiling → clamped.
+ */
+export function resolveQuotaFetchMinIntervalMs(env = process.env) {
+  const raw = env.OMNIROUTE_QUOTA_FETCH_MIN_INTERVAL_MS;
+  if (raw === undefined || raw === null || raw.trim() === "") return DEFAULT_MIN_INTERVAL_MS;
+  const n = Number(raw.trim());
+  if (!Number.isFinite(n) || n < 0) return DEFAULT_MIN_INTERVAL_MS;
+  return Math.min(Math.round(n), MAX_MIN_INTERVAL_MS);
+}
+
+// ─── Shared process-wide instance (used by the provider quota fetchers) ───────
+
+let _sharedThrottle = null;
+
+/** Lazily build (and memoize) the shared throttle from the current env config. */
+export function getQuotaFetchThrottle() {
+  if (!_sharedThrottle) {
+    _sharedThrottle = new MinIntervalThrottle({
+      minIntervalMs: resolveQuotaFetchMinIntervalMs(),
+      jitterMs: DEFAULT_JITTER_MS,
+    });
+  }
+  return _sharedThrottle;
+}
+
+/** Await the shared throttle gate before issuing an upstream quota fetch. */
+export function throttleQuotaFetch() {
+  return getQuotaFetchThrottle().acquire();
+}
+
+/** Test-only: reset the memoized shared throttle (e.g. after changing env). */
+export function resetQuotaFetchThrottle() {
+  _sharedThrottle = null;
+}

package/open-sse/services/quotaMonitor.js

@@ -0,0 +1,310 @@
+/**
+ * quotaMonitor.js — Feature 06
+ * Monitoramento de Quota em Sessão Ativa
+ *
+ * Toggle: providerSpecificData.quotaMonitorEnabled (default: false)
+ * Polling adaptativo: NORMAL (60s) → CRITICAL (15s) → EXHAUSTED
+ * timer.unref() garante que o processo pode fechar normalmente.
+ * Alertas deduplicados por sessão (janela de 5min).
+ */
+
+import { registerQuotaFetcher } from "./quotaPreflight.js";
+import { getSessionInfo } from "../utils/sessionManager.js";
+
+export { registerQuotaFetcher };
+
+const NORMAL_INTERVAL_MS = 60_000;
+const CRITICAL_INTERVAL_MS = 15_000;
+const WARN_THRESHOLD = 0.8;
+const EXHAUSTION_THRESHOLD = 0.95;
+const ALERT_SUPPRESS_WINDOW_MS = 5 * 60_000;
+
+const activeMonitors = new Map();
+const MAX_ALERT_ENTRIES = 500;
+const alertSuppression = new Map();
+
+const _alertSweep = setInterval(() => {
+  const now = Date.now();
+  for (const [key, timestamp] of alertSuppression) {
+    if (now - timestamp > ALERT_SUPPRESS_WINDOW_MS) alertSuppression.delete(key);
+  }
+  while (alertSuppression.size > MAX_ALERT_ENTRIES) {
+    const oldestKey = alertSuppression.keys().next().value;
+    if (oldestKey !== undefined) alertSuppression.delete(oldestKey);
+    else break;
+  }
+}, 60_000);
+if (typeof _alertSweep === "object" && "unref" in _alertSweep) {
+  _alertSweep.unref();
+}
+// Registry mirror from quotaPreflight (same Map reference via re-export)
+const quotaFetcherRegistry = new Map();
+export function registerMonitorFetcher(provider, fetcher) {
+  quotaFetcherRegistry.set(provider, fetcher);
+  registerQuotaFetcher(provider, fetcher);
+}
+
+export function isQuotaMonitorEnabled(connection) {
+  const psd = connection?.providerSpecificData;
+  return psd?.quotaMonitorEnabled === true;
+}
+
+function suppressedAlert(sessionId, provider, accountId, percentUsed) {
+  const key = `${sessionId}:${provider}:${accountId}`;
+  const last = alertSuppression.get(key) ?? 0;
+  if (Date.now() - last < ALERT_SUPPRESS_WINDOW_MS) return false;
+  if (alertSuppression.size >= MAX_ALERT_ENTRIES && !alertSuppression.has(key)) {
+    const oldestKey = alertSuppression.keys().next().value;
+    if (oldestKey !== undefined) alertSuppression.delete(oldestKey);
+  }
+  alertSuppression.set(key, Date.now());
+  console.warn(
+    `[QuotaMonitor] session=${sessionId} ${provider}/${accountId}: ${(percentUsed * 100).toFixed(1)}% quota used`
+  );
+  return true;
+}
+
+function toIsoTimestamp(value) {
+  return typeof value === "number" && Number.isFinite(value) ? new Date(value).toISOString() : null;
+}
+
+function getMonitorStatus(percentUsed) {
+  if (!Number.isFinite(percentUsed)) return "idle";
+  if (percentUsed >= EXHAUSTION_THRESHOLD) return "exhausted";
+  if (percentUsed >= WARN_THRESHOLD) return "warning";
+  return "healthy";
+}
+
+function toPublicSnapshot(sessionId, state) {
+  return {
+    sessionId,
+    provider: state.provider,
+    accountId: state.accountId,
+    status: state.status,
+    startedAt: new Date(state.startedAt).toISOString(),
+    lastPolledAt: toIsoTimestamp(state.lastPolledAt),
+    lastSuccessAt: toIsoTimestamp(state.lastSuccessAt),
+    lastErrorAt: toIsoTimestamp(state.lastErrorAt),
+    lastError: state.lastError,
+    lastQuotaPercent: state.lastQuotaPercent,
+    lastQuotaUsed: state.lastQuotaUsed,
+    lastQuotaTotal: state.lastQuotaTotal,
+    lastResetAt: state.lastResetAt,
+    lastAlertAt: toIsoTimestamp(state.lastAlertAt),
+    nextPollDelayMs: state.nextPollDelayMs,
+    nextPollAt: toIsoTimestamp(state.nextPollAt),
+    totalPolls: state.totalPolls,
+    totalAlerts: state.totalAlerts,
+    consecutiveFailures: state.consecutiveFailures,
+  };
+}
+
+function sortSnapshots(snapshots) {
+  const severityRank = {
+    exhausted: 5,
+    warning: 4,
+    error: 3,
+    starting: 2,
+    idle: 1,
+    healthy: 0,
+  };
+
+  return [...snapshots].sort((left, right) => {
+    const severityDelta = severityRank[right.status] - severityRank[left.status];
+    if (severityDelta !== 0) return severityDelta;
+    const quotaDelta = (right.lastQuotaPercent ?? -1) - (left.lastQuotaPercent ?? -1);
+    if (quotaDelta !== 0) return quotaDelta;
+    return (
+      (right.lastPolledAt ? Date.parse(right.lastPolledAt) : 0) -
+      (left.lastPolledAt ? Date.parse(left.lastPolledAt) : 0)
+    );
+  });
+}
+
+function scheduleNextPoll(sessionId, intervalMs) {
+  const state = activeMonitors.get(sessionId);
+  if (!state || state.stopped) return;
+  state.nextPollDelayMs = intervalMs;
+  state.nextPollAt = Date.now() + intervalMs;
+
+  const { provider, accountId } = state;
+  const timer = setTimeout(async () => {
+    const current = activeMonitors.get(sessionId);
+    if (!current || current.stopped) return;
+    if (current.sessionBound && !getSessionInfo(sessionId)) {
+      stopQuotaMonitor(sessionId);
+      return;
+    }
+
+    try {
+      const fetcher = quotaFetcherRegistry.get(provider);
+      if (!fetcher) {
+        current.status = current.lastQuotaPercent === null ? "idle" : current.status;
+        scheduleNextPoll(sessionId, NORMAL_INTERVAL_MS);
+        return;
+      }
+      current.lastPolledAt = Date.now();
+      current.totalPolls += 1;
+      const previousStatus = current.status;
+      const quota = await fetcher(accountId, current.connectionSnapshot || undefined);
+      const percentUsed =
+        quota && typeof quota.percentUsed === "number" && Number.isFinite(quota.percentUsed)
+          ? quota.percentUsed
+          : null;
+      current.lastSuccessAt = Date.now();
+      current.lastError = null;
+      current.lastErrorAt = null;
+      current.consecutiveFailures = 0;
+      current.lastQuotaPercent = percentUsed;
+      current.lastQuotaUsed =
+        quota && typeof quota.used === "number" && Number.isFinite(quota.used) ? quota.used : null;
+      current.lastQuotaTotal =
+        quota && typeof quota.total === "number" && Number.isFinite(quota.total)
+          ? quota.total
+          : null;
+      current.lastResetAt =
+        quota && typeof quota.resetAt === "string" && quota.resetAt.trim().length > 0
+          ? quota.resetAt
+          : null;
+      current.status = getMonitorStatus(percentUsed);
+
+      if (percentUsed !== null && percentUsed >= EXHAUSTION_THRESHOLD) {
+        const emittedAlert = suppressedAlert(sessionId, provider, accountId, percentUsed);
+        if (emittedAlert) {
+          current.lastAlertAt = Date.now();
+          current.totalAlerts += 1;
+        }
+        if (emittedAlert || previousStatus !== "exhausted") {
+          console.info(
+            `[QuotaMonitor] session=${sessionId}: marking ${accountId} for next-session cooldown`
+          );
+        }
+        scheduleNextPoll(sessionId, CRITICAL_INTERVAL_MS);
+      } else if (percentUsed !== null && percentUsed >= WARN_THRESHOLD) {
+        const emittedAlert = suppressedAlert(sessionId, provider, accountId, percentUsed);
+        if (emittedAlert) {
+          current.lastAlertAt = Date.now();
+          current.totalAlerts += 1;
+        }
+        scheduleNextPoll(sessionId, CRITICAL_INTERVAL_MS);
+      } else {
+        scheduleNextPoll(sessionId, NORMAL_INTERVAL_MS);
+      }
+    } catch (error) {
+      current.lastErrorAt = Date.now();
+      current.lastError = error instanceof Error ? error.message : String(error);
+      current.consecutiveFailures += 1;
+      current.status = "error";
+      scheduleNextPoll(sessionId, NORMAL_INTERVAL_MS);
+    }
+  }, intervalMs);
+
+  if (typeof timer.unref === "function") timer.unref();
+  state.timer = timer;
+}
+
+export function startQuotaMonitor(sessionId, provider, accountId, connection) {
+  if (!isQuotaMonitorEnabled(connection)) return;
+  const current = activeMonitors.get(sessionId);
+  if (current && !current.stopped) {
+    if (current.provider === provider && current.accountId === accountId) {
+      current.connectionSnapshot = connection;
+      current.sessionBound = current.sessionBound || getSessionInfo(sessionId) !== null;
+      return;
+    }
+    stopQuotaMonitor(sessionId);
+  }
+
+  activeMonitors.set(sessionId, {
+    timer: null,
+    stopped: false,
+    provider,
+    accountId,
+    connectionSnapshot: connection,
+    sessionBound: getSessionInfo(sessionId) !== null,
+    status: "starting",
+    startedAt: Date.now(),
+    lastPolledAt: null,
+    lastSuccessAt: null,
+    lastErrorAt: null,
+    lastError: null,
+    lastQuotaPercent: null,
+    lastQuotaUsed: null,
+    lastQuotaTotal: null,
+    lastResetAt: null,
+    lastAlertAt: null,
+    nextPollDelayMs: null,
+    nextPollAt: null,
+    totalPolls: 0,
+    totalAlerts: 0,
+    consecutiveFailures: 0,
+  });
+  scheduleNextPoll(sessionId, NORMAL_INTERVAL_MS);
+}
+
+export function stopQuotaMonitor(sessionId) {
+  const state = activeMonitors.get(sessionId);
+  if (!state) return;
+  state.stopped = true;
+  if (state.timer) {
+    clearTimeout(state.timer);
+    state.timer = null;
+  }
+  activeMonitors.delete(sessionId);
+  for (const key of alertSuppression.keys()) {
+    if (key.startsWith(`${sessionId}:`)) alertSuppression.delete(key);
+  }
+}
+
+export function getActiveMonitorCount() {
+  return activeMonitors.size;
+}
+
+export function getQuotaMonitorSnapshot(sessionId) {
+  const state = activeMonitors.get(sessionId);
+  if (!state || state.stopped) return null;
+  return toPublicSnapshot(sessionId, state);
+}
+
+export function getQuotaMonitorSnapshots() {
+  const snapshots = [];
+  for (const [sessionId, state] of activeMonitors) {
+    if (state.stopped) continue;
+    snapshots.push(toPublicSnapshot(sessionId, state));
+  }
+  return sortSnapshots(snapshots);
+}
+
+export function getQuotaMonitorSummary() {
+  const snapshots = getQuotaMonitorSnapshots();
+  const statusCounts = {
+    starting: 0,
+    idle: 0,
+    healthy: 0,
+    warning: 0,
+    exhausted: 0,
+    error: 0,
+  };
+  const byProvider = {};
+
+  for (const snapshot of snapshots) {
+    statusCounts[snapshot.status] += 1;
+    byProvider[snapshot.provider] = (byProvider[snapshot.provider] || 0) + 1;
+  }
+
+  return {
+    active: snapshots.length,
+    alerting: statusCounts.warning + statusCounts.exhausted,
+    exhausted: statusCounts.exhausted,
+    errors: statusCounts.error,
+    statusCounts,
+    byProvider,
+  };
+}
+
+export function clearQuotaMonitors() {
+  for (const sessionId of [...activeMonitors.keys()]) {
+    stopQuotaMonitor(sessionId);
+  }
+  alertSuppression.clear();
+}