@juspay/neurolink 10.8.19 → 10.8.21

package/CHANGELOG.md

@@ -1,3 +1,11 @@
+## [10.8.21](https://github.com/juspay/neurolink/compare/v10.8.20...v10.8.21) (2026-08-05)
+
+## [10.8.20](https://github.com/juspay/neurolink/compare/v10.8.19...v10.8.20) (2026-08-05)
+
+### Bug Fixes
+
+- **(proxy):** retry transient updater installs and expose worker exits ([756d04e](https://github.com/juspay/neurolink/commit/756d04ed2b39005c9b49917abdad6df78a4e251b))
+
 ## [10.8.19](https://github.com/juspay/neurolink/compare/v10.8.18...v10.8.19) (2026-08-05)
 
 ### Bug Fixes

package/dist/cli/commands/proxy.js

@@ -25,7 +25,7 @@ import { ProxyRuntimeConfigStore } from "../../lib/proxy/runtimeConfig.js";
 import { anthropicAccountKeysEqual, createAccountAllowlist, ENV_ANTHROPIC_ACCOUNT_KEY, isAccountAllowed, LEGACY_ANTHROPIC_ACCOUNT_KEY, normalizeAnthropicAccountKey, shouldLoadFallbackCredential, } from "../../lib/proxy/accountSelection.js";
 import { beginProxyRequest, getProxyActivitySnapshot, trackProxyResponse, } from "../../lib/proxy/proxyActivity.js";
 import { flushProxyLifecycleEvents, getProxyLifecycleLoggerSnapshot, hashProxyLifecycleSessionId, logProxyLifecycleEvent, } from "../../lib/proxy/proxyLifecycle.js";
-import { describeInstallFailure, getGlobalInstallArgs, resolveGlobalInstaller, validateInstalledVersion, } from "../../lib/proxy/globalInstaller.js";
+import { describeInstallFailure, getGlobalInstallArgs, isTransientInstallFailure, resolveGlobalInstaller, validateInstalledVersion, } from "../../lib/proxy/globalInstaller.js";
 import { startUpdaterWorkerSupervisor } from "../../lib/proxy/updaterSupervisor.js";
 import { openProxyWorkerLog } from "../../lib/proxy/workerLog.js";
 import { startRollingProxyServer } from "../../lib/proxy/rollingProxyServer.js";
@@ -671,7 +671,22 @@ async function getRollingActivationFailure(host, port, expectedVersion) {
             typeof failure.message !== "string") {
             return null;
         }
-        return `${failure.phase}: ${failure.message}`;
+        const workerDetail = [
+            typeof failure.workerPid === "number" ? `pid=${failure.workerPid}` : null,
+            typeof failure.workerExitCode === "number" ||
+                failure.workerExitCode === null
+                ? `exitCode=${failure.workerExitCode ?? "none"}`
+                : null,
+            typeof failure.workerExitSignal === "string"
+                ? `exitSignal=${failure.workerExitSignal}`
+                : null,
+            typeof failure.supervisorAction === "string"
+                ? `supervisorAction=${failure.supervisorAction}`
+                : null,
+        ]
+            .filter(Boolean)
+            .join(" ");
+        return `${failure.phase}: ${failure.message}${workerDetail ? ` (${workerDetail})` : ""}`;
     }
     catch {
         return null;
@@ -3252,6 +3267,8 @@ export const proxyGuardCommand = {
         const NATURAL_WINDOW_WAIT_MS = 10 * 60 * 1000; // prefer no admission pause
         const UPDATE_DRAIN_TIMEOUT_MS = 30 * 60 * 1000; // preserve long streams
         const UPDATE_RETRY_DELAY_MS = 5 * 60 * 1000;
+        const UPDATE_RETRY_MAX_DELAY_MS = 30 * 60 * 1000;
+        const UPDATE_RETRY_MAX_ATTEMPTS = 4;
         const UPDATE_ACTIVITY_POLL_MS = 10 * 1000;
         const UPDATE_TIMEOUT_MS = 30 * 1000; // 30 seconds to come healthy
         // Get running version from /health endpoint (with timeout to avoid hanging)
@@ -3276,6 +3293,8 @@ export const proxyGuardCommand = {
         let updateCheckTimeout;
         let updateCheckInterval;
         let updateRetryTimeout;
+        let updateRetryAttempts = 0;
+        let updateRetryVersion = null;
         const stopUpdateChecks = () => {
             guardStopping = true;
             if (updateCheckTimeout) {
@@ -3317,6 +3336,8 @@ export const proxyGuardCommand = {
                 updateVersion = result.latestVersion;
                 persistUpdaterState("record update check", () => recordCheck(result.latestVersion));
                 if (!result.updateAvailable) {
+                    updateRetryAttempts = 0;
+                    updateRetryVersion = null;
                     persistUpdaterState("clear update deferral", () => clearUpdateDeferral());
                     return;
                 }
@@ -3368,7 +3389,7 @@ export const proxyGuardCommand = {
                         if (updateWindow.reason === "drain_failed") {
                             persistUpdaterState("record unavailable update drain", () => recordUpdateDeferred(result.latestVersion, "drain_unavailable", null));
                         }
-                        scheduleUpdateRetry();
+                        scheduleUpdateRetry("update window unavailable", result.latestVersion);
                         return;
                     }
                     // Hold admission closed through install and restart after a quiet
@@ -3376,7 +3397,7 @@ export const proxyGuardCommand = {
                     if (!drainActive) {
                         updateWindow = await waitForWindow(0);
                         if (!updateWindow.ready) {
-                            scheduleUpdateRetry();
+                            scheduleUpdateRetry("update drain unavailable", result.latestVersion);
                             return;
                         }
                     }
@@ -3437,6 +3458,9 @@ export const proxyGuardCommand = {
                         const detail = describeInstallFailure(installErr);
                         logger.always(`[updater] WARNING: global install failed:\n${detail}`);
                         persistUpdaterState("record update failure", () => recordUpdateFailure(result.latestVersion, "install", detail));
+                        if (isTransientInstallFailure(installErr)) {
+                            scheduleUpdateRetry("transient install failure", result.latestVersion);
+                        }
                         return;
                     }
                 }
@@ -3459,6 +3483,8 @@ export const proxyGuardCommand = {
                         return;
                     }
                     persistUpdaterState("record installed update", () => recordUpdateInstalled(result.latestVersion));
+                    updateRetryAttempts = 0;
+                    updateRetryVersion = null;
                     logger.always(`[updater] trampoline validated at v${validation.version} after ${validation.attempts} attempt(s)`);
                 }
                 catch (trampolineError) {
@@ -3610,14 +3636,25 @@ export const proxyGuardCommand = {
                 updateInProgress = false;
             }
         };
-        const scheduleUpdateRetry = () => {
+        const scheduleUpdateRetry = (reason, version) => {
             if (guardStopping || updateRetryTimeout) {
                 return;
             }
+            if (updateRetryVersion !== version) {
+                updateRetryVersion = version;
+                updateRetryAttempts = 0;
+            }
+            if (updateRetryAttempts >= UPDATE_RETRY_MAX_ATTEMPTS) {
+                logger.always(`[updater] retry budget exhausted after ${updateRetryAttempts} attempt(s); waiting for the periodic check`);
+                return;
+            }
+            updateRetryAttempts += 1;
+            const delay = Math.min(UPDATE_RETRY_MAX_DELAY_MS, UPDATE_RETRY_DELAY_MS * 2 ** (updateRetryAttempts - 1));
+            logger.always(`[updater] retry scheduled reason=${reason} attempt=${updateRetryAttempts}/${UPDATE_RETRY_MAX_ATTEMPTS} delayMs=${delay}`);
             updateRetryTimeout = setTimeout(() => {
                 updateRetryTimeout = undefined;
                 void runUpdateCheck();
-            }, UPDATE_RETRY_DELAY_MS);
+            }, delay);
             updateRetryTimeout.unref?.();
         };
         // Run first check after a short delay, then on interval

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

@@ -2,6 +2,12 @@ import type { GlobalInstallerKind, GlobalInstallerResolution, InstalledVersionVa
 /** Resolve a package manager that can update the installation currently running. */
 export declare function resolveGlobalInstaller(options?: ResolveGlobalInstallerOptions): GlobalInstallerResolution;
 export declare function getGlobalInstallArgs(kind: GlobalInstallerKind, packageSpec: string): string[];
+/**
+ * Return whether a global package-manager failure is likely environmental and
+ * worth retrying. Configuration and permission failures deliberately return
+ * false so the updater does not repeatedly mutate a broken installation.
+ */
+export declare function isTransientInstallFailure(error: unknown): boolean;
 /**
  * Validate a freshly installed CLI with retries. Global package replacement
  * can leave executable shims briefly unavailable while filesystem metadata and

package/dist/lib/proxy/globalInstaller.js

@@ -136,6 +136,36 @@ export function getGlobalInstallArgs(kind, packageSpec) {
         ? ["add", "-g", packageSpec]
         : ["install", "--global", "--no-audit", "--no-fund", packageSpec];
 }
+const TRANSIENT_INSTALL_FAILURE_CODES = new Set([
+    "ECONNRESET",
+    "ECONNREFUSED",
+    "EAI_AGAIN",
+    "EHOSTUNREACH",
+    "ENETUNREACH",
+    "ENOTFOUND",
+    "EPIPE",
+    "ETIMEDOUT",
+]);
+/**
+ * Return whether a global package-manager failure is likely environmental and
+ * worth retrying. Configuration and permission failures deliberately return
+ * false so the updater does not repeatedly mutate a broken installation.
+ */
+export function isTransientInstallFailure(error) {
+    let current = error;
+    for (let depth = 0; depth < 5 && current; depth++) {
+        if (typeof current !== "object") {
+            return false;
+        }
+        const candidate = current;
+        if (typeof candidate.code === "string" &&
+            TRANSIENT_INSTALL_FAILURE_CODES.has(candidate.code)) {
+            return true;
+        }
+        current = candidate.cause;
+    }
+    return false;
+}
 /**
  * Validate a freshly installed CLI with retries. Global package replacement
  * can leave executable shims briefly unavailable while filesystem metadata and

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

@@ -36,6 +36,7 @@ export declare class RollingWorkerSupervisor {
     private handleTransferFailure;
     private rejectSocket;
     private describeTransferError;
+    private extractLifecycleFailureDetails;
     private recordFailure;
     private publishState;
 }

package/dist/lib/proxy/rollingWorkerSupervisor.js

@@ -200,7 +200,7 @@ export class RollingWorkerSupervisor {
         }
         return new Promise((resolve, reject) => {
             let settled = false;
-            const finish = (error, phase = "startup") => {
+            const finish = (error, phase = "startup", details) => {
                 if (settled) {
                     return;
                 }
@@ -208,7 +208,7 @@ export class RollingWorkerSupervisor {
                 clearTimeout(readyTimeout);
                 if (error) {
                     if (!this.closed) {
-                        this.recordFailure(generation, expectedVersion, phase, error.message);
+                        this.recordFailure(generation, expectedVersion, phase, error.message, details);
                     }
                     if (this.candidate?.generation === generation) {
                         this.candidate = null;
@@ -307,14 +307,22 @@ export class RollingWorkerSupervisor {
             });
             const offExit = handle.onExit((code, signal) => {
                 if (this.candidate?.generation === generation) {
-                    finish(new Error(`worker ${handle.pid} exited before readiness (code=${code ?? "none"}, signal=${signal ?? "none"})`));
+                    finish(new Error(`worker ${handle.pid} exited before readiness (code=${code ?? "none"}, signal=${signal ?? "none"})`), "startup", {
+                        workerPid: handle.pid,
+                        workerExitCode: code,
+                        workerExitSignal: signal,
+                    });
                     return;
                 }
                 if (this.active?.generation === generation) {
                     this.active.dispose();
                     this.active = null;
                     if (!this.closed) {
-                        this.recordFailure(generation, expectedVersion, "runtime", `worker exited (code=${code ?? "none"}, signal=${signal ?? "none"})`);
+                        this.recordFailure(generation, expectedVersion, "runtime", `worker exited (code=${code ?? "none"}, signal=${signal ?? "none"})`, {
+                            workerPid: handle.pid,
+                            workerExitCode: code,
+                            workerExitSignal: signal,
+                        });
                     }
                     this.options.log?.(`[proxy-supervisor] active worker exited generation=${generation} pid=${handle.pid} code=${code ?? "none"} signal=${signal ?? "none"}`);
                 }
@@ -402,7 +410,16 @@ export class RollingWorkerSupervisor {
     handleTransferFailure(worker, socket, error) {
         this.failedTransfers += 1;
         const detail = this.describeTransferError(error);
-        this.recordFailure(worker.generation, worker.version, "transfer", `worker ${worker.handle.pid} failed to accept a transferred socket: ${detail}`);
+        const lifecycle = this.extractLifecycleFailureDetails(error, worker.handle.pid);
+        this.recordFailure(worker.generation, worker.version, "transfer", `worker ${worker.handle.pid} failed to accept a transferred socket: ${detail}`, {
+            ...lifecycle.details,
+            // If the error already records an exit, the supervisor did not cause
+            // that exit. Otherwise this captures the deliberate cleanup following
+            // the failed transfer, not a claimed root cause for the failure.
+            supervisorAction: lifecycle.observedExit
+                ? "none"
+                : "sigkill_after_transfer_failure",
+        });
         this.options.log?.(`[proxy-supervisor] socket transfer failed generation=${worker.generation} pid=${worker.handle.pid}: ${detail}`);
         if (this.active?.generation === worker.generation && !this.closed) {
             this.active = null;
@@ -427,13 +444,38 @@ export class RollingWorkerSupervisor {
         const code = error.code;
         return code ? `${code}: ${error.message}` : error.message;
     }
-    recordFailure(generation, version, phase, message) {
+    extractLifecycleFailureDetails(error, fallbackPid) {
+        const context = error &&
+            typeof error === "object" &&
+            "context" in error &&
+            error.context &&
+            typeof error.context === "object"
+            ? (error.context ?? {})
+            : {};
+        const workerPid = typeof context.workerPid === "number" ? context.workerPid : fallbackPid;
+        const hasExitCode = typeof context.exitCode === "number" || context.exitCode === null;
+        const hasExitSignal = typeof context.signal === "string" || context.signal === null;
+        return {
+            details: {
+                workerPid,
+                ...(hasExitCode
+                    ? { workerExitCode: context.exitCode }
+                    : {}),
+                ...(hasExitSignal
+                    ? { workerExitSignal: context.signal }
+                    : {}),
+            },
+            observedExit: hasExitCode || hasExitSignal,
+        };
+    }
+    recordFailure(generation, version, phase, message, details = {}) {
         this.lastFailure = {
             at: new Date().toISOString(),
             generation,
             version,
             phase,
             message: message.slice(0, 1_000),
+            ...details,
         };
     }
     publishState() {

package/dist/lib/types/cli.d.ts

@@ -863,6 +863,10 @@ export type ProxyRollingState = {
         version: string;
         phase: "startup" | "activation" | "runtime" | "transfer";
         message: string;
+        workerPid?: number;
+        workerExitCode?: number | null;
+        workerExitSignal?: string | null;
+        supervisorAction?: "none" | "sigkill_after_transfer_failure";
     } | null;
 };
 export type ProxySupervisorState = {

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

@@ -1906,6 +1906,12 @@ export type SpawnProxySocketWorkerOptions = {
     stderr?: "inherit" | "ignore";
     socketAckTimeoutMs?: number;
 };
+export type RollingWorkerFailureDetails = {
+    workerPid?: number;
+    workerExitCode?: number | null;
+    workerExitSignal?: string | null;
+    supervisorAction?: "none" | "sigkill_after_transfer_failure";
+};
 export type RollingWorkerSupervisorSnapshot = {
     generation: number;
     active: {
@@ -1926,13 +1932,13 @@ export type RollingWorkerSupervisorSnapshot = {
     queuedSockets: number;
     rejectedSockets: number;
     failedTransfers: number;
-    lastFailure: {
+    lastFailure: ({
         at: string;
         generation: number;
         version: string;
         phase: "startup" | "activation" | "runtime" | "transfer";
         message: string;
-    } | null;
+    } & RollingWorkerFailureDetails) | null;
 };
 export type RollingWorkerSupervisorOptions = {
     spawnWorker: (generation: number, expectedVersion: string) => RollingWorkerHandle;

package/dist/proxy/globalInstaller.d.ts

@@ -2,6 +2,12 @@ import type { GlobalInstallerKind, GlobalInstallerResolution, InstalledVersionVa
 /** Resolve a package manager that can update the installation currently running. */
 export declare function resolveGlobalInstaller(options?: ResolveGlobalInstallerOptions): GlobalInstallerResolution;
 export declare function getGlobalInstallArgs(kind: GlobalInstallerKind, packageSpec: string): string[];
+/**
+ * Return whether a global package-manager failure is likely environmental and
+ * worth retrying. Configuration and permission failures deliberately return
+ * false so the updater does not repeatedly mutate a broken installation.
+ */
+export declare function isTransientInstallFailure(error: unknown): boolean;
 /**
  * Validate a freshly installed CLI with retries. Global package replacement
  * can leave executable shims briefly unavailable while filesystem metadata and

package/dist/proxy/globalInstaller.js

@@ -136,6 +136,36 @@ export function getGlobalInstallArgs(kind, packageSpec) {
         ? ["add", "-g", packageSpec]
         : ["install", "--global", "--no-audit", "--no-fund", packageSpec];
 }
+const TRANSIENT_INSTALL_FAILURE_CODES = new Set([
+    "ECONNRESET",
+    "ECONNREFUSED",
+    "EAI_AGAIN",
+    "EHOSTUNREACH",
+    "ENETUNREACH",
+    "ENOTFOUND",
+    "EPIPE",
+    "ETIMEDOUT",
+]);
+/**
+ * Return whether a global package-manager failure is likely environmental and
+ * worth retrying. Configuration and permission failures deliberately return
+ * false so the updater does not repeatedly mutate a broken installation.
+ */
+export function isTransientInstallFailure(error) {
+    let current = error;
+    for (let depth = 0; depth < 5 && current; depth++) {
+        if (typeof current !== "object") {
+            return false;
+        }
+        const candidate = current;
+        if (typeof candidate.code === "string" &&
+            TRANSIENT_INSTALL_FAILURE_CODES.has(candidate.code)) {
+            return true;
+        }
+        current = candidate.cause;
+    }
+    return false;
+}
 /**
  * Validate a freshly installed CLI with retries. Global package replacement
  * can leave executable shims briefly unavailable while filesystem metadata and

package/dist/proxy/rollingWorkerSupervisor.d.ts

@@ -36,6 +36,7 @@ export declare class RollingWorkerSupervisor {
     private handleTransferFailure;
     private rejectSocket;
     private describeTransferError;
+    private extractLifecycleFailureDetails;
     private recordFailure;
     private publishState;
 }

package/dist/proxy/rollingWorkerSupervisor.js

@@ -200,7 +200,7 @@ export class RollingWorkerSupervisor {
         }
         return new Promise((resolve, reject) => {
             let settled = false;
-            const finish = (error, phase = "startup") => {
+            const finish = (error, phase = "startup", details) => {
                 if (settled) {
                     return;
                 }
@@ -208,7 +208,7 @@ export class RollingWorkerSupervisor {
                 clearTimeout(readyTimeout);
                 if (error) {
                     if (!this.closed) {
-                        this.recordFailure(generation, expectedVersion, phase, error.message);
+                        this.recordFailure(generation, expectedVersion, phase, error.message, details);
                     }
                     if (this.candidate?.generation === generation) {
                         this.candidate = null;
@@ -307,14 +307,22 @@ export class RollingWorkerSupervisor {
             });
             const offExit = handle.onExit((code, signal) => {
                 if (this.candidate?.generation === generation) {
-                    finish(new Error(`worker ${handle.pid} exited before readiness (code=${code ?? "none"}, signal=${signal ?? "none"})`));
+                    finish(new Error(`worker ${handle.pid} exited before readiness (code=${code ?? "none"}, signal=${signal ?? "none"})`), "startup", {
+                        workerPid: handle.pid,
+                        workerExitCode: code,
+                        workerExitSignal: signal,
+                    });
                     return;
                 }
                 if (this.active?.generation === generation) {
                     this.active.dispose();
                     this.active = null;
                     if (!this.closed) {
-                        this.recordFailure(generation, expectedVersion, "runtime", `worker exited (code=${code ?? "none"}, signal=${signal ?? "none"})`);
+                        this.recordFailure(generation, expectedVersion, "runtime", `worker exited (code=${code ?? "none"}, signal=${signal ?? "none"})`, {
+                            workerPid: handle.pid,
+                            workerExitCode: code,
+                            workerExitSignal: signal,
+                        });
                     }
                     this.options.log?.(`[proxy-supervisor] active worker exited generation=${generation} pid=${handle.pid} code=${code ?? "none"} signal=${signal ?? "none"}`);
                 }
@@ -402,7 +410,16 @@ export class RollingWorkerSupervisor {
     handleTransferFailure(worker, socket, error) {
         this.failedTransfers += 1;
         const detail = this.describeTransferError(error);
-        this.recordFailure(worker.generation, worker.version, "transfer", `worker ${worker.handle.pid} failed to accept a transferred socket: ${detail}`);
+        const lifecycle = this.extractLifecycleFailureDetails(error, worker.handle.pid);
+        this.recordFailure(worker.generation, worker.version, "transfer", `worker ${worker.handle.pid} failed to accept a transferred socket: ${detail}`, {
+            ...lifecycle.details,
+            // If the error already records an exit, the supervisor did not cause
+            // that exit. Otherwise this captures the deliberate cleanup following
+            // the failed transfer, not a claimed root cause for the failure.
+            supervisorAction: lifecycle.observedExit
+                ? "none"
+                : "sigkill_after_transfer_failure",
+        });
         this.options.log?.(`[proxy-supervisor] socket transfer failed generation=${worker.generation} pid=${worker.handle.pid}: ${detail}`);
         if (this.active?.generation === worker.generation && !this.closed) {
             this.active = null;
@@ -427,13 +444,38 @@ export class RollingWorkerSupervisor {
         const code = error.code;
         return code ? `${code}: ${error.message}` : error.message;
     }
-    recordFailure(generation, version, phase, message) {
+    extractLifecycleFailureDetails(error, fallbackPid) {
+        const context = error &&
+            typeof error === "object" &&
+            "context" in error &&
+            error.context &&
+            typeof error.context === "object"
+            ? (error.context ?? {})
+            : {};
+        const workerPid = typeof context.workerPid === "number" ? context.workerPid : fallbackPid;
+        const hasExitCode = typeof context.exitCode === "number" || context.exitCode === null;
+        const hasExitSignal = typeof context.signal === "string" || context.signal === null;
+        return {
+            details: {
+                workerPid,
+                ...(hasExitCode
+                    ? { workerExitCode: context.exitCode }
+                    : {}),
+                ...(hasExitSignal
+                    ? { workerExitSignal: context.signal }
+                    : {}),
+            },
+            observedExit: hasExitCode || hasExitSignal,
+        };
+    }
+    recordFailure(generation, version, phase, message, details = {}) {
         this.lastFailure = {
             at: new Date().toISOString(),
             generation,
             version,
             phase,
             message: message.slice(0, 1_000),
+            ...details,
         };
     }
     publishState() {

package/dist/types/cli.d.ts

@@ -863,6 +863,10 @@ export type ProxyRollingState = {
         version: string;
         phase: "startup" | "activation" | "runtime" | "transfer";
         message: string;
+        workerPid?: number;
+        workerExitCode?: number | null;
+        workerExitSignal?: string | null;
+        supervisorAction?: "none" | "sigkill_after_transfer_failure";
     } | null;
 };
 export type ProxySupervisorState = {

package/dist/types/proxy.d.ts

@@ -1906,6 +1906,12 @@ export type SpawnProxySocketWorkerOptions = {
     stderr?: "inherit" | "ignore";
     socketAckTimeoutMs?: number;
 };
+export type RollingWorkerFailureDetails = {
+    workerPid?: number;
+    workerExitCode?: number | null;
+    workerExitSignal?: string | null;
+    supervisorAction?: "none" | "sigkill_after_transfer_failure";
+};
 export type RollingWorkerSupervisorSnapshot = {
     generation: number;
     active: {
@@ -1926,13 +1932,13 @@ export type RollingWorkerSupervisorSnapshot = {
     queuedSockets: number;
     rejectedSockets: number;
     failedTransfers: number;
-    lastFailure: {
+    lastFailure: ({
         at: string;
         generation: number;
         version: string;
         phase: "startup" | "activation" | "runtime" | "transfer";
         message: string;
-    } | null;
+    } & RollingWorkerFailureDetails) | null;
 };
 export type RollingWorkerSupervisorOptions = {
     spawnWorker: (generation: number, expectedVersion: string) => RollingWorkerHandle;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "10.8.19",
+  "version": "10.8.21",
   "packageManager": "pnpm@10.15.1",
   "description": "TypeScript AI SDK with 24+ LLM providers behind one consistent API. MCP-native (connect any MCP server), voice TTS/STT/realtime, RAG, agents, memory, context compaction. OpenAI · Anthropic · Gemini · Bedrock · Azure · Ollama · DeepSeek · NVIDIA NIM and more.",
   "author": {
@@ -143,7 +143,7 @@
     "test:model-pool": "npx tsx test/continuous-test-suite-model-pool.ts",
     "test:model-not-found-retryable": "npx tsx test/continuous-test-suite-model-not-found-retryable.ts",
     "test:model-capabilities": "npx tsx test/continuous-test-suite-model-capabilities.ts",
-    "test:agent-runtime:vitest": "pnpm exec vitest run test/agentRuntime.test.ts test/agentDelegation.test.ts test/agentPlumbing.test.ts test/toolExecutionRecorder.test.ts",
+    "test:agent-runtime:vitest": "pnpm exec vitest run test/agentRuntime.test.ts",
     "test:retry-after:vitest": "pnpm exec vitest run test/retryAfter.test.ts",
     "test:ci": "pnpm run test && pnpm run test:client && pnpm run test:hitl",
     "// CI tier — fast, no live AI calls, safe for every commit": "",
@@ -152,7 +152,7 @@
     "test:system-messages": "npx tsx test/continuous-test-suite-system-messages.ts",
     "test:test-stubs": "npx tsx test/continuous-test-suite-test-stubs.ts",
     "test:tool-routing-semantic": "npx tsx test/continuous-test-suite-tool-routing-semantic.ts",
-    "test:unit": "pnpm run test:envguard && pnpm run test:bugfixes && pnpm run test:file-detector-extension && pnpm run test:file-detector-magic-bytes && pnpm run test:mcp:infra && pnpm run test:mcp:bash && pnpm run test:mcp:limits && pnpm run test:mcp:spans && pnpm run test:autoresearch:redis && pnpm run test:tool-routing && pnpm run test:tool-routing-cli && pnpm run test:tool-dedup && pnpm run test:model-pool && pnpm run test:litellm-context && pnpm run test:dedup-execute-map && pnpm run test:step-budget-guard:vitest && pnpm run test:system-messages && pnpm run test:tool-routing-semantic && pnpm run test:anthropic-tools-policy && pnpm run test:sagemaker-tools && pnpm run test:anthropic-multimodal && pnpm run test:excel-interop && pnpm run test:model-capabilities && pnpm run test:agent-runtime:vitest && pnpm run test:retry-after:vitest && pnpm run test:sampling-params && pnpm run test:structured-recovery && pnpm run test:prompt-redaction && pnpm run test:mcp-result-cache && pnpm run test:test-stubs && pnpm run test:model-not-found-retryable",
+    "test:unit": "pnpm run test:envguard && pnpm run test:bugfixes && pnpm run test:file-detector-extension && pnpm run test:file-detector-magic-bytes && pnpm run test:mcp:infra && pnpm run test:mcp:bash && pnpm run test:mcp:limits && pnpm run test:mcp:spans && pnpm run test:autoresearch:redis && pnpm run test:tool-routing && pnpm run test:tool-routing-cli && pnpm run test:tool-dedup && pnpm run test:model-pool && pnpm run test:litellm-context && pnpm run test:dedup-execute-map && pnpm run test:step-budget-guard && pnpm run test:agent-plumbing && pnpm run test:tool-execution-recorder && pnpm run test:proxy-terminal-errors && pnpm run test:system-messages && pnpm run test:tool-routing-semantic && pnpm run test:anthropic-tools-policy && pnpm run test:sagemaker-tools && pnpm run test:anthropic-multimodal && pnpm run test:excel-interop && pnpm run test:model-capabilities && pnpm run test:agent-runtime:vitest && pnpm run test:agent-delegation && pnpm run test:retry-after:vitest && pnpm run test:sampling-params && pnpm run test:structured-recovery && pnpm run test:prompt-redaction && pnpm run test:mcp-result-cache && pnpm run test:test-stubs && pnpm run test:model-not-found-retryable",
     "// CI tier — live providers, runs only when API keys are present (test:credentials and test:dynamic make real provider calls when keys are set, so they live here, not in test:unit)": "",
     "test:live": "pnpm run test:providers && pnpm run test:mcp:http && pnpm run test:mcp:sdk && pnpm run test:mcp:cli && pnpm run test:observability && pnpm run test:context && pnpm run test:memory && pnpm run test:tool-reliability && pnpm run test:evaluation && pnpm run test:autoresearch && pnpm run test:credentials && pnpm run test:dynamic",
     "// CI tier — product output (image/video/TTS/PPT) — costs $$ per run": "",
@@ -216,7 +216,11 @@
     "check:all": "pnpm run lint && pnpm run format --check && pnpm run validate && pnpm run validate:commit",
     "test:litellm-context": "npx tsx test/continuous-test-suite-litellm-context-windows.ts",
     "test:dedup-execute-map": "npx tsx test/continuous-test-suite-dedup-execute-map.ts",
-    "test:step-budget-guard:vitest": "pnpm exec vitest run test/stepBudgetGuard.test.ts",
+    "test:agent-delegation": "npx tsx test/continuous-test-suite-agent-delegation.ts",
+    "test:step-budget-guard": "npx tsx test/continuous-test-suite-step-budget-guard.ts",
+    "test:agent-plumbing": "npx tsx test/continuous-test-suite-agent-plumbing.ts",
+    "test:tool-execution-recorder": "npx tsx test/continuous-test-suite-tool-execution-recorder.ts",
+    "test:proxy-terminal-errors": "npx tsx test/continuous-test-suite-proxy-terminal-errors.ts",
     "test:audio": "npx tsx test/continuous-test-suite-audio.ts",
     "test:office": "npx tsx test/continuous-test-suite-office.ts",
     "test:tts:unit": "npx tsx test/continuous-test-suite-tts-unit.ts",