@juspay/neurolink 12.17.1 → 12.17.2

package/dist/server/routes/openaiProxyRoutes.js

@@ -12,12 +12,16 @@
  * provider/model pairs (e.g. "gpt-4o" -> vertex/gemini-2.5-pro).
  */
 import { buildOpenAIError, convertClaudeToOpenAIResponse, convertOpenAIToClaudeRequest, createClaudeToOpenAIStreamTransform, parseOpenAIRequest, } from "../../proxy/openaiFormat.js";
+import { createProxyRouteBodyCapture } from "../../proxy/proxyRouteBodyCapture.js";
 import { ProxyTracer } from "../../proxy/proxyTracer.js";
 import { buildModelsListResponse, handleTranslatedJsonRequest, handleTranslatedStreamRequest, } from "../../proxy/proxyTranslationEngine.js";
 import { buildClientAttribution } from "../../proxy/clientAttribution.js";
 import { logRequest } from "../../proxy/requestLogger.js";
+import { registerInternalProxyRequest, isProxyRequestFinalized, getProxyBridgeResult, releaseProxyRequestAccounting, } from "../../proxy/proxyActivity.js";
+import { recordFinalSuccess, recordFinalError, } from "../../proxy/usageStats.js";
+import { getProxyRequestTraceContext } from "../../proxy/proxyTraceContext.js";
 import { buildProxyTranslationPlan } from "../../proxy/routingPolicy.js";
-import { withTimeout } from "../../utils/async/withTimeout.js";
+import { raceWithAbort, withTimeout } from "../../utils/async/withTimeout.js";
 import { sanitizeForLog } from "../../utils/logSanitize.js";
 import { logger } from "../../utils/logger.js";
 // Maximum time the internal loopback fetch is allowed to take before we
@@ -83,9 +87,102 @@ function adaptForTranslationPlan(parsed) {
 // ---------------------------------------------------------------------------
 // OpenAI -> Anthropic loopback bridge
 // ---------------------------------------------------------------------------
+function startBridgeTracer(ctx, body) {
+    try {
+        const tracer = ProxyTracer.startRequest({
+            requestId: ctx.requestId,
+            method: ctx.method,
+            path: ctx.path,
+            model: body.model,
+            stream: body.stream === true,
+            toolCount: body.tools?.length ?? 0,
+            provider: "openai-bridge",
+            recordRequestMetrics: true,
+            recordUsageMetrics: false,
+            ...buildClientAttribution(ctx.headers),
+        }, ctx.headers);
+        tracer.setMode("full");
+        return tracer;
+    }
+    catch {
+        // Trace setup must not fail the request.
+        return undefined;
+    }
+}
+function buildBridgeHeaders(ctx, stream, token) {
+    // Forward a minimal set of headers. The proxy's own /v1/messages handler
+    // will attach OAuth credentials from its account pool.
+    const forwardHeaders = {
+        "content-type": "application/json",
+        accept: stream ? "text/event-stream" : "application/json",
+        "x-neurolink-internal-request": token,
+    };
+    const traceContext = getProxyRequestTraceContext(ctx.requestId);
+    if (traceContext) {
+        forwardHeaders.traceparent = `00-${traceContext.traceId}-${traceContext.spanId}-${traceContext.traceFlags.toString(16).padStart(2, "0")}`;
+    }
+    for (const [k, v] of Object.entries(ctx.headers)) {
+        if (typeof v !== "string") {
+            continue;
+        }
+        const lower = k.toLowerCase();
+        if (lower.startsWith("anthropic-") ||
+            lower === "x-api-key" ||
+            [
+                "user-agent",
+                "x-neurolink-session-id",
+                "x-claude-code-session-id",
+                "session_id",
+                "session-id",
+                "tracestate",
+                "baggage",
+            ].includes(lower) ||
+            (lower === "traceparent" && !forwardHeaders.traceparent)) {
+            forwardHeaders[lower] = v;
+        }
+    }
+    return forwardHeaders;
+}
+function bridgeAttribution(child) {
+    const servingModelStatus = child?.servingModelStatus ?? "unavailable";
+    const accountIdentityStatus = child?.accountIdentityStatus ??
+        (child?.accountKey &&
+            child.accountType !== "translation" &&
+            child.account !== "unknown"
+            ? "observed"
+            : "unavailable");
+    return { servingModelStatus, accountIdentityStatus };
+}
+async function bridgeJsonResponse(upstream, signal, model, writeLifecycle, errorResponse, capture) {
+    try {
+        const claudeJson = (await raceWithAbort(upstream.json(), signal));
+        // Child owns billed usage; parent owns client delivery and its serialized body.
+        const response = convertClaudeToOpenAIResponse(claudeJson, model);
+        capture.json(response, 200);
+        await writeLifecycle(200);
+        return response;
+    }
+    catch (error) {
+        const status = signal.aborted && signal.reason?.name !== "TimeoutError"
+            ? 499
+            : signal.reason?.name === "TimeoutError"
+                ? 504
+                : 502;
+        await writeLifecycle(status, {
+            errorType: status === 499
+                ? "client_cancelled"
+                : status === 504
+                    ? "loopback_timeout"
+                    : "loopback_response_error",
+            errorMessage: error instanceof Error ? error.message : String(error),
+        });
+        return errorResponse(status, "Anthropic loopback failed");
+    }
+}
 /**
  * Forward an OpenAI-format request targeting a Claude model through the
- * proxy's own /v1/messages endpoint via a loopback fetch().
+ * proxy's own /v1/messages endpoint. The CLI injects its same-worker HTTP
+ * application, so a rolling supervisor cannot move the child to another worker.
  *
  * This reuses the full Claude passthrough path (OAuth account rotation, retry,
  * SSE interception, etc.) and only adds format conversion at the edges.
@@ -96,62 +193,131 @@ function adaptForTranslationPlan(parsed) {
  * port via `createOpenAIProxyRoutes(modelRouter, basePath, loopbackPort)`.
  */
 async function handleOpenAIToAnthropicBridge(args) {
-    const { ctx, body, targetModel, requestStartTime, loopbackPort } = args;
+    const { ctx, body, targetModel, requestStartTime, loopbackPort, internalDispatch, } = args;
     const stream = body.stream === true;
     const toolCount = body.tools?.length ?? 0;
-    const writeLifecycle = (responseStatus, extra = {}) => logRequest({
-        timestamp: new Date().toISOString(),
-        requestId: ctx.requestId,
-        method: ctx.method,
-        path: ctx.path,
-        model: body.model,
-        stream,
-        toolCount,
-        account: "",
-        accountType: "openai-bridge",
-        ...buildClientAttribution(ctx.headers),
-        responseStatus,
-        responseTimeMs: Date.now() - requestStartTime,
-        ...extra,
-    });
-    // Convert to Claude format and remap the model to the router's choice.
-    const claudeBody = convertOpenAIToClaudeRequest(body);
-    claudeBody.model = targetModel;
+    const capture = createProxyRouteBodyCapture(ctx, body.model, stream, requestStartTime);
+    capture.request();
+    const errorResponse = (status, message) => {
+        capture.json(buildOpenAIError(status, message), status);
+        return buildOpenAIErrorResponse(status, message);
+    };
+    const internal = registerInternalProxyRequest(ctx.requestId);
+    const bridgeTracer = startBridgeTracer(ctx, body);
+    const cancellation = new AbortController();
+    const signal = AbortSignal.any([
+        cancellation.signal,
+        AbortSignal.timeout(LOOPBACK_TIMEOUT_MS),
+        ...(ctx.abortSignal ? [ctx.abortSignal] : []),
+    ]);
+    let lifecycleWritten = false;
+    const writeLifecycle = (responseStatus, extra = {}) => {
+        if (lifecycleWritten) {
+            return Promise.resolve();
+        }
+        lifecycleWritten = true;
+        internal.dispose();
+        const child = getProxyBridgeResult(ctx.requestId);
+        const { servingModelStatus, accountIdentityStatus } = bridgeAttribution(child);
+        if (servingModelStatus === "observed" &&
+            child?.model &&
+            child.model !== body.model) {
+            bridgeTracer?.setModelSubstitution(body.model, child.model, child.provider);
+        }
+        if (extra.errorType) {
+            bridgeTracer?.setError(extra.errorType, extra.errorMessage ?? extra.errorType);
+        }
+        bridgeTracer?.end(responseStatus, Date.now() - requestStartTime);
+        if (!isProxyRequestFinalized(ctx.requestId)) {
+            if (responseStatus >= 400) {
+                recordFinalError(responseStatus, child?.account, child?.accountType, {
+                    requestId: ctx.requestId,
+                    errorType: extra.errorType,
+                    message: extra.errorMessage,
+                    terminalOutcome: responseStatus === 499
+                        ? "client_cancelled"
+                        : extra.errorType?.includes("stream")
+                            ? "stream_error"
+                            : "handler_error",
+                });
+            }
+            else {
+                recordFinalSuccess(child?.account, child?.accountType);
+            }
+        }
+        return logRequest({
+            timestamp: new Date().toISOString(),
+            requestId: ctx.requestId,
+            method: ctx.method,
+            path: ctx.path,
+            model: child?.model ?? body.model,
+            servingModelStatus,
+            stream,
+            toolCount,
+            account: child?.account ?? "",
+            accountKey: child?.accountKey,
+            accountType: child?.accountType ?? "openai-bridge",
+            accountIdentityStatus,
+            requestedModel: body.model,
+            provider: child?.provider,
+            errorCode: child?.errorCode,
+            transportScope: child?.transportScope,
+            retryable: child?.retryable,
+            accountingScope: "client",
+            usageOwnerRequestId: internal.requestId,
+            ...buildClientAttribution(ctx.headers),
+            responseStatus,
+            responseTimeMs: Date.now() - requestStartTime,
+            ...extra,
+        }).finally(() => releaseProxyRequestAccounting(ctx.requestId));
+    };
     // SECURITY: Never derive the loopback target from the client-controlled
     // `Host` header. The bridge always fetches from 127.0.0.1 on the listener's
     // configured port — anything else would be an SSRF vector.
     const internalUrl = `http://127.0.0.1:${loopbackPort}/v1/messages`;
-    // Forward a minimal set of headers. The proxy's own /v1/messages handler
-    // will attach OAuth credentials from its account pool.
-    const forwardHeaders = {
-        "content-type": "application/json",
-        accept: stream ? "text/event-stream" : "application/json",
-    };
-    for (const [k, v] of Object.entries(ctx.headers)) {
-        if (typeof v !== "string") {
-            continue;
-        }
-        const lower = k.toLowerCase();
-        if (lower.startsWith("anthropic-") || lower === "x-api-key") {
-            forwardHeaders[lower] = v;
-        }
-    }
     // Bound the self-call with a timeout so a stuck inner handler can't hang
     // the outer /v1/chat/completions request indefinitely.
-    const upstream = await withTimeout(fetch(internalUrl, {
-        method: "POST",
-        headers: forwardHeaders,
-        body: JSON.stringify({ ...claudeBody, stream }),
-    }), LOOPBACK_TIMEOUT_MS, `Anthropic loopback timed out after ${LOOPBACK_TIMEOUT_MS}ms`);
+    let upstream;
+    try {
+        signal.throwIfAborted();
+        // Preparation can reject malformed inputs before dispatch. Keep it within
+        // lifecycle cleanup so the internal capability and parent maps are released.
+        const claudeBody = convertOpenAIToClaudeRequest(body);
+        claudeBody.model = targetModel;
+        const forwardHeaders = buildBridgeHeaders(ctx, stream, internal.token);
+        const requestOptions = {
+            method: "POST",
+            headers: forwardHeaders,
+            body: JSON.stringify({ ...claudeBody, stream }),
+            signal,
+        };
+        upstream = await raceWithAbort(Promise.resolve(internalDispatch
+            ? internalDispatch(new Request(internalUrl, requestOptions))
+            : fetch(internalUrl, requestOptions)), signal);
+    }
+    catch (error) {
+        internal.dispose();
+        const status = ctx.abortSignal?.aborted ? 499 : signal.aborted ? 504 : 502;
+        cancellation.abort(error);
+        await writeLifecycle(status, {
+            errorType: ctx.abortSignal?.aborted
+                ? "client_cancelled"
+                : status === 504
+                    ? "loopback_timeout"
+                    : "loopback_exception",
+            errorMessage: error instanceof Error ? error.message : String(error),
+        });
+        return errorResponse(status, "Anthropic loopback failed");
+    }
     if (!upstream.ok) {
-        const errText = await upstream.text().catch(() => "");
+        const errText = await raceWithAbort(upstream.text(), signal).catch(() => "");
         const safeErrText = sanitizeForLog(errText);
         logger.always(`[proxy:openai] anthropic loopback error ${upstream.status}: ${safeErrText}`);
         await writeLifecycle(upstream.status, {
             errorType: "loopback_upstream_error",
             errorMessage: safeErrText,
         });
-        return buildOpenAIErrorResponse(upstream.status, safeErrText || `Anthropic loopback failed with status ${upstream.status}`);
+        return errorResponse(upstream.status, safeErrText || `Anthropic loopback failed with status ${upstream.status}`);
     }
     if (stream) {
         if (!upstream.body) {
@@ -159,8 +325,9 @@ async function handleOpenAIToAnthropicBridge(args) {
                 errorType: "loopback_empty_stream",
                 errorMessage: "Anthropic loopback returned empty stream body",
             });
-            return buildOpenAIErrorResponse(502, "Anthropic loopback returned empty stream body");
+            return errorResponse(502, "Anthropic loopback returned empty stream body");
         }
+        const clientCapture = capture.accumulator("client_response", "text/event-stream");
         let terminalStreamError;
         const transformed = upstream.body.pipeThrough(createClaudeToOpenAIStreamTransform(body.model, {
             onError: (message) => {
@@ -168,14 +335,28 @@ async function handleOpenAIToAnthropicBridge(args) {
             },
         }));
         const reader = transformed.getReader();
-        let lifecycleWritten = false;
         const finishLifecycle = async (status, errorType, errorMessage) => {
-            if (lifecycleWritten) {
-                return;
-            }
-            lifecycleWritten = true;
+            signal.removeEventListener("abort", onAbort);
+            clientCapture.finish(status);
             await writeLifecycle(status, { errorType, errorMessage });
         };
+        const onAbort = () => {
+            const outcome = terminalStreamError
+                ? resolveStreamCancellationLifecycle(terminalStreamError)
+                : {
+                    status: signal.reason?.name === "TimeoutError" ? 504 : 499,
+                    errorType: signal.reason?.name === "TimeoutError"
+                        ? "loopback_timeout"
+                        : "client_cancelled",
+                    errorMessage: "Anthropic loopback cancelled",
+                };
+            void finishLifecycle(outcome.status, outcome.errorType, outcome.errorMessage);
+            void withTimeout(reader.cancel(signal.reason), 1000, "Loopback cancellation timed out").catch(() => undefined);
+        };
+        signal.addEventListener("abort", onAbort, { once: true });
+        if (signal.aborted) {
+            onAbort();
+        }
         const trackedStream = new ReadableStream({
             async pull(controller) {
                 try {
@@ -190,6 +371,7 @@ async function handleOpenAIToAnthropicBridge(args) {
                         controller.close();
                         return;
                     }
+                    clientCapture.append(value);
                     controller.enqueue(value);
                 }
                 catch (error) {
@@ -199,13 +381,15 @@ async function handleOpenAIToAnthropicBridge(args) {
                 }
             },
             async cancel(reason) {
-                try {
-                    await reader.cancel(reason);
-                }
-                finally {
-                    const cancellation = resolveStreamCancellationLifecycle(terminalStreamError);
-                    await finishLifecycle(cancellation.status, cancellation.errorType, cancellation.errorMessage);
-                }
+                const outcome = resolveStreamCancellationLifecycle(terminalStreamError);
+                // Claim the observed outcome before abort dispatch, but never keep
+                // provider work alive while a metadata sink waits for publication.
+                const finalizing = finishLifecycle(outcome.status, outcome.errorType, outcome.errorMessage);
+                cancellation.abort(reason);
+                await Promise.all([
+                    finalizing,
+                    withTimeout(reader.cancel(reason), 1000, "Loopback cancellation timed out").catch(() => undefined),
+                ]);
             },
         });
         return new Response(trackedStream, {
@@ -217,14 +401,7 @@ async function handleOpenAIToAnthropicBridge(args) {
             },
         });
     }
-    const claudeJson = (await upstream.json());
-    await writeLifecycle(200, {
-        inputTokens: claudeJson.usage?.input_tokens,
-        outputTokens: claudeJson.usage?.output_tokens,
-        cacheCreationTokens: claudeJson.usage?.cache_creation_input_tokens,
-        cacheReadTokens: claudeJson.usage?.cache_read_input_tokens,
-    });
-    return convertClaudeToOpenAIResponse(claudeJson, body.model);
+    return bridgeJsonResponse(upstream, signal, body.model, writeLifecycle, errorResponse, capture);
 }
 // ---------------------------------------------------------------------------
 // Route factory
@@ -243,7 +420,7 @@ async function handleOpenAIToAnthropicBridge(args) {
  *                        headers — to avoid SSRF.
  * @returns RouteGroup with OpenAI-compatible endpoints.
  */
-export function createOpenAIProxyRoutes(modelRouter, basePath = "", loopbackPort = DEFAULT_LOOPBACK_PORT, runtimeConfigProvider) {
+export function createOpenAIProxyRoutes(modelRouter, basePath = "", loopbackPort = DEFAULT_LOOPBACK_PORT, runtimeConfigProvider, internalDispatch) {
     return {
         prefix: `${basePath}/v1`,
         routes: [
@@ -285,6 +462,7 @@ export function createOpenAIProxyRoutes(modelRouter, basePath = "", loopbackPort
                                 targetModel,
                                 requestStartTime,
                                 loopbackPort,
+                                internalDispatch,
                             });
                         }
                         catch (err) {
@@ -296,6 +474,20 @@ export function createOpenAIProxyRoutes(modelRouter, basePath = "", loopbackPort
                             const rawMessage = err instanceof Error ? err.message : String(err);
                             const internalDetail = sanitizeForLog(rawMessage);
                             logger.always(`[proxy:openai] anthropic loopback failed: ${internalDetail}`);
+                            const status = ctx.abortSignal?.aborted
+                                ? 499
+                                : err instanceof Error && "status" in err && err.status === 503
+                                    ? 503
+                                    : err instanceof Error && err.name === "TimeoutError"
+                                        ? 504
+                                        : 502;
+                            if (!isProxyRequestFinalized(ctx.requestId)) {
+                                recordFinalError(status, undefined, undefined, {
+                                    requestId: ctx.requestId,
+                                    errorType: status === 499 ? "client_cancelled" : "loopback_exception",
+                                    message: internalDetail,
+                                });
+                            }
                             await logRequest({
                                 timestamp: new Date().toISOString(),
                                 requestId: ctx.requestId,
@@ -306,12 +498,12 @@ export function createOpenAIProxyRoutes(modelRouter, basePath = "", loopbackPort
                                 toolCount: body.tools?.length ?? 0,
                                 account: "",
                                 accountType: "openai-bridge",
-                                responseStatus: 502,
+                                responseStatus: status,
                                 responseTimeMs: Date.now() - requestStartTime,
-                                errorType: "loopback_exception",
+                                errorType: status === 499 ? "client_cancelled" : "loopback_exception",
                                 errorMessage: internalDetail,
-                            });
-                            return buildOpenAIErrorResponse(502, "Anthropic loopback failed");
+                            }).finally(() => releaseProxyRequestAccounting(ctx.requestId));
+                            return buildOpenAIErrorResponse(status, "Anthropic loopback failed");
                         }
                     }
                     // --- Parse request ---

package/dist/types/cli.d.ts

@@ -842,6 +842,9 @@ export type ProxyTelemetryArgs = {
     format?: "json" | "text";
     maxRows?: number;
     proxyUrl?: string;
+    admissionLookbackMinutes?: number;
+    requestTimeoutMs?: number;
+    ingestionGraceMs?: number;
 };
 /** A fallback chain entry (serialisable subset of FallbackEntry) */
 export type FallbackInfo = {

package/dist/types/codex.d.ts

@@ -175,7 +175,11 @@ export type CodexResponsesRequest = {
 export type CodexFallbackResult = {
     text: string;
     toolCalls: NonNullable<InternalResult["toolCalls"]>;
-    usage?: NonNullable<InternalResult["usage"]>;
+    usage?: NonNullable<InternalResult["usage"]> & {
+        /** Numeric serializer compatibility must not imply provider observation. */
+        inputTokensObserved?: boolean;
+        outputTokensObserved?: boolean;
+    };
     finishReason: "end_turn" | "tool_use";
 };
 /** Incremental Claude frames and explicit upstream cancellation. */

package/dist/types/index.d.ts

@@ -54,6 +54,7 @@ export * from "./providerCatalog.generated.js";
 export * from "./providers.js";
 export * from "./proxy.js";
 export * from "./proxyClient.js";
+export * from "./proxyContext.js";
 export * from "./rag.js";
 export * from "./scorer.js";
 export * from "./sdk.js";
@@ -96,3 +97,4 @@ export * from "./agentNetwork.js";
 export * from "./localUsage.js";
 export * from "./dispatch.js";
 export * from "./proxyRestart.js";
+export * from "./proxyBudget.js";

package/dist/types/index.js

@@ -58,6 +58,7 @@ export * from "./providerCatalog.generated.js";
 export * from "./providers.js";
 export * from "./proxy.js";
 export * from "./proxyClient.js";
+export * from "./proxyContext.js";
 export * from "./rag.js";
 export * from "./scorer.js";
 export * from "./sdk.js";
@@ -111,3 +112,4 @@ export * from "./localUsage.js";
 // resolveRequestKind() dispatch-decision types
 export * from "./dispatch.js";
 export * from "./proxyRestart.js";
+export * from "./proxyBudget.js";