@juspay/neurolink 12.17.0 → 12.17.2

package/dist/server/routes/codexProxyRoutes.js

@@ -24,7 +24,11 @@ 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 { registerProxyResponseObserver } from "../../proxy/proxyActivity.js";
+import { registerProxyResponseObserver, isProxyRequestFinalized, } from "../../proxy/proxyActivity.js";
+import { prepareProxyRequestContext, ProxyContextPreflightError, } from "../../proxy/proxyContextPreflight.js";
+import { reserveProxyTokenBudget, settleProxyTokenBudget, getProxyTokenBudgetError, getProxyTokenBudgetSessionKey, } from "../../proxy/proxyTokenBudget.js";
+import { emitProxyOtelEvent } from "../../proxy/otelLogSink.js";
+import { getRuntimeContextWindow, clearRuntimeOutputCeiling, registerRuntimeContextWindow, registerRuntimeOutputCeiling, } from "../../constants/contextWindows.js";
 import { logRequest, logRequestAttempt, logBodyCapture, isProxyBodyCaptureEnabled, } from "../../proxy/requestLogger.js";
 import { createRawStreamCapture } from "../../proxy/rawStreamCapture.js";
 import { resolveProxyLogTraceContext } from "../../proxy/proxyTraceContext.js";
@@ -130,8 +134,14 @@ const BLOCKED_UPSTREAM_HEADERS = new Set([
     "accept-encoding",
 ]);
 /** Build a Codex error body as a Response with the intended status. */
-function buildCodexErrorResponse(status, message) {
-    return new Response(JSON.stringify({ error: { type: "proxy_error", message } }), { status, headers: { "content-type": "application/json" } });
+function buildCodexErrorResponse(status, message, code) {
+    return new Response(JSON.stringify({
+        error: {
+            type: "proxy_error",
+            message,
+            ...(code ? { code, retryable: false } : {}),
+        },
+    }), { status, headers: { "content-type": "application/json" } });
 }
 /**
  * Load the Codex account pool from the token store, refreshing expired OAuth
@@ -404,8 +414,39 @@ function captureCodexResponse(ctx, response, phase, account, attempt) {
 }
 async function executeCodexResponsesRequest(ctx) {
     const requestStartTime = Date.now();
-    const body = ctx.body ?? {};
-    const bodyStr = JSON.stringify(body);
+    let body = (ctx.body ?? {});
+    let bodyStr;
+    let preparedContext;
+    let contextPreflight;
+    let budgetLease;
+    let budgetDispatched = false;
+    const settleBudget = async (actualTokens) => {
+        if (!budgetLease) {
+            return;
+        }
+        try {
+            if (budgetDispatched) {
+                await settleProxyTokenBudget(budgetLease, actualTokens);
+                if (budgetLease.snapshot.settlement === "unconfirmed") {
+                    emitProxyOtelEvent("token_budget", {
+                        requestId: ctx.requestId,
+                        event: "settlement_unconfirmed",
+                    });
+                }
+            }
+            else {
+                await budgetLease.cancelBeforeDispatch();
+            }
+        }
+        catch (error) {
+            emitProxyOtelEvent("token_budget", {
+                requestId: ctx.requestId,
+                event: "settlement_unconfirmed",
+                errorCode: getProxyTokenBudgetError(error)?.code ??
+                    "PROXY_TOKEN_BUDGET_UNAVAILABLE",
+            });
+        }
+    };
     const model = typeof body.model === "string"
         ? body.model
         : "-";
@@ -434,6 +475,7 @@ async function executeCodexResponsesRequest(ctx) {
             provider: "openai",
             userAgent: ctx.headers["user-agent"],
             recordRequestMetrics: !isFallbackRequest,
+            recordUsageMetrics: true,
         }, ctx.headers);
     }
     catch {
@@ -445,6 +487,9 @@ async function executeCodexResponsesRequest(ctx) {
         method: ctx.method,
         path: ctx.path,
         model,
+        requestedModel: model,
+        contextPreflight,
+        tokenBudget: budgetLease ? { ...budgetLease.snapshot } : undefined,
         stream: true,
         toolCount: Array.isArray(body.tools)
             ? body.tools.length
@@ -466,10 +511,28 @@ async function executeCodexResponsesRequest(ctx) {
     });
     let finalOutcomeRecorded = false;
     const recordFinalOutcome = async (account, responseStatus, extra = {}) => {
+        await settleBudget(extra.inputTokens !== undefined && extra.outputTokens !== undefined
+            ? extra.inputTokens + extra.outputTokens
+            : undefined);
         if (finalOutcomeRecorded) {
             return;
         }
         finalOutcomeRecorded = true;
+        if (isProxyRequestFinalized(ctx.requestId)) {
+            // Runtime owns the client final, but this route still owns its span.
+            const status = ctx.abortSignal?.aborted
+                ? ctx.abortSignal.reason?.name === "TimeoutError"
+                    ? 504
+                    : 499
+                : responseStatus;
+            try {
+                tracer?.end(status, Date.now() - requestStartTime);
+            }
+            catch {
+                /* best effort */
+            }
+            return;
+        }
         try {
             if (extra.errorType) {
                 tracer?.setError(extra.errorType, extra.errorMessage ?? extra.errorType);
@@ -510,6 +573,9 @@ async function executeCodexResponsesRequest(ctx) {
             method: ctx.method,
             path: ctx.path,
             model,
+            requestedModel: model,
+            contextPreflight,
+            tokenBudget: budgetLease ? { ...budgetLease.snapshot } : undefined,
             stream: true,
             toolCount: Array.isArray(body.tools)
                 ? body.tools.length
@@ -525,6 +591,30 @@ async function executeCodexResponsesRequest(ctx) {
         }).catch(() => undefined);
     };
     const dispatch = async () => {
+        try {
+            preparedContext = prepareProxyRequestContext({
+                provider: "codex",
+                model,
+                body,
+            });
+            contextPreflight = preparedContext.evidence;
+            body = preparedContext.body;
+            bodyStr = JSON.stringify(body);
+        }
+        catch (error) {
+            if (!(error instanceof ProxyContextPreflightError)) {
+                throw error;
+            }
+            contextPreflight = error.evidence;
+            await recordFinalOutcome(undefined, error.status, {
+                errorType: "context_preflight",
+                errorCode: error.code,
+                errorMessage: error.message,
+                retryable: false,
+                terminalOutcome: "handler_error",
+            });
+            return buildCodexErrorResponse(error.status, error.message, error.code);
+        }
         const accounts = await loadCodexProxyAccounts();
         const cancelRequest = async (account) => {
             await recordFinalOutcome(account, 499, {
@@ -601,6 +691,36 @@ async function executeCodexResponsesRequest(ctx) {
                 if (ctx.abortSignal?.aborted) {
                     return cancelRequest(lastAttemptedAccount);
                 }
+                await settleBudget();
+                budgetLease = undefined;
+                budgetDispatched = false;
+                try {
+                    budgetLease = await reserveProxyTokenBudget({
+                        provider: "codex",
+                        accountKey: account.key,
+                        sessionKey: getProxyTokenBudgetSessionKey(new Headers(ctx.headers)),
+                        requestId: ctx.requestId,
+                        reservationTokens: preparedContext.totalTokensReservation,
+                        estimateProvenance: "estimated_input_plus_serving_model_output_reserve",
+                    });
+                }
+                catch (error) {
+                    const budgetError = getProxyTokenBudgetError(error);
+                    if (!budgetError) {
+                        throw error;
+                    }
+                    await recordFinalOutcome(account, budgetError.status, {
+                        errorType: "token_budget",
+                        errorCode: budgetError.code,
+                        errorMessage: budgetError.message,
+                        retryable: false,
+                        terminalOutcome: "handler_error",
+                    });
+                    return buildCodexErrorResponse(budgetError.status, budgetError.message, budgetError.code);
+                }
+                if (ctx.abortSignal?.aborted) {
+                    return cancelRequest(account);
+                }
                 attempt += 1;
                 const attemptStartedAt = Date.now();
                 lastAttemptedAccount = account;
@@ -622,6 +742,7 @@ async function executeCodexResponsesRequest(ctx) {
                         attempt,
                         ...tracer?.getTraceContext(),
                     });
+                    budgetDispatched = true;
                     upstream = await fetch(CODEX_RESPONSES_URL, {
                         method: "POST",
                         headers: upstreamHeaders,
@@ -742,8 +863,12 @@ async function executeCodexResponsesRequest(ctx) {
                                         !semantic.completed);
                                 const usageExtra = usage
                                     ? {
-                                        inputTokens: usage.inputTokens,
-                                        outputTokens: usage.outputTokens,
+                                        inputTokens: usage.inputTokensObserved
+                                            ? usage.inputTokens
+                                            : undefined,
+                                        outputTokens: usage.outputTokensObserved
+                                            ? usage.outputTokens
+                                            : undefined,
                                         cacheReadTokens: usage.cacheReadTokens,
                                         cacheCreationTokens: usage.cacheCreationTokens,
                                         reasoningTokens: usage.reasoningTokensObserved
@@ -751,7 +876,8 @@ async function executeCodexResponsesRequest(ctx) {
                                             : undefined,
                                     }
                                     : {};
-                                if (usage) {
+                                if (usage?.inputTokensObserved &&
+                                    usage.outputTokensObserved) {
                                     try {
                                         tracer?.setUsage({
                                             ...usage,
@@ -781,6 +907,11 @@ async function executeCodexResponsesRequest(ctx) {
                                 if (failed) {
                                     recordAttemptError(account.label, CODEX_ACCOUNT_TYPE, 502);
                                     writeAttempt(account, attempt, attemptStartedAt, 502, {
+                                        // An internal fallback has no separate final row. Keep
+                                        // its observed usage on this attempt when a later
+                                        // provider owns the client final.
+                                        ...usageExtra,
+                                        inputIncludesCachedTokens: true,
                                         errorType: semantic.errorType ?? "incomplete_stream",
                                         errorCode: semantic.errorCode,
                                         errorMessage: semantic.errorMessage ??
@@ -963,6 +1094,7 @@ async function executeCodexResponsesRequest(ctx) {
         return await dispatch();
     }
     catch (error) {
+        await settleBudget();
         try {
             tracer?.end(502, Date.now() - requestStartTime);
         }
@@ -972,6 +1104,50 @@ async function executeCodexResponsesRequest(ctx) {
         throw error;
     }
 }
+/** Accept exact positive limits advertised by successful Codex model discovery. */
+function registerCodexDiscoveredLimits(body) {
+    if (Buffer.byteLength(body, "utf8") > 2 * 1024 * 1024) {
+        return;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(body);
+    }
+    catch {
+        return;
+    }
+    if (!parsed ||
+        typeof parsed !== "object" ||
+        !("models" in parsed) ||
+        !Array.isArray(parsed.models)) {
+        return;
+    }
+    for (const candidate of parsed.models.slice(0, 1024)) {
+        if (!candidate || typeof candidate !== "object") {
+            continue;
+        }
+        const model = candidate.slug ?? candidate.id;
+        if (typeof model !== "string" || model.length === 0 || model.length > 256) {
+            continue;
+        }
+        const context = candidate.context_window;
+        const output = candidate.max_output_tokens;
+        if (Number.isSafeInteger(context) && context > 0) {
+            registerRuntimeContextWindow("codex", model, context);
+        }
+        const knownContext = getRuntimeContextWindow("codex", model);
+        if (Number.isSafeInteger(output) &&
+            output > 0 &&
+            (knownContext === undefined || output < knownContext)) {
+            registerRuntimeOutputCeiling("codex", model, output);
+        }
+        else {
+            // Rediscovery may shrink the context or stop advertising an output cap.
+            // Do not preserve a stale ceiling that can make every input invalid.
+            clearRuntimeOutputCeiling("codex", model);
+        }
+    }
+}
 /**
  * Relay Codex model discovery upstream.
  *
@@ -1035,7 +1211,10 @@ async function handleCodexModelsRequest(ctx) {
                     // Bound the upstream call, as the responses route does. Without a
                     // signal a stalled connection holds the proxy request open with no
                     // ceiling, and the CLI blocks on model discovery at startup.
-                    signal: AbortSignal.timeout(CODEX_UPSTREAM_TIMEOUT_MS),
+                    signal: AbortSignal.any([
+                        ...(ctx.abortSignal ? [ctx.abortSignal] : []),
+                        AbortSignal.timeout(CODEX_UPSTREAM_TIMEOUT_MS),
+                    ]),
                 });
             }
             catch (error) {
@@ -1075,6 +1254,9 @@ async function handleCodexModelsRequest(ctx) {
             // query was not forwarded correctly, and hiding it behind a retry would
             // bury the exact regression this route was added to fix.
             const body = await upstream.text();
+            if (upstream.ok) {
+                registerCodexDiscoveredLimits(body);
+            }
             const contentType = upstream.headers.get("content-type") ?? "application/json";
             return new Response(body, {
                 status: upstream.status,

package/dist/server/routes/openaiProxyRoutes.d.ts

@@ -31,7 +31,7 @@ declare function resolveStreamCancellationLifecycle(terminalStreamError: string
  *                        headers — to avoid SSRF.
  * @returns RouteGroup with OpenAI-compatible endpoints.
  */
-export declare function createOpenAIProxyRoutes(modelRouter?: ModelRouterInterface, basePath?: string, loopbackPort?: number, runtimeConfigProvider?: ProxyRuntimeConfigProvider): RouteGroup;
+export declare function createOpenAIProxyRoutes(modelRouter?: ModelRouterInterface, basePath?: string, loopbackPort?: number, runtimeConfigProvider?: ProxyRuntimeConfigProvider, internalDispatch?: (request: Request) => Response | Promise<Response>): RouteGroup;
 export declare const __testHooks: {
     resolveStreamCancellationLifecycle: typeof resolveStreamCancellationLifecycle;
 };