@juspay/neurolink 10.4.2 → 10.4.3

package/dist/proxy/socketWorkerRuntime.js

@@ -8,6 +8,7 @@ function isTransferableProxySocket(handle) {
         typeof candidate.resume === "function" &&
         typeof candidate.destroy === "function" &&
         typeof candidate.end === "function" &&
+        typeof candidate.off === "function" &&
         typeof candidate.once === "function");
 }
 function destroyTransferredHandle(handle) {
@@ -153,6 +154,16 @@ export function attachSocketWorkerProcess(server, input) {
         // synchronously here would truncate that in-flight request.
         setImmediate(() => runtime.drain());
     };
+    const takePendingSocket = (socketId) => {
+        const pending = pendingSockets.get(socketId);
+        if (!pending) {
+            return undefined;
+        }
+        pendingSockets.delete(socketId);
+        pending.socket.off("error", pending.onError);
+        pending.socket.off("close", pending.onClose);
+        return pending.socket;
+    };
     const onMessage = (message, handle) => {
         if (message &&
             typeof message === "object" &&
@@ -176,7 +187,27 @@ export function attachSocketWorkerProcess(server, input) {
                     socket.destroy();
                     return;
                 }
-                pendingSockets.set(socketId, socket);
+                // A client can reset while the transferred handle is paused between
+                // acceptance and commit. The HTTP server has not seen the socket yet,
+                // so it cannot install its normal transport-error handler for us.
+                const onError = () => {
+                    if (pendingSockets.get(socketId)?.socket !== socket) {
+                        return;
+                    }
+                    takePendingSocket(socketId);
+                    socket.destroy();
+                    drainWhenPendingSettled();
+                };
+                const onClose = () => {
+                    if (pendingSockets.get(socketId)?.socket !== socket) {
+                        return;
+                    }
+                    takePendingSocket(socketId);
+                    drainWhenPendingSettled();
+                };
+                pendingSockets.set(socketId, { socket, onError, onClose });
+                socket.once("error", onError);
+                socket.once("close", onClose);
                 try {
                     process.send({
                         type: "proxy-worker:socket-accepted",
@@ -185,14 +216,14 @@ export function attachSocketWorkerProcess(server, input) {
                         socketId,
                     }, (error) => {
                         if (error) {
-                            pendingSockets.delete(socketId);
-                            socket.destroy();
+                            takePendingSocket(socketId)?.destroy();
+                            drainWhenPendingSettled();
                         }
                     });
                 }
                 catch {
-                    pendingSockets.delete(socketId);
-                    socket.destroy();
+                    takePendingSocket(socketId)?.destroy();
+                    drainWhenPendingSettled();
                 }
             }
             else {
@@ -229,11 +260,10 @@ export function attachSocketWorkerProcess(server, input) {
             }
             else if (message.type === "proxy-worker:socket-commit" ||
                 message.type === "proxy-worker:socket-cancel") {
-                const socket = pendingSockets.get(message.socketId);
+                const socket = takePendingSocket(message.socketId);
                 if (!socket) {
                     return;
                 }
-                pendingSockets.delete(message.socketId);
                 if (message.type === "proxy-worker:socket-commit") {
                     runtime.acceptSocket(socket);
                 }
@@ -259,10 +289,9 @@ export function attachSocketWorkerProcess(server, input) {
     // is exiting. The zero-downtime guarantee applies to the rolling handoff
     // (control-message) path, not to process termination.
     const drain = () => {
-        for (const socket of pendingSockets.values()) {
-            socket.destroy();
+        for (const socketId of [...pendingSockets.keys()]) {
+            takePendingSocket(socketId)?.destroy();
         }
-        pendingSockets.clear();
         runtime.drain();
     };
     const onTerminationSignal = () => drain();
@@ -283,10 +312,9 @@ export function attachSocketWorkerProcess(server, input) {
             process.off("disconnect", drain);
             process.off("SIGTERM", onTerminationSignal);
             process.off("SIGINT", onTerminationSignal);
-            for (const socket of pendingSockets.values()) {
-                socket.destroy();
+            for (const socketId of [...pendingSockets.keys()]) {
+                takePendingSocket(socketId)?.destroy();
             }
-            pendingSockets.clear();
             runtime.close();
         },
     };

package/dist/server/routes/claudeProxyRoutes.js

@@ -2241,6 +2241,7 @@ async function handleAnthropicSuccessfulResponse(args) {
         attemptNumber,
         finalBodyStr,
         upstreamSpan,
+        logAttempt,
         logProxyBody,
         logFinalRequest,
     });
@@ -2248,6 +2249,8 @@ async function handleAnthropicSuccessfulResponse(args) {
 async function handleAnthropicStreamingSuccessResponse(args) {
     const { account, accountState, response, responseHeaders, tracer, requestStartTime, fetchStartMs, attemptNumber, finalBodyStr, upstreamSpan, logAttempt, logProxyBody, logFinalRequest, } = args;
     if (!response.body) {
+        recordAttemptError(account.label, account.type, 502);
+        logAttempt(502, "stream_error", "No response body from upstream");
         upstreamSpan?.end();
         tracer?.setError("stream_error", "No response body from upstream");
         tracer?.end(502, Date.now() - requestStartTime);
@@ -2386,6 +2389,9 @@ async function handleAnthropicStreamingSuccessResponse(args) {
             failure: { message: preflight.message, rateLimit: isRateLimit },
         };
     }
+    logAttempt(response.status, undefined, undefined, {
+        attemptDurationMs: Date.now() - fetchStartMs,
+    });
     const streamOutcomeTracker = createStreamTerminalOutcomeTracker();
     let mainStreamClosed = false;
     const remainingStream = new ReadableStream({
@@ -2693,8 +2699,11 @@ function attachAnthropicSuccessStreamTelemetry(args) {
     });
 }
 async function handleAnthropicJsonSuccessResponse(args) {
-    const { account, response, responseHeaders, tracer, requestStartTime, fetchStartMs, attemptNumber, finalBodyStr, upstreamSpan, logProxyBody, logFinalRequest, } = args;
+    const { account, response, responseHeaders, tracer, requestStartTime, fetchStartMs, attemptNumber, finalBodyStr, upstreamSpan, logAttempt, logProxyBody, logFinalRequest, } = args;
     const responseText = await response.text();
+    logAttempt(response.status, undefined, undefined, {
+        attemptDurationMs: Date.now() - fetchStartMs,
+    });
     tracer?.logUpstreamResponseBody(responseText);
     logProxyBody({
         phase: "upstream_response",
@@ -2779,8 +2788,8 @@ async function handleAnthropicJsonSuccessResponse(args) {
     }
     return { response: responseJson };
 }
-async function handleAnthropicSuccessfulRetryResponse(args) {
-    const { body, account, accountState, retryResp, tracer, requestStartTime, fetchStartMs, attemptNumber, finalBodyStr, upstreamSpan, logProxyBody, logFinalRequest, } = args;
+async function handleAnthropicSuccessfulNonStreamRetryResponse(args) {
+    const { account, accountState, retryResp, tracer, requestStartTime, fetchStartMs, attemptNumber, finalBodyStr, upstreamSpan, logAttempt, logProxyBody, logFinalRequest, } = args;
     const retryQuota = parseQuotaHeaders(retryResp.headers);
     if (retryQuota) {
         // Keep the auth-retry success path in parity with the main success path:
@@ -2802,63 +2811,11 @@ async function handleAnthropicSuccessfulRetryResponse(args) {
             });
         });
     }
-    if (body.stream && retryResp.body) {
-        const retryReader = retryResp.body.getReader();
-        const streamOutcomeTracker = createStreamTerminalOutcomeTracker();
-        let retryStreamClosed = false;
-        const retryStream = new ReadableStream({
-            async pull(controller) {
-                if (retryStreamClosed) {
-                    return;
-                }
-                try {
-                    const { done, value } = await retryReader.read();
-                    if (retryStreamClosed) {
-                        return;
-                    }
-                    if (done) {
-                        retryStreamClosed = true;
-                        streamOutcomeTracker.complete();
-                        controller.close();
-                        return;
-                    }
-                    controller.enqueue(value);
-                }
-                catch (streamErr) {
-                    const errMsg = describeTransportError(streamErr);
-                    logger.always(`[proxy] mid-stream error (auth-retry) account=${account.label}: ${errMsg}`);
-                    streamOutcomeTracker.fail(errMsg);
-                    if (!retryStreamClosed) {
-                        retryStreamClosed = true;
-                        const errorEvent = `event: error\ndata: ${JSON.stringify({ type: "error", error: { type: "api_error", message: `Upstream stream interrupted: ${errMsg}` } })}\n\n`;
-                        controller.enqueue(new TextEncoder().encode(errorEvent));
-                        controller.close();
-                    }
-                }
-            },
-            cancel() {
-                retryStreamClosed = true;
-                streamOutcomeTracker.cancel();
-                return retryReader.cancel();
-            },
-        });
-        return attachAnthropicSuccessStreamTelemetry({
-            account,
-            response: retryResp,
-            responseHeaders: Object.fromEntries([...retryResp.headers.entries()]),
-            remainingStream: retryStream,
-            streamOutcome: streamOutcomeTracker.outcome,
-            tracer,
-            requestStartTime,
-            attemptNumber,
-            finalBodyStr,
-            upstreamSpan,
-            logProxyBody,
-            logFinalRequest,
-        });
-    }
     const retryRespHeaders = Object.fromEntries([...retryResp.headers.entries()]);
     const retryText = await retryResp.text();
+    logAttempt(retryResp.status, undefined, undefined, {
+        attemptDurationMs: Date.now() - fetchStartMs,
+    });
     tracer?.logUpstreamResponseHeaders(retryRespHeaders);
     tracer?.logUpstreamResponseBody(retryText);
     logProxyBody({
@@ -2960,7 +2917,7 @@ async function handleAnthropicAuthRetry(args) {
         const retryLogAttempt = (status, errorType, errorMessage, extra) => logAttempt(status, errorType, errorMessage, {
             ...extra,
             attempt: retryAttemptNumber,
-            attemptDurationMs: Date.now() - retryAttemptStartedAt,
+            attemptDurationMs: extra?.attemptDurationMs ?? Date.now() - retryAttemptStartedAt,
         });
         const retryBodyStr = buildUpstreamBody(account.token).bodyStr;
         const retryFetchStartMs = Date.now();
@@ -2986,23 +2943,54 @@ async function handleAnthropicAuthRetry(args) {
                 authRetrySucceeded = true;
                 accountState.consecutiveRefreshFailures = 0;
                 logger.always(`[proxy] ← 200 account=${account.label} (after ${authRetry + 1} refresh(es))`);
-                const successResponse = await handleAnthropicSuccessfulRetryResponse({
-                    ctx,
-                    body,
-                    account,
-                    accountState,
-                    retryResp,
-                    tracer,
-                    requestStartTime,
-                    fetchStartMs: retryFetchStartMs,
-                    attemptNumber: retryAttemptNumber,
-                    finalBodyStr: retryBodyStr,
-                    upstreamSpan: currentUpstreamSpan,
-                    logProxyBody,
-                    logFinalRequest,
-                });
+                const successResult = body.stream
+                    ? await handleAnthropicSuccessfulResponse({
+                        ctx,
+                        body,
+                        account,
+                        accountState,
+                        response: retryResp,
+                        tracer,
+                        requestStartTime,
+                        fetchStartMs: retryFetchStartMs,
+                        attemptNumber: retryAttemptNumber,
+                        finalBodyStr: retryBodyStr,
+                        upstreamSpan: currentUpstreamSpan,
+                        logAttempt: retryLogAttempt,
+                        logProxyBody,
+                        logFinalRequest,
+                    })
+                    : {
+                        response: await handleAnthropicSuccessfulNonStreamRetryResponse({
+                            account,
+                            accountState,
+                            retryResp,
+                            tracer,
+                            requestStartTime,
+                            fetchStartMs: retryFetchStartMs,
+                            attemptNumber: retryAttemptNumber,
+                            finalBodyStr: retryBodyStr,
+                            upstreamSpan: currentUpstreamSpan,
+                            logAttempt: retryLogAttempt,
+                            logProxyBody,
+                            logFinalRequest,
+                        }),
+                    };
+                if ("retryNextAccount" in successResult) {
+                    const failure = successResult.failure;
+                    return {
+                        continueLoop: true,
+                        lastError: failure?.message ?? currentLastError,
+                        authFailureMessage: currentAuthFailureMessage,
+                        sawRateLimit: currentSawRateLimit || Boolean(failure?.rateLimit),
+                        sawTransientFailure: currentSawTransientFailure ||
+                            Boolean(failure && !failure.rateLimit),
+                        sawNetworkError: currentSawNetworkError,
+                        upstreamSpan: undefined,
+                    };
+                }
                 return {
-                    response: successResponse,
+                    response: successResult.response,
                     continueLoop: false,
                     lastError: currentLastError,
                     authFailureMessage: currentAuthFailureMessage,

package/dist/types/proxy.d.ts

@@ -1121,6 +1121,7 @@ export type ProxyAnalysisAccount = {
     unclassifiedRateLimits: number;
 };
 /** Offline report generated from proxy request, attempt, and lifecycle logs. */
+export type ProxyAnalysisStreamName = "lifecycle" | "requests" | "attempts" | "debug";
 export type ProxyAnalysisReport = {
     generatedAt: string;
     since: string;
@@ -1129,6 +1130,7 @@ export type ProxyAnalysisReport = {
         lifecycle: number;
         requests: number;
         attempts: number;
+        debug: number;
     };
     coverage: {
         lifecycle: boolean;
@@ -1143,6 +1145,20 @@ export type ProxyAnalysisReport = {
         unsupportedLifecycleLines: number;
         lifecycleSequenceGaps: number;
         lifecycleSequenceDuplicates: number;
+        streams: Record<ProxyAnalysisStreamName, {
+            observedFrom: string | null;
+            observedTo: string | null;
+            startsAtOrBeforeRequestedWindow: boolean;
+        }>;
+        bodyArtifacts: {
+            capturesIndexed: number;
+            artifactsReferenced: number;
+            artifactsPresent: number;
+            artifactsMissing: number;
+            invalidPaths: number;
+            writeFailures: number;
+            truncatedCaptures: number;
+        };
     };
     lifecycle: {
         accepted: number;
@@ -1392,6 +1408,7 @@ export type StoredBodyArtifact = {
     storedFileBytes?: number;
     redactedBody?: string;
     bodyTruncated?: boolean;
+    bodyWriteFailed?: boolean;
 };
 /** File the proxy logger tracks for rotation and cleanup. */
 export type ManagedLogFile = {
@@ -1653,6 +1670,11 @@ export type ProxyWorkerStatusMessage = {
     generation: number;
     pid: number;
     socketId: string;
+} | {
+    type: "proxy-worker:replacement-requested";
+    generation: number;
+    pid: number;
+    reason: "environment";
 };
 export type ProxyWorkerSocketMessage = {
     type: "proxy-worker:socket";
@@ -1661,6 +1683,8 @@ export type ProxyWorkerSocketMessage = {
 };
 export type ProxyWorkerIpcMessage = ProxyWorkerControlMessage | ProxyWorkerStatusMessage | ProxyWorkerSocketMessage;
 export type TransferableProxySocket = Pick<import("node:net").Socket, "destroy" | "end" | "pause" | "resume" | "once">;
+/** A transferred socket whose temporary handoff listeners can be detached. */
+export type DetachableTransferableProxySocket = TransferableProxySocket & Pick<import("node:net").Socket, "off">;
 export type RollingWorkerHandle = {
     pid: number;
     sendControl: (message: ProxyWorkerControlMessage) => void;
@@ -1714,6 +1738,11 @@ export type RollingWorkerSupervisorOptions = {
     socketQueueTimeoutMs?: number;
     shutdownTimeoutMs?: number;
     onStateChange?: (snapshot: RollingWorkerSupervisorSnapshot) => void;
+    onReplacementRequested?: (request: {
+        generation: number;
+        pid: number;
+        reason: "environment";
+    }) => void;
     log?: (message: string) => void;
 };
 export type RollingProxyServerOptions = {
@@ -1854,6 +1883,7 @@ export type ProxyRuntimeConfigReloadResult = {
     applied: boolean;
     changed: boolean;
     generation: number;
+    environmentChanged?: boolean;
     error?: string;
 };
 /** Safe runtime configuration diagnostics exposed through proxy status. */
@@ -1933,7 +1963,7 @@ export type StatusStats = {
         transientRateLimits?: number;
         quotaRateLimits?: number;
         cooling: boolean;
-        status?: "active" | "cooling" | "disabled" | "excluded" | "removed";
+        status?: "active" | "cooling" | "disabled" | "excluded" | "removed" | "unattributed";
     }[];
     persistence?: ProxyStatsPersistenceStatus;
 };

package/package.json

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