@juspay/neurolink 12.17.1 → 12.17.2

package/dist/proxy/requestLogger.d.ts

@@ -37,6 +37,7 @@ export declare function prepareProxyBodyForLogging(body: unknown): {
     bytes?: number;
     truncated: boolean;
     originalBytes?: number;
+    unparseableFrames: number;
 };
 /** Cheap gate for response observers; avoid copying diagnostics on the serving path. */
 export declare function isProxyBodyCaptureEnabled(): boolean;

package/dist/proxy/requestLogger.js

@@ -10,6 +10,8 @@ import { randomUUID } from "node:crypto";
 import { join } from "path";
 import { homedir } from "os";
 import { logger } from "../utils/logger.js";
+import { calculateCost, hasPricing, isExactPricingMatch, } from "../utils/pricing.js";
+import { proxyTokenUsage } from "./proxyTokenUsage.js";
 import { chmodSync, existsSync, mkdirSync, readdirSync, rmSync, statSync, unlinkSync, } from "fs";
 import { writeFile } from "fs/promises";
 import { setImmediate as yieldToRequests } from "node:timers/promises";
@@ -19,7 +21,7 @@ import { isBorrowedRequest } from "./shareContext.js";
 import { OtelBridge } from "../observability/otelBridge.js";
 import { SeverityNumber } from "@opentelemetry/api-logs";
 import { configureProxyLifecycleLogger } from "./proxyLifecycle.js";
-import { notifyProxyFinalLog, notifyProxyAttemptLog } from "./proxyActivity.js";
+import { notifyProxyFinalLog, notifyProxyAttemptLog, getProxyRequestAccounting, } from "./proxyActivity.js";
 import { withTimeout } from "../utils/async/withTimeout.js";
 import { resolveProxyLogTraceContext, proxyLogContext, } from "./proxyTraceContext.js";
 let logDir = null;
@@ -191,7 +193,64 @@ export function initRequestLogger(enabled = true, customLogsDir) {
         logger.warn(`[proxy] Request logging disabled — failed to create log directory: ${err instanceof Error ? err.message : String(err)}`);
     }
 }
+/** Keep price-table estimates distinct from actual subscription billing. */
+function annotateRequestPricing(entry) {
+    entry.apiEquivalentCostUsd = null;
+    entry.apiEquivalentCacheSavingsUsd = null;
+    entry.pricingBasis = "api_price_table";
+    entry.pricingProvider = entry.provider ?? "openai-compatible";
+    if (entry.usageOwnerRequestId &&
+        entry.usageOwnerRequestId !== entry.requestId) {
+        entry.pricingStatus = "owned_by_child";
+        return;
+    }
+    const input = entry.inputTokens;
+    const output = entry.outputTokens;
+    const cacheRead = entry.cacheReadTokens ?? 0;
+    const cacheCreation = entry.cacheCreationTokens ?? 0;
+    if (input === undefined ||
+        output === undefined ||
+        !Number.isFinite(input) ||
+        input < 0 ||
+        !Number.isFinite(output) ||
+        output < 0 ||
+        !Number.isFinite(cacheRead) ||
+        cacheRead < 0 ||
+        !Number.isFinite(cacheCreation) ||
+        cacheCreation < 0 ||
+        (entry.inputIncludesCachedTokens === true &&
+            cacheRead + cacheCreation > input)) {
+        entry.pricingStatus = "usage_incomplete";
+        return;
+    }
+    if (!hasPricing(entry.pricingProvider, entry.model)) {
+        entry.pricingStatus = "unavailable";
+        return;
+    }
+    if (!isExactPricingMatch(entry.pricingProvider, entry.model)) {
+        entry.pricingStatus = "inferred";
+        return;
+    }
+    const usage = proxyTokenUsage({
+        inputTokens: input,
+        outputTokens: output,
+        cacheReadTokens: cacheRead,
+        cacheCreationTokens: cacheCreation,
+        inputIncludesCachedTokens: entry.inputIncludesCachedTokens,
+    });
+    entry.pricingStatus = "exact";
+    entry.apiEquivalentCostUsd = calculateCost(entry.pricingProvider, entry.model, usage);
+    const uncachedCost = calculateCost(entry.pricingProvider, entry.model, {
+        ...usage,
+        input: usage.input + (usage.cacheReadTokens ?? 0),
+        cacheReadTokens: 0,
+    });
+    entry.apiEquivalentCacheSavingsUsd = Math.max(0, Math.round((uncachedCost - entry.apiEquivalentCostUsd) * 1_000_000) /
+        1_000_000);
+}
 export async function logRequest(entry) {
+    Object.assign(entry, getProxyRequestAccounting(entry.requestId));
+    annotateRequestPricing(entry);
     if (!entry.traceId || entry.traceFlags === undefined) {
         const traceCtx = resolveProxyLogTraceContext(entry);
         if (traceCtx) {
@@ -206,7 +265,9 @@ export async function logRequest(entry) {
                 : entry.responseStatus >= 400 || entry.errorType
                     ? "handler_error"
                     : "completed";
-    notifyProxyFinalLog(entry);
+    if (!notifyProxyFinalLog(entry)) {
+        return;
+    }
     if (!logEnabled || (!logDir && !isProxyOtelOnly())) {
         return;
     }
@@ -239,6 +300,7 @@ export async function logRequestAttempt(entry) {
             entry.traceFlags = traceCtx.traceFlags;
         }
     }
+    Object.assign(entry, getProxyRequestAccounting(entry.requestId));
     notifyProxyAttemptLog(entry);
     if (!logEnabled || (!logDir && !isProxyOtelOnly())) {
         return;
@@ -306,8 +368,13 @@ function emitOtlpLogRecord(entry) {
             return;
         }
         const otelLogger = provider.getLogger("neurolink-proxy", "1.0.0");
-        // Determine severity based on response status
-        const isError = (entry.responseStatus ?? 0) >= 400;
+        // A streaming response can fail after sending HTTP 200. Indexed fields
+        // and severity must agree with the final semantic outcome in the body.
+        const isError = (entry.responseStatus ?? 0) >= 400 ||
+            Boolean(entry.errorType) ||
+            entry.terminalOutcome === "stream_error" ||
+            entry.terminalOutcome === "handler_error" ||
+            entry.terminalOutcome === "client_cancelled";
         const isRateLimit = entry.responseStatus === 429;
         const severityNumber = isError
             ? isRateLimit
@@ -324,6 +391,18 @@ function emitOtlpLogRecord(entry) {
                 : `${entry.method} ${entry.path} → ${entry.responseStatus} (${entry.responseTimeMs}ms)`,
             attributes: {
                 "proxy.record_kind": "request_final",
+                "proxy.accounting_scope": entry.accountingScope ?? "client",
+                ...(entry.parentRequestId
+                    ? { "proxy.parent_request_id": entry.parentRequestId }
+                    : {}),
+                ...(entry.usageOwnerRequestId
+                    ? { "proxy.usage_owner_request_id": entry.usageOwnerRequestId }
+                    : {}),
+                ...(entry.inputIncludesCachedTokens !== undefined
+                    ? {
+                        "ai.input_includes_cached_tokens": entry.inputIncludesCachedTokens,
+                    }
+                    : {}),
                 // Core request fields
                 "request.id": entry.requestId,
                 "http.method": entry.method,
@@ -334,6 +413,19 @@ function emitOtlpLogRecord(entry) {
                 "ai.model": entry.model,
                 "ai.stream": entry.stream,
                 "ai.tool_count": entry.toolCount,
+                "ai.pricing.status": entry.pricingStatus,
+                "ai.pricing.basis": entry.pricingBasis,
+                "ai.pricing.provider": entry.pricingProvider,
+                ...(entry.apiEquivalentCostUsd !== null &&
+                    entry.apiEquivalentCostUsd !== undefined
+                    ? { "ai.cost.api_equivalent_usd": entry.apiEquivalentCostUsd }
+                    : {}),
+                ...(entry.apiEquivalentCacheSavingsUsd !== null &&
+                    entry.apiEquivalentCacheSavingsUsd !== undefined
+                    ? {
+                        "ai.cost.cache_savings_usd": entry.apiEquivalentCacheSavingsUsd,
+                    }
+                    : {}),
                 // Account info
                 "account.name": entry.account,
                 "account.type": entry.accountType,
@@ -368,7 +460,9 @@ function emitOtlpLogRecord(entry) {
                 ...(entry.traceId && { "trace.id": entry.traceId }),
                 ...(entry.spanId && { "span.id": entry.spanId }),
                 // Derived fields for dashboards (matches backfill script)
-                is_success: entry.responseStatus === 200,
+                is_success: !isError &&
+                    entry.responseStatus >= 200 &&
+                    entry.responseStatus < 400,
                 is_rate_limited: entry.responseStatus === 429,
                 is_overloaded: entry.responseStatus === 529,
                 is_error: isError,
@@ -584,11 +678,19 @@ export async function logBodyCapture(entry) {
             bodyTruncated: stored.bodyTruncated,
             bodyCaptureLimitBytes: stored.bodyCaptureLimitBytes,
             originalRedactedBodyBytes: stored.originalRedactedBodyBytes,
+            inputRetainedBytes: stored.inputRetainedBytes,
+            inputEncoding: stored.inputEncoding,
+            sourceTruncated: stored.sourceTruncated,
+            processingTruncated: stored.processingTruncated,
+            redactionLossy: stored.redactionLossy,
+            unparseableRedactedFrames: stored.unparseableRedactedFrames,
             bodyWriteFailed: stored.bodyWriteFailed,
             captureError: processed.error,
             captureAdmission: processed.admission,
             captureQueueWaitMs: processed.queueWaitMs,
             captureProcessingMs: processed.processingMs,
+            captureAdmissionWaitMs: processed.admissionWaitMs,
+            captureWorkerQueueWaitMs: processed.workerQueueWaitMs,
             metadata: processed.error ? undefined : metadata.metadata,
         };
         if (traceCtx) {

package/dist/proxy/restartControl.js

@@ -87,7 +87,7 @@ export async function startProxyRestartControl(options) {
             drainingWorkers: snapshot.draining.length,
         };
     };
-    const assertIdle = () => {
+    const assertReplacementAvailable = () => {
         const snapshot = options.server.snapshot();
         if (closing || !snapshot.active) {
             throw new Error("No serving worker is available for a rolling restart.");
@@ -96,8 +96,13 @@ export async function startProxyRestartControl(options) {
             throw new Error("An update or worker replacement is already in progress.");
         }
         if (snapshot.draining.length) {
-            throw new Error("A previous worker is still finishing requests; another restart is deferred.");
+            throw new Error("Previous workers are still draining; another restart is deferred.");
         }
+        // This replaces a worker, not the listener/supervisor. Normal admissions
+        // can overlap preflight and activation: the rolling supervisor retains
+        // each previous generation until its pending transfers commit, then drains
+        // its existing streams. Full quiescence is only required before replacing
+        // the supervisor itself (updateCoordinator.isProxyRuntimeSettled).
     };
     const operate = async (restart) => {
         if (busy || closing) {
@@ -118,7 +123,7 @@ export async function startProxyRestartControl(options) {
             };
         };
         try {
-            assertIdle();
+            assertReplacementAvailable();
             const before = options.server.snapshot();
             const active = before.active;
             if (!active) {
@@ -135,7 +140,7 @@ export async function startProxyRestartControl(options) {
             if (!version || !/^\d+\.\d+\.\d+$/.test(version)) {
                 throw new Error("The configured worker executable did not report a valid installed version.");
             }
-            assertIdle();
+            assertReplacementAvailable();
             if (options.server.snapshot().active?.pid !== previousWorkerPid) {
                 throw new Error("Serving worker changed during preflight; retry the check.");
             }

package/dist/proxy/rollingWorkerProcess.js

@@ -1,4 +1,5 @@
 import { spawn } from "node:child_process";
+import { handleProxyTokenBudgetMessage, releaseProxyTokenBudgetOwner, } from "./proxyTokenBudget.js";
 import { ErrorFactory } from "../utils/errorHandling.js";
 import { isProxyWorkerStatusMessage, PROXY_SOCKET_WORKER_ENV, PROXY_SOCKET_OFFER_TIMEOUT, PROXY_SOCKET_COMMIT_TIMEOUT, } from "./rollingWorkerProtocol.js";
 /**
@@ -12,6 +13,8 @@ export function spawnProxySocketWorker(options) {
     const statusListeners = new Set();
     const pendingStatusMessages = [];
     let spawnError;
+    let budgetResponseFailure;
+    let budgetTerminationTimeout;
     const child = (options.spawn ?? spawn)(options.command, options.args, {
         env: {
             ...process.env,
@@ -84,6 +87,38 @@ export function spawnProxySocketWorker(options) {
         }
         pending.callback(error);
     };
+    /** Lost budget replies leave unknown leases; release them only after exit. */
+    const quarantineBudgetDeliveryFailure = () => {
+        if (budgetResponseFailure) {
+            return;
+        }
+        const error = ErrorFactory.proxyWorkerLifecycle(`proxy worker ${childPid} token budget response delivery failed`);
+        budgetResponseFailure = error;
+        // An IPC-disconnected worker may ignore graceful shutdown. Retain its
+        // reservation occupancy until exit, but bound how long it can survive.
+        budgetTerminationTimeout = setTimeout(() => {
+            if (child.exitCode === null && child.signalCode === null) {
+                child.kill("SIGKILL");
+            }
+        }, 1_000);
+        budgetTerminationTimeout.unref?.();
+        try {
+            publishStatus({
+                type: "proxy-worker:fatal",
+                generation: options.generation,
+                pid: childPid,
+                message: error.message,
+            });
+            for (const socketId of [...pendingSockets.keys()]) {
+                settleSocket(socketId, error);
+            }
+        }
+        finally {
+            if (child.exitCode === null && child.signalCode === null) {
+                child.kill("SIGTERM");
+            }
+        }
+    };
     /**
      * Accept messages only from this worker and start a fresh deadline for
      * the commit phase.
@@ -120,12 +155,35 @@ export function spawnProxySocketWorker(options) {
         }
     };
     child.on("message", (message) => {
+        if (budgetResponseFailure) {
+            return;
+        }
+        if (handleProxyTokenBudgetMessage(message, { pid: childPid, generation: options.generation }, (response) => {
+            if (!child.connected) {
+                quarantineBudgetDeliveryFailure();
+                return;
+            }
+            try {
+                child.send(response, (error) => {
+                    if (error) {
+                        quarantineBudgetDeliveryFailure();
+                    }
+                });
+            }
+            catch {
+                quarantineBudgetDeliveryFailure();
+            }
+        })) {
+            return;
+        }
         onInternalMessage(message);
         if (isProxyWorkerStatusMessage(message)) {
             publishStatus(message);
         }
     });
     child.once("exit", (code, signal) => {
+        clearTimeout(budgetTerminationTimeout);
+        releaseProxyTokenBudgetOwner(childPid, options.generation);
         for (const socketId of [...pendingSockets.keys()]) {
             settleSocket(socketId, ErrorFactory.proxyWorkerLifecycle(`proxy worker ${childPid} exited before socket transfer committed (code=${code ?? "none"}, signal=${signal ?? "none"})`, {
                 workerPid: childPid,
@@ -136,6 +194,9 @@ export function spawnProxySocketWorker(options) {
         }
     });
     const sendControl = (message) => {
+        if (budgetResponseFailure) {
+            throw budgetResponseFailure;
+        }
         if (!child.connected) {
             throw new Error(`proxy worker ${childPid} IPC channel is closed`);
         }
@@ -149,6 +210,10 @@ export function spawnProxySocketWorker(options) {
         pid: childPid,
         sendControl,
         sendSocket: (generation, socket, callback) => {
+            if (budgetResponseFailure) {
+                callback(budgetResponseFailure);
+                return;
+            }
             if (!child.connected) {
                 callback(new Error(`proxy worker ${childPid} IPC channel is closed`));
                 return;

package/dist/proxy/rollingWorkerSupervisor.js

@@ -287,6 +287,13 @@ export class RollingWorkerSupervisor {
                         this.publishState();
                         this.notifyShutdownWaiters();
                     }
+                    else if (this.draining.has(generation)) {
+                        // A retiring generation still owns requests and budget leases.
+                        // Preserve its fatal cause without dropping actual-exit tracking.
+                        this.recordFailure(generation, expectedVersion, "runtime", message.message, { workerPid: handle.pid });
+                        this.options.log?.(`[proxy-supervisor] draining worker reported fatal generation=${generation} pid=${handle.pid}: ${message.message}`);
+                        this.publishState();
+                    }
                     return;
                 }
                 if (message.type === "proxy-worker:replacement-requested") {

package/dist/proxy/updateCoordinator.d.ts

@@ -1,4 +1,4 @@
-import type { ProxyUpdateWindowOptions, ProxyUpdateWindowResult } from "../types/index.js";
+import type { ProxyRuntimeActivity, ProxyUpdateWindowOptions, ProxyUpdateWindowResult } from "../types/index.js";
 /**
  * A replacement updater starts from the newly installed package. The registry
  * then reports no newer version even when its launchd parent still runs the
@@ -12,9 +12,22 @@ export declare function shouldRefreshStaleSupervisor(options: {
     workerVersion?: string;
     supervisorVersion?: string;
 }): boolean;
+/** An idle active worker alone does not make its supervisor safe to stop. */
+export declare function isProxyRuntimeSettled(activity: ProxyRuntimeActivity): boolean;
+/** Parse untrusted status conservatively; incomplete rolling evidence is busy. */
+export declare function parseProxyRuntimeActivity(payload: unknown): ProxyRuntimeActivity | null;
 /**
  * Prefer a naturally quiet window, then briefly drain new inference traffic.
  * Existing requests are never interrupted; a bounded drain failure is returned
  * to the caller so admission can be reopened and retried later.
  */
 export declare function waitForProxyUpdateWindow(options: ProxyUpdateWindowOptions): Promise<ProxyUpdateWindowResult>;
+/** An asynchronous staging job must not publish after its service owner changes. */
+export declare function isProxyUpdateOwnerCurrent(options: {
+    stopping: boolean;
+    parentPid: number;
+    updaterPid: number;
+    parentStatus: "running" | "not_running" | "unknown";
+    runtimePid?: number;
+    runtimeUpdaterPid?: number;
+}): boolean;

package/dist/proxy/updateCoordinator.js

@@ -11,8 +11,56 @@ export function shouldRefreshStaleSupervisor(options) {
         typeof options.supervisorVersion === "string" &&
         options.supervisorVersion !== options.runningVersion);
 }
+/** An idle active worker alone does not make its supervisor safe to stop. */
+export function isProxyRuntimeSettled(activity) {
+    return (activity.activeRequests === 0 &&
+        (activity.drainingWorkers ?? 0) === 0 &&
+        (activity.queuedSockets ?? 0) === 0 &&
+        (activity.pendingTransfers ?? 0) === 0 &&
+        (activity.candidateWorkers ?? 0) === 0);
+}
+/** Parse untrusted status conservatively; incomplete rolling evidence is busy. */
+export function parseProxyRuntimeActivity(payload) {
+    if (!payload || typeof payload !== "object") {
+        return null;
+    }
+    const value = payload;
+    const active = value.activity?.activeRequests;
+    if (typeof active !== "number" ||
+        !Number.isSafeInteger(active) ||
+        active < 0) {
+        return null;
+    }
+    const result = {
+        activeRequests: active,
+        lastActivityAt: typeof value.activity?.lastActivityAt === "string"
+            ? value.activity.lastActivityAt
+            : null,
+    };
+    const rolling = value.autoUpdate?.rolling;
+    if (value.autoUpdate?.supervisorPid && !rolling) {
+        return null;
+    }
+    if (rolling) {
+        if (!Array.isArray(rolling.draining) ||
+            typeof rolling.queuedSockets !== "number" ||
+            !Number.isSafeInteger(rolling.queuedSockets) ||
+            rolling.queuedSockets < 0 ||
+            typeof rolling.pendingTransfers !== "number" ||
+            !Number.isSafeInteger(rolling.pendingTransfers) ||
+            rolling.pendingTransfers < 0 ||
+            rolling.candidate === undefined) {
+            return null;
+        }
+        result.drainingWorkers = rolling.draining.length;
+        result.queuedSockets = rolling.queuedSockets;
+        result.pendingTransfers = rolling.pendingTransfers;
+        result.candidateWorkers = rolling.candidate === null ? 0 : 1;
+    }
+    return result;
+}
 function isQuiet(activity, quietThresholdMs, nowMs) {
-    if (activity.activeRequests > 0) {
+    if (!isProxyRuntimeSettled(activity)) {
         return false;
     }
     if (!activity.lastActivityAt) {
@@ -61,7 +109,7 @@ export async function waitForProxyUpdateWindow(options) {
         }
         const activity = await options.getActivity();
         options.onPhase?.("draining", activity);
-        if (activity?.activeRequests === 0) {
+        if (activity && isProxyRuntimeSettled(activity)) {
             return { ready: true, draining: true };
         }
         await wait(options.pollIntervalMs);
@@ -70,3 +118,10 @@ export async function waitForProxyUpdateWindow(options) {
     options.onPhase?.("drain_timeout", activity);
     return { ready: false, draining: true, reason: "drain_timeout" };
 }
+/** An asynchronous staging job must not publish after its service owner changes. */
+export function isProxyUpdateOwnerCurrent(options) {
+    return (!options.stopping &&
+        options.parentStatus === "running" &&
+        options.runtimePid === options.parentPid &&
+        options.runtimeUpdaterPid === options.updaterPid);
+}

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

@@ -2,7 +2,7 @@ import { buildTranslationOptions } from "../../proxy/proxyTranslationEngine.js";
 import { ProxyTracer } from "../../proxy/proxyTracer.js";
 import { isPermanentRefreshFailure } from "../../proxy/tokenRefresh.js";
 import type { ProxyAccountDirectoryOverride } from "../../types/index.js";
-import type { AccountAllowlist, AccountAdmissionLease, JsonObject, AccountCooldownPlan, AccountQuota, AccountQuotaWindow, AccountUsageFetchResult, AnthropicAttemptLogger, AnthropicAuthRetryResult, AnthropicEntitlementFailure, AnthropicInvalidRequestFailure, AnthropicLoopState, AnthropicScopedExhaustion, AnthropicNonOkResult, AnthropicSuccessResult, AnthropicUpstreamFetchResult, ClaudeFinalRequestLogger, ClaudeLoggedErrorBuilder, ClaudeRequest, ClaudeProxyRouteRuntimeOptions, ModelRouterInterface, ParsedClaudeError, ProxyAccountRoutingDecision, ProxyAccountSortMetrics, ProxyBodyCaptureLogger, ProxyLimitsRefreshResponse, ProxyQuotaCooldownUpdate, ProxyOveragePolicy, ProxyPassthroughAccount, QueuedAccountAdmission, RouteGroup, RuntimeAccountState, ServerContext, StreamTerminalOutcome } from "../../types/index.js";
+import type { AccountAllowlist, AccountAdmissionLease, JsonObject, AccountCooldownPlan, AccountQuota, AccountQuotaWindow, AccountUsageFetchResult, AnthropicAttemptLogger, AnthropicAuthRetryResult, AnthropicEntitlementFailure, AnthropicInvalidRequestFailure, AnthropicLoopState, AnthropicScopedExhaustion, AnthropicNonOkResult, AnthropicSuccessResult, AnthropicUpstreamBody, AnthropicUpstreamBodyBuilder, AnthropicUpstreamFetchResult, ClaudeFinalRequestLogger, ClaudeLoggedErrorBuilder, ClaudeRequest, ClaudeProxyRouteRuntimeOptions, ModelRouterInterface, ParsedClaudeError, ProxyAccountRoutingDecision, ProxyAccountSortMetrics, ProxyBodyCaptureLogger, ProxyLimitsRefreshResponse, ProxyQuotaCooldownUpdate, ProxyOveragePolicy, ProxyPassthroughAccount, QueuedAccountAdmission, RouteGroup, RuntimeAccountState, ServerContext, StreamTerminalOutcome } from "../../types/index.js";
 declare function tryAcquireAccountAdmission(accountKey: string, capacity: number | undefined): AccountAdmissionLease | undefined;
 declare function enqueueAccountAdmission(accountKey: string, capacity: number): QueuedAccountAdmission;
 declare function acquireAccountAdmission(accountKey: string, capacity: number, abortSignal?: AbortSignal, timeoutMs?: number): Promise<AccountAdmissionLease | undefined>;
@@ -269,10 +269,7 @@ declare function handleAnthropicAuthRetry(args: {
     account: ProxyPassthroughAccount;
     accountState: RuntimeAccountState;
     headers: Record<string, string>;
-    buildUpstreamBody: (token: string) => {
-        bodyStr: string;
-        sessionId?: string;
-    };
+    buildUpstreamBody: AnthropicUpstreamBodyBuilder;
     url: string;
     enabledAccounts: ProxyPassthroughAccount[];
     orderedAccounts: ProxyPassthroughAccount[];
@@ -346,9 +343,11 @@ declare function handleAnthropicNonOkResponse(args: {
  */
 declare function isAntiAbuseConstruction429(headers: Record<string, string>, body: string): boolean;
 declare function fetchAnthropicAccountResponse(args: {
+    ctx: ServerContext;
     url: string;
     headers: Record<string, string>;
     finalBodyStr: string;
+    preparedContext: AnthropicUpstreamBody["preparedContext"];
     requestedModel?: string;
     account: ProxyPassthroughAccount;
     accountState: RuntimeAccountState;