@fudrouter/fsrouter 0.6.63 → 0.6.64

package/open-sse/services/qoderModels.js

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

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

@@ -1,310 +0,0 @@
-/**
- * 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();
-}