@juspay/neurolink 12.40.3 → 12.41.0

package/dist/proxy/proxyConfig.js

@@ -217,6 +217,10 @@ const MIN_SESSION_AFFINITY_IDLE_TTL_MS = 60_000;
 const MAX_SESSION_AFFINITY_IDLE_TTL_MS = 86_400_000;
 const MIN_SPILL_INFLIGHT = 0;
 const MAX_SPILL_INFLIGHT = 100;
+/** Prior design left this uncapped and flagged it as an open risk (unbounded
+ *  chain degrades worst-case exhausted-turn latency linearly). 8 is deliberate
+ *  headroom (2 providers x up to 4 models each). */
+const MAX_CODEX_OUTBOUND_FALLBACK_TARGETS = 8;
 function kebabToCamelRoutingKey(kebabKey) {
     return kebabKey.replace(/-([a-z])/g, (_match, letter) => letter.toUpperCase());
 }
@@ -419,6 +423,68 @@ export function validateProxyConfig(config) {
                 rawSpillInflight > MAX_SPILL_INFLIGHT)) {
             errors.push("routing.spill-inflight must be an integer between 0 and 100");
         }
+        const rawCodexOutboundEnabled = readRoutingPolicyKey(routing, "codex-outbound-fallback-enabled");
+        const normalizedCodexOutboundEnabled = typeof rawCodexOutboundEnabled === "string"
+            ? rawCodexOutboundEnabled.trim().toLowerCase()
+            : undefined;
+        if (rawCodexOutboundEnabled !== undefined &&
+            typeof rawCodexOutboundEnabled !== "boolean" &&
+            normalizedCodexOutboundEnabled !== "true" &&
+            normalizedCodexOutboundEnabled !== "false") {
+            errors.push("routing.codex-outbound-fallback-enabled must be a boolean");
+        }
+        const rawCodexOutboundTargets = readRoutingPolicyKey(routing, "codex-outbound-fallback-targets");
+        if (rawCodexOutboundTargets !== undefined) {
+            if (!Array.isArray(rawCodexOutboundTargets)) {
+                errors.push("routing.codex-outbound-fallback-targets must be an array");
+            }
+            else if (rawCodexOutboundTargets.length > MAX_CODEX_OUTBOUND_FALLBACK_TARGETS) {
+                errors.push(`routing.codex-outbound-fallback-targets must have at most ${MAX_CODEX_OUTBOUND_FALLBACK_TARGETS} entries`);
+            }
+            else {
+                rawCodexOutboundTargets.forEach((entry, index) => {
+                    const field = `routing.codex-outbound-fallback-targets[${index}]`;
+                    if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
+                        errors.push(`${field} must be an object`);
+                        return;
+                    }
+                    const target = entry;
+                    if (target.provider !== "anthropic" && target.provider !== "vertex") {
+                        errors.push(`${field}.provider must be anthropic or vertex`);
+                    }
+                    if (typeof target.model !== "string" || target.model.trim() === "") {
+                        errors.push(`${field}.model must be a non-empty string`);
+                    }
+                });
+            }
+        }
+        const rawCodexOutboundModelMappings = readRoutingPolicyKey(routing, "codex-outbound-fallback-model-mappings");
+        if (rawCodexOutboundModelMappings !== undefined) {
+            if (!Array.isArray(rawCodexOutboundModelMappings)) {
+                errors.push("routing.codex-outbound-fallback-model-mappings must be an array");
+            }
+            else {
+                rawCodexOutboundModelMappings.forEach((entry, index) => {
+                    const field = `routing.codex-outbound-fallback-model-mappings[${index}]`;
+                    if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
+                        errors.push(`${field} must be an object`);
+                        return;
+                    }
+                    const mapping = entry;
+                    if (typeof mapping.from !== "string" || mapping.from.trim() === "") {
+                        errors.push(`${field}.from must be a non-empty string`);
+                    }
+                    if (typeof mapping.to !== "string" || mapping.to.trim() === "") {
+                        errors.push(`${field}.to must be a non-empty string`);
+                    }
+                    if (mapping.provider !== undefined &&
+                        (typeof mapping.provider !== "string" ||
+                            mapping.provider.trim() === "")) {
+                        errors.push(`${field}.provider must be a non-empty string`);
+                    }
+                });
+            }
+        }
     }
     if (!hasAccounts && !hasRouting) {
         errors.push('Config must contain at least one of "accounts" or "routing"');
@@ -754,6 +820,60 @@ export function parseRoutingConfig(raw) {
             logger.warn(`[proxy-config] Ignoring routing.spillInflight: expected integer between 0 and 100, got ${String(rawSpillInflight)}`);
         }
     }
+    const rawCodexOutboundEnabled = readRoutingPolicyKey(raw, "codex-outbound-fallback-enabled");
+    if (rawCodexOutboundEnabled !== undefined) {
+        if (typeof rawCodexOutboundEnabled === "boolean") {
+            result.codexOutboundFallbackEnabled = rawCodexOutboundEnabled;
+        }
+        else if (typeof rawCodexOutboundEnabled === "string" &&
+            ["true", "false"].includes(rawCodexOutboundEnabled.trim().toLowerCase())) {
+            result.codexOutboundFallbackEnabled =
+                rawCodexOutboundEnabled.trim().toLowerCase() === "true";
+        }
+        else {
+            logger.warn(`[proxy-config] Ignoring routing.codexOutboundFallbackEnabled: expected boolean, got ${typeof rawCodexOutboundEnabled}`);
+        }
+    }
+    const rawCodexOutboundTargets = readRoutingPolicyKey(raw, "codex-outbound-fallback-targets");
+    if (Array.isArray(rawCodexOutboundTargets)) {
+        result.codexOutboundFallbackTargets = rawCodexOutboundTargets
+            .filter((t) => t !== null && typeof t === "object")
+            .map((t) => {
+            const provider = t.provider === "anthropic" || t.provider === "vertex"
+                ? t.provider
+                : undefined;
+            const model = String(t.model ?? "").trim();
+            if (!provider || !model) {
+                logger.warn(`[proxy-config] Skipping codex-outbound-fallback-targets entry with invalid provider/model: ${JSON.stringify(t)}`);
+                return null;
+            }
+            return { provider, model };
+        })
+            .filter((t) => t !== null)
+            .slice(0, MAX_CODEX_OUTBOUND_FALLBACK_TARGETS);
+    }
+    // codex-outbound-fallback-model-mappings: identical shape to the existing
+    // model-mappings block above — same from/to/provider extraction and drop rule.
+    const rawCodexOutboundModelMappings = readRoutingPolicyKey(raw, "codex-outbound-fallback-model-mappings");
+    if (Array.isArray(rawCodexOutboundModelMappings)) {
+        result.codexOutboundFallbackModelMappings = rawCodexOutboundModelMappings
+            .filter((m) => m !== null && typeof m === "object")
+            .map((m) => {
+            const from = String(m.from ?? "").trim();
+            const to = String(m.to ?? "").trim();
+            const provider = String(m.provider ?? "anthropic").trim() || "anthropic";
+            if (!from || !to) {
+                logger.warn(`[proxy-config] Skipping codex-outbound-fallback-model-mappings entry with empty "from" or "to": ${JSON.stringify(m)}`);
+                return null;
+            }
+            return {
+                from,
+                to,
+                provider,
+            };
+        })
+            .filter((m) => m !== null);
+    }
     return result;
 }
 // ---------------------------------------------------------------------------

package/dist/proxy/proxyTokenUsage.d.ts

@@ -5,3 +5,18 @@ import type { TokenUsage, UsageContext } from "../types/index.js";
  * https://developers.openai.com/api/docs/guides/prompt-caching#monitor-cache-performance
  */
 export declare function proxyTokenUsage(usage: UsageContext): TokenUsage;
+/**
+ * Read Anthropic's `usage.cache_creation.ephemeral_1h_input_tokens` — the
+ * 1-hour-TTL share of `cache_creation_input_tokens` — from an untyped usage
+ * object. Returns undefined when the breakdown is absent (older replies, or a
+ * request that wrote no 1h breakpoint), so callers leave the field unset and
+ * price exactly as before.
+ */
+export declare function readCacheCreation1hTokens(usage: unknown): number | undefined;
+/**
+ * Spread target for a usage literal: the key exists only when a 1h count was
+ * observed, so every payload without one keeps its exact old shape.
+ */
+export declare function oneHourCacheWriteFields(count: number | undefined): {
+    cacheCreation1hTokens?: number;
+};

package/dist/proxy/proxyTokenUsage.js

@@ -16,6 +16,39 @@ export function proxyTokenUsage(usage) {
             : input + cached + usage.outputTokens,
         cacheReadTokens: usage.cacheReadTokens,
         cacheCreationTokens: usage.cacheCreationTokens,
+        // Spread only when present so every existing caller's result keeps its
+        // exact old shape (no new `undefined`-valued key to trip deep-equal checks).
+        ...(usage.cacheCreation1hTokens !== undefined
+            ? { cacheCreation1hTokens: usage.cacheCreation1hTokens }
+            : {}),
         reasoning: usage.reasoningTokens,
     };
 }
+/**
+ * Read Anthropic's `usage.cache_creation.ephemeral_1h_input_tokens` — the
+ * 1-hour-TTL share of `cache_creation_input_tokens` — from an untyped usage
+ * object. Returns undefined when the breakdown is absent (older replies, or a
+ * request that wrote no 1h breakpoint), so callers leave the field unset and
+ * price exactly as before.
+ */
+export function readCacheCreation1hTokens(usage) {
+    if (typeof usage !== "object" || usage === null) {
+        return undefined;
+    }
+    const breakdown = usage.cache_creation;
+    if (typeof breakdown !== "object" || breakdown === null) {
+        return undefined;
+    }
+    const raw = breakdown
+        .ephemeral_1h_input_tokens;
+    return typeof raw === "number" && Number.isFinite(raw) && raw >= 0
+        ? raw
+        : undefined;
+}
+/**
+ * Spread target for a usage literal: the key exists only when a 1h count was
+ * observed, so every payload without one keeps its exact old shape.
+ */
+export function oneHourCacheWriteFields(count) {
+    return count === undefined ? {} : { cacheCreation1hTokens: count };
+}

package/dist/proxy/proxyTracer.d.ts

@@ -14,7 +14,7 @@
  * - TelemetryService for metrics recording
  */
 import { type Span } from "@opentelemetry/api";
-import type { AccountSelectionContext, ProxyRequestContext, ResponseInfoContext, UpstreamAttemptContext, UsageContext, ProxyUsageAttributionOptions, RuntimeRequestMetadata, ProxyLogTraceContext } from "../types/index.js";
+import type { AccountSelectionContext, ProxyRequestContext, ProxyRequestOrigin, ResponseInfoContext, UpstreamAttemptContext, UsageContext, ProxyUsageAttributionOptions, RuntimeRequestMetadata, ProxyLogTraceContext } from "../types/index.js";
 declare class ProxyTracer {
     private readonly rootSpan;
     private readonly proxyTracer;
@@ -40,6 +40,8 @@ declare class ProxyTracer {
     private accountEmail?;
     private usage?;
     private mode;
+    /** Where the Claude-shaped request originated, for cache/cost attribution. */
+    private requestOrigin;
     private constructor();
     /**
      * Create a root span for a proxy request and set Langfuse context.
@@ -60,6 +62,12 @@ declare class ProxyTracer {
     setAccountSelection(ctx: AccountSelectionContext): void;
     /** Attribute fallback metrics to the account that actually served them. */
     setServedAccount(account: string, accountType: string): void;
+    /**
+     * Record where the Claude-shaped request this span covers originated, so
+     * the token/cost counters below can be broken down by origin (e.g. to
+     * measure Codex-fallback cache-hit rate separately from native traffic).
+     */
+    setRequestOrigin(origin: ProxyRequestOrigin): void;
     /** Record token usage and cost on the root span. */
     setUsage(ctx: UsageContext, options?: ProxyUsageAttributionOptions): void;
     /**
@@ -126,6 +134,13 @@ export declare function recordFallbackAttempt(attrs: {
     status: "success" | "failure";
     errorMessage?: string;
     durationMs: number;
+    /** Namespaces the leg-health key for a fallback direction other than the
+     *  existing Claude-engine chain (e.g. `"codex-outbound"`), so a dead-leg
+     *  alert for `anthropic/claude-...` reached via Codex-outbound fallback
+     *  never merges its failure streak with the same provider/model reached
+     *  through the Claude engine's own configured chain. Omitted entirely by
+     *  every existing call site, which keeps their leg key exactly as before. */
+    direction?: string;
 }): void;
 /**
  * Records one Codex-outbound tool-declaration schema degradation (a

package/dist/proxy/proxyTracer.js

@@ -221,6 +221,8 @@ class ProxyTracer {
     accountEmail;
     usage;
     mode = "full";
+    /** Where the Claude-shaped request originated, for cache/cost attribution. */
+    requestOrigin = "native";
     constructor(rootSpan, requestId, model, stream, billingProvider) {
         this.rootSpan = rootSpan;
         this.requestId = requestId;
@@ -380,6 +382,15 @@ class ProxyTracer {
             "proxy.account.served_type": accountType,
         });
     }
+    /**
+     * Record where the Claude-shaped request this span covers originated, so
+     * the token/cost counters below can be broken down by origin (e.g. to
+     * measure Codex-fallback cache-hit rate separately from native traffic).
+     */
+    setRequestOrigin(origin) {
+        this.requestOrigin = origin;
+        this.rootSpan.setAttribute("proxy.request_origin", origin);
+    }
     /** Record token usage and cost on the root span. */
     setUsage(ctx, options = {}) {
         if (options.recordMetrics !== undefined) {
@@ -695,10 +706,18 @@ class ProxyTracer {
         }
         // Token metrics (only if usage was captured)
         if (this.recordUsageMetrics && this.usage) {
-            const tokenLabels = {
-                model: this.model,
-                account: this.accountEmail ?? "unknown",
-            };
+            // `origin` is added to the label set only when it is not the default
+            // "native" value, so every pre-existing series keeps its exact old
+            // label set {model, account} when the Codex-outbound-fallback flag is
+            // off (or simply unused) — Ruling 1's byte-for-byte requirement — and
+            // no metric series is restarted for traffic this PR does not touch.
+            const tokenLabels = this.requestOrigin === "native"
+                ? { model: this.model, account: this.accountEmail ?? "unknown" }
+                : {
+                    model: this.model,
+                    account: this.accountEmail ?? "unknown",
+                    origin: this.requestOrigin,
+                };
             m.tokensInput.add(proxyTokenUsage(this.usage).input, tokenLabels);
             m.tokensOutput.add(this.usage.outputTokens, tokenLabels);
             // Skipped, not zeroed, when the provider reported no breakdown: a zero
@@ -850,7 +869,9 @@ export function recordFallbackAttempt(attrs) {
     // Leg health is tracked outside the metrics try/catch: a telemetry failure
     // must not be the reason an operator never hears that a leg is dead.
     try {
-        trackFallbackLegHealth(`${attrs.provider}/${attrs.model}`, attrs.status, attrs.errorMessage);
+        trackFallbackLegHealth(attrs.direction
+            ? `${attrs.direction}:${attrs.provider}/${attrs.model}`
+            : `${attrs.provider}/${attrs.model}`, attrs.status, attrs.errorMessage);
     }
     catch {
         // Never let health reporting break a request.

package/dist/proxy/requestLogger.js

@@ -239,6 +239,7 @@ function annotateRequestPricing(entry) {
     const output = entry.outputTokens;
     const cacheRead = entry.cacheReadTokens ?? 0;
     const cacheCreation = entry.cacheCreationTokens ?? 0;
+    const cacheCreation1h = entry.cacheCreation1hTokens;
     if (input === undefined ||
         output === undefined ||
         !Number.isFinite(input) ||
@@ -249,6 +250,11 @@ function annotateRequestPricing(entry) {
         cacheRead < 0 ||
         !Number.isFinite(cacheCreation) ||
         cacheCreation < 0 ||
+        // The 1h count is a subset of the cache-write total.
+        (cacheCreation1h !== undefined &&
+            (!Number.isFinite(cacheCreation1h) ||
+                cacheCreation1h < 0 ||
+                cacheCreation1h > cacheCreation)) ||
         (entry.inputIncludesCachedTokens === true &&
             cacheRead + cacheCreation > input) ||
         // When input includes the cached portion but the provider never reported
@@ -275,6 +281,9 @@ function annotateRequestPricing(entry) {
         cacheReadTokens: cacheRead,
         cacheCreationTokens: cacheCreation,
         inputIncludesCachedTokens: entry.inputIncludesCachedTokens,
+        ...(entry.cacheCreation1hTokens !== undefined
+            ? { cacheCreation1hTokens: entry.cacheCreation1hTokens }
+            : {}),
     });
     entry.pricingStatus = "exact";
     entry.apiEquivalentCostUsd = calculateCost(entry.pricingProvider, entry.model, usage);

package/dist/proxy/runtimeConfig.js

@@ -39,6 +39,17 @@ function resolveQuotaRoutingEnabled(envValue, configured) {
     const normalized = envValue.trim().toLowerCase();
     return normalized !== "off" && normalized !== "false" && normalized !== "0";
 }
+function resolveCodexOutboundFallbackEnabled(envValue, configured) {
+    if (envValue === undefined || envValue.trim() === "") {
+        // Unlike resolveQuotaRoutingEnabled's `configured ?? true`, this defaults
+        // false — required so today's behavior is byte-identical when unconfigured.
+        // An empty/whitespace-only value (e.g. `FOO=` in a .env file) is treated
+        // the same as unset, not as an explicit opt-in.
+        return configured ?? false;
+    }
+    const normalized = envValue.trim().toLowerCase();
+    return normalized !== "off" && normalized !== "false" && normalized !== "0";
+}
 function resolveSessionSoftLimit(envValue, configured, rejectInvalid) {
     if (envValue !== undefined) {
         const parsed = Number(envValue);
@@ -234,6 +245,9 @@ async function buildCandidate(options, generation, allowMissingConfig, allowMiss
     const sessionAffinity = routing?.sessionAffinity ?? false;
     const sessionAffinityIdleTtlMs = routing?.sessionAffinityIdleTtlMs ?? 3_600_000;
     const spillInflight = routing?.spillInflight ?? 0;
+    const codexOutboundFallbackEnabled = resolveCodexOutboundFallbackEnabled(effectiveEnv.NEUROLINK_PROXY_CODEX_OUTBOUND_FALLBACK, routing?.codexOutboundFallbackEnabled);
+    const codexOutboundFallbackTargets = routing?.codexOutboundFallbackTargets ?? [];
+    const codexOutboundFallbackModelMappings = routing?.codexOutboundFallbackModelMappings ?? [];
     const fingerprintSource = JSON.stringify({
         strategy,
         passthrough: options.passthrough,
@@ -249,6 +263,9 @@ async function buildCandidate(options, generation, allowMissingConfig, allowMiss
         sessionAffinity,
         sessionAffinityIdleTtlMs,
         spillInflight,
+        codexOutboundFallbackEnabled,
+        codexOutboundFallbackTargets,
+        codexOutboundFallbackModelMappings,
     });
     const configHash = createHash("sha256")
         .update(fingerprintSource)
@@ -274,6 +291,9 @@ async function buildCandidate(options, generation, allowMissingConfig, allowMiss
             sessionAffinity,
             sessionAffinityIdleTtlMs,
             spillInflight,
+            codexOutboundFallbackEnabled,
+            codexOutboundFallbackTargets,
+            codexOutboundFallbackModelMappings,
         }),
         configFilePresent,
         envFilePresent,

package/dist/proxy/sseInterceptor.js

@@ -16,6 +16,7 @@
  *   const data = await telemetry; // resolves on stream end
  */
 import { hasUsefulClaudeContent } from "./claudeOutputObservation.js";
+import { readCacheCreation1hTokens } from "./proxyTokenUsage.js";
 // ---------------------------------------------------------------------------
 // Constants
 // ---------------------------------------------------------------------------
@@ -180,6 +181,9 @@ function finalize(acc) {
             inputTokens: acc.inputTokens,
             outputTokens: acc.outputTokens,
             cacheCreationInputTokens: acc.cacheCreationInputTokens,
+            ...(acc.cacheCreation1hInputTokens !== undefined
+                ? { cacheCreation1hInputTokens: acc.cacheCreation1hInputTokens }
+                : {}),
             cacheReadInputTokens: acc.cacheReadInputTokens,
             totalTokens,
         },
@@ -213,6 +217,11 @@ function processMessageStart(acc, parsed) {
         acc.inputTokens += usage.input_tokens ?? 0;
         acc.outputTokens += usage.output_tokens ?? 0;
         acc.cacheCreationInputTokens += usage.cache_creation_input_tokens ?? 0;
+        const oneHour = readCacheCreation1hTokens(usage);
+        if (oneHour !== undefined) {
+            acc.cacheCreation1hInputTokens =
+                (acc.cacheCreation1hInputTokens ?? 0) + oneHour;
+        }
         acc.cacheReadInputTokens += usage.cache_read_input_tokens ?? 0;
     }
 }

package/dist/proxy/vertexAnthropicFallback.js

@@ -15,6 +15,7 @@
 import { logger } from "../utils/logger.js";
 import { claudeDisabledThinkingReplacement, modelSupportsForcedToolChoice, } from "../models/modelRegistry.js";
 import { isTransientNetworkError } from "./proxyFetch.js";
+import { readCacheCreation1hTokens } from "./proxyTokenUsage.js";
 /** Vertex pins the Anthropic API version in the body, not a header. */
 const VERTEX_ANTHROPIC_VERSION = "vertex-2023-10-16";
 const CLOUD_PLATFORM_SCOPE = "https://www.googleapis.com/auth/cloud-platform";
@@ -640,6 +641,14 @@ function readUsageEvent(event, into) {
         into.inputTokens = num(usage.input_tokens);
         into.cacheCreationTokens = num(usage.cache_creation_input_tokens);
         into.cacheReadTokens = num(usage.cache_read_input_tokens);
+        // The 1h-TTL share of the cache-write total, reported by Anthropic as
+        // `cache_creation.ephemeral_1h_input_tokens`. Set only when the breakdown
+        // holds a valid count, so any other reply leaves the field unset and
+        // prices exactly as it did before.
+        const oneHour = readCacheCreation1hTokens(usage);
+        if (oneHour !== undefined) {
+            into.cacheCreation1hTokens = oneHour;
+        }
     }
     // Every message_delta restates the running total, so the last one wins.
     const output = num(usage.output_tokens);

package/dist/server/routes/claudeProxyRoutes.js

@@ -169,6 +169,7 @@ const UPSTREAM_FETCH_TIMEOUT_MS = 15 * 60 * 1000; // 15 minutes
 import { prepareProxyRequestContext, ProxyContextPreflightError, } from "../../proxy/proxyContextPreflight.js";
 import { reserveProxyTokenBudget, getProxyTokenBudgetError, getProxyTokenBudgetSessionKey, } from "../../proxy/proxyTokenBudget.js";
 import { observeAnthropicBudgetResponse } from "../../proxy/anthropicBudgetResponse.js";
+import { readCacheCreation1hTokens, oneHourCacheWriteFields, } from "../../proxy/proxyTokenUsage.js";
 function prepareAnthropicWire(ctx, bodyStr) {
     const body = JSON.parse(bodyStr);
     const prepared = prepareProxyRequestContext({
@@ -2777,6 +2778,7 @@ async function handleClaudePassthroughStreamResponse(args) {
                     inputTokens: data.usage.inputTokens,
                     outputTokens: data.usage.outputTokens,
                     cacheCreationTokens: data.usage.cacheCreationInputTokens,
+                    ...oneHourCacheWriteFields(data.usage.cacheCreation1hInputTokens),
                     cacheReadTokens: data.usage.cacheReadInputTokens,
                 });
                 capturedTracer.logStreamEvents(data.events);
@@ -2787,6 +2789,7 @@ async function handleClaudePassthroughStreamResponse(args) {
                     inputTokens: data.usage.inputTokens,
                     outputTokens: data.usage.outputTokens,
                     cacheCreationTokens: data.usage.cacheCreationInputTokens,
+                    ...oneHourCacheWriteFields(data.usage.cacheCreation1hInputTokens),
                     cacheReadTokens: data.usage.cacheReadInputTokens,
                 };
                 if (!isNaN(rateLimit5h)) {
@@ -2810,6 +2813,7 @@ async function handleClaudePassthroughStreamResponse(args) {
                     inputTokens: data.usage.inputTokens,
                     outputTokens: data.usage.outputTokens,
                     cacheCreationTokens: data.usage.cacheCreationInputTokens,
+                    ...oneHourCacheWriteFields(data.usage.cacheCreation1hInputTokens),
                     cacheReadTokens: data.usage.cacheReadInputTokens,
                 });
                 logProxyBody({
@@ -2881,6 +2885,7 @@ async function handleClaudePassthroughStreamResponse(args) {
                     inputTokens: data.usage.inputTokens,
                     outputTokens: data.usage.outputTokens,
                     cacheCreationTokens: data.usage.cacheCreationInputTokens,
+                    ...oneHourCacheWriteFields(data.usage.cacheCreation1hInputTokens),
                     cacheReadTokens: data.usage.cacheReadInputTokens,
                 });
                 logProxyBody({
@@ -2977,6 +2982,7 @@ async function handleClaudePassthroughJsonResponse(args) {
                 inputTokens: usage.input_tokens ?? 0,
                 outputTokens: usage.output_tokens ?? 0,
                 cacheCreationTokens: usage.cache_creation_input_tokens ?? 0,
+                ...oneHourCacheWriteFields(readCacheCreation1hTokens(usage)),
                 cacheReadTokens: usage.cache_read_input_tokens ?? 0,
             });
             const rateLimit5h = parseFloat(response.headers.get("anthropic-ratelimit-unified-5h-utilization") ??
@@ -2988,6 +2994,7 @@ async function handleClaudePassthroughJsonResponse(args) {
                     inputTokens: usage.input_tokens ?? 0,
                     outputTokens: usage.output_tokens ?? 0,
                     cacheCreationTokens: usage.cache_creation_input_tokens ?? 0,
+                    ...oneHourCacheWriteFields(readCacheCreation1hTokens(usage)),
                     cacheReadTokens: usage.cache_read_input_tokens ?? 0,
                 };
                 if (!isNaN(rateLimit5h)) {
@@ -3009,6 +3016,7 @@ async function handleClaudePassthroughJsonResponse(args) {
             inputTokens: usage?.input_tokens,
             outputTokens: usage?.output_tokens,
             cacheCreationTokens: usage?.cache_creation_input_tokens,
+            ...oneHourCacheWriteFields(readCacheCreation1hTokens(usage)),
             cacheReadTokens: usage?.cache_read_input_tokens,
         });
     }
@@ -5248,6 +5256,7 @@ function attachAnthropicSuccessStreamTelemetry(args) {
                     inputTokens: data.usage.inputTokens,
                     outputTokens: data.usage.outputTokens,
                     cacheCreationTokens: data.usage.cacheCreationInputTokens,
+                    ...oneHourCacheWriteFields(data.usage.cacheCreation1hInputTokens),
                     cacheReadTokens: data.usage.cacheReadInputTokens,
                 });
                 // Bill the borrowing grant from the same totals. A stream's usage is
@@ -5272,6 +5281,7 @@ function attachAnthropicSuccessStreamTelemetry(args) {
                     inputTokens: data.usage.inputTokens,
                     outputTokens: data.usage.outputTokens,
                     cacheCreationTokens: data.usage.cacheCreationInputTokens,
+                    ...oneHourCacheWriteFields(data.usage.cacheCreation1hInputTokens),
                     cacheReadTokens: data.usage.cacheReadInputTokens,
                 };
                 if (!isNaN(rateLimit5h)) {
@@ -5292,6 +5302,7 @@ function attachAnthropicSuccessStreamTelemetry(args) {
                     inputTokens: data.usage.inputTokens,
                     outputTokens: data.usage.outputTokens,
                     cacheCreationTokens: data.usage.cacheCreationInputTokens,
+                    ...oneHourCacheWriteFields(data.usage.cacheCreation1hInputTokens),
                     cacheReadTokens: data.usage.cacheReadInputTokens,
                 };
                 if (failure) {
@@ -5381,6 +5392,7 @@ function attachAnthropicSuccessStreamTelemetry(args) {
                     inputTokens: data.usage.inputTokens,
                     outputTokens: data.usage.outputTokens,
                     cacheCreationTokens: data.usage.cacheCreationInputTokens,
+                    ...oneHourCacheWriteFields(data.usage.cacheCreation1hInputTokens),
                     cacheReadTokens: data.usage.cacheReadInputTokens,
                 };
                 // Settled on the untraced path too: whether telemetry is exported has
@@ -5527,6 +5539,7 @@ async function handleAnthropicJsonSuccessResponse(args) {
                 inputTokens: usage.input_tokens ?? 0,
                 outputTokens: usage.output_tokens ?? 0,
                 cacheCreationTokens: usage.cache_creation_input_tokens ?? 0,
+                ...oneHourCacheWriteFields(readCacheCreation1hTokens(usage)),
                 cacheReadTokens: usage.cache_read_input_tokens ?? 0,
             });
             const rateLimit5h = parseFloat(response.headers.get("anthropic-ratelimit-unified-5h-utilization") ??
@@ -5538,6 +5551,7 @@ async function handleAnthropicJsonSuccessResponse(args) {
                     inputTokens: usage.input_tokens ?? 0,
                     outputTokens: usage.output_tokens ?? 0,
                     cacheCreationTokens: usage.cache_creation_input_tokens ?? 0,
+                    ...oneHourCacheWriteFields(readCacheCreation1hTokens(usage)),
                     cacheReadTokens: usage.cache_read_input_tokens ?? 0,
                 };
                 if (!isNaN(rateLimit5h)) {
@@ -5559,6 +5573,7 @@ async function handleAnthropicJsonSuccessResponse(args) {
             inputTokens: usage?.input_tokens,
             outputTokens: usage?.output_tokens,
             cacheCreationTokens: usage?.cache_creation_input_tokens,
+            ...oneHourCacheWriteFields(readCacheCreation1hTokens(usage)),
             cacheReadTokens: usage?.cache_read_input_tokens,
         });
     }
@@ -5571,6 +5586,7 @@ async function handleAnthropicJsonSuccessResponse(args) {
             inputTokens: noTracerUsage?.input_tokens,
             outputTokens: noTracerUsage?.output_tokens,
             cacheCreationTokens: noTracerUsage?.cache_creation_input_tokens,
+            ...oneHourCacheWriteFields(readCacheCreation1hTokens(noTracerUsage)),
             cacheReadTokens: noTracerUsage?.cache_read_input_tokens,
         });
     }
@@ -5646,6 +5662,7 @@ async function handleAnthropicSuccessfulNonStreamRetryResponse(args) {
                 inputTokens: retryUsage.input_tokens ?? 0,
                 outputTokens: retryUsage.output_tokens ?? 0,
                 cacheCreationTokens: retryUsage.cache_creation_input_tokens ?? 0,
+                ...oneHourCacheWriteFields(readCacheCreation1hTokens(retryUsage)),
                 cacheReadTokens: retryUsage.cache_read_input_tokens ?? 0,
             });
         }
@@ -5659,6 +5676,7 @@ async function handleAnthropicSuccessfulNonStreamRetryResponse(args) {
             inputTokens: retryUsage?.input_tokens,
             outputTokens: retryUsage?.output_tokens,
             cacheCreationTokens: retryUsage?.cache_creation_input_tokens,
+            ...oneHourCacheWriteFields(readCacheCreation1hTokens(retryUsage)),
             cacheReadTokens: retryUsage?.cache_read_input_tokens,
         });
     }
@@ -6637,6 +6655,9 @@ function createClaudeRequestRuntimeContext(args) {
             ...(extra?.cacheCreationTokens !== undefined
                 ? { cacheCreationTokens: extra.cacheCreationTokens }
                 : {}),
+            ...(extra?.cacheCreation1hTokens !== undefined
+                ? { cacheCreation1hTokens: extra.cacheCreation1hTokens }
+                : {}),
             ...(extra?.cacheReadTokens !== undefined
                 ? { cacheReadTokens: extra.cacheReadTokens }
                 : {}),
@@ -6736,6 +6757,9 @@ function createAnthropicAttemptLogger(args) {
             ...(extra?.cacheCreationTokens !== undefined
                 ? { cacheCreationTokens: extra.cacheCreationTokens }
                 : {}),
+            ...(extra?.cacheCreation1hTokens !== undefined
+                ? { cacheCreation1hTokens: extra.cacheCreation1hTokens }
+                : {}),
             ...(extra?.cacheReadTokens !== undefined
                 ? { cacheReadTokens: extra.cacheReadTokens }
                 : {}),
@@ -7106,7 +7130,47 @@ function buildDeferredClaudeAccountFailureResponse(args) {
 async function handleAnthropicRoutedClaudeRequest(args) {
     const { ctx, body, modelRouter, configGeneration, tracer, requestStartTime, accountStrategy, primaryAccountKey, accountAllowlist, quotaRoutingEnabled = isQuotaRoutingEnabled(), sessionSoftLimit = getSessionSoftLimit(), sessionResetToleranceMs = getSessionResetToleranceMs(), ranking = "expiry-first", preferPrimary = false, sessionAffinityEnabled = false, sessionAffinityIdleTtlMs = 3_600_000, spillInflight = 0, buildLoggedClaudeError, logProxyBody, logFinalRequest, setRoutingDecision, } = args;
     const parsedRequest = parseClaudeRequest(body);
-    const configuredFallbackPlan = buildProxyTranslationPlan({ provider: "anthropic", model: body.model }, modelRouter?.getFallbackChain() ?? [], body.model, parsedRequest);
+    // Loop prevention for the Codex-outbound-fallback leg (stage-c-trigger.md
+    // §3): a request that reached this handler AS a Codex-outbound fallback
+    // loopback call must never be offered a fallback chain that routes back
+    // into Codex, or Codex(exhausted) -> Anthropic -> Codex could cycle.
+    //
+    // The `x-neurolink-internal-origin` header alone is NOT the security
+    // boundary — any external client can send an arbitrary header. The real
+    // boundary is `consumeInternalProxyRequest`: it looks the caller-supplied
+    // `x-neurolink-internal-request` token up in a server-only, in-memory map
+    // keyed by a `crypto.randomUUID()` this same process minted (in
+    // `registerInternalProxyRequest`, codexProxyRoutes.ts) immediately before
+    // issuing its own loopback fetch, and returns a value only when that
+    // exact token is present. An external client cannot guess or observe
+    // that token — it never appears in any response the proxy sends a
+    // client — so it cannot forge a match.
+    //
+    // That call is single-use (deleted on read) and already made exactly
+    // once per request, earlier, by this worker's request-tracking
+    // middleware (`registerProxyRequestTracking` in proxy.ts) — which needs
+    // the same answer to set `RuntimeRequestMetadata.accountingScope` before
+    // any route handler runs. Calling `consumeInternalProxyRequest` a SECOND
+    // time here, with the same token, always finds it already deleted and
+    // returns `undefined` — silently leaving this filter permanently
+    // disengaged regardless of whether the request was genuinely internal.
+    // Read the middleware's already-authoritative result instead, via
+    // `getProxyRequestAccounting(ctx.requestId)` — the same lookup this file
+    // already uses elsewhere (~9322, ~9510) to distinguish an internal leg
+    // from a client request, and which is populated only when the
+    // middleware's own `consumeInternalProxyRequest` call found a genuine
+    // token match. This preserves the same unforgeable boundary without
+    // consuming the token twice.
+    const isCodexOutboundFallbackLeg = ctx.headers["x-neurolink-internal-origin"] === "codex-outbound-fallback" &&
+        getProxyRequestAccounting(ctx.requestId)?.accountingScope === "internal";
+    // The loopback leg owns the turn's usage metrics (its Codex parent records
+    // none), so the fallback origin label has to be stamped here.
+    if (isCodexOutboundFallbackLeg) {
+        tracer?.setRequestOrigin("codex-fallback");
+    }
+    const configuredFallbackPlan = buildProxyTranslationPlan({ provider: "anthropic", model: body.model }, isCodexOutboundFallbackLeg
+        ? (modelRouter?.getFallbackChain() ?? []).filter((entry) => entry.provider !== "codex")
+        : (modelRouter?.getFallbackChain() ?? []), body.model, parsedRequest);
     const hasConfiguredFallback = configuredFallbackPlan.attempts
         .slice(1)
         .some((attempt) => Boolean(attempt.provider && attempt.model));