zevairouter 1.0.118 → 1.0.119

package/src/app/api/metrics/route.js

@@ -0,0 +1,32 @@
+import { getActiveRequests, getProviderConnections, getUsageStats } from "@/lib/db/index.js";
+import { responseCache } from "@/lib/responseCache.js";
+
+function metric(name, help, type, value) {
+  return `# HELP ${name} ${help}\n# TYPE ${name} ${type}\n${name} ${Number(value) || 0}\n`;
+}
+
+export async function GET() {
+  const [stats, activeRequests, connections] = await Promise.all([
+    getUsageStats("all"),
+    getActiveRequests(),
+    getProviderConnections({ isActive: true }),
+  ]);
+  const cache = responseCache.getStats();
+  const active = activeRequests.reduce((sum, request) => sum + (request.count || 0), 0);
+
+  const body = [
+    metric("zevai_requests_total", "Completed routed requests.", "counter", stats.totalRequests),
+    metric("zevai_prompt_tokens_total", "Prompt tokens processed.", "counter", stats.totalPromptTokens),
+    metric("zevai_completion_tokens_total", "Completion tokens processed.", "counter", stats.totalCompletionTokens),
+    metric("zevai_cost_total", "Estimated provider cost.", "counter", stats.totalCost),
+    metric("zevai_active_requests", "Requests currently in flight.", "gauge", active),
+    metric("zevai_active_provider_connections", "Configured active provider connections.", "gauge", connections.length),
+    metric("zevai_cache_hits_total", "Response cache hits.", "counter", cache.hits),
+    metric("zevai_cache_misses_total", "Response cache misses.", "counter", cache.misses),
+    metric("zevai_cache_entries", "Responses currently cached.", "gauge", cache.entries),
+  ].join("");
+
+  return new Response(body, {
+    headers: { "Content-Type": "text/plain; version=0.0.4; charset=utf-8" },
+  });
+}

package/src/app/api/models/test/ping.js

@@ -40,7 +40,7 @@ function createSilentWavFile() {
 async function getInternalHeaders() {
   let apiKey = null;
   try {
-    const keys = await getApiKeys();
+    const keys = await getApiKeys(true);
     apiKey = keys.find((k) => k.isActive !== false)?.key || null;
   } catch {}
 

package/src/lib/db/adapters/sqljsAdapter.js

@@ -11,7 +11,37 @@ async function loadSql() {
 }
 
 export async function createSqlJsAdapter(filePath) {
-  const SQLLib = await loadSql();
+  const lockPath = `${filePath}.sqljs.lock`;
+  let lockFd;
+  try {
+    lockFd = fs.openSync(lockPath, "wx");
+  } catch (error) {
+    if (error.code !== "EEXIST") throw error;
+    const ownerPid = Number.parseInt(fs.readFileSync(lockPath, "utf8"), 10);
+    try {
+      if (Number.isInteger(ownerPid) && ownerPid > 0) process.kill(ownerPid, 0);
+      throw new Error(`sql.js database is already owned by process ${ownerPid || "unknown"}`);
+    } catch (ownerError) {
+      if (ownerError.code !== "ESRCH") throw ownerError;
+      fs.rmSync(lockPath, { force: true });
+      lockFd = fs.openSync(lockPath, "wx");
+    }
+  }
+  fs.writeFileSync(lockFd, String(process.pid));
+  fs.closeSync(lockFd);
+  const releaseLock = () => {
+    try {
+      if (fs.readFileSync(lockPath, "utf8") === String(process.pid)) fs.rmSync(lockPath, { force: true });
+    } catch {}
+  };
+
+  let SQLLib;
+  try {
+    SQLLib = await loadSql();
+  } catch (error) {
+    releaseLock();
+    throw error;
+  }
   const buf = fs.existsSync(filePath) ? fs.readFileSync(filePath) : null;
   let db = new SQLLib.Database(buf);
   db.exec(PRAGMA_SQL);
@@ -104,9 +134,16 @@ export async function createSqlJsAdapter(filePath) {
     }
   }
 
+  let closed = false;
   function close() {
-    if (dirty) persist();
-    db.close();
+    if (closed) return;
+    closed = true;
+    try {
+      if (dirty) persist();
+      db.close();
+    } finally {
+      releaseLock();
+    }
   }
 
   return { driver: "sql.js", run, get, all, exec, transaction, close, raw: db };

package/src/lib/db/driver.js

@@ -1,8 +1,9 @@
 import { ensureDirs, DATA_FILE } from "./paths.js";
 
 // Use global to survive Next.js dev hot-reload (module state resets on reload)
-if (!global._dbAdapter) global._dbAdapter = { instance: null, initPromise: null, logged: false };
+if (!global._dbAdapter) global._dbAdapter = { instance: null, initPromise: null, closePromise: null, logged: false };
 const state = global._dbAdapter;
+if (!("closePromise" in state)) state.closePromise = null;
 
 async function tryBunSqlite() {
   // Bun runtime only — built-in, no install needed
@@ -89,6 +90,21 @@ export async function getAdapter() {
   return state.initPromise;
 }
 
+export async function closeAdapter() {
+  if (state.closePromise) return state.closePromise;
+  state.closePromise = (async () => {
+    try {
+      const adapter = state.instance || (state.initPromise ? await state.initPromise : null);
+      await adapter?.close?.();
+    } finally {
+      state.instance = null;
+      state.initPromise = null;
+      state.closePromise = null;
+    }
+  })();
+  return state.closePromise;
+}
+
 export function getAdapterSync() {
   if (!state.instance) throw new Error("[DB] adapter not initialized — await getAdapter() first");
   return state.instance;

package/src/lib/db/index.js

@@ -43,7 +43,7 @@ export {
 // API keys
 export {
   getApiKeys, getApiKeyById, createApiKey, updateApiKey, deleteApiKey, validateApiKey,
-  checkApiKeyBudget,
+  checkApiKeyBudget, admitApiKeyRequest, rotateApiKey, maskApiKey,
 } from "./repos/apiKeysRepo.js";
 
 // Combos

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

@@ -1,24 +1,41 @@
 import { v4 as uuidv4 } from "uuid";
 import { getAdapter } from "../driver.js";
 
-function rowToKey(row) {
+const activeBudgetKeys = new Set();
+const rateWindows = new Map();
+
+function parseAllowedModels(value) {
+  if (Array.isArray(value)) return value;
+  if (!value) return [];
+  try { return JSON.parse(value); } catch { return []; }
+}
+
+export function maskApiKey(key) {
+  if (!key) return null;
+  return key.length <= 12 ? `${key.slice(0, 4)}…` : `${key.slice(0, 8)}…${key.slice(-4)}`;
+}
+
+function rowToKey(row, includeSecret = false) {
   if (!row) return null;
   return {
     id: row.id,
-    key: row.key,
+    key: includeSecret ? row.key : undefined,
+    maskedKey: maskApiKey(row.key),
     name: row.name,
     machineId: row.machineId,
     isActive: row.isActive === 1 || row.isActive === true,
     createdAt: row.createdAt,
     budgetDaily: row.budgetDaily || 0,
     budgetMonthly: row.budgetMonthly || 0,
+    requestsPerMinute: row.requestsPerMinute || 0,
+    allowedModels: parseAllowedModels(row.allowedModels),
   };
 }
 
-export async function getApiKeys() {
+export async function getApiKeys(includeSecrets = false) {
   const db = await getAdapter();
   const rows = db.all(`SELECT * FROM apiKeys ORDER BY createdAt ASC`);
-  return rows.map(rowToKey);
+  return rows.map((row) => rowToKey(row, includeSecrets));
 }
 
 export async function getApiKeyById(id) {
@@ -53,17 +70,62 @@ export async function updateApiKey(id, data) {
   db.transaction(() => {
     const row = db.get(`SELECT * FROM apiKeys WHERE id = ?`, [id]);
     if (!row) return;
-    const merged = { ...rowToKey(row), ...data };
+    const merged = { ...rowToKey(row, true), ...data };
     db.run(
-      `UPDATE apiKeys SET key = ?, name = ?, machineId = ?, isActive = ?, budgetDaily = ?, budgetMonthly = ? WHERE id = ?`,
+      `UPDATE apiKeys SET key = ?, name = ?, machineId = ?, isActive = ?, budgetDaily = ?, budgetMonthly = ?, requestsPerMinute = ?, allowedModels = ? WHERE id = ?`,
       [merged.key, merged.name, merged.machineId, merged.isActive ? 1 : 0,
-       Number(merged.budgetDaily) || 0, Number(merged.budgetMonthly) || 0, id]
+       Number(merged.budgetDaily) || 0, Number(merged.budgetMonthly) || 0,
+       Number(merged.requestsPerMinute) || 0, JSON.stringify(merged.allowedModels || []), id]
     );
     result = merged;
   });
   return result;
 }
 
+export async function rotateApiKey(id) {
+  const db = await getAdapter();
+  const row = db.get(`SELECT * FROM apiKeys WHERE id = ?`, [id]);
+  if (!row) return null;
+  const { generateApiKeyWithMachine } = await import("@/shared/utils/apiKey");
+  const key = generateApiKeyWithMachine(row.machineId).key;
+  db.run(`UPDATE apiKeys SET key = ? WHERE id = ?`, [key, id]);
+  return { ...rowToKey({ ...row, key }), key };
+}
+
+export async function admitApiKeyRequest(key, model) {
+  const db = await getAdapter();
+  const row = db.get(
+    `SELECT budgetDaily, budgetMonthly, requestsPerMinute, allowedModels FROM apiKeys WHERE key = ?`,
+    [key]
+  );
+  if (!row) return { allowed: true, release() {} };
+
+  const allowedModels = parseAllowedModels(row.allowedModels);
+  if (allowedModels.length > 0 && !allowedModels.includes(model)) {
+    return { allowed: false, status: 403, reason: `Model ${model} is not allowed for this API key` };
+  }
+
+  const rpm = Number(row.requestsPerMinute) || 0;
+  if (rpm > 0) {
+    const now = Date.now();
+    const window = (rateWindows.get(key) || []).filter((timestamp) => now - timestamp < 60_000);
+    if (window.length >= rpm) {
+      const retryAfter = Math.max(1, Math.ceil((60_000 - (now - window[0])) / 1000));
+      rateWindows.set(key, window);
+      return { allowed: false, status: 429, retryAfter, reason: "API key rate limit exceeded" };
+    }
+    window.push(now);
+    rateWindows.set(key, window);
+  }
+
+  const budgeted = Number(row.budgetDaily) > 0 || Number(row.budgetMonthly) > 0;
+  if (budgeted && activeBudgetKeys.has(key)) {
+    return { allowed: false, status: 429, retryAfter: 1, reason: "A budgeted request is already in progress" };
+  }
+  if (budgeted) activeBudgetKeys.add(key);
+  return { allowed: true, release: () => activeBudgetKeys.delete(key) };
+}
+
 export async function deleteApiKey(id) {
   const db = await getAdapter();
   const res = db.run(`DELETE FROM apiKeys WHERE id = ?`, [id]);
@@ -118,9 +180,7 @@ export async function checkApiKeyBudget(key) {
       spentMonthly = r?.total || 0;
     }
   } catch (e) {
-    // On read failure, fail open (don't block legit traffic) but log
-    console.error("[apiKeysRepo] budget check failed:", e.message);
-    return { allowed: true };
+    return { allowed: false, error: true, reason: "Budget accounting unavailable" };
   }
 
   if (budgetDaily > 0 && spentDaily >= budgetDaily) {

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

@@ -239,21 +239,11 @@ export async function getRequestDetailById(id) {
   return row ? parseJson(row.data, null) : null;
 }
 
-const _shutdownHandler = async () => {
+export async function flushRequestDetails() {
   if (flushTimer) { clearTimeout(flushTimer); flushTimer = null; }
-  if (writeBuffer.length > 0) await flushToDatabase();
-};
-
-function ensureShutdownHandler() {
-  process.off("beforeExit", _shutdownHandler);
-  process.off("SIGINT", _shutdownHandler);
-  process.off("SIGTERM", _shutdownHandler);
-  process.off("exit", _shutdownHandler);
-
-  process.on("beforeExit", _shutdownHandler);
-  process.on("SIGINT", _shutdownHandler);
-  process.on("SIGTERM", _shutdownHandler);
-  process.on("exit", _shutdownHandler);
+  while (isFlushing) await new Promise((resolve) => setTimeout(resolve, 10));
+  while (writeBuffer.length > 0) {
+    await flushToDatabase();
+    while (isFlushing) await new Promise((resolve) => setTimeout(resolve, 10));
+  }
 }
-
-ensureShutdownHandler();

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

@@ -202,10 +202,6 @@ export function trackPendingRequest(model, provider, connectionId, started, erro
   if (!started && error && provider) {
     lastErrorProvider.provider = provider.toLowerCase();
     lastErrorProvider.ts = Date.now();
-    // Fire-and-forget alert (alerter respects alertEnabled setting + throttling)
-    import("../../alerter.js")
-      .then((m) => m.alertProviderDown(provider, `${provider} request failed`))
-      .catch(() => {});
   }
 
   const t = new Date().toLocaleTimeString("en-US", { hour12: false, hour: "2-digit", minute: "2-digit", second: "2-digit" });
@@ -359,7 +355,7 @@ export async function getUsageStats(period = "all") {
   } catch {}
 
   let allApiKeys = [];
-  try { allApiKeys = await getApiKeys(); } catch {}
+  try { allApiKeys = await getApiKeys(true); } catch {}
   const apiKeyMap = {};
   for (const k of allApiKeys) apiKeyMap[k.key] = { name: k.name, id: k.id, createdAt: k.createdAt };
 

package/src/lib/db/schema.js

@@ -82,6 +82,8 @@ export const TABLES = {
       // Per-key spending caps (USD). NULL/0 = unlimited.
       budgetDaily: "REAL DEFAULT 0",
       budgetMonthly: "REAL DEFAULT 0",
+      requestsPerMinute: "INTEGER DEFAULT 0",
+      allowedModels: "TEXT",
     },
     indexes: ["CREATE INDEX IF NOT EXISTS idx_ak_key ON apiKeys(key)"],
   },

package/src/lib/localDb.js

@@ -15,7 +15,7 @@ export {
   listContextFiles, getEnabledContextFiles, getContextFile,
   createContextFile, createContextFilesBulk, updateContextFile, deleteContextFile,
   getApiKeys, getApiKeyById, createApiKey, updateApiKey, deleteApiKey, validateApiKey,
-  checkApiKeyBudget,
+  checkApiKeyBudget, admitApiKeyRequest, rotateApiKey, maskApiKey,
   getCombos, getComboById, getComboByName,
   createCombo, updateCombo, deleteCombo,
   getModelAliases, setModelAlias, deleteModelAlias,

package/src/lib/usage/quotaRefresh.js

@@ -14,7 +14,7 @@ const STAGGER_MS = 4 * 1000;               // gap between connections in a sweep
 const MIN_START_DELAY_MS = 15 * 1000;      // let the server settle before first sweep
 
 if (!globalThis._quotaRefreshState) {
-  globalThis._quotaRefreshState = { started: false, timer: null, running: false };
+  globalThis._quotaRefreshState = { started: false, startTimer: null, timer: null, running: false };
 }
 const state = globalThis._quotaRefreshState;
 
@@ -48,11 +48,21 @@ async function sweepOnce() {
 export function startQuotaRefreshLoop() {
   if (state.started) return;
   state.started = true;
-  setTimeout(() => {
+  state.startTimer = setTimeout(() => {
+    state.startTimer = null;
     void sweepOnce();
     state.timer = setInterval(() => void sweepOnce(), REFRESH_INTERVAL_MS);
     if (state.timer.unref) state.timer.unref();
   }, MIN_START_DELAY_MS);
+  if (state.startTimer.unref) state.startTimer.unref();
+}
+
+export function stopQuotaRefreshLoop() {
+  if (state.startTimer) clearTimeout(state.startTimer);
+  if (state.timer) clearInterval(state.timer);
+  state.startTimer = null;
+  state.timer = null;
+  state.started = false;
 }
 
 /** Trigger an immediate one-off sweep (fire-and-forget). */

package/src/shared/services/initializeApp.js

@@ -15,6 +15,9 @@ import {
 } from "@/lib/tunnel";
 import { getMitmStatus, startMitm, loadEncryptedPassword, initDbHooks, restoreToolDNS, removeAllDNSEntriesSync } from "@/mitm/manager";
 import { syncToJson as syncMitmAliasCache } from "@/lib/mitmAliasCache";
+import { flushRequestDetails } from "@/lib/db/repos/requestDetailsRepo";
+import { closeAdapter } from "@/lib/db/driver";
+import { stopQuotaRefreshLoop } from "@/lib/usage/quotaRefresh";
 
 // Inject correct paths and DB hooks into manager.js (CJS) from ESM context
 (function bootstrapMitm() {
@@ -64,7 +67,13 @@ export async function initializeApp() {
     }
 
     if (!g.signalHandlersRegistered) {
-      const cleanup = () => {
+      let shuttingDown = false;
+      const cleanup = async () => {
+        if (shuttingDown) return;
+        shuttingDown = true;
+        stopQuotaRefreshLoop();
+        try { await flushRequestDetails(); } catch (e) { console.error("[InitApp] request detail flush failed:", e); }
+        try { await closeAdapter(); } catch (e) { console.error("[InitApp] database close failed:", e); }
         try { removeAllDNSEntriesSync(); } catch { /* best effort */ }
         killCloudflared();
         process.exit();
@@ -108,7 +117,7 @@ async function autoStartMitm() {
       return;
     }
 
-    const keys = await getApiKeys();
+    const keys = await getApiKeys(true);
     const activeKey = keys.find(k => k.isActive !== false);
 
     console.log("[InitApp] MITM was enabled, auto-starting...");

package/src/sse/handlers/chat.js

@@ -85,7 +85,10 @@ export async function handleChat(request, clientRawRequest = null) {
       const budget = await checkApiKeyBudget(apiKey);
       if (!budget.allowed) {
         log.warn("BUDGET", `Blocked: ${budget.reason}`);
-        return errorResponse(HTTP_STATUS.PAYMENT_REQUIRED, budget.reason || "Budget exceeded");
+        return errorResponse(
+        budget.error ? HTTP_STATUS.SERVICE_UNAVAILABLE : HTTP_STATUS.PAYMENT_REQUIRED,
+        budget.reason || "Budget exceeded"
+      );
       }
     }
   }
@@ -95,57 +98,111 @@ export async function handleChat(request, clientRawRequest = null) {
     return errorResponse(HTTP_STATUS.BAD_REQUEST, "Missing model");
   }
 
-  // ── Response cache: serve identical non-streaming requests instantly ──
-  const { responseCache, isCacheableRequest } = await import("@/lib/responseCache.js");
-  const cacheCheck = settings.responseCacheEnabled !== false ? isCacheableRequest(body, request.headers) : { cacheable: false, reason: "disabled" };
-  let cacheKey = null;
-  if (cacheCheck.cacheable) {
-    cacheKey = responseCache.buildKey(body);
-    const cached = cacheKey ? responseCache.get(cacheKey) : null;
-    if (cached) {
-      log.info("CACHE", `HIT ${modelStr} | age=${Math.round((Date.now() - cached.storedAt) / 1000)}s | hits=${cached.hits}`);
-      return new Response(JSON.stringify(cached.body), {
-        status: cached.status,
-        headers: {
-          "Content-Type": "application/json",
-          "X-ZevAI-Cache": "HIT",
-          "X-ZevAI-Cache-Age": String(Math.round((Date.now() - cached.storedAt) / 1000)),
-        },
+  let admission = null;
+  if (apiKey) {
+    const { admitApiKeyRequest } = await import("@/lib/db/index.js");
+    admission = await admitApiKeyRequest(apiKey, modelStr);
+    if (!admission.allowed) {
+      const headers = admission.retryAfter ? { "Retry-After": String(admission.retryAfter) } : undefined;
+      return new Response(JSON.stringify({ error: { message: admission.reason } }), {
+        status: admission.status || 429,
+        headers: { "Content-Type": "application/json", ...headers },
       });
     }
-    log.debug("CACHE", `MISS ${modelStr} (${cacheCheck.reason || "new"})`);
   }
+  const finishAdmission = (response) => releaseAdmissionOnResponse(response, admission?.release);
 
-  // Bypass naming/warmup requests before combo rotation to avoid wasting rotation slots
-  const userAgent = request?.headers?.get("user-agent") || "";
-  const bypassResponse = handleBypassRequest(body, modelStr, userAgent, !!settings.ccFilterNaming);
-  if (bypassResponse) return bypassResponse.response || bypassResponse;
-
-  // Check if model is a combo (has multiple models with fallback)
-  const comboModels = await getComboModels(modelStr);
-  if (comboModels) {
-    // Check for combo-specific strategy first, fallback to global
-    const comboStrategies = settings.comboStrategies || {};
-    const comboSpecificStrategy = comboStrategies[modelStr]?.fallbackStrategy;
-    const comboStrategy = comboSpecificStrategy || settings.comboStrategy || "fallback";
-    
-    const comboStickyLimit = settings.comboStickyRoundRobinLimit;
-    log.info("CHAT", `Combo "${modelStr}" with ${comboModels.length} models (strategy: ${comboStrategy}, sticky: ${comboStickyLimit})`);
-    const comboResp = await handleComboChat({
-      body,
-      models: comboModels,
-      handleSingleModel: (b, m) => handleSingleModelChat(b, m, clientRawRequest, request, apiKey),
-      log,
-      comboName: modelStr,
-      comboStrategy,
-      comboStickyLimit
-    });
-    return maybeCacheResponse(comboResp, cacheKey, modelStr);
+  try {
+    // ── Response cache: serve identical non-streaming requests instantly ──
+    const { responseCache, isCacheableRequest } = await import("@/lib/responseCache.js");
+    const cacheCheck = settings.responseCacheEnabled !== false ? isCacheableRequest(body, request.headers) : { cacheable: false, reason: "disabled" };
+    let cacheKey = null;
+    if (cacheCheck.cacheable) {
+      cacheKey = responseCache.buildKey(body);
+      const cached = cacheKey ? responseCache.get(cacheKey) : null;
+      if (cached) {
+        log.info("CACHE", `HIT ${modelStr} | age=${Math.round((Date.now() - cached.storedAt) / 1000)}s | hits=${cached.hits}`);
+        return finishAdmission(new Response(JSON.stringify(cached.body), {
+          status: cached.status,
+          headers: {
+            "Content-Type": "application/json",
+            "X-ZevAI-Cache": "HIT",
+            "X-ZevAI-Cache-Age": String(Math.round((Date.now() - cached.storedAt) / 1000)),
+          },
+        }));
+      }
+      log.debug("CACHE", `MISS ${modelStr} (${cacheCheck.reason || "new"})`);
+    }
+
+    // Bypass naming/warmup requests before combo rotation to avoid wasting rotation slots
+    const userAgent = request?.headers?.get("user-agent") || "";
+    const bypassResponse = handleBypassRequest(body, modelStr, userAgent, !!settings.ccFilterNaming);
+    if (bypassResponse) return finishAdmission(bypassResponse.response || bypassResponse);
+
+    // Check if model is a combo (has multiple models with fallback)
+    const comboModels = await getComboModels(modelStr);
+    if (comboModels) {
+      // Check for combo-specific strategy first, fallback to global
+      const comboStrategies = settings.comboStrategies || {};
+      const comboSpecificStrategy = comboStrategies[modelStr]?.fallbackStrategy;
+      const comboStrategy = comboSpecificStrategy || settings.comboStrategy || "fallback";
+
+      const comboStickyLimit = settings.comboStickyRoundRobinLimit;
+      log.info("CHAT", `Combo "${modelStr}" with ${comboModels.length} models (strategy: ${comboStrategy}, sticky: ${comboStickyLimit})`);
+      const comboResp = await handleComboChat({
+        body,
+        models: comboModels,
+        handleSingleModel: (b, m) => handleSingleModelChat(b, m, clientRawRequest, request, apiKey),
+        log,
+        comboName: modelStr,
+        comboStrategy,
+        comboStickyLimit
+      });
+      return finishAdmission(await maybeCacheResponse(comboResp, cacheKey, modelStr));
+    }
+
+    // Single model request
+    const singleResp = await handleSingleModelChat(body, modelStr, clientRawRequest, request, apiKey);
+    return finishAdmission(await maybeCacheResponse(singleResp, cacheKey, modelStr));
+  } catch (error) {
+    admission?.release?.();
+    throw error;
+  }
+}
+
+export function releaseAdmissionOnResponse(response, release) {
+  if (!release) return response;
+  if (!response?.body || !response.headers.get("content-type")?.includes("text/event-stream")) {
+    release();
+    return response;
   }
 
-  // Single model request
-  const singleResp = await handleSingleModelChat(body, modelStr, clientRawRequest, request, apiKey);
-  return maybeCacheResponse(singleResp, cacheKey, modelStr);
+  const reader = response.body.getReader();
+  const body = new ReadableStream({
+    async pull(controller) {
+      try {
+        const { done, value } = await reader.read();
+        if (done) {
+          release();
+          controller.close();
+        } else {
+          controller.enqueue(value);
+        }
+      } catch (error) {
+        release();
+        controller.error(error);
+      }
+    },
+    async cancel(reason) {
+      release();
+      await reader.cancel(reason);
+    },
+  });
+  return new Response(body, {
+    status: response.status,
+    statusText: response.statusText,
+    headers: response.headers,
+  });
 }
 
 /**
@@ -346,6 +403,7 @@ async function handleSingleModelChat(body, modelStr, clientRawRequest = null, re
       },
       contextInjectionEnabled: !!chatSettings.contextInjectionEnabled,
       providerThinking,
+      signal: request?.signal,
       // Detect source format by endpoint + body
       sourceFormatOverride: request?.url ? detectFormatByEndpoint(new URL(request.url).pathname, body) : null,
       onCredentialsRefreshed: async (newCreds) => {

package/src/sse/services/auth.js

@@ -341,6 +341,16 @@ export async function markAccountUnavailable(connectionId, status, errorText, pr
   const lockKey = Object.keys(lockUpdate)[0];
   const connName = conn?.displayName || conn?.name || conn?.email || connectionId.slice(0, 8);
   log.warn("AUTH", `${connName} locked ${lockKey} for ${Math.round(cooldownMs / 1000)}s [${status}]`);
+  if (provider) {
+    import("@/lib/alerter.js")
+      .then((alerts) => {
+        alerts.alertProviderDown(provider, `${connName}: ${reason}`);
+        if (status === 429 || reason.toLowerCase().includes("quota")) {
+          alerts.alertQuotaExhausted(provider, connName);
+        }
+      })
+      .catch(() => {});
+  }
 
   if (provider && status && reason) {
     console.error(`\u274c ${provider} [${status}]: ${reason}`);