@juspay/neurolink 9.86.0 → 9.86.2

package/dist/lib/providers/anthropic.js

@@ -13,6 +13,7 @@ import { createProxyFetch } from "../proxy/proxyFetch.js";
 import { AuthenticationError, NetworkError, ProviderError, RateLimitError, } from "../types/index.js";
 import { logger } from "../utils/logger.js";
 import { redactUrlCredentials } from "../utils/logSanitize.js";
+import { ANTHROPIC_MAX_CACHE_BREAKPOINTS, applyAnthropicHistoryCacheBreakpoints, countAnthropicCacheMarkers, } from "../utils/anthropicCacheBreakpoints.js";
 import { calculateCost } from "../utils/pricing.js";
 import { createAnthropicConfig, getProviderModel, validateApiKey, } from "../utils/providerConfig.js";
 import { composeAbortSignals, createTimeoutController, mergeAbortSignals, TimeoutError, } from "../utils/timeout.js";
@@ -1123,9 +1124,23 @@ export class AnthropicProvider extends BaseProvider {
                 }
                 // Extended thinking passthrough (providerOptions.anthropic.thinking).
                 const thinking = options.providerOptions?.anthropic?.thinking;
+                // Prompt-cache parity with the native Vertex+Claude path: upstream
+                // layers mark only the stable prefix (system via MessageBuilder,
+                // last tool via GenerationHandler) — the growing conversation
+                // history has no breakpoint, so on every turn it falls after the
+                // last marker and is re-billed as fresh input. Add rolling history
+                // breakpoints in whatever budget remains under Anthropic's
+                // four-marker ceiling; pre-existing markers are counted so the
+                // request can never exceed the cap.
+                const cacheMarkersUsed = countAnthropicCacheMarkers({
+                    system,
+                    tools,
+                    messages: messages,
+                });
+                const cachedMessages = applyAnthropicHistoryCacheBreakpoints(messages, ANTHROPIC_MAX_CACHE_BREAKPOINTS - cacheMarkersUsed);
                 const params = {
                     model: modelId,
-                    messages,
+                    messages: cachedMessages,
                     max_tokens: resolveClaudeMaxTokens(modelId, options.maxOutputTokens),
                     ...(system ? { system } : {}),
                     ...(options.temperature !== undefined &&
@@ -1345,10 +1360,19 @@ export class AnthropicProvider extends BaseProvider {
             .then((usage) => {
             streamSpan.setAttribute("gen_ai.usage.input_tokens", usage.promptTokens || 0);
             streamSpan.setAttribute("gen_ai.usage.output_tokens", usage.completionTokens || 0);
+            if (usage.cacheReadTokens) {
+                streamSpan.setAttribute("gen_ai.usage.cached_input_tokens", usage.cacheReadTokens);
+            }
             const cost = calculateCost(this.providerName, this.modelName, {
                 input: usage.promptTokens || 0,
                 output: usage.completionTokens || 0,
                 total: usage.totalTokens || 0,
+                ...(usage.cacheReadTokens
+                    ? { cacheReadTokens: usage.cacheReadTokens }
+                    : {}),
+                ...(usage.cacheCreationTokens
+                    ? { cacheCreationTokens: usage.cacheCreationTokens }
+                    : {}),
             });
             if (cost && cost > 0) {
                 streamSpan.setAttribute("neurolink.cost", cost);
@@ -1372,11 +1396,26 @@ export class AnthropicProvider extends BaseProvider {
             const conversation = payload.messages.slice();
             let totalInput = 0;
             let totalOutput = 0;
+            let totalCacheRead = 0;
+            let totalCacheWrite = 0;
             let lastStop = null;
             for (let step = 0; step < maxSteps; step++) {
+                // Prompt-cache parity with the native Vertex+Claude path — rolling
+                // history breakpoints, re-applied per step so the stable prefix
+                // stays byte-identical while the breakpoint follows the growing
+                // tail. Budget respects markers upstream layers already placed
+                // (system / last tool / message blocks) so the request never
+                // exceeds Anthropic's four-marker cap. Pure: `conversation` itself
+                // is never mutated, so re-counting per step stays stable.
+                const cacheMarkersUsed = countAnthropicCacheMarkers({
+                    system: payload.system,
+                    tools: anthropicTools,
+                    messages: conversation,
+                });
+                const cachedConversation = applyAnthropicHistoryCacheBreakpoints(conversation, ANTHROPIC_MAX_CACHE_BREAKPOINTS - cacheMarkersUsed);
                 const params = {
                     model: modelId,
-                    messages: conversation,
+                    messages: cachedConversation,
                     max_tokens: resolveClaudeMaxTokens(modelId, options.maxTokens),
                     stream: true,
                     ...(payload.system ? { system: payload.system } : {}),
@@ -1406,6 +1445,12 @@ export class AnthropicProvider extends BaseProvider {
                     if (event.type === "message_start") {
                         totalInput += event.message.usage.input_tokens ?? 0;
                         totalOutput += event.message.usage.output_tokens ?? 0;
+                        // Anthropic reports cache reads/writes SEPARATELY from
+                        // input_tokens on the same message_start event — without these
+                        // the streaming path silently drops all cache accounting.
+                        totalCacheRead += event.message.usage.cache_read_input_tokens ?? 0;
+                        totalCacheWrite +=
+                            event.message.usage.cache_creation_input_tokens ?? 0;
                     }
                     else if (event.type === "content_block_start") {
                         blockTypes.set(event.index, event.content_block.type);
@@ -1578,7 +1623,11 @@ export class AnthropicProvider extends BaseProvider {
             resolveUsage({
                 promptTokens: totalInput,
                 completionTokens: totalOutput,
-                totalTokens: totalInput + totalOutput,
+                totalTokens: totalInput + totalCacheRead + totalCacheWrite + totalOutput,
+                ...(totalCacheRead > 0 ? { cacheReadTokens: totalCacheRead } : {}),
+                ...(totalCacheWrite > 0
+                    ? { cacheCreationTokens: totalCacheWrite }
+                    : {}),
             });
             resolveFinish(lastStop ?? "stop");
         };

package/dist/lib/providers/openaiChatCompletionsClient.d.ts

@@ -13,7 +13,7 @@
  * Nothing here imports from "ai" or "@ai-sdk/*". The whole point of this
  * module is to be the native replacement for the AI SDK's OpenAI wrapper.
  */
-import type { OpenAICompatBuildBodyArgs, OpenAICompatChatMessage, OpenAICompatChatRequest, OpenAICompatChatTool, OpenAICompatMessage, OpenAICompatMessageContent, OpenAICompatResponseFormat, OpenAICompatSSEResult, OpenAICompatStreamChunk, OpenAICompatToolChoiceWire, OpenAICompatV3CallToolChoice, OpenAICompatV3CallTools, Tool } from "../types/index.js";
+import type { OpenAICompatBuildBodyArgs, OpenAICompatChatMessage, OpenAICompatChatRequest, OpenAICompatChatTool, OpenAICompatMessage, OpenAICompatMessageContent, OpenAICompatResponseFormat, OpenAICompatSSEResult, OpenAICompatStreamChunk, OpenAICompatToolChoiceWire, OpenAICompatV3CallToolChoice, OpenAICompatV3CallTools, DeferredUsage, Tool } from "../types/index.js";
 export declare const stripTrailingSlash: (s: string) => string;
 export declare const safeStringify: (value: unknown) => string;
 export declare const stringifyToolInput: (input: unknown) => string;
@@ -38,17 +38,9 @@ export declare const buildBody: (args: OpenAICompatBuildBodyArgs) => OpenAICompa
 export declare const parseSSEStream: (body: ReadableStream<Uint8Array>, onTextDelta: (delta: string) => void, onReasoningDelta?: (delta: string) => void) => Promise<OpenAICompatSSEResult>;
 export declare const buildAPIError: (url: string, body: OpenAICompatChatRequest, res: Response) => Promise<Error>;
 export declare const createDeferredAnalytics: () => {
-    usagePromise: Promise<{
-        promptTokens: number;
-        completionTokens: number;
-        totalTokens: number;
-    }>;
+    usagePromise: Promise<DeferredUsage>;
     finishPromise: Promise<string>;
-    resolveUsage: (u: {
-        promptTokens: number;
-        completionTokens: number;
-        totalTokens: number;
-    }) => void;
+    resolveUsage: (u: DeferredUsage) => void;
     resolveFinish: (reason: string) => void;
 };
 export declare const createChunkQueue: () => {

package/dist/lib/proxy/accountQuota.d.ts

@@ -35,5 +35,10 @@ export declare function loadAccountQuota(accountKey: string): Promise<AccountQuo
  * Update quota for a single account.
  * Updates in-memory cache immediately (non-blocking),
  * then debounces the disk write to every 5 seconds.
+ *
+ * Loads the persisted file into the cache before the first write so a save
+ * after a process restart merges with existing entries instead of rewriting
+ * the file with only the accounts used since boot (which silently erased
+ * other accounts' snapshots and blinded quota-aware routing to them).
  */
 export declare function saveAccountQuota(accountKey: string, quota: AccountQuota): Promise<void>;

package/dist/lib/proxy/accountQuota.js

@@ -174,10 +174,17 @@ export async function loadAccountQuota(accountKey) {
  * Update quota for a single account.
  * Updates in-memory cache immediately (non-blocking),
  * then debounces the disk write to every 5 seconds.
+ *
+ * Loads the persisted file into the cache before the first write so a save
+ * after a process restart merges with existing entries instead of rewriting
+ * the file with only the accounts used since boot (which silently erased
+ * other accounts' snapshots and blinded quota-aware routing to them).
  */
 export async function saveAccountQuota(accountKey, quota) {
+    if (!cacheLoaded) {
+        await loadAccountQuotas();
+    }
     memoryCache[accountKey] = quota;
-    cacheLoaded = true;
     dirty = true;
     scheduleFlush();
 }

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

@@ -44,18 +44,32 @@ declare function resetEpochToMs(resetEpoch: number | undefined, now: number): nu
  * allow a couple of jittered same-account retries, then a short cooldown.
  */
 declare function planCooldownFor429(quota: AccountQuota | null, retryAfterMs: number, now: number): AccountCooldownPlan;
+/**
+ * Seed each account's runtime quota from the persisted snapshots in
+ * ~/.neurolink/account-quotas.json (keyed by label). Runtime state is
+ * in-memory only, so without this the quota-aware ordering is blind after a
+ * proxy restart: all accounts tie, selection falls back to token-store
+ * enumeration order, and the first account served becomes self-reinforcing
+ * (it alone has data) — starving the others regardless of their resets.
+ * Never overwrites fresher in-memory quota; stale disk snapshots degrade
+ * gracefully because past reset timestamps are ignored by resetEpochToMs.
+ */
+declare function seedRuntimeQuotasFromDisk(accounts: ProxyPassthroughAccount[]): Promise<void>;
 /**
  * Order accounts to MAXIMIZE quota utilization (fill-first, smart order):
  * spend the account whose window refreshes SOONEST first, so its about-to-reset
  * allowance isn't wasted, then move to accounts with longer-dated resets.
  *
  * Priority among usable accounts:
- *   1. soonest WEEKLY (7d) reset  — the scarce, use-it-or-lose-it ceiling
- *   2. soonest SESSION (5h) reset
- *   3. highest weekly utilization — finish off the one closest to done
- * Accounts with no quota data yet keep insertion order (stable sort) and sit
- * after those with a known soonest reset. Cooling/rejected accounts sort last,
- * soonest-back-to-service first, as last resort.
+ *   1. no quota data yet — probe first: one request reveals its windows and
+ *      self-corrects the ordering. (Ranking unknowns last would starve them
+ *      forever: never picked → never observed → never comparable.)
+ *   2. soonest WEEKLY (7d) reset  — the scarce, use-it-or-lose-it ceiling
+ *   3. soonest SESSION (5h) reset
+ *   4. highest weekly utilization — finish off the one closest to done
+ *   5. configured primary account, then insertion order
+ * Cooling/rejected accounts sort last, soonest-back-to-service first, as
+ * last resort.
  */
 declare function orderAccountsByQuota(accounts: ProxyPassthroughAccount[], now: number): ProxyPassthroughAccount[];
 /**
@@ -95,6 +109,8 @@ export declare const __testHooks: {
     planCooldownFor429: typeof planCooldownFor429;
     orderAccountsByQuota: typeof orderAccountsByQuota;
     resetEpochToMs: typeof resetEpochToMs;
+    seedRuntimeQuotasFromDisk: typeof seedRuntimeQuotasFromDisk;
+    getAccountRuntimeState: (key: string) => RuntimeAccountState | undefined;
     setConfiguredPrimaryAccountKey: (key: string | undefined) => void;
     getConfiguredPrimaryAccountKey: () => string | undefined;
     setPrimaryAccountIndex: (index: number) => void;

package/dist/lib/server/routes/claudeProxyRoutes.js

@@ -13,7 +13,7 @@ import { access, readFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { buildStableClaudeCodeBillingHeader, CLAUDE_CLI_USER_AGENT, CLAUDE_CODE_OAUTH_BETAS, getOrCreateClaudeCodeIdentity, parseClaudeCodeUserId, } from "../../auth/anthropicOAuth.js";
-import { parseQuotaHeaders, saveAccountQuota, } from "../../proxy/accountQuota.js";
+import { loadAccountQuotas, parseQuotaHeaders, saveAccountQuota, } from "../../proxy/accountQuota.js";
 import { buildClaudeError, ClaudeStreamSerializer, generateToolUseId, parseClaudeRequest, serializeClaudeResponse, } from "../../proxy/claudeFormat.js";
 import { buildAnthropicModelsListResponse, buildTranslationOptions, extractText, extractToolArgs, extractUsageFromStreamResult, handleTranslatedJsonRequest, handleTranslatedStreamRequest, hasTranslatedOutput, } from "../../proxy/proxyTranslationEngine.js";
 import { tracers } from "../../telemetry/tracers.js";
@@ -242,6 +242,30 @@ function maybeCoolFromQuota(state, quota, now) {
         logger.always(`[proxy] proactively cooling account (${reason}) ~${minutesUntil(clamped, now)}m from success-response quota (status rejected)`);
     }
 }
+/**
+ * Seed each account's runtime quota from the persisted snapshots in
+ * ~/.neurolink/account-quotas.json (keyed by label). Runtime state is
+ * in-memory only, so without this the quota-aware ordering is blind after a
+ * proxy restart: all accounts tie, selection falls back to token-store
+ * enumeration order, and the first account served becomes self-reinforcing
+ * (it alone has data) — starving the others regardless of their resets.
+ * Never overwrites fresher in-memory quota; stale disk snapshots degrade
+ * gracefully because past reset timestamps are ignored by resetEpochToMs.
+ */
+async function seedRuntimeQuotasFromDisk(accounts) {
+    try {
+        const persisted = await loadAccountQuotas();
+        for (const account of accounts) {
+            const state = getOrCreateRuntimeState(account.key);
+            if (!state.quota && persisted[account.label]) {
+                state.quota = persisted[account.label];
+            }
+        }
+    }
+    catch {
+        // Non-fatal: seeding is best-effort; ordering falls back to probe-first.
+    }
+}
 /** Quota-aware selection is on by default; disable with
  *  NEUROLINK_PROXY_QUOTA_ROUTING=off|false|0. Only affects the fill-first
  *  strategy (round-robin keeps strict rotation). */
@@ -260,6 +284,7 @@ function accountSortMetrics(accountKey, now) {
     const sessionRejected = q?.sessionStatus === "rejected" && sessionReset !== undefined;
     return {
         usable: !coolingActive && !weeklyRejected && !sessionRejected,
+        hasQuota: !!q,
         coolingUntil: st?.coolingUntil ?? 0,
         weeklyReset: weeklyReset ?? Number.POSITIVE_INFINITY,
         sessionReset: sessionReset ?? Number.POSITIVE_INFINITY,
@@ -272,14 +297,18 @@ function accountSortMetrics(accountKey, now) {
  * allowance isn't wasted, then move to accounts with longer-dated resets.
  *
  * Priority among usable accounts:
- *   1. soonest WEEKLY (7d) reset  — the scarce, use-it-or-lose-it ceiling
- *   2. soonest SESSION (5h) reset
- *   3. highest weekly utilization — finish off the one closest to done
- * Accounts with no quota data yet keep insertion order (stable sort) and sit
- * after those with a known soonest reset. Cooling/rejected accounts sort last,
- * soonest-back-to-service first, as last resort.
+ *   1. no quota data yet — probe first: one request reveals its windows and
+ *      self-corrects the ordering. (Ranking unknowns last would starve them
+ *      forever: never picked → never observed → never comparable.)
+ *   2. soonest WEEKLY (7d) reset  — the scarce, use-it-or-lose-it ceiling
+ *   3. soonest SESSION (5h) reset
+ *   4. highest weekly utilization — finish off the one closest to done
+ *   5. configured primary account, then insertion order
+ * Cooling/rejected accounts sort last, soonest-back-to-service first, as
+ * last resort.
  */
 function orderAccountsByQuota(accounts, now) {
+    const primaryKey = configuredPrimaryAccountKey;
     return [...accounts].sort((a, b) => {
         const ma = accountSortMetrics(a.key, now);
         const mb = accountSortMetrics(b.key, now);
@@ -291,13 +320,22 @@ function orderAccountsByQuota(accounts, now) {
             const bu = mb.coolingUntil || Number.POSITIVE_INFINITY;
             return au - bu;
         }
+        if (ma.hasQuota !== mb.hasQuota) {
+            return ma.hasQuota ? 1 : -1;
+        }
         if (ma.weeklyReset !== mb.weeklyReset) {
             return ma.weeklyReset - mb.weeklyReset;
         }
         if (ma.sessionReset !== mb.sessionReset) {
             return ma.sessionReset - mb.sessionReset;
         }
-        return mb.weeklyUsed - ma.weeklyUsed;
+        if (ma.weeklyUsed !== mb.weeklyUsed) {
+            return mb.weeklyUsed - ma.weeklyUsed;
+        }
+        if (primaryKey && (a.key === primaryKey) !== (b.key === primaryKey)) {
+            return a.key === primaryKey ? -1 : 1;
+        }
+        return 0;
     });
 }
 // ---------------------------------------------------------------------------
@@ -1280,6 +1318,7 @@ async function loadClaudeProxyAccounts(args) {
         state.lastToken = account.token;
         state.lastRefreshToken = account.refreshToken;
     }
+    await seedRuntimeQuotasFromDisk(accounts);
     const enabledAccounts = accounts.filter((account) => {
         return !getOrCreateRuntimeState(account.key).permanentlyDisabled;
     });
@@ -3777,6 +3816,11 @@ export const __testHooks = {
     planCooldownFor429,
     orderAccountsByQuota,
     resetEpochToMs,
+    seedRuntimeQuotasFromDisk,
+    getAccountRuntimeState: (key) => {
+        const state = accountRuntimeState.get(key);
+        return state ? { ...state } : undefined;
+    },
     setConfiguredPrimaryAccountKey: (key) => {
         configuredPrimaryAccountKey = key;
     },

package/dist/lib/types/common.d.ts

@@ -223,6 +223,11 @@ export type RawUsageObject = {
     cacheReadInputTokens?: number;
     cacheCreationTokens?: number;
     cacheReadTokens?: number;
+    cachedInputTokens?: number;
+    inputTokenDetails?: {
+        cacheReadTokens?: number;
+        cacheWriteTokens?: number;
+    };
     prompt_tokens_details?: {
         cached_tokens?: number;
     };
@@ -232,6 +237,18 @@ export type RawUsageObject = {
     thinkingTokens?: number;
     usage?: RawUsageObject;
 };
+/**
+ * Aggregated usage resolved by a provider's deferred-analytics pair after a
+ * multi-step stream loop ends. The cache fields are optional — only providers
+ * with prompt caching (Anthropic) populate them.
+ */
+export type DeferredUsage = {
+    promptTokens: number;
+    completionTokens: number;
+    totalTokens: number;
+    cacheReadTokens?: number;
+    cacheCreationTokens?: number;
+};
 /**
  * Options for token extraction from raw usage objects.
  */

package/dist/lib/utils/anthropicCacheBreakpoints.d.ts

@@ -1,4 +1,6 @@
-import type { VertexAnthropicCacheInput, VertexAnthropicCacheOutput } from "../types/index.js";
+import type { VertexAnthropicCacheInput, VertexAnthropicCacheOutput, VertexAnthropicMessage } from "../types/index.js";
+/** Anthropic allows at most four `cache_control` breakpoints per request. */
+export declare const ANTHROPIC_MAX_CACHE_BREAKPOINTS = 4;
 /**
  * Annotate a native Vertex+Claude request with prompt-cache breakpoints.
  *
@@ -13,3 +15,29 @@ import type { VertexAnthropicCacheInput, VertexAnthropicCacheOutput } from "../t
  * Pure: the inputs are cloned, never mutated.
  */
 export declare function applyVertexAnthropicCacheBreakpoints(input: VertexAnthropicCacheInput): VertexAnthropicCacheOutput;
+/**
+ * Count the `cache_control` markers already present on a request. The direct
+ * Anthropic path (AI-SDK pipeline) arrives with markers the upstream layers
+ * placed — MessageBuilder tags the system prompt, GenerationHandler tags the
+ * last tool definition, and message content blocks may carry translated
+ * AI-SDK markers. Anthropic rejects requests with more than four markers, so
+ * any additional history breakpoints must fit in the remaining budget.
+ */
+export declare function countAnthropicCacheMarkers(input: {
+    system?: string | ReadonlyArray<{
+        cache_control?: unknown;
+    }> | undefined;
+    tools?: ReadonlyArray<{
+        cache_control?: unknown;
+    }> | undefined;
+    messages: ReadonlyArray<VertexAnthropicMessage>;
+}): number;
+/**
+ * Rolling history breakpoints for request paths whose stable-prefix markers
+ * are managed upstream (direct Anthropic: system via MessageBuilder, last
+ * tool via GenerationHandler). Marks the last content block of up to `budget`
+ * tail messages; a tail block that already carries a marker is left as-is
+ * without consuming budget (it already serves as that breakpoint). Pure —
+ * the input array is cloned, never mutated.
+ */
+export declare function applyAnthropicHistoryCacheBreakpoints(input: ReadonlyArray<VertexAnthropicMessage>, budget: number): VertexAnthropicMessage[];

package/dist/lib/utils/anthropicCacheBreakpoints.js

@@ -16,7 +16,8 @@
  */
 const EPHEMERAL = { type: "ephemeral" };
 /** Anthropic allows at most four `cache_control` breakpoints per request. */
-const MAX_BREAKPOINTS = 4;
+export const ANTHROPIC_MAX_CACHE_BREAKPOINTS = 4;
+const MAX_BREAKPOINTS = ANTHROPIC_MAX_CACHE_BREAKPOINTS;
 /**
  * Annotate a native Vertex+Claude request with prompt-cache breakpoints.
  *
@@ -60,6 +61,58 @@ export function applyVertexAnthropicCacheBreakpoints(input) {
     }
     return { system, tools, messages };
 }
+/**
+ * Count the `cache_control` markers already present on a request. The direct
+ * Anthropic path (AI-SDK pipeline) arrives with markers the upstream layers
+ * placed — MessageBuilder tags the system prompt, GenerationHandler tags the
+ * last tool definition, and message content blocks may carry translated
+ * AI-SDK markers. Anthropic rejects requests with more than four markers, so
+ * any additional history breakpoints must fit in the remaining budget.
+ */
+export function countAnthropicCacheMarkers(input) {
+    let count = 0;
+    if (Array.isArray(input.system)) {
+        count += input.system.filter((b) => b.cache_control).length;
+    }
+    if (input.tools) {
+        count += input.tools.filter((t) => t.cache_control).length;
+    }
+    for (const message of input.messages) {
+        if (Array.isArray(message.content)) {
+            count += message.content.filter((b) => b.cache_control).length;
+        }
+    }
+    return count;
+}
+/**
+ * Rolling history breakpoints for request paths whose stable-prefix markers
+ * are managed upstream (direct Anthropic: system via MessageBuilder, last
+ * tool via GenerationHandler). Marks the last content block of up to `budget`
+ * tail messages; a tail block that already carries a marker is left as-is
+ * without consuming budget (it already serves as that breakpoint). Pure —
+ * the input array is cloned, never mutated.
+ */
+export function applyAnthropicHistoryCacheBreakpoints(input, budget) {
+    const messages = input.map((m) => ({ ...m }));
+    let remaining = Math.max(0, Math.min(budget, MAX_BREAKPOINTS));
+    for (let i = messages.length - 1; i >= 0 && remaining > 0; i--) {
+        if (lastContentBlockHasMarker(messages[i])) {
+            continue;
+        }
+        if (markLastContentBlock(messages, i)) {
+            remaining--;
+        }
+    }
+    return messages;
+}
+/** True when the last content block of a message already carries `cache_control`. */
+function lastContentBlockHasMarker(message) {
+    if (!Array.isArray(message.content) || message.content.length === 0) {
+        return false;
+    }
+    const last = message.content[message.content.length - 1];
+    return !!last.cache_control;
+}
 /**
  * Place a cache breakpoint on the last content block of `messages[i]`.
  * Anthropic attaches `cache_control` to a content block, not the message

package/dist/lib/utils/tokenUtils.d.ts

@@ -30,12 +30,17 @@ export declare function extractTotalTokens(usage: RawUsageObject, input: number,
 export declare function extractReasoningTokens(usage: RawUsageObject): number | undefined;
 /**
  * Extract cache creation token count from various provider formats
- * Supports: cacheCreationInputTokens, cacheCreationTokens
+ * Supports: cacheCreationInputTokens, cacheCreationTokens, and the ai@6
+ * normalized `inputTokenDetails.cacheWriteTokens` (the only shape the native
+ * direct-Anthropic path reports through generateText).
  */
 export declare function extractCacheCreationTokens(usage: RawUsageObject): number | undefined;
 /**
  * Extract cache read token count from various provider formats
- * Supports: cacheReadInputTokens, cacheReadTokens
+ * Supports: cacheReadInputTokens, cacheReadTokens, and the ai@6 normalized
+ * shapes — flat `cachedInputTokens` and nested
+ * `inputTokenDetails.cacheReadTokens` (the only shapes the native
+ * direct-Anthropic path reports through generateText).
  */
 export declare function extractCacheReadTokens(usage: RawUsageObject): number | undefined;
 /**

package/dist/lib/utils/tokenUtils.js

@@ -74,7 +74,9 @@ export function extractReasoningTokens(usage) {
 }
 /**
  * Extract cache creation token count from various provider formats
- * Supports: cacheCreationInputTokens, cacheCreationTokens
+ * Supports: cacheCreationInputTokens, cacheCreationTokens, and the ai@6
+ * normalized `inputTokenDetails.cacheWriteTokens` (the only shape the native
+ * direct-Anthropic path reports through generateText).
  */
 export function extractCacheCreationTokens(usage) {
     if (typeof usage.cacheCreationInputTokens === "number" &&
@@ -85,11 +87,18 @@ export function extractCacheCreationTokens(usage) {
         usage.cacheCreationTokens > 0) {
         return usage.cacheCreationTokens;
     }
+    if (typeof usage.inputTokenDetails?.cacheWriteTokens === "number" &&
+        usage.inputTokenDetails.cacheWriteTokens > 0) {
+        return usage.inputTokenDetails.cacheWriteTokens;
+    }
     return undefined;
 }
 /**
  * Extract cache read token count from various provider formats
- * Supports: cacheReadInputTokens, cacheReadTokens
+ * Supports: cacheReadInputTokens, cacheReadTokens, and the ai@6 normalized
+ * shapes — flat `cachedInputTokens` and nested
+ * `inputTokenDetails.cacheReadTokens` (the only shapes the native
+ * direct-Anthropic path reports through generateText).
  */
 export function extractCacheReadTokens(usage) {
     if (typeof usage.cacheReadInputTokens === "number" &&
@@ -99,6 +108,14 @@ export function extractCacheReadTokens(usage) {
     if (typeof usage.cacheReadTokens === "number" && usage.cacheReadTokens > 0) {
         return usage.cacheReadTokens;
     }
+    if (typeof usage.cachedInputTokens === "number" &&
+        usage.cachedInputTokens > 0) {
+        return usage.cachedInputTokens;
+    }
+    if (typeof usage.inputTokenDetails?.cacheReadTokens === "number" &&
+        usage.inputTokenDetails.cacheReadTokens > 0) {
+        return usage.inputTokenDetails.cacheReadTokens;
+    }
     return undefined;
 }
 /**

package/dist/providers/anthropic.js

@@ -13,6 +13,7 @@ import { createProxyFetch } from "../proxy/proxyFetch.js";
 import { AuthenticationError, NetworkError, ProviderError, RateLimitError, } from "../types/index.js";
 import { logger } from "../utils/logger.js";
 import { redactUrlCredentials } from "../utils/logSanitize.js";
+import { ANTHROPIC_MAX_CACHE_BREAKPOINTS, applyAnthropicHistoryCacheBreakpoints, countAnthropicCacheMarkers, } from "../utils/anthropicCacheBreakpoints.js";
 import { calculateCost } from "../utils/pricing.js";
 import { createAnthropicConfig, getProviderModel, validateApiKey, } from "../utils/providerConfig.js";
 import { composeAbortSignals, createTimeoutController, mergeAbortSignals, TimeoutError, } from "../utils/timeout.js";
@@ -1123,9 +1124,23 @@ export class AnthropicProvider extends BaseProvider {
                 }
                 // Extended thinking passthrough (providerOptions.anthropic.thinking).
                 const thinking = options.providerOptions?.anthropic?.thinking;
+                // Prompt-cache parity with the native Vertex+Claude path: upstream
+                // layers mark only the stable prefix (system via MessageBuilder,
+                // last tool via GenerationHandler) — the growing conversation
+                // history has no breakpoint, so on every turn it falls after the
+                // last marker and is re-billed as fresh input. Add rolling history
+                // breakpoints in whatever budget remains under Anthropic's
+                // four-marker ceiling; pre-existing markers are counted so the
+                // request can never exceed the cap.
+                const cacheMarkersUsed = countAnthropicCacheMarkers({
+                    system,
+                    tools,
+                    messages: messages,
+                });
+                const cachedMessages = applyAnthropicHistoryCacheBreakpoints(messages, ANTHROPIC_MAX_CACHE_BREAKPOINTS - cacheMarkersUsed);
                 const params = {
                     model: modelId,
-                    messages,
+                    messages: cachedMessages,
                     max_tokens: resolveClaudeMaxTokens(modelId, options.maxOutputTokens),
                     ...(system ? { system } : {}),
                     ...(options.temperature !== undefined &&
@@ -1345,10 +1360,19 @@ export class AnthropicProvider extends BaseProvider {
             .then((usage) => {
             streamSpan.setAttribute("gen_ai.usage.input_tokens", usage.promptTokens || 0);
             streamSpan.setAttribute("gen_ai.usage.output_tokens", usage.completionTokens || 0);
+            if (usage.cacheReadTokens) {
+                streamSpan.setAttribute("gen_ai.usage.cached_input_tokens", usage.cacheReadTokens);
+            }
             const cost = calculateCost(this.providerName, this.modelName, {
                 input: usage.promptTokens || 0,
                 output: usage.completionTokens || 0,
                 total: usage.totalTokens || 0,
+                ...(usage.cacheReadTokens
+                    ? { cacheReadTokens: usage.cacheReadTokens }
+                    : {}),
+                ...(usage.cacheCreationTokens
+                    ? { cacheCreationTokens: usage.cacheCreationTokens }
+                    : {}),
             });
             if (cost && cost > 0) {
                 streamSpan.setAttribute("neurolink.cost", cost);
@@ -1372,11 +1396,26 @@ export class AnthropicProvider extends BaseProvider {
             const conversation = payload.messages.slice();
             let totalInput = 0;
             let totalOutput = 0;
+            let totalCacheRead = 0;
+            let totalCacheWrite = 0;
             let lastStop = null;
             for (let step = 0; step < maxSteps; step++) {
+                // Prompt-cache parity with the native Vertex+Claude path — rolling
+                // history breakpoints, re-applied per step so the stable prefix
+                // stays byte-identical while the breakpoint follows the growing
+                // tail. Budget respects markers upstream layers already placed
+                // (system / last tool / message blocks) so the request never
+                // exceeds Anthropic's four-marker cap. Pure: `conversation` itself
+                // is never mutated, so re-counting per step stays stable.
+                const cacheMarkersUsed = countAnthropicCacheMarkers({
+                    system: payload.system,
+                    tools: anthropicTools,
+                    messages: conversation,
+                });
+                const cachedConversation = applyAnthropicHistoryCacheBreakpoints(conversation, ANTHROPIC_MAX_CACHE_BREAKPOINTS - cacheMarkersUsed);
                 const params = {
                     model: modelId,
-                    messages: conversation,
+                    messages: cachedConversation,
                     max_tokens: resolveClaudeMaxTokens(modelId, options.maxTokens),
                     stream: true,
                     ...(payload.system ? { system: payload.system } : {}),
@@ -1406,6 +1445,12 @@ export class AnthropicProvider extends BaseProvider {
                     if (event.type === "message_start") {
                         totalInput += event.message.usage.input_tokens ?? 0;
                         totalOutput += event.message.usage.output_tokens ?? 0;
+                        // Anthropic reports cache reads/writes SEPARATELY from
+                        // input_tokens on the same message_start event — without these
+                        // the streaming path silently drops all cache accounting.
+                        totalCacheRead += event.message.usage.cache_read_input_tokens ?? 0;
+                        totalCacheWrite +=
+                            event.message.usage.cache_creation_input_tokens ?? 0;
                     }
                     else if (event.type === "content_block_start") {
                         blockTypes.set(event.index, event.content_block.type);
@@ -1578,7 +1623,11 @@ export class AnthropicProvider extends BaseProvider {
             resolveUsage({
                 promptTokens: totalInput,
                 completionTokens: totalOutput,
-                totalTokens: totalInput + totalOutput,
+                totalTokens: totalInput + totalCacheRead + totalCacheWrite + totalOutput,
+                ...(totalCacheRead > 0 ? { cacheReadTokens: totalCacheRead } : {}),
+                ...(totalCacheWrite > 0
+                    ? { cacheCreationTokens: totalCacheWrite }
+                    : {}),
             });
             resolveFinish(lastStop ?? "stop");
         };