@juspay/neurolink 12.12.9 → 12.12.10

package/dist/proxy/rollingWorkerSupervisor.js

@@ -1,6 +1,6 @@
 import { ErrorFactory } from "../utils/errorHandling.js";
-import { PROXY_SOCKET_OFFER_TIMEOUT } from "./rollingWorkerProtocol.js";
-const DEFAULT_READY_TIMEOUT_MS = 30_000;
+import { PROXY_SOCKET_OFFER_TIMEOUT, PROXY_SOCKET_COMMIT_TIMEOUT, } from "./rollingWorkerProtocol.js";
+const DEFAULT_READY_TIMEOUT_MS = 120_000;
 const DEFAULT_SOCKET_QUEUE_LIMIT = 1_024;
 const DEFAULT_SOCKET_QUEUE_TIMEOUT_MS = 30_000;
 const DEFAULT_SHUTDOWN_TIMEOUT_MS = 30_000;
@@ -95,10 +95,14 @@ export class RollingWorkerSupervisor {
         });
         return this.replacement;
     }
+    /**
+     * Admit a paused socket to the active generation or the bounded
+     * readiness queue.
+     */
     acceptSocket(socket) {
         socket.pause();
         if (this.closed) {
-            this.rejectSocket(socket);
+            this.rejectSocket(socket, undefined, undefined, "supervisor_closed");
             return;
         }
         if (this.active &&
@@ -110,9 +114,13 @@ export class RollingWorkerSupervisor {
         this.queueSocket(socket);
         this.flushQueuedSockets();
     }
+    /**
+     * Retain a socket only within the queue capacity and deadline, recording
+     * classified rejection.
+     */
     queueSocket(socket) {
         if (this.queuedSockets.length >= this.options.socketQueueLimit) {
-            this.rejectSocket(socket);
+            this.rejectSocket(socket, undefined, undefined, "queue_capacity");
             return;
         }
         const queued = {
@@ -121,7 +129,7 @@ export class RollingWorkerSupervisor {
                 const index = this.queuedSockets.indexOf(queued);
                 if (index >= 0) {
                     this.queuedSockets.splice(index, 1);
-                    this.rejectSocket(socket);
+                    this.rejectSocket(socket, undefined, undefined, "queue_timeout");
                 }
             }, this.options.socketQueueTimeoutMs),
         };
@@ -201,8 +209,13 @@ export class RollingWorkerSupervisor {
             finish();
         }
     }
+    /**
+     * Validate candidate readiness and activation while preserving an
+     * independent listener for actual exit.
+     */
     spawnCandidate(expectedVersion) {
         const generation = ++this.generation;
+        let workerProcessInstanceId;
         let handle;
         try {
             handle = this.options.spawnWorker(generation, expectedVersion);
@@ -212,6 +225,19 @@ export class RollingWorkerSupervisor {
             this.publishState();
             return Promise.reject(error instanceof Error ? error : new Error(String(error)));
         }
+        // Keep this evidence listener until actual exit, even when candidate
+        // failure or a fatal message detaches the operational state listeners.
+        handle.onExit((code, signal) => {
+            this.recordEvent({
+                type: "worker_exit",
+                generation,
+                version: expectedVersion,
+                workerPid: handle.pid,
+                workerProcessInstanceId,
+                workerExitCode: code,
+                workerExitSignal: signal,
+            });
+        });
         return new Promise((resolve, reject) => {
             let settled = false;
             const finish = (error, phase = "startup", details) => {
@@ -266,6 +292,7 @@ export class RollingWorkerSupervisor {
                     return;
                 }
                 if (message.type === "proxy-worker:ready") {
+                    workerProcessInstanceId = message.processInstanceId;
                     if (message.version !== expectedVersion) {
                         finish(new Error(`worker ${handle.pid} reported v${message.version}; expected v${expectedVersion}`));
                         return;
@@ -441,6 +468,10 @@ export class RollingWorkerSupervisor {
             worker.handle.terminate("SIGTERM");
         }
     }
+    /**
+     * Cancel the affected handoff and request bounded replacement without
+     * killing unrelated streams.
+     */
     handleTransferFailure(worker, socket, error) {
         this.failedTransfers += 1;
         const detail = this.describeTransferError(error);
@@ -454,12 +485,15 @@ export class RollingWorkerSupervisor {
         const lifecycle = this.extractLifecycleFailureDetails(error, worker.handle.pid);
         const cancelledOffer = error instanceof Error &&
             error.code === PROXY_SOCKET_OFFER_TIMEOUT;
-        if (cancelledOffer && this.active?.generation === worker.generation) {
+        const commitTimeout = error instanceof Error &&
+            error.code === PROXY_SOCKET_COMMIT_TIMEOUT;
+        if (!lifecycle.observedExit &&
+            this.active?.generation === worker.generation) {
             this.consecutiveOfferTimeouts += 1;
             // Persistent stalls need recovery, but keep serving existing streams
             // until a replacement activates. Avoid accumulating draining workers or
             // spawning repeatedly when the whole host is under pressure.
-            if (this.consecutiveOfferTimeouts >= 3 &&
+            if ((this.consecutiveOfferTimeouts >= 3 || !cancelledOffer) &&
                 !this.candidate &&
                 this.draining.size === 0 &&
                 Date.now() - this.lastStallReplacementAt >= 60_000 &&
@@ -468,11 +502,15 @@ export class RollingWorkerSupervisor {
                 this.options.onReplacementRequested?.({
                     generation: worker.generation,
                     pid: worker.handle.pid,
-                    reason: "socket_offer_timeout",
+                    reason: commitTimeout
+                        ? "socket_commit_timeout"
+                        : cancelledOffer
+                            ? "socket_offer_timeout"
+                            : "socket_transfer_failure",
                 });
             }
         }
-        this.recordFailure(worker.generation, worker.version, "transfer", `worker ${worker.handle.pid} failed to accept a transferred socket: ${detail}`, {
+        this.recordFailure(worker.generation, worker.version, "transfer", `worker ${worker.handle.pid} socket transfer failed: ${detail}`, {
             ...lifecycle.details,
             // If the error already records an exit, the supervisor did not cause
             // that exit. Otherwise this captures the deliberate cleanup following
@@ -481,24 +519,18 @@ export class RollingWorkerSupervisor {
                 ? "cancel_uncommitted_socket"
                 : lifecycle.observedExit
                     ? "none"
-                    : "sigkill_after_transfer_failure",
+                    : "cancel_socket_replace_before_drain",
         });
         this.options.log?.(`[proxy-supervisor] socket transfer failed generation=${worker.generation} pid=${worker.handle.pid}: ${detail}`);
-        if (!cancelledOffer &&
-            this.active?.generation === worker.generation &&
-            !this.closed) {
-            this.active = null;
-            this.draining.set(worker.generation, worker);
-            if (!lifecycle.observedExit) {
-                // The child may own a duplicate of an incompletely transferred socket.
-                // SIGKILL closes its descriptor without worker-side shutdown(2), after
-                // which the parent rejects its copy rather than attempting unsafe replay.
-                worker.handle.terminate("SIGKILL");
-            }
-            this.publishState();
-        }
+        // A failed handoff is not evidence that every connection on this worker
+        // failed. Cancel only the affected socket and activate a replacement before
+        // draining existing streams. Actual exits are handled by onExit below.
         this.rejectSocket(socket, worker.generation, worker.version, "transfer_failure");
     }
+    /**
+     * Record a classified admission rejection before releasing the
+     * parent-owned socket.
+     */
     rejectSocket(socket, generation = this.active?.generation ?? null, version = this.active?.version ?? null, reason = "unavailable") {
         this.rejectedSockets += 1;
         this.recordEvent({
@@ -541,6 +573,10 @@ export class RollingWorkerSupervisor {
             observedExit: hasExitCode || hasExitSignal,
         };
     }
+    /**
+     * Retain the latest failure and its observed process evidence in the
+     * incident journal.
+     */
     recordFailure(generation, version, phase, message, details = {}) {
         this.lastFailure = {
             at: new Date().toISOString(),
@@ -556,14 +592,26 @@ export class RollingWorkerSupervisor {
             version,
             phase,
             reason: message,
+            ...details,
         });
     }
+    /**
+     * Publish an independent incident record and retain only a bounded
+     * recent summary.
+     */
     recordEvent(event) {
-        this.recentEvents.push({
+        const recorded = {
             at: new Date().toISOString(),
             ...event,
             ...(event.reason ? { reason: event.reason.slice(0, 1_000) } : {}),
-        });
+        };
+        this.recentEvents.push(recorded);
+        try {
+            this.options.onEvent?.(recorded);
+        }
+        catch (error) {
+            this.options.log?.(`[proxy-supervisor] event journal failed: ${String(error)}`);
+        }
         if (this.recentEvents.length > MAX_RECENT_SUPERVISOR_EVENTS) {
             this.recentEvents.splice(0, this.recentEvents.length - MAX_RECENT_SUPERVISOR_EVENTS);
         }

package/dist/proxy/socketWorkerRuntime.d.ts

@@ -6,9 +6,14 @@ import type { SocketWorkerRuntime, SocketWorkerRuntimeOptions } from "../types/i
  * soon as draining begins.
  */
 export declare function createSocketWorkerRuntime(server: Server, options?: SocketWorkerRuntimeOptions): SocketWorkerRuntime;
+/**
+ * Attach the IPC ownership protocol and keep committed sockets addressable
+ * by late cancellation.
+ */
 export declare function attachSocketWorkerProcess(server: Server, input: {
     generation: number;
     version: string;
+    processInstanceId?: string;
     onActivated?: () => void;
     onDrained?: () => void;
 }): SocketWorkerRuntime;

package/dist/proxy/socketWorkerRuntime.js

@@ -120,9 +120,17 @@ export function createSocketWorkerRuntime(server, options) {
         }),
     };
 }
+/**
+ * Attach the IPC ownership protocol and keep committed sockets addressable
+ * by late cancellation.
+ */
 export function attachSocketWorkerProcess(server, input) {
     let activated = false;
     let gracefulDrain = false;
+    // A commit can reach the worker before its parent's send callback settles.
+    // Retain ownership until close so a late cancellation affects only that
+    // connection, never the worker's other requests. Never replay this socket.
+    const committedSockets = new Map();
     const pendingSockets = new Map();
     const send = (message) => {
         if (!process.connected || !process.send) {
@@ -164,6 +172,7 @@ export function attachSocketWorkerProcess(server, input) {
         pending.socket.off("close", pending.onClose);
         return pending.socket;
     };
+    /** Apply supervisor messages while retaining ownership of pending and committed sockets. */
     const onMessage = (message, handle) => {
         if (message &&
             typeof message === "object" &&
@@ -183,7 +192,7 @@ export function attachSocketWorkerProcess(server, input) {
                     socket.destroy();
                     return;
                 }
-                if (pendingSockets.has(socketId)) {
+                if (pendingSockets.has(socketId) || committedSockets.has(socketId)) {
                     socket.destroy();
                     return;
                 }
@@ -260,14 +269,20 @@ export function attachSocketWorkerProcess(server, input) {
             }
             else if (message.type === "proxy-worker:socket-commit" ||
                 message.type === "proxy-worker:socket-cancel") {
-                const socket = takePendingSocket(message.socketId);
+                const socket = takePendingSocket(message.socketId) ??
+                    (message.type === "proxy-worker:socket-cancel"
+                        ? committedSockets.get(message.socketId)
+                        : undefined);
                 if (!socket) {
                     return;
                 }
                 if (message.type === "proxy-worker:socket-commit") {
+                    committedSockets.set(message.socketId, socket);
+                    socket.once("close", () => committedSockets.delete(message.socketId));
                     runtime.acceptSocket(socket);
                 }
                 else {
+                    committedSockets.delete(message.socketId);
                     socket.destroy();
                 }
                 drainWhenPendingSettled();
@@ -304,6 +319,7 @@ export function attachSocketWorkerProcess(server, input) {
         generation: input.generation,
         pid: process.pid,
         version: input.version,
+        processInstanceId: input.processInstanceId,
     });
     return {
         ...runtime,
@@ -316,6 +332,7 @@ export function attachSocketWorkerProcess(server, input) {
                 takePendingSocket(socketId)?.destroy();
             }
             runtime.close();
+            committedSockets.clear();
         },
     };
 }

package/dist/server/routes/codexProxyRoutes.js

@@ -409,6 +409,7 @@ export async function handleCodexResponsesRequest(ctx) {
     let attempt = 0;
     let lastErrorMessage = "All Codex accounts failed";
     let lastErrorStatus = 502;
+    let lastFailure = { errorType: "all_accounts_failed" };
     let lastAttemptedAccount;
     for (const account of eligible) {
         let authRetried = false;
@@ -458,8 +459,33 @@ export async function handleCodexResponsesRequest(ctx) {
                     errorMessage,
                     ...(errorCode ? { errorCode } : {}),
                     transportScope,
-                    retryable: true,
+                    // These codes prove failure before HTTP dispatch. Socket resets,
+                    // EPIPE and generic timeouts may follow dispatch and must not replay.
+                    retryable: [
+                        "UND_ERR_CONNECT_TIMEOUT",
+                        "ECONNREFUSED",
+                        "ENOTFOUND",
+                        "EAI_AGAIN",
+                    ].includes(errorCode ?? ""),
                 });
+                lastFailure = {
+                    errorType: "network_error",
+                    errorMessage,
+                    errorCode,
+                    transportScope,
+                };
+                if (![
+                    "UND_ERR_CONNECT_TIMEOUT",
+                    "ECONNREFUSED",
+                    "ENOTFOUND",
+                    "EAI_AGAIN",
+                ].includes(errorCode ?? "")) {
+                    await recordFinalOutcome(account, 502, {
+                        ...lastFailure,
+                        errorMessage,
+                    });
+                    return buildCodexErrorResponse(502, "Codex upstream request failed");
+                }
                 lastErrorMessage = "Codex upstream request failed";
                 lastErrorStatus = 502;
                 break; // rotate to next account
@@ -621,6 +647,10 @@ export async function handleCodexResponsesRequest(ctx) {
                         if (disabled) {
                             logger.always(`[proxy] codex account=${account.label} disabled until re-authentication. Run: neurolink auth login codex --label ${account.label}`);
                         }
+                        lastFailure = {
+                            errorType: "authentication_error",
+                            errorCode: "refresh_invalid",
+                        };
                         lastErrorStatus = 401;
                         lastErrorMessage = "Codex token refresh failed; re-login required";
                         break;
@@ -629,6 +659,10 @@ export async function handleCodexResponsesRequest(ctx) {
                     // account, so a 5xx or a timeout cannot cost the user a login.
                     await saveAccountCooldown(account.key, Date.now() + CODEX_AUTH_COOLDOWN_MS, "auth").catch(() => undefined);
                     logger.debug(`[proxy] codex account=${account.label} refresh failed transiently; cooling and rotating`);
+                    lastFailure = {
+                        errorType: "auth_refresh_unavailable",
+                        errorCode: getCodexTransportErrorCode(error),
+                    };
                     lastErrorStatus = 503;
                     lastErrorMessage = "Codex token refresh temporarily unavailable";
                     break;
@@ -653,6 +687,7 @@ export async function handleCodexResponsesRequest(ctx) {
                     rateLimitKind,
                     cooldownReason: plan.reason,
                 });
+                lastFailure = { errorType: "rate_limit_error" };
                 lastErrorStatus = 429;
                 lastErrorMessage = "Codex account rate-limited";
                 break; // rotate
@@ -674,14 +709,15 @@ export async function handleCodexResponsesRequest(ctx) {
                 errorMessage,
                 retryable: upstream.status >= 500,
             });
+            lastFailure = { errorType };
             lastErrorStatus = upstream.status >= 500 ? 502 : upstream.status;
             lastErrorMessage = errorMessage;
             break; // rotate
         }
     }
     await recordFinalOutcome(lastAttemptedAccount, lastErrorStatus, {
-        errorType: "all_accounts_failed",
-        errorMessage: lastErrorMessage,
+        ...lastFailure,
+        errorMessage: lastFailure.errorMessage ?? lastErrorMessage,
     });
     return buildCodexErrorResponse(lastErrorStatus, lastErrorMessage);
 }

package/dist/services/server/ai/observability/instrumentation.js

@@ -30,6 +30,10 @@ function createOtelResource(config, serviceName) {
         "deployment.environment": config.environment || "dev",
     });
 }
+/**
+ * Configure OTLP metrics and logs with bounded serialization batches for
+ * request-serving processes.
+ */
 function initializeOtlpMetricsAndLogs(resource, otlpEndpoint, serviceName) {
     if (!otlpEndpoint) {
         return;
@@ -69,7 +73,9 @@ function initializeOtlpMetricsAndLogs(resource, otlpEndpoint, serviceName) {
         });
         const logProcessor = new BatchLogRecordProcessor(logExporter, {
             maxQueueSize: 2048,
-            maxExportBatchSize: 512,
+            // Body logs contain up to 16 KB each. Bound exporter JSON work to
+            // roughly 1 MB per batch instead of an 8 MB main-thread serialization.
+            maxExportBatchSize: 64,
             scheduledDelayMillis: 2000,
             exportTimeoutMillis: 30000,
         });

package/dist/types/cli.d.ts

@@ -872,7 +872,7 @@ export type ProxyRollingState = {
         workerPid?: number;
         workerExitCode?: number | null;
         workerExitSignal?: string | null;
-        supervisorAction?: "none" | "sigkill_after_transfer_failure" | "cancel_uncommitted_socket";
+        supervisorAction?: "none" | "sigkill_after_transfer_failure" | "cancel_socket_replace_before_drain" | "cancel_uncommitted_socket";
     } | null;
 };
 export type ProxySupervisorState = {

package/dist/types/proxy.d.ts

@@ -625,7 +625,26 @@ export type ProxyRequestLogSinkSnapshot = {
     unconfirmedWrites: number;
     lastErrorCode?: string;
 };
+export type ProcessedProxyBodyCapture = {
+    headers?: Record<string, string>;
+    stored: StoredBodyArtifact;
+    error?: string;
+    queueWaitMs?: number;
+    processingMs?: number;
+};
+export type ProxyBodyCaptureWorkerSnapshot = {
+    attempted: number;
+    completed: number;
+    rejected: number;
+    failed: number;
+    pending: number;
+    pendingBytes: number;
+    maxPending: number;
+    maxPendingBytes: number;
+    lastError?: string;
+};
 export type ProxyRequestLoggerSnapshot = {
+    bodyCapture?: ProxyBodyCaptureWorkerSnapshot;
     enabled: boolean;
     requests: ProxyRequestLogSinkSnapshot;
     attempts: ProxyRequestLogSinkSnapshot;
@@ -1618,7 +1637,7 @@ export type ProxyResponseTrackingObserver = {
     }) => unknown;
 };
 /** Versioned lifecycle event names persisted by the proxy adapter. */
-export type ProxyLifecycleEventName = "request_accepted" | "response_headers" | "response_first_chunk" | "request_terminal";
+export type ProxyLifecycleEventName = "runtime_sample" | "supervisor_event" | "request_accepted" | "response_headers" | "response_first_chunk" | "request_terminal";
 /** Client-facing terminal classifications recorded by lifecycle metadata. */
 export type ProxyLifecycleTerminalOutcome = ProxyResponseTerminalOutcome | "handler_error" | "unknown";
 /** Content-free lifecycle event accepted by the bounded metadata logger. */
@@ -1649,6 +1668,20 @@ export type ProxyLifecycleEventInput = {
     errorCode?: string;
     timestampMs?: number;
     monotonicMs?: number;
+    /** Parent-owned evidence, independent of the serving worker's journal tail. */
+    supervisorEvent?: RollingWorkerSupervisorEvent;
+    runtimeSample?: ProxyRuntimeSample;
+};
+/** Process CPU and event-loop evidence; host load is not a request count. */
+export type ProxyRuntimeSample = {
+    intervalMs: number;
+    cpuPercentOneCore: number;
+    rssBytes: number;
+    heapUsedBytes: number;
+    eventLoopDelayP99Ms: number;
+    eventLoopDelayMaxMs: number;
+    hostLoad1m: number;
+    availableParallelism: number;
 };
 /** Data-quality counters for the bounded lifecycle metadata sink. */
 export type ProxyLifecycleLoggerSnapshot = {
@@ -1676,6 +1709,7 @@ export type ProxyLifecycleLoggerSnapshot = {
 };
 /** Lifecycle logger configuration. Queue overrides are used by stress tests. */
 export type ProxyLifecycleLoggerOptions = {
+    filePrefix?: "proxy-lifecycle" | "proxy-supervisor";
     enabled: boolean;
     logDir?: string;
     queueCapacity?: number;
@@ -1686,10 +1720,13 @@ export type ProxyLifecycleLoggerOptions = {
 };
 /** Serialized lifecycle line awaiting a bounded batch write. */
 export type QueuedProxyLifecycleEvent = {
+    filePrefix?: string;
     logDir: string;
     date: string;
     record: Record<string, unknown>;
     writeRetries: number;
+    /** Resolve only after the original append settles; uncertain writes fail. */
+    onPersisted?: (confirmed: boolean) => void;
 };
 /** Percentile summary used by offline proxy log analysis. */
 export type ProxyLatencySummary = {
@@ -1714,6 +1751,13 @@ export type ProxyAnalysisAccount = {
 /** Offline report generated from proxy request, attempt, and lifecycle logs. */
 export type ProxyAnalysisStreamName = "lifecycle" | "requests" | "attempts" | "debug";
 export type ProxyAnalysisReport = {
+    runtime: {
+        samples: number;
+        maxEventLoopDelayMs: number | null;
+        maxRssBytes: number | null;
+        maxCpuPercentOneCore: number | null;
+        maxHostLoad1m: number | null;
+    };
     generatedAt: string;
     since: string;
     until: string;
@@ -1770,7 +1814,18 @@ export type ProxyAnalysisReport = {
         };
     };
     lifecycle: {
+        /** Accepted requests lacking transport terminals when their worker exited. */
+        unconfirmedAtWorkerExit: Array<{
+            requestId: string;
+            workerProcessInstanceId: string;
+            at: string;
+            workerExitCode: number | null;
+            workerExitSignal: string | null;
+            providerFinalRecorded: boolean;
+        }>;
         accepted: number;
+        /** Accepted metadata requests that do not require model final records. */
+        auxiliaryRequests: number;
         headers: number;
         firstChunks: number;
         terminal: number;
@@ -2375,6 +2430,7 @@ export type ProxyWorkerStatusMessage = {
     generation: number;
     pid: number;
     version: string;
+    processInstanceId?: string;
 } | {
     type: "proxy-worker:drained";
     generation: number;
@@ -2417,6 +2473,8 @@ export type RollingWorkerHandle = {
     onExit: (listener: (code: number | null, signal: string | null) => void) => () => void;
 };
 export type SpawnProxySocketWorkerOptions = {
+    /** Injectable process boundary for deterministic IPC fault tests. */
+    spawn?: typeof import("node:child_process").spawn;
     generation: number;
     expectedVersion: string;
     command: string;
@@ -2430,15 +2488,20 @@ export type RollingWorkerFailureDetails = {
     workerPid?: number;
     workerExitCode?: number | null;
     workerExitSignal?: string | null;
-    supervisorAction?: "none" | "sigkill_after_transfer_failure" | "cancel_uncommitted_socket";
+    supervisorAction?: "none" | "sigkill_after_transfer_failure" | "cancel_socket_replace_before_drain" | "cancel_uncommitted_socket";
 };
 export type RollingWorkerSupervisorEvent = {
     at: string;
-    type: "activated" | "failure" | "failed_transfer" | "rejected_socket";
+    type: "activated" | "failure" | "failed_transfer" | "rejected_socket" | "worker_exit";
     generation: number | null;
     version: string | null;
     phase?: "startup" | "activation" | "runtime" | "transfer";
     reason?: string;
+    workerPid?: number;
+    workerProcessInstanceId?: string;
+    workerExitCode?: number | null;
+    workerExitSignal?: string | null;
+    supervisorAction?: RollingWorkerFailureDetails["supervisorAction"];
 };
 export type RollingWorkerSupervisorSnapshot = {
     generation: number;
@@ -2481,10 +2544,11 @@ export type RollingWorkerSupervisorOptions = {
     socketQueueTimeoutMs?: number;
     shutdownTimeoutMs?: number;
     onStateChange?: (snapshot: RollingWorkerSupervisorSnapshot) => void;
+    onEvent?: (event: RollingWorkerSupervisorEvent) => void;
     onReplacementRequested?: (request: {
         generation: number;
         pid: number;
-        reason: "environment" | "socket_offer_timeout";
+        reason: "environment" | "socket_offer_timeout" | "socket_commit_timeout" | "socket_transfer_failure";
     }) => void;
     log?: (message: string) => void;
 };
@@ -2501,6 +2565,7 @@ export type RollingProxyServerOptions = {
     recoveryDelayMs?: number;
     maxRecoveryDelayMs?: number;
     onStateChange?: (snapshot: RollingWorkerSupervisorSnapshot) => void;
+    onEvent?: (event: RollingWorkerSupervisorEvent) => void;
     log?: (message: string) => void;
 };
 export type RollingProxyServer = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "12.12.9",
+  "version": "12.12.10",
   "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": {