@amir83nasr/10router 0.1.8 → 0.1.9

package/src/app/api/usage/stream/route.js

@@ -2,84 +2,90 @@ import { getUsageStats, statsEmitter, getActiveRequests } from "@/lib/usageDb";
 
 export const dynamic = "force-dynamic";
 
+// ── SHARED STATS CACHE ───────────────────────────────────────────────────
+// Every open dashboard tab holds one of these streams, and statsEmitter fires
+// on every saved request. Recomputing getUsageStats() (two full table reads +
+// a 100-row scan + the whole daily-summary fold) once per client per event
+// made server CPU scale with tabs × request rate. One cache + one in-flight
+// recompute, shared by every subscriber in this process, makes N tabs cost the
+// same as one. Module scope persists across requests in the Node server.
+//
+// Only the active/recent overlay is pushed downstream (that is all the client
+// merges), so the heavy snapshot is read for its cached fields alone.
+let cache = null;
+let inflight = null;
+
+// Concurrent bursts collapse onto a single getUsageStats() call.
+function refreshStats() {
+  if (!inflight) {
+    inflight = Promise.resolve()
+      .then(() => getUsageStats("all"))
+      .then((stats) => {
+        cache = stats;
+        return stats;
+      })
+      .catch(() => cache) // keep serving the last good snapshot
+      .finally(() => {
+        inflight = null;
+      });
+  }
+  return inflight;
+}
+
+// Fresh active/recent overlay, primed by the shared snapshot. Null before the
+// first compute so callers can skip a duplicate push.
+async function overlay() {
+  if (!cache) await refreshStats();
+  if (!cache) return null;
+  return getActiveRequests();
+}
+
+// ── STREAM ───────────────────────────────────────────────────────────────
 export async function GET() {
   const encoder = new TextEncoder();
-  const state = {
-    closed: false,
-    keepalive: null,
-    send: null,
-    sendPending: null,
-    cachedStats: null,
+  let closed = false;
+  let keepalive = null;
+  let controller = null;
+
+  const write = (chunk) => {
+    if (closed) return;
+    try {
+      controller.enqueue(encoder.encode(chunk));
+    } catch {
+      teardown();
+    }
   };
 
-  const stream = new ReadableStream({
-    async start(controller) {
-      // Full stats refresh (heavy) + immediate lightweight push
-      state.send = async () => {
-        if (state.closed) return;
-        try {
-          // Push lightweight update immediately so UI reflects changes fast
-          if (state.cachedStats) {
-            const { activeRequests, recentRequests, errorProvider } = await getActiveRequests();
-            const quickStats = {
-              ...state.cachedStats,
-              activeRequests,
-              recentRequests,
-              errorProvider,
-            };
-            controller.enqueue(encoder.encode(`data: ${JSON.stringify(quickStats)}\n\n`));
-          }
-          // Then do full recalc and update cache
-          const stats = await getUsageStats();
-          state.cachedStats = stats;
-          controller.enqueue(encoder.encode(`data: ${JSON.stringify(stats)}\n\n`));
-        } catch {
-          state.closed = true;
-          statsEmitter.off("update", state.send);
-          statsEmitter.off("pending", state.sendPending);
-          clearInterval(state.keepalive);
-        }
-      };
+  const sendEvent = (payload) => write(`data: ${JSON.stringify(payload)}\n\n`);
 
-      // Lightweight push: only refresh activeRequests + recentRequests on pending changes
-      state.sendPending = async () => {
-        if (state.closed || !state.cachedStats) return;
-        try {
-          const { activeRequests, recentRequests, errorProvider } = await getActiveRequests();
-          const stats = { ...state.cachedStats, activeRequests, recentRequests, errorProvider };
-          controller.enqueue(encoder.encode(`data: ${JSON.stringify(stats)}\n\n`));
-        } catch {
-          state.closed = true;
-          statsEmitter.off("update", state.send);
-          statsEmitter.off("pending", state.sendPending);
-          clearInterval(state.keepalive);
-        }
-      };
+  const send = async () => {
+    if (closed) return;
+    const stats = await overlay();
+    if (stats && !closed) sendEvent(stats);
+  };
 
-      await state.send();
+  // Cheap path: only the active/recent overlay moved.
+  const sendPending = send;
 
-      statsEmitter.on("update", state.send);
-      statsEmitter.on("pending", state.sendPending);
+  const teardown = () => {
+    if (closed) return;
+    closed = true;
+    statsEmitter.off("update", send);
+    statsEmitter.off("pending", sendPending);
+    clearInterval(keepalive);
+  };
 
-      state.keepalive = setInterval(() => {
-        if (state.closed) {
-          clearInterval(state.keepalive);
-          return;
-        }
-        try {
-          controller.enqueue(encoder.encode(": ping\n\n"));
-        } catch {
-          state.closed = true;
-          clearInterval(state.keepalive);
-        }
-      }, 25000);
+  const stream = new ReadableStream({
+    async start(c) {
+      controller = c;
+      await send();
+      if (closed) return;
+      statsEmitter.on("update", send);
+      statsEmitter.on("pending", sendPending);
+      keepalive = setInterval(() => write(": ping\n\n"), 25000);
     },
-
     cancel() {
-      state.closed = true;
-      statsEmitter.off("update", state.send);
-      statsEmitter.off("pending", state.sendPending);
-      clearInterval(state.keepalive);
+      teardown();
     },
   });
 

package/src/app/api/v1/models/route.js

@@ -108,10 +108,22 @@ const LIVE_MODEL_RESOLVERS = {
     return result?.models?.length ? { models: result.models } : null;
   },
   zed: async (conn) => {
-    const result = await resolveZedModels({
-      accessToken: conn.accessToken,
-      providerSpecificData: conn.providerSpecificData || {},
-    });
+    const proxy = await resolveConnectionProxyConfig(conn.providerSpecificData || {});
+    const result = await resolveZedModels(
+      {
+        accessToken: conn.accessToken,
+        providerSpecificData: conn.providerSpecificData || {},
+      },
+      {
+        proxyOptions: {
+          connectionProxyEnabled: proxy.connectionProxyEnabled === true,
+          connectionProxyUrl: proxy.connectionProxyUrl || "",
+          connectionNoProxy: proxy.connectionNoProxy || "",
+          vercelRelayUrl: proxy.vercelRelayUrl || "",
+          strictProxy: proxy.strictProxy === true,
+        },
+      },
+    );
     if (!result?.models?.length) return null;
     return {
       models: result.models
@@ -182,10 +194,12 @@ async function fetchCompatibleModelIds(connection) {
   if (isOpenAICompatibleProvider(connection.provider)) {
     headers.Authorization = `Bearer ${connection.apiKey}`;
   } else if (isAnthropicCompatibleProvider(connection.provider)) {
+    // Anthropic's model list lives at the API root, not under /messages.
+    // `-"/messages".length` matters: a bare -9 eats the "m" of "models".
     if (url.endsWith("/messages/models")) {
-      url = url.slice(0, -9);
+      url = url.slice(0, -"/messages".length);
     } else if (url.endsWith("/messages")) {
-      url = `${url.slice(0, -9)}/models`;
+      url = `${url.slice(0, -"/messages".length)}/models`;
     }
     headers["x-api-key"] = connection.apiKey;
     headers["anthropic-version"] = "2023-06-01";

package/src/lib/db/index.js

@@ -1,11 +1,13 @@
 // Public API barrel — all DB functions
 import { getAdapter } from "./driver.js";
 import { stringifyJson, parseJson } from "./helpers/jsonCol.js";
+import { invalidateSettingsCache } from "./repos/settingsRepo.js";
 
 // Settings
 export {
   getSettings,
   updateSettings,
+  invalidateSettingsCache,
   isCloudEnabled,
   getCloudUrl,
   exportSettings,
@@ -303,6 +305,7 @@ export async function importDb(payload) {
     }
   });
 
+  invalidateSettingsCache(); // writes here bypass updateSettings
   return await exportDb();
 }
 

package/src/lib/db/repos/settingsRepo.js

@@ -62,10 +62,23 @@ const DEFAULT_SETTINGS = {
   pxpipeTimeoutMs: 15000,
 };
 
+// Settings are read ~3× per chat request (chat.js twice, auth.ts once) and
+// re-merge ~40 defaults each time. Same short-TTL pattern as
+// requestDetailsRepo's CONFIG_CACHE_TTL_MS; writes refresh it immediately.
+const SETTINGS_CACHE_TTL_MS = 2000;
+
+let cachedSettings = null;
+let cachedSettingsTs = 0;
+
 async function readRaw() {
+  if (cachedSettings && Date.now() - cachedSettingsTs < SETTINGS_CACHE_TTL_MS) {
+    return cachedSettings;
+  }
   const db = await getAdapter();
   const row = db.get(`SELECT data FROM settings WHERE id = 1`);
-  return row ? parseJson(row.data, {}) : {};
+  cachedSettings = row ? parseJson(row.data, {}) : {};
+  cachedSettingsTs = Date.now();
+  return cachedSettings;
 }
 
 // Merge raw settings with defaults; backward-compat for missing keys
@@ -92,6 +105,12 @@ export async function getSettings() {
   return mergeWithDefaults(raw);
 }
 
+// For writers that bypass updateSettings (bulk restore in db/index.js).
+export function invalidateSettingsCache() {
+  cachedSettings = null;
+  cachedSettingsTs = 0;
+}
+
 // Atomic read-merge-write inside transaction (prevents losing concurrent updates)
 export async function updateSettings(updates) {
   const db = await getAdapter();
@@ -105,6 +124,8 @@ export async function updateSettings(updates) {
       [stringifyJson(next)],
     );
   });
+  cachedSettings = next;
+  cachedSettingsTs = Date.now();
   return mergeWithDefaults(next);
 }
 

package/src/lib/oauth/services/xai.js

@@ -202,10 +202,6 @@ export class XaiService extends OAuthService {
 
       spinner.start("Waiting for xAI authorization...");
       await new Promise((resolve, reject) => {
-        const timeout = setTimeout(
-          () => reject(new Error("Authentication timeout (5 minutes)")),
-          300000,
-        );
         const iv = setInterval(() => {
           if (callbackParams) {
             clearInterval(iv);
@@ -213,6 +209,10 @@ export class XaiService extends OAuthService {
             resolve();
           }
         }, 100);
+        const timeout = setTimeout(() => {
+          clearInterval(iv); // else the 100ms poll spins forever after reject
+          reject(new Error("Authentication timeout (5 minutes)"));
+        }, 300000);
       });
       close();
 

package/src/lib/validateComboModels.ts

@@ -0,0 +1,48 @@
+// Combo member validation (server-side, POST/PUT /api/combos).
+//
+// A member is valid when it is `provider/model` (provider resolved later at
+// request time), a model alias, or another combo (nested). Anything else —
+// bare words like "Support"/"Last" from a bad paste — dies at request time
+// with "Invalid model format" and burns the whole combo run, so reject it at
+// save time with a message naming the bad entries.
+
+export interface ComboMemberContext {
+  aliases?: Record<string, unknown>;
+  comboNames?: string[];
+  selfName?: string | null;
+}
+
+export function findComboMemberProblems(
+  members: unknown,
+  { aliases = {}, comboNames = [], selfName = null }: ComboMemberContext = {},
+): string[] {
+  if (!Array.isArray(members)) return ["models must be an array"];
+  const problems: string[] = [];
+  const seen = new Set<string>();
+  for (const raw of members) {
+    const m = typeof raw === "string" ? raw.trim() : "";
+    if (!m) {
+      problems.push("empty model entry");
+      continue;
+    }
+    if (seen.has(m)) {
+      problems.push(`duplicate model "${m}"`);
+      continue;
+    }
+    seen.add(m);
+    if (m.includes("/")) {
+      const slash = m.indexOf("/");
+      if (slash === 0 || slash === m.length - 1)
+        problems.push(`bad model shape "${m}" (want provider/model)`);
+      continue;
+    }
+    if (selfName && m === selfName) {
+      problems.push(`combo "${m}" cannot include itself`);
+      continue;
+    }
+    if (aliases && aliases[m]) continue;
+    if (comboNames.includes(m)) continue;
+    problems.push(`unknown model "${m}" (want provider/model, an alias, or a combo)`);
+  }
+  return problems;
+}

package/src/shared/components/UsageStats.tsx

@@ -31,7 +31,13 @@ const ProviderTopology = dynamic(
   () => import("@/app/(dashboard)/dashboard/usage/components/ProviderTopology"),
   { ssr: false },
 );
-import UsageChart from "@/app/(dashboard)/dashboard/usage/components/UsageChart";
+// Lazy-load: keeps recharts out of the usage page's initial bundle
+const UsageChart = dynamic(
+  () => import("@/app/(dashboard)/dashboard/usage/components/UsageChart"),
+  {
+    ssr: false,
+  },
+);
 import ProviderHealth from "@/app/(dashboard)/dashboard/usage/components/ProviderHealth";
 
 function timeAgo(timestamp: any) {

package/src/shared/hooks/useShutdown.ts

@@ -32,6 +32,8 @@ export function useShutdown() {
         timers.current.push(t as unknown as number);
       });
     }
+    // Poll finished: leaving the spinner is part of the same transition.
+    setShuttingDown(false);
     if (Date.now() >= deadline - HEALTH_POLL_MS) setTimedOut(true);
     else setStopped(true);
   }, []);
@@ -60,9 +62,5 @@ export function useShutdown() {
     setTimedOut(false);
   }, []);
 
-  useEffect(() => {
-    if (stopped || timedOut) setShuttingDown(false);
-  }, [stopped, timedOut]);
-
   return { confirmOpen, shuttingDown, stopped, timedOut, open, confirm, reset };
 }

package/src/sse/handlers/chat.js

@@ -312,7 +312,11 @@ async function handleSingleModelChat(
       if (pid) {
         refreshedCredentials.projectId = pid;
         // Persist to DB in background so subsequent requests have it immediately
-        updateProviderCredentials(credentials.connectionId, { projectId: pid }).catch(() => {});
+        updateProviderCredentials(credentials.connectionId, { projectId: pid }).catch((err) => {
+          // Not fatal — next request re-resolves the projectId — but log it,
+          // otherwise a broken write silently costs latency on every request.
+          log.warn("CHAT", `failed to persist projectId for ${credentials.connectionId}:`, err);
+        });
       }
     }
 

package/src/sse/services/antigravityQuota.ts

@@ -134,14 +134,18 @@ async function _doRefresh(
     const usage = await getAntigravityUsage(accessToken, providerSpecificData, proxyOptions);
     // 401/403 usage responses can contain an empty quotas object plus message.
     // Preserve known cache instead of replacing it with an upstream error response.
-    if (!usage?.quotas || usage.message) return null;
+    // (Empty `{}` is a valid empty snapshot, not a missing one.)
+    // Producer is untyped JS, so the shape is asserted at this boundary.
+    const quotas = usage?.quotas as
+      Record<string, { remainingPercentage: number; resetAt?: string }> | undefined;
+    if (!quotas || usage.message) return null;
 
     // Update in-memory cache. Caller logs CACHE_BLOCK only if requested model is exhausted.
     // Strike blocks are re-asserted after every refresh so an optimistic
     // upstream reading cannot resurrect a pair we just circuit-broke.
-    quotaCache.set(connectionId, applyActiveStrikeBlocks(connectionId, usage.quotas));
+    quotaCache.set(connectionId, applyActiveStrikeBlocks(connectionId, quotas));
 
-    return usage.quotas;
+    return quotas;
   } catch (e: any) {
     log.warn("AG_QUOTA", `${connectionId.slice(0, 8)} | refresh failed: ${e.message}`);
     return null;

package/src/sse/services/model.ts

@@ -46,26 +46,15 @@ export async function getModelInfo(modelStr: string): Promise<any> {
     // Provider-node prefixes are user-defined. They must not override built-in
     // provider ids/aliases such as `cf`, `openai`, or `hf`.
     if (!RESERVED_PROVIDER_PREFIXES.has(parsed.providerAlias)) {
-      const openaiNodes = await getProviderNodes({ type: "openai-compatible" });
-      const matchedOpenAI = openaiNodes.find((node: any) => node.prefix === parsed.providerAlias);
-      if (matchedOpenAI) {
-        return { provider: matchedOpenAI.id, model: parsed.model };
-      }
-
-      const anthropicNodes = await getProviderNodes({ type: "anthropic-compatible" });
-      const matchedAnthropic = anthropicNodes.find(
-        (node: any) => node.prefix === parsed.providerAlias,
-      );
-      if (matchedAnthropic) {
-        return { provider: matchedAnthropic.id, model: parsed.model };
-      }
-
-      const embeddingNodes = await getProviderNodes({ type: "custom-embedding" });
-      const matchedEmbedding = embeddingNodes.find(
-        (node: any) => node.prefix === parsed.providerAlias,
-      );
-      if (matchedEmbedding) {
-        return { provider: matchedEmbedding.id, model: parsed.model };
+      // One scan instead of three identical type-filtered queries; prefix→id
+      // matching is unambiguous across node types (checked in that order).
+      const nodes = await getProviderNodes();
+      const NODE_TYPE_ORDER = ["openai-compatible", "anthropic-compatible", "custom-embedding"];
+      for (const type of NODE_TYPE_ORDER) {
+        const match = nodes.find(
+          (node: any) => node.type === type && node.prefix === parsed.providerAlias,
+        );
+        if (match) return { provider: match.id, model: parsed.model };
       }
     }
     return {