@juspay/neurolink 9.54.4 → 9.54.5

package/dist/cli/commands/proxy.js

@@ -201,27 +201,200 @@ async function isProxyHealthy(host, port, timeoutMs) {
         return false;
     }
 }
+// ---------------------------------------------------------------------------
+// Stable entrypoint for launchd
+// ---------------------------------------------------------------------------
+/**
+ * Path to a small trampoline script that the plist invokes.
+ * The trampoline re-resolves `neurolink` via PATH on every launch,
+ * so launchd never gets pinned to a version-specific store path.
+ */
+const TRAMPOLINE_DIR = join(homedir(), ".neurolink", "bin");
+const TRAMPOLINE_PATH = join(TRAMPOLINE_DIR, "neurolink-proxy");
+/**
+ * Verify a candidate bin path actually runs by invoking `--version` on it.
+ * Returns the version string on success, or undefined on any failure.
+ */
+function probeBinVersion(binPath) {
+    try {
+        const { execFileSync } = _require("node:child_process");
+        const out = execFileSync(binPath, ["--version"], {
+            encoding: "utf8",
+            timeout: 5_000,
+            stdio: ["ignore", "pipe", "ignore"],
+        }).trim();
+        return out || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Write (or overwrite) the trampoline shell script.
+ *
+ * Defensive design: the trampoline tries multiple candidates in order and
+ * only `exec`s one whose `--version` check succeeds. If every PATH-based
+ * candidate is broken (stale shims, missing packages), it falls back to the
+ * baked-in `node + script` path that was verified to work at install time.
+ */
+function writeTrampoline() {
+    const { writeFileSync, mkdirSync, existsSync, chmodSync } = _require("fs");
+    if (!existsSync(TRAMPOLINE_DIR)) {
+        mkdirSync(TRAMPOLINE_DIR, { recursive: true });
+    }
+    // Baked-in fallback: the specific node + JS script currently running
+    // (guaranteed to work, since we ARE running). Used only if all PATH-based
+    // candidates fail their --version probe.
+    const bakedNode = process.execPath;
+    const bakedScript = process.argv[1] ?? join(__dirname, "..", "index.js");
+    // Shell-escape the baked paths (they shouldn't contain quotes in practice,
+    // but be safe for paths with spaces).
+    const shEscape = (s) => `'${s.replace(/'/g, "'\\''")}'`;
+    const script = `#!/bin/sh
+# Auto-generated by \`neurolink proxy install\` — do not edit.
+# Resolves a working neurolink binary on every launchd invocation so the
+# plist never gets pinned to a broken/stale shim.
+
+# Probe a candidate: must be executable and respond to --version cleanly.
+_try() {
+  [ -n "$1" ] && [ -x "$1" ] || return 1
+  "$1" --version >/dev/null 2>&1 || return 1
+  return 0
+}
+
+# 1. Explicit user override (escape hatch for broken environments).
+if [ -n "\${NEUROLINK_BIN:-}" ]; then
+  if _try "$NEUROLINK_BIN"; then
+    exec "$NEUROLINK_BIN" "$@"
+  fi
+  echo "[neurolink-proxy] WARN: NEUROLINK_BIN=$NEUROLINK_BIN is not runnable, trying defaults" >&2
+fi
+
+# 2. PATH-based and common install locations. First working one wins.
+for cand in \\
+    "$(command -v neurolink 2>/dev/null || true)" \\
+    "\${PNPM_HOME:-}/neurolink" \\
+    "$HOME/.local/share/pnpm/neurolink" \\
+    "$HOME/Library/pnpm/neurolink" \\
+    "/usr/local/bin/neurolink" \\
+    "/opt/homebrew/bin/neurolink"; do
+  if _try "$cand"; then
+    exec "$cand" "$@"
+  fi
+done
+
+# 3. Baked-in fallback: the exact node + script that worked at install time.
+#    Always valid at install time; may become stale after package updates
+#    (but at that point the PATH candidates above should work).
+BAKED_NODE=${shEscape(bakedNode)}
+BAKED_SCRIPT=${shEscape(bakedScript)}
+if [ -x "$BAKED_NODE" ] && [ -f "$BAKED_SCRIPT" ]; then
+  exec "$BAKED_NODE" "$BAKED_SCRIPT" "$@"
+fi
+
+echo "[neurolink-proxy] FATAL: no working neurolink binary found." >&2
+echo "[neurolink-proxy] Tried: PATH, \\$PNPM_HOME, \\$HOME/.local/share/pnpm, \\$HOME/Library/pnpm, /usr/local/bin, /opt/homebrew/bin, baked-in install path." >&2
+echo "[neurolink-proxy] Fix: reinstall with 'pnpm add -g @juspay/neurolink' or set NEUROLINK_BIN=/path/to/working/neurolink." >&2
+exit 127
+`;
+    writeFileSync(TRAMPOLINE_PATH, script, { mode: 0o755 });
+    chmodSync(TRAMPOLINE_PATH, 0o755);
+}
+/**
+ * Resolve the `pnpm` binary defensively.
+ *
+ * Tries multiple candidates in order of preference and validates each by
+ * running `--version`. Returns the first one that actually works, along
+ * with a list of all candidates tried (for diagnostics). This defends
+ * against environments where `which pnpm` returns a broken shim or an
+ * incompatible version.
+ *
+ * Honors `NEUROLINK_PNPM_PATH` as an escape hatch.
+ */
+function resolveFullPnpmPath() {
+    const candidates = [];
+    // 1. User override
+    if (process.env.NEUROLINK_PNPM_PATH) {
+        candidates.push(process.env.NEUROLINK_PNPM_PATH);
+    }
+    // 2. PNPM_HOME (pnpm's own env variable)
+    if (process.env.PNPM_HOME) {
+        candidates.push(join(process.env.PNPM_HOME, "pnpm"));
+    }
+    // 3. `which pnpm` — whatever is on PATH
+    try {
+        const { execFileSync } = _require("node:child_process");
+        const whichOut = execFileSync("which", ["pnpm"], {
+            encoding: "utf8",
+            timeout: 5_000,
+            stdio: ["ignore", "pipe", "ignore"],
+        }).trim();
+        if (whichOut) {
+            candidates.push(whichOut);
+        }
+    }
+    catch {
+        // ignore
+    }
+    // 4. Common standalone installer locations
+    candidates.push(join(homedir(), ".local", "share", "pnpm", "pnpm"));
+    candidates.push(join(homedir(), "Library", "pnpm", "pnpm"));
+    // Dedupe while preserving order
+    const seen = new Set();
+    const unique = candidates.filter((p) => {
+        if (!p || seen.has(p)) {
+            return false;
+        }
+        seen.add(p);
+        return true;
+    });
+    // Probe each candidate
+    const tried = unique.map((path) => {
+        const version = probeBinVersion(path);
+        return { path, version, working: version !== undefined };
+    });
+    const working = tried.find((r) => r.working);
+    if (working) {
+        return {
+            bin: working.path,
+            resolved: true,
+            version: working.version,
+            tried,
+        };
+    }
+    return { bin: "pnpm", resolved: false, tried };
+}
 function spawnFailOpenGuard(host, port, parentPid) {
+    // The guard runs the same version as this process, so process.argv[1]
+    // (the currently-running script) is correct here — no stale-path risk.
     const entryScript = process.argv[1];
     if (!entryScript) {
         return undefined;
     }
+    const args = [
+        entryScript,
+        "proxy",
+        "guard",
+        "--host",
+        host,
+        "--port",
+        String(port),
+        "--parent-pid",
+        String(parentPid),
+        "--quiet",
+    ];
+    // Write guard stdout/stderr to a log file instead of discarding them.
+    const { openSync, closeSync, mkdirSync, existsSync } = _require("fs");
+    const guardLogDir = join(homedir(), ".neurolink", "logs");
+    if (!existsSync(guardLogDir)) {
+        mkdirSync(guardLogDir, { recursive: true });
+    }
+    const guardLogPath = join(guardLogDir, "proxy-guard.log");
+    const logFd = openSync(guardLogPath, "a");
     try {
-        const args = [
-            entryScript,
-            "proxy",
-            "guard",
-            "--host",
-            host,
-            "--port",
-            String(port),
-            "--parent-pid",
-            String(parentPid),
-            "--quiet",
-        ];
         const child = spawn(process.execPath, args, {
             detached: true,
-            stdio: "ignore",
+            stdio: ["ignore", logFd, logFd],
         });
         child.unref();
         return child.pid;
@@ -230,6 +403,9 @@ function spawnFailOpenGuard(host, port, parentPid) {
         logger.debug(`[proxy] failed to start fail-open guard: ${error instanceof Error ? error.message : String(error)}`);
         return undefined;
     }
+    finally {
+        closeSync(logFd); // parent closes its copy; child keeps the fd
+    }
 }
 async function runProxyTelemetryManager(command) {
     const { existsSync } = await import("fs");
@@ -568,10 +744,7 @@ async function createProxyStartApp(params) {
                     success: account.successCount,
                     errors: account.errorCount,
                     rateLimits: account.rateLimitCount,
-                    backoffLevel: account.currentBackoffLevel,
-                    cooling: account.coolingUntil
-                        ? account.coolingUntil > Date.now()
-                        : false,
+                    cooling: false, // No persistent cooldown — always active
                 })),
             },
             config: params.proxyConfig
@@ -1294,34 +1467,113 @@ export const proxyGuardCommand = {
                     logger.always(`[guard] WARNING: invalid version format "${result.latestVersion}", skipping`);
                     return;
                 }
-                logger.always(`[guard] traffic quiet, installing @juspay/neurolink@${result.latestVersion}...`);
+                // Resolve pnpm to a deterministic path, validating that it actually
+                // runs (some environments have broken shims on PATH).
+                const pnpmResolution = resolveFullPnpmPath();
+                // Log the full candidate list so operators can see why a particular
+                // pnpm was chosen (or why none worked).
+                logger.always(`[guard] pnpm candidates: ${pnpmResolution.tried
+                    .map((c) => `${c.path}(${c.working ? `v${c.version}` : "BROKEN"})`)
+                    .join(", ")}`);
+                if (!pnpmResolution.resolved) {
+                    // Environmental problem, not version-specific — skip this cycle
+                    // without suppressing the version (so we retry on the next tick
+                    // once the user fixes pnpm).
+                    logger.always(`[guard] WARNING: no working pnpm found; skipping update cycle. Install pnpm or set NEUROLINK_PNPM_PATH.`);
+                    return;
+                }
+                logger.always(`[guard] traffic quiet, installing @juspay/neurolink@${result.latestVersion} via ${pnpmResolution.bin} (pnpm v${pnpmResolution.version})...`);
                 const { execFileSync } = await import("node:child_process");
                 try {
-                    execFileSync("pnpm", ["add", "-g", `@juspay/neurolink@${result.latestVersion}`], {
+                    execFileSync(pnpmResolution.bin, ["add", "-g", `@juspay/neurolink@${result.latestVersion}`], {
                         timeout: 120_000,
                         stdio: "pipe",
                     });
                 }
                 catch (installErr) {
-                    logger.always(`[guard] WARNING: pnpm install failed: ${installErr instanceof Error ? installErr.message : String(installErr)}`);
-                    suppressVersion(result.latestVersion, "install_failed");
+                    // Capture stderr for actionable diagnostics
+                    const stderr = installErr &&
+                        typeof installErr === "object" &&
+                        "stderr" in installErr
+                        ? String(installErr.stderr).slice(0, 500)
+                        : "";
+                    const msg = installErr instanceof Error
+                        ? installErr.message
+                        : String(installErr);
+                    logger.always(`[guard] WARNING: pnpm install failed: ${msg}${stderr ? `\n  stderr: ${stderr}` : ""}`);
+                    suppressVersion(result.latestVersion, `install_failed: ${msg.slice(0, 200)}${stderr ? ` | stderr: ${stderr.slice(0, 200)}` : ""}`);
                     return;
                 }
-                // 4. Restart via launchctl
+                // 4. Rewrite the launchd plist so it picks up the (possibly new)
+                //    stable bin path, then restart via launchctl.
+                try {
+                    const { writeFileSync, existsSync: fsExists, mkdirSync: fsMkdir, } = await import("fs");
+                    if (!fsExists(PLIST_DIR)) {
+                        fsMkdir(PLIST_DIR, { recursive: true });
+                    }
+                    // Rewrite the trampoline and plist so the restarted service
+                    // resolves the newly installed binary via PATH.
+                    writeTrampoline();
+                    // Validate the trampoline actually resolves to the NEW version
+                    // before asking launchd to restart. If the install somehow left
+                    // PATH still pointing at the old version, don't kickstart.
+                    const probed = probeBinVersion(TRAMPOLINE_PATH);
+                    if (!probed) {
+                        logger.always(`[guard] WARNING: trampoline does not resolve to a working neurolink after install; skipping restart.`);
+                        suppressVersion(result.latestVersion, `trampoline_broken_after_install: ${TRAMPOLINE_PATH} --version failed`);
+                        return;
+                    }
+                    if (probed !== result.latestVersion) {
+                        // The trampoline resolves to a DIFFERENT version than what we
+                        // just installed. This means `pnpm add -g` installed into a
+                        // store that PATH doesn't reach (store mismatch), or PATH still
+                        // shadows with an older shim. Restarting would run the wrong
+                        // version — abort.
+                        logger.always(`[guard] ABORT: trampoline resolves to v${probed} but installed v${result.latestVersion}.`);
+                        logger.always(`[guard]   pnpm used: ${pnpmResolution.bin} (v${pnpmResolution.version})`);
+                        logger.always(`[guard]   This usually means pnpm's global store doesn't match the PATH-visible neurolink.`);
+                        logger.always(`[guard]   Fix: run 'pnpm add -g @juspay/neurolink' with the SAME pnpm whose bin dir is on PATH.`);
+                        suppressVersion(result.latestVersion, `version_mismatch: trampoline=${probed} expected=${result.latestVersion} pnpm=${pnpmResolution.bin}(v${pnpmResolution.version})`);
+                        return;
+                    }
+                    const existingArgs = parseExistingPlistArgs();
+                    const updatedPlist = buildPlist(port, host, existingArgs.envFile, existingArgs.configFile);
+                    writeFileSync(PLIST_PATH, updatedPlist, "utf-8");
+                    logger.always(`[guard] trampoline (resolves to v${probed}) + plist rewritten at ${PLIST_PATH}`);
+                }
+                catch (plistErr) {
+                    logger.always(`[guard] WARNING: failed to rewrite plist (restart may use stale path): ${plistErr instanceof Error ? plistErr.message : String(plistErr)}`);
+                    // Continue with restart anyway — the stable bin symlink may still be correct
+                }
                 // Signal the health loop to not exit when it detects
                 // the parent PID is gone — we're intentionally restarting.
                 updateRestartInProgress = true;
-                logger.always(`[guard] restarting proxy via launchctl...`);
+                logger.always(`[guard] restarting proxy via launchctl bootout/bootstrap...`);
                 const uid = process.getuid?.() ?? 501;
                 try {
-                    execFileSync("launchctl", ["kickstart", "-k", `gui/${uid}/${PLIST_LABEL}`], {
+                    // bootout unloads the in-memory job definition. This is required
+                    // because `kickstart -k` reuses the cached plist and ignores any
+                    // on-disk changes (like the trampoline rewrite above).
+                    try {
+                        execFileSync("launchctl", ["bootout", `gui/${uid}/${PLIST_LABEL}`], { timeout: 10_000, stdio: "pipe" });
+                    }
+                    catch {
+                        // Job may not be loaded (first install, or already unloaded)
+                    }
+                    // bootstrap loads the plist fresh from disk, picking up the
+                    // new trampoline-based ProgramArguments.
+                    execFileSync("launchctl", ["bootstrap", `gui/${uid}`, PLIST_PATH], {
                         timeout: 10_000,
                         stdio: "pipe",
                     });
                 }
-                catch {
-                    logger.always(`[guard] WARNING: launchctl kickstart failed`);
-                    suppressVersion(result.latestVersion, "restart_failed");
+                catch (restartErr) {
+                    updateRestartInProgress = false;
+                    const msg = restartErr instanceof Error
+                        ? restartErr.message
+                        : String(restartErr);
+                    logger.always(`[guard] WARNING: launchctl bootstrap failed: ${msg}`);
+                    suppressVersion(result.latestVersion, `restart_failed: ${msg.slice(0, 200)}`);
                     return;
                 }
                 // 5. Wait for healthy restart
@@ -1584,9 +1836,42 @@ function buildLaunchdPath() {
     }
     return [...segments].join(":");
 }
+/**
+ * Parse the existing launchd plist to extract --env-file and --config values.
+ * Used by the auto-updater to rewrite the plist with the same configuration.
+ */
+function parseExistingPlistArgs() {
+    try {
+        const { readFileSync, existsSync: fsExists } = _require("fs");
+        if (!fsExists(PLIST_PATH)) {
+            return {};
+        }
+        const xml = readFileSync(PLIST_PATH, "utf-8");
+        // Extract --env-file value: <string>--env-file</string>\n    <string>VALUE</string>
+        const envMatch = xml.match(/<string>--env-file<\/string>\s*<string>([^<]+)<\/string>/);
+        const configMatch = xml.match(/<string>--config<\/string>\s*<string>([^<]+)<\/string>/);
+        // Unescape XML entities so buildPlist() doesn't double-escape them.
+        const unescapeXml = (value) => value
+            ?.replace(/&apos;/g, "'")
+            .replace(/&quot;/g, '"')
+            .replace(/&gt;/g, ">")
+            .replace(/&lt;/g, "<")
+            .replace(/&amp;/g, "&");
+        return {
+            envFile: unescapeXml(envMatch?.[1]),
+            configFile: unescapeXml(configMatch?.[1]),
+        };
+    }
+    catch {
+        return {};
+    }
+}
 function buildPlist(port, host, envFile, configFile) {
-    const nodeExec = escapeXml(process.execPath);
-    const entryScript = escapeXml(process.argv[1] ?? join(__dirname, "..", "index.js"));
+    // The plist invokes the trampoline script (a tiny shell wrapper at
+    // ~/.neurolink/bin/neurolink-proxy) which re-resolves the real
+    // `neurolink` binary via PATH on every launch.  This way, launchd
+    // is never pinned to a version-specific pnpm store path.
+    const trampolinePath = escapeXml(TRAMPOLINE_PATH);
     const envFileArgs = envFile
         ? `
     <string>--env-file</string>
@@ -1607,8 +1892,7 @@ function buildPlist(port, host, envFile, configFile) {
 
   <key>ProgramArguments</key>
   <array>
-    <string>${nodeExec}</string>
-    <string>${entryScript}</string>
+    <string>${trampolinePath}</string>
     <string>proxy</string>
     <string>start</string>
     <string>--port</string>
@@ -1709,6 +1993,24 @@ export const proxyInstallCommand = {
         if (!existsSync(PLIST_DIR)) {
             mkdirSync(PLIST_DIR, { recursive: true });
         }
+        writeTrampoline();
+        console.info(chalk.green(`✓ Trampoline written to ${TRAMPOLINE_PATH}`));
+        // Sanity-check: run the trampoline itself and confirm it resolves to
+        // a working neurolink binary. This catches environments where every
+        // PATH-based candidate is broken AND the baked-in path is unreachable.
+        const trampolineVersion = probeBinVersion(TRAMPOLINE_PATH);
+        if (!trampolineVersion) {
+            console.info(chalk.red(`✗ Trampoline validation failed: ${TRAMPOLINE_PATH} --version did not run cleanly.`));
+            console.info(chalk.yellow(`  The launchd service would not be able to start neurolink. Fix your install first.`));
+            console.info(chalk.yellow(`  Try: 'pnpm add -g @juspay/neurolink' or set NEUROLINK_BIN=/path/to/working/neurolink.`));
+            process.exit(1);
+        }
+        if (trampolineVersion !== PROXY_VERSION) {
+            console.info(chalk.red(`✗ Trampoline resolves to v${trampolineVersion} but this installer is v${PROXY_VERSION}.`));
+            console.info(chalk.yellow(`  PATH may shadow this installation with an older version. Fix your PATH or set NEUROLINK_BIN.`));
+            process.exit(1);
+        }
+        console.info(chalk.green(`✓ Trampoline validated (resolves to neurolink v${trampolineVersion})`));
         const plist = buildPlist(port, host, envFile, configFile);
         writeFileSync(PLIST_PATH, plist, "utf-8");
         console.info(chalk.green(`✓ Plist written to ${PLIST_PATH}`));

package/dist/lib/proxy/routingPolicy.d.ts

@@ -1,4 +1,4 @@
-import type { ClaudeProxyModelTier, CooldownSkippedAccount, FallbackEntry, ParsedClaudeRequest, ProxyTranslationAttempt, ProxyTranslationPlan, RuntimeAccountState } from "../types/index.js";
+import type { ClaudeProxyModelTier, FallbackEntry, ParsedClaudeRequest, ProxyTranslationAttempt, ProxyTranslationPlan } from "../types/index.js";
 export type { ClaudeProxyModelTier, ProxyTranslationAttempt, ProxyTranslationPlan, };
 export declare function inferClaudeProxyModelTier(modelName: string): ClaudeProxyModelTier;
 /**
@@ -12,32 +12,7 @@ export declare function buildProxyTranslationPlan(primary: {
     model?: string;
 }, fallbackChain: FallbackEntry[], requestedModel: string, _parsed: ParsedClaudeRequest): ProxyTranslationPlan;
 /**
- * Check whether an account is currently cooling down.
- * Returns the cooldown timestamp if active, null otherwise.
+ * Parse the retry-after header from an upstream 429 response.
+ * Returns milliseconds to wait, or 0 if no valid header present.
  */
-export declare function getAccountCooldownUntil(state: RuntimeAccountState, now?: number): number | null;
-/**
- * Partition accounts into eligible (no cooldown) and skipped (cooling down).
- */
-export declare function partitionAccountsByCooldown<T extends {
-    key: string;
-}>(accounts: T[], getState: (account: T) => RuntimeAccountState, now?: number): {
-    eligible: T[];
-    skipped: CooldownSkippedAccount<T>[];
-};
-/**
- * Apply a rate-limit cooldown to an account.
- * Uses simple exponential backoff with a floor and cap.
- */
-export declare function applyRateLimitCooldown(args: {
-    state: RuntimeAccountState;
-    retryAfterMs?: number;
-    now?: number;
-    capMs: number;
-}): {
-    backoffMs: number;
-};
-/**
- * Clear cooldown state for an account after a successful request.
- */
-export declare function clearAccountCooldown(state: RuntimeAccountState): void;
+export declare function parseRetryAfterMs(retryAfterHeader: string | null): number;

package/dist/lib/proxy/routingPolicy.js

@@ -1,4 +1,3 @@
-const DEFAULT_COOLDOWN_FLOOR_MS = 1_000;
 export function inferClaudeProxyModelTier(modelName) {
     const normalized = modelName.toLowerCase();
     if (normalized.includes("opus")) {
@@ -50,55 +49,24 @@ export function buildProxyTranslationPlan(primary, fallbackChain, requestedModel
     };
 }
 // ---------------------------------------------------------------------------
-// Simple per-account cooldown
+// Retry-after parsing helper
 // ---------------------------------------------------------------------------
 /**
- * Check whether an account is currently cooling down.
- * Returns the cooldown timestamp if active, null otherwise.
+ * Parse the retry-after header from an upstream 429 response.
+ * Returns milliseconds to wait, or 0 if no valid header present.
  */
-export function getAccountCooldownUntil(state, now = Date.now()) {
-    if (state.coolingUntil && state.coolingUntil > now) {
-        return state.coolingUntil;
+export function parseRetryAfterMs(retryAfterHeader) {
+    if (!retryAfterHeader) {
+        return 0;
     }
-    return null;
-}
-/**
- * Partition accounts into eligible (no cooldown) and skipped (cooling down).
- */
-export function partitionAccountsByCooldown(accounts, getState, now = Date.now()) {
-    const eligible = [];
-    const skipped = [];
-    for (const account of accounts) {
-        const state = getState(account);
-        const until = getAccountCooldownUntil(state, now);
-        if (until !== null) {
-            skipped.push({
-                account,
-                cooldown: { until, backoffLevel: state.backoffLevel },
-            });
-            continue;
-        }
-        eligible.push(account);
+    const seconds = parseInt(retryAfterHeader, 10);
+    if (!Number.isNaN(seconds)) {
+        return Math.max(1, seconds) * 1000;
     }
-    return { eligible, skipped };
-}
-/**
- * Apply a rate-limit cooldown to an account.
- * Uses simple exponential backoff with a floor and cap.
- */
-export function applyRateLimitCooldown(args) {
-    const now = args.now ?? Date.now();
-    const baseCooldownMs = Math.max(args.retryAfterMs ?? 0, DEFAULT_COOLDOWN_FLOOR_MS);
-    const backoffMs = Math.min(baseCooldownMs * 2 ** args.state.backoffLevel, args.capMs);
-    args.state.coolingUntil = now + backoffMs;
-    args.state.backoffLevel += 1;
-    return { backoffMs };
-}
-/**
- * Clear cooldown state for an account after a successful request.
- */
-export function clearAccountCooldown(state) {
-    state.coolingUntil = undefined;
-    state.backoffLevel = 0;
+    const date = new Date(retryAfterHeader);
+    if (!Number.isNaN(date.getTime())) {
+        return Math.max(1000, date.getTime() - Date.now());
+    }
+    return 0;
 }
 //# sourceMappingURL=routingPolicy.js.map

package/dist/lib/proxy/usageStats.d.ts

@@ -8,7 +8,6 @@ export declare function recordAttempt(accountLabel: string, accountType: string)
 export declare function recordFinalSuccess(accountLabel?: string, accountType?: string): void;
 export declare function recordAttemptError(accountLabel: string, accountType: string, status: number): void;
 export declare function recordFinalError(_status: number, accountLabel?: string, accountType?: string): void;
-export declare function recordCooldown(accountLabel: string, accountType: string, cooldownUntil: number, backoffLevel: number): void;
 export declare function getStats(): ProxyStats;
 export declare function getAccountStats(label: string): AccountStats | undefined;
 export declare function resetStats(): void;

package/dist/lib/proxy/usageStats.js

@@ -24,7 +24,6 @@ export function recordFinalSuccess(accountLabel, accountType) {
     if (accountLabel && accountType) {
         const acct = ensureAccount(accountLabel, accountType);
         acct.successCount++;
-        acct.currentBackoffLevel = 0;
     }
 }
 export function recordAttemptError(accountLabel, accountType, status) {
@@ -45,11 +44,6 @@ export function recordFinalError(_status, accountLabel, accountType) {
         acct.lastErrorAt = Date.now();
     }
 }
-export function recordCooldown(accountLabel, accountType, cooldownUntil, backoffLevel) {
-    const acct = ensureAccount(accountLabel, accountType);
-    acct.coolingUntil = cooldownUntil;
-    acct.currentBackoffLevel = backoffLevel;
-}
 export function getStats() {
     const accounts = {};
     for (const [label, account] of Object.entries(stats.accounts)) {
@@ -80,7 +74,6 @@ function ensureAccount(label, type) {
             errorCount: 0,
             rateLimitCount: 0,
             lastAttemptAt: 0,
-            currentBackoffLevel: 0,
         };
     }
     return stats.accounts[label];