zevairouter 1.0.152 → 1.0.154

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

@@ -4,6 +4,7 @@ import path from "node:path";
 import { DATA_DIR } from "../../dataDir.js";
 import { getProxyPoolById, getProxyPools } from "../../../models/index.js";
 import { getOptimalWorkerCount, isAutoConcurrencyValue } from "../../systemSpecs.js";
+import { redactCredentialText, redactCredentialUrl } from "../../providerConnectionSanitizer.js";
 import { KiroService } from "./kiro.js";
 import { createKiroCallbackMonitor, runKiroGoogleAutomation } from "./kiroGoogleAutomation.js";
 
@@ -266,6 +267,7 @@ function buildJobActivity(accounts) {
   return accounts
     .flatMap((account) => (account.logs || []).map((entry) => ({
       ...entry,
+      message: redactCredentialText(entry.message),
       email: account.email,
       line: account.line,
       workerId: account.workerId || null,
@@ -278,12 +280,9 @@ function buildJobActivity(accounts) {
 function maskProxyUrl(proxyUrl) {
   if (!proxyUrl) return null;
   try {
-    const url = new URL(proxyUrl);
-    if (url.username || url.password) {
-      url.username = "***";
-      url.password = "***";
-    }
-    return url.toString();
+    // Validate first so malformed input still gets the conservative fallback.
+    new URL(proxyUrl);
+    return redactCredentialUrl(proxyUrl);
   } catch {
     // If not a valid URL, just mask middle portion
     return proxyUrl.length > 20
@@ -296,14 +295,17 @@ function sanitizeAccount(account) {
   return {
     email: account.email,
     status: account.status,
-    error: account.error || null,
+    error: redactCredentialText(account.error) || null,
     connectionId: account.connectionId || null,
     workerId: account.workerId || null,
     line: account.line,
     proxyUrl: maskProxyUrl(account.proxyUrl) || null,
     currentStep: account.currentStep || null,
     updatedAt: account.updatedAt || null,
-    logs: (account.logs || []).slice(-20),
+    logs: (account.logs || []).slice(-20).map((entry) => ({
+      ...entry,
+      message: redactCredentialText(entry.message),
+    })),
     manualSessionAvailable: Boolean(account.manualSession?.page) && account.status === "needs_manual",
     manualSessionOpened: Boolean(account.manualSession?.opened),
   };
@@ -320,7 +322,7 @@ function sanitizeJob(job, extras = {}) {
     finishedAt: job.finishedAt,
     accounts: job.accounts.map(sanitizeAccount),
     activity: buildJobActivity(job.accounts),
-    error: job.error || null,
+    error: redactCredentialText(job.error) || null,
     preview: extras.preview || null,
   };
 }
@@ -389,6 +391,18 @@ export { parsePlaywrightProxy };
 export async function createFreshContext(browser, proxy, opts = {}) {
   let effectiveProxy = proxy;
   let socksBridge = null;
+  const {
+    DEFAULT_CONTEXT_CLOSE_TIMEOUT_MS,
+    DEFAULT_CONTEXT_CREATE_TIMEOUT_MS,
+    newStealthContext,
+    withAutomationTimeout,
+  } = await import("./bulkImportBrowserEngine.js");
+  const contextTimeoutMs = Number.isFinite(opts.timeoutMs) && opts.timeoutMs > 0
+    ? opts.timeoutMs
+    : DEFAULT_CONTEXT_CREATE_TIMEOUT_MS;
+  const closeTimeoutMs = Number.isFinite(opts.closeTimeoutMs) && opts.closeTimeoutMs > 0
+    ? opts.closeTimeoutMs
+    : DEFAULT_CONTEXT_CLOSE_TIMEOUT_MS;
   const useNativeCloakProfile =
     opts.profile === "codebuddy-cn" && opts.nativeCloakProfile === true;
 
@@ -396,7 +410,12 @@ export async function createFreshContext(browser, proxy, opts = {}) {
   if (proxy) {
     const { ensureSocksHttpBridge, isSocksProxyUrl } = await import("./socksHttpBridge.js");
     if (isSocksProxyUrl(proxy)) {
-      socksBridge = await ensureSocksHttpBridge(proxy);
+      socksBridge = await withAutomationTimeout(ensureSocksHttpBridge(proxy), {
+        timeoutMs: contextTimeoutMs,
+        message: `SOCKS proxy bridge timed out after ${Math.round(contextTimeoutMs / 1000)}s`,
+        code: "SOCKS_BRIDGE_TIMEOUT",
+        onLateResolve: (bridge) => bridge?.release?.(),
+      });
       if (socksBridge?.httpProxyUrl) {
         effectiveProxy = socksBridge.httpProxyUrl;
       }
@@ -479,28 +498,44 @@ export async function createFreshContext(browser, proxy, opts = {}) {
   let context;
   try {
     // Strip languages/fingerprint (not Playwright options) + attach HW init script.
-    const { newStealthContext } = await import("./bulkImportBrowserEngine.js");
-    context = await newStealthContext(browser, contextOptions);
+    context = await withAutomationTimeout(newStealthContext(browser, contextOptions), {
+      timeoutMs: contextTimeoutMs,
+      message: `Browser context creation timed out after ${Math.round(contextTimeoutMs / 1000)}s`,
+      code: "BROWSER_CONTEXT_TIMEOUT",
+      onLateResolve: (lateContext) => withAutomationTimeout(lateContext?.close?.(), {
+        timeoutMs: closeTimeoutMs,
+        message: `Late browser context close timed out after ${Math.round(closeTimeoutMs / 1000)}s`,
+        code: "BROWSER_CONTEXT_CLOSE_TIMEOUT",
+      }).catch(() => null),
+    });
   } catch (error) {
     await socksBridge?.release().catch(() => null);
     throw error;
   }
 
-  // Release the SOCKS bridge when the context closes
-  if (socksBridge) {
-    const originalClose = context.close.bind(context);
-    context.close = async (...args) => {
-      try {
-        return await originalClose(...args);
-      } finally {
-        await socksBridge.release().catch(() => null);
-      }
-    };
-  }
+  // Every caller inherits a bounded close, including derived provider managers.
+  // This keeps one dead renderer from pinning a worker forever on small VPS hosts.
+  const originalClose = context.close.bind(context);
+  let closePromise = null;
+  context.close = (...args) => {
+    if (!closePromise) {
+      const closeTask = Promise.resolve().then(() => originalClose(...args));
+      closePromise = withAutomationTimeout(closeTask, {
+        timeoutMs: closeTimeoutMs,
+        message: `Browser context close timed out after ${Math.round(closeTimeoutMs / 1000)}s`,
+        code: "BROWSER_CONTEXT_CLOSE_TIMEOUT",
+      }).finally(() => socksBridge?.release().catch(() => null));
+    }
+    return closePromise;
+  };
 
   let page;
   try {
-    page = await context.newPage();
+    page = await withAutomationTimeout(context.newPage(), {
+      timeoutMs: contextTimeoutMs,
+      message: `Browser page creation timed out after ${Math.round(contextTimeoutMs / 1000)}s`,
+      code: "BROWSER_PAGE_TIMEOUT",
+    });
   } catch (error) {
     await context.close().catch(() => null);
     throw error;
@@ -522,7 +557,7 @@ export async function createFreshContext(browser, proxy, opts = {}) {
 }
 
 function isHeadlessBrowser(browser) {
-  if (!browser) return true;
+  if (!browser) return false;
   const opts = browser._options || browser._initializer || {};
   if (typeof opts.headless === "boolean") return opts.headless;
   return true;
@@ -532,12 +567,25 @@ async function relaunchAsHeaded(account) {
   if (!account?.manualSession?.context) return false;
   const oldContext = account.manualSession.context;
   const oldPage = account.manualSession.page;
-  const oldBrowser = oldContext.browser?.();
+
+  let engine;
+  try {
+    engine = await import("./bulkImportBrowserEngine.js");
+  } catch {
+    return false;
+  }
 
   let storageState = null;
   let lastUrl = "";
   try {
-    storageState = await oldContext.storageState();
+    storageState = await engine.withAutomationTimeout(
+      Promise.resolve().then(() => oldContext.storageState()),
+      {
+        timeoutMs: engine.DEFAULT_CONTEXT_CLOSE_TIMEOUT_MS,
+        message: "Browser storage-state capture timed out",
+        code: "BROWSER_STORAGE_STATE_TIMEOUT",
+      },
+    );
   } catch {
     storageState = null;
   }
@@ -550,8 +598,7 @@ async function relaunchAsHeaded(account) {
   // Manual assist: relaunch headed CloakBrowser (stock Chromium retired).
   let newBrowser;
   try {
-    const { launchBulkImportBrowser } = await import("./bulkImportBrowserEngine.js");
-    newBrowser = await launchBulkImportBrowser({
+    newBrowser = await engine.launchBulkImportBrowser({
       headless: false,
       windowSize: { width: 1280, height: 900 },
     });
@@ -561,17 +608,58 @@ async function relaunchAsHeaded(account) {
 
   let newContext;
   try {
-    const { newStealthContext } = await import("./bulkImportBrowserEngine.js");
-    newContext = await newStealthContext(newBrowser, {
-      viewport: null,
-      ...(storageState ? { storageState } : {}),
-    });
+    newContext = await engine.withAutomationTimeout(
+      engine.newStealthContext(newBrowser, {
+        viewport: null,
+        ...(storageState ? { storageState } : {}),
+      }),
+      {
+        timeoutMs: engine.DEFAULT_CONTEXT_CREATE_TIMEOUT_MS,
+        message: "Headed browser context creation timed out",
+        code: "BROWSER_CONTEXT_TIMEOUT",
+        onLateResolve: (context) => engine.withAutomationTimeout(
+          Promise.resolve().then(() => context?.close?.()),
+          {
+            timeoutMs: engine.DEFAULT_CONTEXT_CLOSE_TIMEOUT_MS,
+            message: "Late headed browser context close timed out",
+            code: "BROWSER_CONTEXT_CLOSE_TIMEOUT",
+          },
+        ).catch(() => null),
+      },
+    );
   } catch {
-    await newBrowser.close().catch(() => null);
+    await engine.forceCloseBrowser(newBrowser).catch(() => null);
     return false;
   }
 
-  const newPage = await newContext.newPage();
+  const originalClose = newContext.close.bind(newContext);
+  let closePromise = null;
+  newContext.close = (...args) => {
+    if (!closePromise) {
+      closePromise = engine.withAutomationTimeout(
+        Promise.resolve().then(() => originalClose(...args)),
+        {
+          timeoutMs: engine.DEFAULT_CONTEXT_CLOSE_TIMEOUT_MS,
+          message: "Headed browser context close timed out",
+          code: "BROWSER_CONTEXT_CLOSE_TIMEOUT",
+        },
+      );
+    }
+    return closePromise;
+  };
+
+  let newPage;
+  try {
+    newPage = await engine.withAutomationTimeout(newContext.newPage(), {
+      timeoutMs: engine.DEFAULT_CONTEXT_CREATE_TIMEOUT_MS,
+      message: "Headed browser page creation timed out",
+      code: "BROWSER_PAGE_TIMEOUT",
+    });
+  } catch {
+    await newContext.close().catch(() => null);
+    await engine.forceCloseBrowser(newBrowser).catch(() => null);
+    return false;
+  }
   if (lastUrl) {
     try {
       await newPage.goto(lastUrl, { waitUntil: "domcontentloaded", timeout: 20_000 });
@@ -581,7 +669,9 @@ async function relaunchAsHeaded(account) {
   const rebind = account.manualSession.rebind;
   account.manualSession.context = newContext;
   account.manualSession.page = newPage;
-  account.manualSession.headedBrowser = newBrowser;
+  account.manualSession.headedBrowser = {
+    close: () => engine.forceCloseBrowser(newBrowser),
+  };
 
   if (typeof rebind === "function") {
     try {
@@ -589,10 +679,9 @@ async function relaunchAsHeaded(account) {
     } catch {}
   }
 
-  void oldContext.close().catch(() => null);
-  if (oldBrowser && oldBrowser !== newBrowser) {
-    void oldBrowser.close().catch(() => null);
-  }
+  // Only close this account's old context. Its browser is shared by other
+  // workers and is owned by runJob, which performs the process-level cleanup.
+  void Promise.resolve().then(() => oldContext.close()).catch(() => null);
 
   return true;
 }
@@ -603,8 +692,18 @@ async function revealBrowserWindow(page, { account } = {}) {
   try {
     const context = page.context?.();
     const browser = context?.browser?.();
+    let headless = isHeadlessBrowser(browser);
+    if (browser) {
+      try {
+        const { getBulkImportBrowserHeadless } = await import("./bulkImportBrowserEngine.js");
+        const tracked = getBulkImportBrowserHeadless(browser);
+        if (typeof tracked === "boolean") headless = tracked;
+      } catch {
+        // Fall back to Playwright's exposed initializer fields.
+      }
+    }
 
-    if (account && isHeadlessBrowser(browser)) {
+    if (account && headless) {
       const relaunched = await relaunchAsHeaded(account);
       if (relaunched) {
         await account.manualSession.page.bringToFront?.().catch(() => null);
@@ -669,6 +768,23 @@ export class KiroBulkImportManager {
     this.latestJobId = readPersistedLatestJobId(this.metaFile);
   }
 
+  buildPersistedSnapshot(job) {
+    return buildPersistedSnapshot(job);
+  }
+
+  readPersistedJob(jobId) {
+    return jobId ? readJsonFile(getJobFile(jobId, this.storageDir)) : null;
+  }
+
+  writePersistedJob(jobId, snapshot) {
+    if (!jobId || !snapshot) return;
+    writeJsonFile(getJobFile(jobId, this.storageDir), snapshot);
+  }
+
+  persistLatestJobId(jobId) {
+    writePersistedLatestJobId(jobId, this.metaFile);
+  }
+
   // Persist the encrypted resume vault for a job. Written once at start time;
   // credentials are static for the lifetime of a job.
   persistResumeBlob(job) {
@@ -896,7 +1012,7 @@ export class KiroBulkImportManager {
 
     this.jobs.set(jobId, job);
     this.latestJobId = jobId;
-    writePersistedLatestJobId(jobId, this.metaFile);
+    this.persistLatestJobId(jobId);
     await this.persistJobSnapshot(job, { forcePreview: false });
     this.persistResumeBlob(job);
     void this.runJob(jobId);
@@ -1072,7 +1188,7 @@ export class KiroBulkImportManager {
         job.lastPreviewCapturedAt = Date.now();
       }
 
-      writeJsonFile(getJobFile(job.jobId, this.storageDir), buildPersistedSnapshot(job));
+      this.writePersistedJob(job.jobId, this.buildPersistedSnapshot(job));
     };
 
     job.persistPromise = Promise.resolve(job.persistPromise).catch(() => null).then(runPersist);
@@ -1289,12 +1405,29 @@ export class KiroBulkImportManager {
     }
   }
 
+  shouldPrelaunchBrowser(_job) {
+    return true;
+  }
+
   async runJob(jobId) {
     const job = this.jobs.get(jobId);
     if (!job) return;
 
     try {
-      job.browser = await this.browserLauncher(job);
+      const {
+        DEFAULT_BROWSER_LAUNCH_TIMEOUT_MS,
+        forceCloseBrowser,
+        withAutomationTimeout,
+      } = await import("./bulkImportBrowserEngine.js");
+      if (this.shouldPrelaunchBrowser(job)) {
+        const launchTask = Promise.resolve().then(() => this.browserLauncher(job));
+        job.browser = await withAutomationTimeout(launchTask, {
+          timeoutMs: DEFAULT_BROWSER_LAUNCH_TIMEOUT_MS,
+          message: `Automation browser launch timed out after ${Math.round(DEFAULT_BROWSER_LAUNCH_TIMEOUT_MS / 1000)}s`,
+          code: "BROWSER_LAUNCH_TIMEOUT",
+          onLateResolve: (browser) => forceCloseBrowser(browser),
+        });
+      }
       job.accounts.forEach((account) => {
         if (account.status === "queued" && (account.logs || []).length === 1) {
           this.setAccountStep(account, "waiting_for_worker", "Waiting for a free worker");

package/src/lib/providerConnectionSanitizer.js

@@ -0,0 +1,180 @@
+const SAFE_CONNECTION_FIELDS = [
+  "id", "provider", "authType", "name", "displayName", "email",
+  "priority", "globalPriority", "defaultModel", "isActive",
+  "testStatus", "status", "lastTested", "lastError", "lastErrorAt",
+  "lastErrorType", "errorType", "errorCode", "statusCode",
+  "providerErrorCode", "rateLimitedUntil", "expiresAt", "expiresIn",
+  "tokenType", "scope", "projectId", "lastUsedAt", "consecutiveUseCount",
+  "consecutiveAuthFailures", "backoffLevel", "autoDisabledAt",
+  "autoDisabledReason", "createdAt", "updatedAt",
+];
+
+const SAFE_PROVIDER_DATA_FIELDS = [
+  "baseUrl", "azureEndpoint", "deployment", "apiVersion", "organization",
+  "accountId", "region", "projectId", "resourceUrl", "proxyPoolId",
+  "connectionProxyEnabled", "connectionProxyUrl", "connectionNoProxy",
+  "githubLogin", "githubName", "githubEmail", "githubUserId", "username",
+  "firstName", "lastName", "authMethod", "authKind", "chatgptAccountId",
+  "chatgptPlanType", "uid", "enterpriseId", "userId", "organizationId",
+  "profileArn", "startUrl", "machineId", "subscriptionTier",
+  "hasGrokCodeAccess", "domain", "refreshExpiresAt", "refreshExpiresIn",
+  "tokenType", "email", "name", "expireTime", "nodeName", "prefix",
+  "apiType", "enabledModels",
+];
+
+const SAFE_MODEL_LOCK_REASON_FIELDS = [
+  "model", "providerErrorCode", "reason", "lockedAt", "resetsAt",
+];
+
+const URL_FIELDS = new Set([
+  "baseUrl", "azureEndpoint", "resourceUrl", "startUrl", "connectionProxyUrl",
+]);
+const REDACTED_CONNECTION_TEXT_FIELDS = new Set(["lastError", "autoDisabledReason"]);
+const SENSITIVE_URL_PARAM = /(?:api[_-]?key|access[_-]?token|auth|credential|password|secret|signature|token)/i;
+const SENSITIVE_QUERY_VALUE = /([?&](?:api[_-]?key|access[_-]?token|auth|credential|password|secret|signature|token)=)[^&#\s;,]+/gi;
+const SENSITIVE_TEXT_VALUE = /(\b(?:api[_-]?key|access[_-]?token|authorization|auth|credential|password|passwd|secret|signature|token)\b["']?\s*[:=]\s*)(?!(?:Bearer|Basic)\b)(?:"[^"]*"|'[^']*'|[^\s,;&}]+)/gi;
+const AUTHORIZATION_VALUE = /\b(Bearer|Basic)\s+[a-z\d._~+\/-]+=*/gi;
+const SCHEME_USERINFO = /([a-z][a-z\d+.-]*:\/\/)[^@\s/]+@/gi;
+const SCHEMELESS_USERINFO = /(^|[\s("'`])[^:@/\s]+:[^@/\s]+@/gi;
+const SAFE_PROXY_POOL_FIELDS = [
+  "id", "name", "noProxy", "type", "isActive", "strictProxy",
+  "testStatus", "lastTestedAt", "lastError", "createdAt", "updatedAt",
+  "boundConnectionCount",
+];
+
+function copyPrimitive(value) {
+  if (value === null || ["string", "number", "boolean"].includes(typeof value)) {
+    return value;
+  }
+
+  if (Array.isArray(value) && value.every((item) => (
+    item === null || ["string", "number", "boolean"].includes(typeof item)
+  ))) {
+    return [...value];
+  }
+
+  return undefined;
+}
+
+export function redactCredentialUrl(value) {
+  if (typeof value !== "string" || !value) return value;
+
+  // Without `//`, URL treats `user:pass@host` as an opaque custom scheme and
+  // leaves the userinfo untouched. Parse only authority-bearing URLs.
+  if (/^[a-z][a-z\d+.-]*:\/\//i.test(value)) {
+    try {
+      const parsed = new URL(value);
+      if (parsed.username) parsed.username = "***";
+      if (parsed.password) parsed.password = "***";
+      for (const key of parsed.searchParams.keys()) {
+        if (SENSITIVE_URL_PARAM.test(key)) parsed.searchParams.set(key, "***");
+      }
+      return parsed.toString();
+    } catch {
+      // Fall through to the non-normalizing text redactor.
+    }
+  }
+
+  return value
+    .replace(SCHEME_USERINFO, "$1***:***@")
+    .replace(SCHEMELESS_USERINFO, "$1***:***@")
+    .replace(SENSITIVE_QUERY_VALUE, "$1***")
+    .replace(SENSITIVE_TEXT_VALUE, "$1***");
+}
+
+export function redactCredentialText(value) {
+  if (typeof value !== "string" || !value) return value;
+  return value
+    .replace(SCHEME_USERINFO, "$1***:***@")
+    .replace(SCHEMELESS_USERINFO, "$1***:***@")
+    .replace(SENSITIVE_QUERY_VALUE, "$1***")
+    .replace(SENSITIVE_TEXT_VALUE, "$1***")
+    .replace(AUTHORIZATION_VALUE, "$1 ***");
+}
+
+function redactCredentialValue(value) {
+  if (typeof value === "string") return redactCredentialText(value);
+  if (Array.isArray(value)) {
+    return value.map((item) => typeof item === "string" ? redactCredentialText(item) : item);
+  }
+  return value;
+}
+
+export function sanitizeProxyPool(proxyPool, { revealProxyUrl = false } = {}) {
+  if (!proxyPool || typeof proxyPool !== "object") return {};
+
+  const safe = {};
+  for (const field of SAFE_PROXY_POOL_FIELDS) {
+    const copied = copyPrimitive(proxyPool[field]);
+    if (copied !== undefined) safe[field] = copied;
+  }
+
+  const proxyUrl = copyPrimitive(proxyPool.proxyUrl);
+  if (typeof proxyUrl === "string") {
+    safe.proxyUrl = revealProxyUrl ? proxyUrl : redactCredentialUrl(proxyUrl);
+  }
+  if (safe.lastError !== undefined) {
+    safe.lastError = redactCredentialValue(safe.lastError);
+  }
+
+  return safe;
+}
+
+function sanitizeProviderSpecificData(providerSpecificData) {
+  if (!providerSpecificData || typeof providerSpecificData !== "object" || Array.isArray(providerSpecificData)) {
+    return undefined;
+  }
+
+  const safe = {};
+  for (const field of SAFE_PROVIDER_DATA_FIELDS) {
+    const copied = copyPrimitive(providerSpecificData[field]);
+    if (copied === undefined) continue;
+    safe[field] = URL_FIELDS.has(field) ? redactCredentialUrl(copied) : copied;
+  }
+  return safe;
+}
+
+function sanitizeModelLockReason(reason) {
+  if (!reason || typeof reason !== "object" || Array.isArray(reason)) return undefined;
+  const safe = {};
+  for (const field of SAFE_MODEL_LOCK_REASON_FIELDS) {
+    const copied = copyPrimitive(reason[field]);
+    if (copied !== undefined) {
+      safe[field] = field === "reason" ? redactCredentialValue(copied) : copied;
+    }
+  }
+  return Object.keys(safe).length > 0 ? safe : undefined;
+}
+
+/**
+ * Build the browser-facing representation of a provider connection. Provider
+ * records contain OAuth credentials, so response shaping is intentionally an
+ * allowlist instead of a top-level token denylist.
+ */
+export function sanitizeProviderConnection(connection) {
+  if (!connection || typeof connection !== "object") return {};
+
+  const safe = {};
+  for (const field of SAFE_CONNECTION_FIELDS) {
+    const copied = copyPrimitive(connection[field]);
+    if (copied !== undefined) {
+      safe[field] = REDACTED_CONNECTION_TEXT_FIELDS.has(field)
+        ? redactCredentialValue(copied)
+        : copied;
+    }
+  }
+
+  for (const [field, value] of Object.entries(connection)) {
+    if (!field.startsWith("modelLock_")) continue;
+    const copied = copyPrimitive(value);
+    if (copied !== undefined) safe[field] = copied;
+  }
+
+  const modelLockReason = sanitizeModelLockReason(connection.modelLockReason);
+  if (modelLockReason) safe.modelLockReason = modelLockReason;
+
+  const providerSpecificData = sanitizeProviderSpecificData(connection.providerSpecificData);
+  if (providerSpecificData) safe.providerSpecificData = providerSpecificData;
+
+  return safe;
+}

package/src/lib/responseCache.js

@@ -8,7 +8,7 @@
  *
  * What's cached:
  *   - Non-streaming (stream: false) successful (2xx) JSON responses
- *   - Keyed by SHA-256 of (model + canonical request body)
+ *   - Keyed by SHA-256 of (API-key tenant + canonical request body)
  *
  * What's NEVER cached (correctness first):
  *   - Streaming requests (stream: true) — SSE can't be replayed safely
@@ -43,9 +43,12 @@ class ResponseCache {
    * Build a deterministic cache key from the request.
    * Canonicalizes JSON (sorted keys) so key order doesn't matter.
    */
-  buildKey(body) {
+  buildKey(body, tenantScope = "local") {
     try {
-      const canonical = JSON.stringify(sortKeysDeep(stripVolatile(body)));
+      const canonical = JSON.stringify({
+        tenantScope: String(tenantScope || "local"),
+        body: sortKeysDeep(body),
+      });
       return crypto.createHash("sha256").update(canonical).digest("hex");
     } catch {
       return null;
@@ -113,14 +116,6 @@ function sortKeysDeep(value) {
   return value;
 }
 
-// Remove fields that legitimately differ between identical-intent requests
-// but shouldn't bust the cache.
-function stripVolatile(body) {
-  if (!body || typeof body !== "object") return body;
-  const { user, session_id, request_id, ...rest } = body;
-  return rest;
-}
-
 // Singleton
 export const responseCache = new ResponseCache();
 
@@ -135,12 +130,21 @@ export function isCacheableRequest(body, headers) {
   if (body.stream === true) return { cacheable: false, reason: "streaming" };
   if (Array.isArray(body.tools) && body.tools.length > 0) return { cacheable: false, reason: "tools" };
   if (body.tool_choice) return { cacheable: false, reason: "tool_choice" };
+  if (body.temperature !== 0) return { cacheable: false, reason: "non-deterministic-temperature" };
+  if (body.top_p !== undefined && body.top_p !== 1) return { cacheable: false, reason: "non-deterministic-top-p" };
+  if (body.n !== undefined && body.n !== 1) return { cacheable: false, reason: "multiple-choices" };
 
   // Respect client opt-out header
   const h = headers && typeof headers.get === "function"
     ? headers.get("x-zevai-no-cache")
     : headers?.["x-zevai-no-cache"];
   if (h) return { cacheable: false, reason: "client-opt-out" };
+  const cacheControl = headers && typeof headers.get === "function"
+    ? headers.get("cache-control")
+    : headers?.["cache-control"];
+  if (/\b(?:no-cache|no-store)\b/i.test(cacheControl || "")) {
+    return { cacheable: false, reason: "cache-control" };
+  }
 
   return { cacheable: true };
 }
@@ -151,8 +155,14 @@ export function isCacheableRequest(body, headers) {
 export function isCacheableResponse(responseBody, status) {
   if (status !== 200) return false;
   if (!responseBody || typeof responseBody !== "object") return false;
-  // Don't cache error payloads even at 200
-  if (responseBody.error) return false;
+  // Providers sometimes return failure envelopes with HTTP 200.
+  if (responseBody.error != null) return false;
+  if (Array.isArray(responseBody.errors) && responseBody.errors.length > 0) return false;
+  if (responseBody.success === false) return false;
+  const type = String(responseBody.type || "").toLowerCase();
+  const responseStatus = String(responseBody.status || "").toLowerCase();
+  if (type === "error" || type.endsWith(".failed") || responseStatus === "failed") return false;
+  if (responseBody.choices?.some((choice) => choice?.error != null)) return false;
   // Don't cache estimated usage (token counts unreliable)
   if (responseBody.usage?.estimated) return false;
   return true;