@juspay/neurolink 10.6.4 → 10.6.5

package/dist/lib/providers/sagemaker/streaming.js

@@ -87,12 +87,12 @@ async function createProtocolSpecificStream(responseStream, parser, capability,
                     if (done) {
                         // Stream ended - send final chunk if needed
                         if (!finalUsage && accumulatedText) {
-                            finalUsage = estimateTokenUsage("", accumulatedText);
+                            finalUsage = estimateTokenUsage(options.prompt ?? "", accumulatedText);
                         }
                         const finalChunk = {
                             type: "finish",
                             finishReason: "stop",
-                            usage: finalUsage,
+                            usage: toLanguageModelV2Usage(finalUsage),
                         };
                         controller.enqueue(finalChunk);
                         options.onComplete?.(finalUsage || {
@@ -182,11 +182,11 @@ async function createProtocolSpecificStream(responseStream, parser, capability,
                         if (parser.isComplete(chunk)) {
                             finalUsage =
                                 parser.extractUsage(chunk) ||
-                                    estimateTokenUsage("", accumulatedText);
+                                    estimateTokenUsage(options.prompt ?? "", accumulatedText);
                             const finalChunk = {
                                 type: "finish",
                                 finishReason: chunk.finishReason || "stop",
-                                usage: finalUsage,
+                                usage: toLanguageModelV2Usage(finalUsage),
                             };
                             controller.enqueue(finalChunk);
                             options.onComplete?.(finalUsage);
@@ -271,7 +271,7 @@ async function createSyntheticStreamFromResponse(responseStream, options) {
                 const finalChunk = {
                     type: "finish",
                     finishReason: "stop",
-                    usage,
+                    usage: toLanguageModelV2Usage(usage),
                 };
                 controller.enqueue(finalChunk);
                 options.onComplete?.(usage);
@@ -305,7 +305,7 @@ export async function createSyntheticStream(text, usage, options = {}) {
             const finalChunk = {
                 type: "finish",
                 finishReason: "stop",
-                usage,
+                usage: toLanguageModelV2Usage(usage),
             };
             controller.enqueue(finalChunk);
             options.onComplete?.(usage);
@@ -313,6 +313,64 @@ export async function createSyntheticStream(text, usage, options = {}) {
         },
     });
 }
+/**
+ * Map the internal SageMakerUsage shape to AI SDK v2 usage keys. Stream
+ * finish parts previously carried promptTokens/completionTokens, but the
+ * SDK's v2→v3 bridge reads inputTokens/outputTokens/totalTokens — every
+ * streamed SageMaker turn resolved to undefined (zero) usage.
+ */
+function toLanguageModelV2Usage(usage) {
+    const inputTokens = usage?.promptTokens ?? 0;
+    const outputTokens = usage?.completionTokens ?? 0;
+    return {
+        inputTokens,
+        outputTokens,
+        totalTokens: usage?.total || inputTokens + outputTokens,
+    };
+}
+/**
+ * Extract REAL token usage from a complete (non-streaming) SageMaker
+ * response body when the endpoint reports it. Covers the OpenAI-compatible
+ * shape (vLLM / TGI-OpenAI: usage.prompt_tokens/completion_tokens), the
+ * generic input_tokens/output_tokens shape, and the HuggingFace TGI shape
+ * (details.tokens.input/generated). Returns undefined when no real counts
+ * are present so callers can fall back to estimateTokenUsage.
+ */
+export function parseUsageFromResponseBody(body) {
+    // TGI-style endpoints wrap the response in an array
+    // ([{ generated_text, details: { tokens } }]) — normalize to the first
+    // item so those endpoints get real usage instead of the char estimate.
+    const responseBody = Array.isArray(body) ? body[0] : body;
+    if (!responseBody || typeof responseBody !== "object") {
+        return undefined;
+    }
+    const usageRecord = (responseBody.usage ?? responseBody.tokens);
+    if (usageRecord && typeof usageRecord === "object") {
+        const promptTokens = Number(usageRecord.prompt_tokens ?? usageRecord.input_tokens) || 0;
+        const completionTokens = Number(usageRecord.completion_tokens ?? usageRecord.output_tokens) || 0;
+        if (promptTokens > 0 || completionTokens > 0) {
+            return {
+                promptTokens,
+                completionTokens,
+                total: Number(usageRecord.total_tokens) || promptTokens + completionTokens,
+            };
+        }
+    }
+    const details = responseBody.details;
+    const tokens = details?.tokens;
+    if (tokens && typeof tokens === "object") {
+        const promptTokens = Number(tokens.input) || 0;
+        const completionTokens = Number(tokens.generated) || 0;
+        if (promptTokens > 0 || completionTokens > 0) {
+            return {
+                promptTokens,
+                completionTokens,
+                total: Number(tokens.total) || promptTokens + completionTokens,
+            };
+        }
+    }
+    return undefined;
+}
 /**
  * Estimate token usage from text content
  *

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

@@ -225,6 +225,7 @@ export type RawUsageObject = {
     cacheReadTokens?: number;
     cachedInputTokens?: number;
     inputTokenDetails?: {
+        noCacheTokens?: number;
         cacheReadTokens?: number;
         cacheWriteTokens?: number;
     };
@@ -248,6 +249,8 @@ export type DeferredUsage = {
     totalTokens: number;
     cacheReadTokens?: number;
     cacheCreationTokens?: number;
+    /** Reasoning/thinking tokens — a SUBSET already included in completionTokens. */
+    reasoningTokens?: number;
 };
 /**
  * Options for token extraction from raw usage objects.

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

@@ -1,4 +1,4 @@
-import type { NeuroLinkEvents, TypedEventEmitter } from "./common.js";
+import type { DeferredUsage, NeuroLinkEvents, TypedEventEmitter } from "./common.js";
 import type { JSONSchema7 } from "./middleware.js";
 import type { LanguageModelV3, LanguageModelV3CallOptions } from "./middleware.js";
 import type { StreamOptions } from "./stream.js";
@@ -271,12 +271,13 @@ export type OpenAICompatBuildBodyArgs = {
  * the deferred analytics promises.
  */
 export type OpenAICompatStreamLifecycleListeners = {
-    /** Fired once the deferred usage promise resolves with the final aggregated token counts. */
-    onUsage?: (usage: {
-        promptTokens: number;
-        completionTokens: number;
-        totalTokens: number;
-    }) => void;
+    /**
+     * Fired once the deferred usage promise resolves with the final aggregated
+     * token counts. promptTokens is the UNCACHED remainder; cacheReadTokens
+     * carries the cached portion (non-overlapping convention), and
+     * reasoningTokens is a subset of completionTokens.
+     */
+    onUsage?: (usage: DeferredUsage) => void;
     /**
      * Fired once the deferred finish promise resolves. `reason` is "stop",
      * "length", "tool-calls", "content-filter", or "error". When the loop

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

@@ -1623,6 +1623,12 @@ export type CollectedChunkResult = {
     cacheReadTokens?: number;
     /** Cache creation tokens (symmetry; Gemini does not emit this). */
     cacheCreationTokens?: number;
+    /**
+     * Gemini thinking tokens (usageMetadata.thoughtsTokenCount). Billed at the
+     * output rate but NOT included in candidatesTokenCount — Gemini reports
+     * totalTokenCount = prompt + candidates + thoughts.
+     */
+    reasoningTokens?: number;
 };
 /** Push-based text channel for incremental streaming. */
 export type TextChannel = {

package/dist/lib/utils/pricing.js

@@ -653,15 +653,27 @@ function findRates(provider, model) {
     if (!providerPricing) {
         return undefined;
     }
+    // Bedrock model IDs carry region/vendor prefixes ("us.anthropic.claude-…",
+    // "global.anthropic.claude-…", "anthropic.claude-…") or arrive as full
+    // inference-profile ARNs ("arn:aws:bedrock:…:inference-profile/us.anthropic.
+    // claude-…" — the form this repo's own setup guides recommend). None of
+    // those match the bare pricing keys ("claude-…"), so every Bedrock call
+    // priced to $0. Strip everything up to and including the vendor prefix; the
+    // trailing "-v1:0" version suffix is absorbed by the longest-prefix match
+    // below. Non-Anthropic Bedrock models (meta./amazon./mistral.) don't match
+    // and fall through unchanged, exactly as before.
+    const modelKey = stripped === "bedrock" || stripped === "amazonbedrock"
+        ? model.replace(/^.*\banthropic\./, "")
+        : model;
     // Exact match
-    if (providerPricing[model]) {
-        return providerPricing[model];
+    if (providerPricing[modelKey]) {
+        return providerPricing[modelKey];
     }
     // Longest-prefix match (skip the synthetic "_default" sentinel below)
     const sortedKeys = Object.keys(providerPricing)
         .filter((k) => k !== "_default")
         .sort((a, b) => b.length - a.length);
-    const key = sortedKeys.find((k) => model.startsWith(k));
+    const key = sortedKeys.find((k) => modelKey.startsWith(k));
     if (key) {
         return providerPricing[key];
     }

package/dist/lib/utils/tokenUtils.js

@@ -44,10 +44,13 @@ export function extractOutputTokens(usage) {
  * Falls back to input + output if total is not provided
  */
 export function extractTotalTokens(usage, input, output) {
-    if (typeof usage.total === "number") {
+    // A literal 0 alongside non-zero components means the provider omitted the
+    // figure (several gateways/parsers emit total: 0) — fall through to the
+    // computed sum instead of letting the zero win.
+    if (typeof usage.total === "number" && usage.total > 0) {
         return usage.total;
     }
-    if (typeof usage.totalTokens === "number") {
+    if (typeof usage.totalTokens === "number" && usage.totalTokens > 0) {
         return usage.totalTokens;
     }
     return input + output;
@@ -185,7 +188,6 @@ export function extractTokenUsage(result, options = {}) {
     // Extract base token counts
     let input = extractInputTokens(usage);
     const output = extractOutputTokens(usage);
-    const total = extractTotalTokens(usage, input, output);
     // Extract optional token fields
     const reasoning = extractReasoningTokens(usage);
     const cacheCreationTokens = extractCacheCreationTokens(usage);
@@ -204,6 +206,39 @@ export function extractTokenUsage(result, options = {}) {
             input = Math.max(0, input - overlappingCached);
         }
     }
+    // ai@6-shape rebase: when the cache values came ONLY from the ai@6
+    // normalized shape (cachedInputTokens / inputTokenDetails.*), the flat
+    // input is cache-INCLUSIVE — asLanguageModelUsage reports
+    // inputTokens.total = noCache + cacheRead + cacheWrite — so `input` must
+    // be rebased onto the uncached portion or calculateCost bills the cached
+    // tokens twice (full input rate + cacheRead/cacheCreation rate). The
+    // native fields excluded below (cacheReadInputTokens / cacheReadTokens /
+    // cacheCreationInputTokens / cacheCreationTokens) follow the
+    // non-overlapping convention where input is already the uncached
+    // remainder, and the overlapping snake_case shape was already rebased
+    // above — neither must be rebased again.
+    if ((cacheReadTokens !== undefined || cacheCreationTokens !== undefined) &&
+        usage.cacheReadInputTokens === undefined &&
+        usage.cacheReadTokens === undefined &&
+        usage.cacheCreationInputTokens === undefined &&
+        usage.cacheCreationTokens === undefined &&
+        usage.prompt_tokens_details?.cached_tokens === undefined &&
+        (usage.cachedInputTokens !== undefined ||
+            usage.inputTokenDetails !== undefined)) {
+        const noCacheTokens = usage.inputTokenDetails?.noCacheTokens;
+        if (typeof noCacheTokens === "number") {
+            input = noCacheTokens;
+        }
+        else {
+            input = Math.max(0, input -
+                (cacheReadTokens ?? 0) -
+                (usage.inputTokenDetails?.cacheWriteTokens ?? 0));
+        }
+    }
+    // Total: prefer the provider-reported figure; the fallback conserves every
+    // billed component — cache tokens are additive on top of the (post-rebase)
+    // uncached input. Reasoning is already inside `output`, so it is NOT added.
+    const total = extractTotalTokens(usage, input + (cacheReadTokens ?? 0) + (cacheCreationTokens ?? 0), output);
     // Calculate cache savings if enabled
     const cacheSavingsPercent = calculateCacheSavings
         ? calculateCacheSavingsPercent(cacheReadTokens, input)

package/dist/neurolink.js

@@ -2746,7 +2746,10 @@ Current user's request: ${currentInput}`;
         if (!usage || model === "unknown") {
             return undefined;
         }
-        const totalCost = calculateAdvancedCost(model, usage.input || 0, usage.output || 0, provider === "unknown" ? undefined : provider);
+        const totalCost = calculateAdvancedCost(model, usage.input || 0, usage.output || 0, provider === "unknown" ? undefined : provider, {
+            cacheReadTokens: usage.cacheReadTokens,
+            cacheCreationTokens: usage.cacheCreationTokens,
+        });
         return totalCost > 0 ? totalCost : undefined;
     }
     /**
@@ -4134,6 +4137,20 @@ Current user's request: ${currentInput}`;
                     input: textResult.usage.input || 0,
                     output: textResult.usage.output || 0,
                     total: textResult.usage.total || 0,
+                    // Optional tiers must be forwarded or they silently vanish at
+                    // this DTO boundary (cache-aware cost + savings need them).
+                    ...(textResult.usage.cacheReadTokens !== undefined && {
+                        cacheReadTokens: textResult.usage.cacheReadTokens,
+                    }),
+                    ...(textResult.usage.cacheCreationTokens !== undefined && {
+                        cacheCreationTokens: textResult.usage.cacheCreationTokens,
+                    }),
+                    ...(textResult.usage.reasoning !== undefined && {
+                        reasoning: textResult.usage.reasoning,
+                    }),
+                    ...(textResult.usage.cacheSavingsPercent !== undefined && {
+                        cacheSavingsPercent: textResult.usage.cacheSavingsPercent,
+                    }),
                 }
                 : undefined,
             responseTime: textResult.responseTime,

package/dist/providers/amazonBedrock.js

@@ -253,6 +253,8 @@ export class AmazonBedrockProvider extends BaseProvider {
         let iteration = 0;
         let totalInputTokens = 0;
         let totalOutputTokens = 0;
+        let totalCacheReadTokens = 0;
+        let totalCacheWriteTokens = 0;
         let lastFinishReason;
         while (iteration < maxIterations) {
             iteration++;
@@ -263,8 +265,12 @@ export class AmazonBedrockProvider extends BaseProvider {
                 logger.debug(`[AmazonBedrockProvider] Received Bedrock response`, JSON.stringify(response, null, 2));
                 // Accumulate real token counts and capture the stop reason so
                 // Pipeline B (Langfuse) gets correct usage and finishReason.
+                // Converse follows the Anthropic additive convention: inputTokens is
+                // the UNCACHED remainder; cache reads/writes are reported separately.
                 totalInputTokens += response.usage?.inputTokens ?? 0;
                 totalOutputTokens += response.usage?.outputTokens ?? 0;
+                totalCacheReadTokens += response.usage?.cacheReadInputTokens ?? 0;
+                totalCacheWriteTokens += response.usage?.cacheWriteInputTokens ?? 0;
                 if (response.stopReason) {
                     lastFinishReason = response.stopReason;
                 }
@@ -281,7 +287,18 @@ export class AmazonBedrockProvider extends BaseProvider {
                         usage: {
                             input: totalInputTokens,
                             output: totalOutputTokens,
-                            total: totalInputTokens + totalOutputTokens,
+                            // Cache reads/writes are billed tokens reported separately
+                            // from inputTokens — the total must include them.
+                            total: totalInputTokens +
+                                totalCacheReadTokens +
+                                totalCacheWriteTokens +
+                                totalOutputTokens,
+                            ...(totalCacheReadTokens > 0 && {
+                                cacheReadTokens: totalCacheReadTokens,
+                            }),
+                            ...(totalCacheWriteTokens > 0 && {
+                                cacheCreationTokens: totalCacheWriteTokens,
+                            }),
                         },
                         finishReason: lastFinishReason,
                     };
@@ -387,13 +404,26 @@ export class AmazonBedrockProvider extends BaseProvider {
                 const totalDuration = Date.now() - startTime;
                 logger.info(`[AmazonBedrockProvider] Total callBedrock duration: ${totalDuration}ms`);
                 generateSpan.setAttribute("gen_ai.response.stop_reason", response.stopReason ?? "");
-                generateSpan.setAttribute("gen_ai.usage.input_tokens", response.usage?.inputTokens ?? 0);
+                const spanCacheRead = response.usage?.cacheReadInputTokens ?? 0;
+                const spanCacheWrite = response.usage?.cacheWriteInputTokens ?? 0;
+                // Converse's inputTokens is only the UNCACHED remainder — the span
+                // attribute reports the FULL prompt (uncached + cache read/write)
+                // so telemetry matches the cache-inclusive pricing inputs below.
+                generateSpan.setAttribute("gen_ai.usage.input_tokens", (response.usage?.inputTokens ?? 0) + spanCacheRead + spanCacheWrite);
+                generateSpan.setAttribute("gen_ai.usage.cache_read_input_tokens", spanCacheRead);
+                generateSpan.setAttribute("gen_ai.usage.cache_creation_input_tokens", spanCacheWrite);
                 generateSpan.setAttribute("gen_ai.usage.output_tokens", response.usage?.outputTokens ?? 0);
                 const cost = calculateCost(this.providerName, this.modelName, {
                     input: response.usage?.inputTokens ?? 0,
                     output: response.usage?.outputTokens ?? 0,
                     total: (response.usage?.inputTokens ?? 0) +
+                        spanCacheRead +
+                        spanCacheWrite +
                         (response.usage?.outputTokens ?? 0),
+                    ...(spanCacheRead > 0 && { cacheReadTokens: spanCacheRead }),
+                    ...(spanCacheWrite > 0 && {
+                        cacheCreationTokens: spanCacheWrite,
+                    }),
                 });
                 if (cost && cost > 0) {
                     generateSpan.setAttribute("neurolink.cost", cost);
@@ -996,7 +1026,9 @@ export class AmazonBedrockProvider extends BaseProvider {
                     };
                     return {
                         stream: asyncIterable,
-                        usage: { total: 0, input: 0, output: 0 },
+                        // The generate() fallback already computed real usage — a
+                        // hardcoded zero object here threw it away.
+                        usage: generateResult.usage,
                         model: this.modelName || this.getDefaultModel(),
                         provider: this.getProviderName(),
                         metadata: {
@@ -1025,6 +1057,8 @@ export class AmazonBedrockProvider extends BaseProvider {
         // so Pipeline B (Langfuse) gets real token counts from Bedrock streams.
         let streamTotalInputTokens = 0;
         let streamTotalOutputTokens = 0;
+        let streamTotalCacheReadTokens = 0;
+        let streamTotalCacheWriteTokens = 0;
         let streamLastStopReason;
         // The REAL issue: ReadableStream errors don't bubble up to the caller
         // So we need to make the first streaming call synchronously to test permissions
@@ -1130,6 +1164,12 @@ export class AmazonBedrockProvider extends BaseProvider {
                                         chunk.metadata.usage.inputTokens ?? 0;
                                     streamTotalOutputTokens +=
                                         chunk.metadata.usage.outputTokens ?? 0;
+                                    // inputTokens excludes cache reads/writes (Converse follows
+                                    // the Anthropic additive convention) — track them too.
+                                    streamTotalCacheReadTokens +=
+                                        chunk.metadata.usage.cacheReadInputTokens ?? 0;
+                                    streamTotalCacheWriteTokens +=
+                                        chunk.metadata.usage.cacheWriteInputTokens ?? 0;
                                     // Stream is effectively complete after metadata chunk
                                     break;
                                 }
@@ -1177,6 +1217,8 @@ export class AmazonBedrockProvider extends BaseProvider {
                             if (usage) {
                                 streamTotalInputTokens += usage.input;
                                 streamTotalOutputTokens += usage.output;
+                                streamTotalCacheReadTokens += usage.cacheReadTokens ?? 0;
+                                streamTotalCacheWriteTokens += usage.cacheCreationTokens ?? 0;
                             }
                             if (stopReason) {
                                 streamLastStopReason = stopReason;
@@ -1248,7 +1290,18 @@ export class AmazonBedrockProvider extends BaseProvider {
                         const aggregatedUsage = {
                             input: streamTotalInputTokens,
                             output: streamTotalOutputTokens,
-                            total: streamTotalInputTokens + streamTotalOutputTokens,
+                            // Cache reads/writes are billed tokens reported separately
+                            // from inputTokens — the total must include them.
+                            total: streamTotalInputTokens +
+                                streamTotalCacheReadTokens +
+                                streamTotalCacheWriteTokens +
+                                streamTotalOutputTokens,
+                            ...(streamTotalCacheReadTokens > 0 && {
+                                cacheReadTokens: streamTotalCacheReadTokens,
+                            }),
+                            ...(streamTotalCacheWriteTokens > 0 && {
+                                cacheCreationTokens: streamTotalCacheWriteTokens,
+                            }),
                         };
                         // Resolve analytics with accumulated token counts from Bedrock
                         // metadata chunks so Pipeline A also reports real usage.
@@ -1276,7 +1329,9 @@ export class AmazonBedrockProvider extends BaseProvider {
             };
             return {
                 stream: wrappedStreamIterable,
-                usage: { total: 0, input: 0, output: 0 },
+                // No usage key here on purpose: the real aggregate resolves through
+                // `analytics` after the stream drains. A literal zero object is
+                // truthy and would block every downstream usage fallback.
                 model: this.modelName || this.getDefaultModel(),
                 provider: this.getProviderName(),
                 analytics: analyticsPromise,
@@ -1468,10 +1523,17 @@ export class AmazonBedrockProvider extends BaseProvider {
             if (chunk.metadata?.usage) {
                 const input = chunk.metadata.usage.inputTokens ?? 0;
                 const output = chunk.metadata.usage.outputTokens ?? 0;
+                const cacheRead = chunk.metadata.usage.cacheReadInputTokens ?? 0;
+                const cacheWrite = chunk.metadata.usage.cacheWriteInputTokens ?? 0;
                 streamUsage = {
                     input,
                     output,
-                    total: chunk.metadata.usage.totalTokens ?? input + output,
+                    // Computed rather than trusting totalTokens: inputTokens excludes
+                    // cache reads/writes (additive convention), and the total must
+                    // count every billed component.
+                    total: input + cacheRead + cacheWrite + output,
+                    ...(cacheRead > 0 && { cacheReadTokens: cacheRead }),
+                    ...(cacheWrite > 0 && { cacheCreationTokens: cacheWrite }),
                 };
                 // Stream is effectively complete after metadata chunk
                 break;

package/dist/providers/anthropic.js

@@ -7,6 +7,7 @@ import { ANTHROPIC_TOKEN_URL, CLAUDE_CLI_USER_AGENT, CLAUDE_CODE_CLIENT_ID, CLAU
 import { AnthropicModels, TOKEN_EXPIRY_BUFFER_MS, } from "../constants/enums.js";
 import { BaseProvider } from "../core/baseProvider.js";
 import { DEFAULT_MAX_STEPS } from "../core/constants.js";
+import { streamAnalyticsCollector } from "../core/streamAnalytics.js";
 import { getModelCapabilities, getRecommendedModelForTier, isModelAvailableForTier, } from "../models/anthropicModels.js";
 import { createOAuthFetch } from "../proxy/oauthFetch.js";
 import { createProxyFetch } from "../proxy/proxyFetch.js";
@@ -1408,13 +1409,24 @@ export class AnthropicProvider extends BaseProvider {
         let capturedProviderError;
         const client = this.client;
         const toolsUsed = [];
+        const streamStartTime = Date.now();
+        // Hoisted out of runLoop so the error path can resolve the usage
+        // accumulated by steps that completed BEFORE the failure — those steps
+        // were billed and must not be reported as zero.
+        let totalInput = 0;
+        let totalOutput = 0;
+        let totalCacheRead = 0;
+        let totalCacheWrite = 0;
+        let lastStop = null;
+        const buildDeferredUsage = () => ({
+            promptTokens: totalInput,
+            completionTokens: totalOutput,
+            totalTokens: totalInput + totalCacheRead + totalCacheWrite + totalOutput,
+            ...(totalCacheRead > 0 ? { cacheReadTokens: totalCacheRead } : {}),
+            ...(totalCacheWrite > 0 ? { cacheCreationTokens: totalCacheWrite } : {}),
+        });
         const runLoop = async () => {
             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++) {
                 // Mid-turn discovery sync: search_tools (tools.discovery) hydrates
                 // new tools into toolsRecord between steps; Claude only calls tools
@@ -1471,10 +1483,20 @@ export class AnthropicProvider extends BaseProvider {
                 const thinkingAcc = new Map();
                 const toolAcc = new Map();
                 let stopReason = null;
+                // message_start carries a small output placeholder and message_delta
+                // reports the CUMULATIVE output for the message — latest wins within
+                // the step (adding both double-counted the placeholder every step).
+                // Write-through: each event folds only the DELTA over this step's
+                // previous value into totalOutput, so the total is correct at every
+                // point mid-drain — a step killed mid-stream (abort/timeout) still
+                // counts the billed output it already reported.
+                let stepOutputTokens = 0;
                 for await (const event of events) {
                     if (event.type === "message_start") {
                         totalInput += event.message.usage.input_tokens ?? 0;
-                        totalOutput += event.message.usage.output_tokens ?? 0;
+                        const startOutputTokens = event.message.usage.output_tokens ?? 0;
+                        totalOutput += startOutputTokens - stepOutputTokens;
+                        stepOutputTokens = startOutputTokens;
                         // 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.
@@ -1526,7 +1548,9 @@ export class AnthropicProvider extends BaseProvider {
                     }
                     else if (event.type === "message_delta") {
                         stopReason = event.delta.stop_reason ?? stopReason;
-                        totalOutput += event.usage?.output_tokens ?? 0;
+                        const cumulativeOutputTokens = event.usage?.output_tokens ?? stepOutputTokens;
+                        totalOutput += cumulativeOutputTokens - stepOutputTokens;
+                        stepOutputTokens = cumulativeOutputTokens;
                     }
                 }
                 lastStop = stopReason;
@@ -1654,15 +1678,7 @@ export class AnthropicProvider extends BaseProvider {
                 });
                 conversation.push({ role: "user", content: resultBlocks });
             }
-            resolveUsage({
-                promptTokens: totalInput,
-                completionTokens: totalOutput,
-                totalTokens: totalInput + totalCacheRead + totalCacheWrite + totalOutput,
-                ...(totalCacheRead > 0 ? { cacheReadTokens: totalCacheRead } : {}),
-                ...(totalCacheWrite > 0
-                    ? { cacheCreationTokens: totalCacheWrite }
-                    : {}),
-            });
+            resolveUsage(buildDeferredUsage());
             resolveFinish(lastStop ?? "stop");
         };
         const loopPromise = runLoop()
@@ -1673,6 +1689,9 @@ export class AnthropicProvider extends BaseProvider {
             logger.error("Anthropic: Stream error", {
                 error: error instanceof Error ? error.message : String(error),
             });
+            // Report whatever the completed steps accumulated — they were billed
+            // — and unblock any consumer awaiting the usage promise.
+            resolveUsage(buildDeferredUsage());
             resolveFinish("error");
             throw this.formatProviderError(error);
         })
@@ -1734,6 +1753,21 @@ export class AnthropicProvider extends BaseProvider {
             model: this.modelName,
             toolCalls: [],
             toolResults: [],
+            // Wire the deferred usage/finish promises into the analytics collector
+            // (mirrors openaiChatCompletionsBase). Without this the loop computed a
+            // fully correct aggregate that was consumed only by the OTel span —
+            // stream consumers and session cost tracking saw no usage at all.
+            // Chained off finishPromise so requestDuration reflects the DRAINED
+            // stream, not the milliseconds it took to construct this result object.
+            analytics: finishPromise.then(() => streamAnalyticsCollector.createAnalytics(this.providerName, modelId, {
+                textStream: (async function* () { })(),
+                usage: usagePromise,
+                finishReason: finishPromise,
+            }, Date.now() - streamStartTime, {
+                requestId: options.requestId ??
+                    `${this.providerName}-stream-${Date.now()}`,
+                streamingMode: true,
+            })),
         };
     }
     async isAvailable() {