@juspay/neurolink 9.86.1 → 9.86.3

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/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");
         };

package/dist/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/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/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/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/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;
 /**