@juspay/neurolink 12.9.0 → 12.9.1

package/dist/cli/commands/proxy.js

@@ -26,7 +26,7 @@ import { ProxyRuntimeConfigStore } from "../../proxy/runtimeConfig.js";
 import { startProxyLogCleanupScheduler } from "../../proxy/logCleanupScheduler.js";
 import { anthropicAccountKeysEqual, createAccountAllowlist, isAccountAllowed, LEGACY_ANTHROPIC_ACCOUNT_KEY, normalizeAnthropicAccountKey, shouldLoadFallbackCredential, } from "../../proxy/accountSelection.js";
 import { resolveProxyStatusAccountIdentity } from "../../proxy/codexAccountUsage.js";
-import { beginProxyRequest, getProxyActivitySnapshot, trackProxyResponse, } from "../../proxy/proxyActivity.js";
+import { beginProxyRequest, getProxyActivitySnapshot, takeProxyResponseObservers, trackProxyResponse, } from "../../proxy/proxyActivity.js";
 import { flushProxyLifecycleEvents, getProxyLifecycleLoggerSnapshot, hashProxyLifecycleSessionId, logProxyLifecycleEvent, } from "../../proxy/proxyLifecycle.js";
 import { describeInstallFailure, getGlobalInstallArgs, isTransientInstallFailure, resolveGlobalInstaller, validateInstalledVersion, } from "../../proxy/globalInstaller.js";
 import { startUpdaterWorkerSupervisor } from "../../proxy/updaterSupervisor.js";
@@ -1120,6 +1120,27 @@ function registerProxyRequestTracking(app, requestMetadata, readiness) {
                 responseStatus,
                 elapsedMs: performance.now() - startedMonotonicMs,
             });
+            const routeResponseObservers = takeProxyResponseObservers(metadata);
+            const notifyRouteFirstChunk = (details) => {
+                for (const observer of routeResponseObservers) {
+                    try {
+                        observer.onFirstChunk?.(details);
+                    }
+                    catch {
+                        // Route-level accounting must never interfere with the relay.
+                    }
+                }
+            };
+            const notifyRouteTerminal = (details) => {
+                for (const observer of routeResponseObservers) {
+                    try {
+                        observer.onTerminal?.(details);
+                    }
+                    catch {
+                        // Route-level accounting must never interfere with the relay.
+                    }
+                }
+            };
             c.res = trackProxyResponse(c.res, finish, {
                 onFirstChunk: ({ observedBodyBytes, responseChunks }) => {
                     logProxyLifecycleEvent({
@@ -1137,6 +1158,10 @@ function registerProxyRequestTracking(app, requestMetadata, readiness) {
                         responseChunks,
                         elapsedMs: performance.now() - startedMonotonicMs,
                     });
+                    notifyRouteFirstChunk({
+                        observedBodyBytes,
+                        responseChunks,
+                    });
                 },
                 onTerminal: ({ outcome, observedBodyBytes, responseChunks }) => {
                     logProxyLifecycleEvent({
@@ -1157,6 +1182,11 @@ function registerProxyRequestTracking(app, requestMetadata, readiness) {
                         errorType: metadata.terminalErrorType,
                         errorCode: metadata.terminalErrorCode,
                     });
+                    notifyRouteTerminal({
+                        outcome,
+                        observedBodyBytes,
+                        responseChunks,
+                    });
                 },
             });
         }
@@ -1484,7 +1514,10 @@ export async function createProxyStartApp(params) {
                 neurolink: params.neurolink,
                 toolRegistry: params.neurolink.getToolRegistry(),
                 timestamp: Date.now(),
-                metadata: {},
+                // Keep route terminal observers on the runtime request metadata so the
+                // outer response tracker can notify them without adding a second body
+                // wrapper to streaming routes.
+                metadata: (metadata ?? {}),
                 // Route handlers publish limit/quota headers here. Only the streaming
                 // paths build their own Response (and set headers directly); every
                 // JSON and error path returns a plain object, so without this the

package/dist/proxy/proxyActivity.d.ts

@@ -1,4 +1,6 @@
 import type { ProxyActivitySnapshot, ProxyResponseTrackingObserver } from "../types/index.js";
+export declare function registerProxyResponseObserver(metadata: object, observer: ProxyResponseTrackingObserver): void;
+export declare function takeProxyResponseObservers(metadata: object): ProxyResponseTrackingObserver[];
 /** Track one client-facing proxy request until its response body settles. */
 export declare function beginProxyRequest(): () => void;
 export declare function getProxyActivitySnapshot(): ProxyActivitySnapshot;

package/dist/proxy/proxyActivity.js

@@ -3,6 +3,24 @@ import { logger } from "../utils/logger.js";
 const PROXY_RESPONSE_CANCEL_TIMEOUT_MS = 1_000;
 let activeRequests = 0;
 let lastActivityAtMs = null;
+// Route handlers can attach terminal observers to their request context without
+// wrapping the response body a second time. The HTTP runtime drains every
+// response through one tracker, which fans these observers out at the point
+// where bytes actually leave the proxy.
+const responseObserversByMetadata = new WeakMap();
+export function registerProxyResponseObserver(metadata, observer) {
+    const existing = responseObserversByMetadata.get(metadata);
+    if (existing) {
+        existing.push(observer);
+        return;
+    }
+    responseObserversByMetadata.set(metadata, [observer]);
+}
+export function takeProxyResponseObservers(metadata) {
+    const observers = responseObserversByMetadata.get(metadata) ?? [];
+    responseObserversByMetadata.delete(metadata);
+    return observers;
+}
 function touchActivity() {
     lastActivityAtMs = Date.now();
 }

package/dist/server/routes/codexProxyRoutes.js

@@ -24,7 +24,7 @@ import { loadAccountQuotas, saveAccountQuota, } from "../../proxy/accountQuota.j
 import { createCodexUsageTap } from "../../proxy/codexUsage.js";
 import { CODEX_ACCOUNT_PREFIX, parseCodexRateLimitHeaders, } from "../../proxy/codexAccountUsage.js";
 import { buildClientAttribution } from "../../proxy/clientAttribution.js";
-import { trackProxyResponse } from "../../proxy/proxyActivity.js";
+import { registerProxyResponseObserver } from "../../proxy/proxyActivity.js";
 import { logRequest, logRequestAttempt } from "../../proxy/requestLogger.js";
 import { parseRetryAfterMs } from "../../proxy/routingPolicy.js";
 import { recordAttempt, recordAttemptError, recordFinalError, recordFinalSuccess, } from "../../proxy/usageStats.js";
@@ -459,7 +459,7 @@ export async function handleCodexResponsesRequest(ctx) {
                     status: upstream.status,
                     headers,
                 });
-                return trackProxyResponse(relay, () => undefined, {
+                registerProxyResponseObserver(ctx.metadata, {
                     onTerminal: ({ outcome }) => {
                         void usageSeen
                             .then((usage) => {
@@ -491,6 +491,7 @@ export async function handleCodexResponsesRequest(ctx) {
                             .catch(() => undefined);
                     },
                 });
+                return relay;
             }
             const errText = await upstream.text().catch(() => "");
             // 401/403 → try a forced token refresh once, then rotate.

package/package.json

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