@juspay/neurolink 10.6.4 → 10.7.0

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() {

package/dist/providers/googleAiStudio.js

@@ -591,6 +591,7 @@ export class GoogleAIStudioProvider extends BaseProvider {
                     let totalInputTokens = 0;
                     let totalOutputTokens = 0;
                     let totalCacheReadTokens = 0;
+                    let totalReasoningTokens = 0;
                     let step = 0;
                     let completedWithFinalAnswer = false;
                     const failedTools = new Map();
@@ -627,6 +628,7 @@ export class GoogleAIStudioProvider extends BaseProvider {
                                 totalInputTokens += chunkResult.inputTokens;
                                 totalOutputTokens += chunkResult.outputTokens;
                                 totalCacheReadTokens += chunkResult.cacheReadTokens ?? 0;
+                                totalReasoningTokens += chunkResult.reasoningTokens ?? 0;
                                 const stepText = extractTextFromParts(chunkResult.rawResponseParts);
                                 // If no function calls, this was the final step — channel
                                 // already received all text parts incrementally.
@@ -723,13 +725,21 @@ export class GoogleAIStudioProvider extends BaseProvider {
                             model: modelName,
                             tokenUsage: {
                                 input: adjustedInputTokens,
-                                output: totalOutputTokens,
+                                // Thinking tokens are billed at the output rate but Gemini
+                                // does NOT include them in candidatesTokenCount, so they
+                                // are folded into `output` — what calculateCost bills at
+                                // the output rate — with `reasoning` as the subset.
+                                output: totalOutputTokens + totalReasoningTokens,
                                 total: adjustedInputTokens +
                                     totalCacheReadTokens +
-                                    totalOutputTokens,
+                                    totalOutputTokens +
+                                    totalReasoningTokens,
                                 ...(totalCacheReadTokens > 0
                                     ? { cacheReadTokens: totalCacheReadTokens }
                                     : {}),
+                                ...(totalReasoningTokens > 0
+                                    ? { reasoning: totalReasoningTokens }
+                                    : {}),
                             },
                             requestDuration: responseTime,
                             timestamp: new Date().toISOString(),
@@ -862,6 +872,7 @@ export class GoogleAIStudioProvider extends BaseProvider {
                 let totalInputTokens = 0;
                 let totalOutputTokens = 0;
                 let totalCacheReadTokens = 0;
+                let totalReasoningTokens = 0;
                 const allToolCalls = [];
                 const toolExecutions = [];
                 let step = 0;
@@ -892,6 +903,7 @@ export class GoogleAIStudioProvider extends BaseProvider {
                         totalInputTokens += chunkResult.inputTokens;
                         totalOutputTokens += chunkResult.outputTokens;
                         totalCacheReadTokens += chunkResult.cacheReadTokens ?? 0;
+                        totalReasoningTokens += chunkResult.reasoningTokens ?? 0;
                         const stepText = extractTextFromParts(chunkResult.rawResponseParts);
                         // If no function calls, we're done
                         if (chunkResult.stepFunctionCalls.length === 0) {
@@ -975,12 +987,25 @@ export class GoogleAIStudioProvider extends BaseProvider {
                     model: modelName,
                     usage: {
                         input: adjustedInputTokens,
-                        output: totalOutputTokens,
-                        total: adjustedInputTokens + totalCacheReadTokens + totalOutputTokens,
+                        // Thinking tokens are billed at the output rate but Gemini
+                        // does NOT include them in candidatesTokenCount, so they are
+                        // folded into `output` — what calculateCost bills at the
+                        // output rate — with `reasoning` as the subset.
+                        output: totalOutputTokens + totalReasoningTokens,
+                        total: adjustedInputTokens +
+                            totalCacheReadTokens +
+                            totalOutputTokens +
+                            totalReasoningTokens,
                         ...(totalCacheReadTokens > 0
                             ? { cacheReadTokens: totalCacheReadTokens }
                             : {}),
+                        ...(totalReasoningTokens > 0
+                            ? { reasoning: totalReasoningTokens }
+                            : {}),
                     },
+                    ...(totalReasoningTokens > 0 && {
+                        reasoningTokens: totalReasoningTokens,
+                    }),
                     responseTime,
                     toolsUsed: allToolCalls.map((tc) => tc.toolName),
                     toolExecutions: resolveToolExecutionRecords(options, toolExecutions),

package/dist/providers/googleNativeGemini3.js

@@ -601,6 +601,7 @@ export async function collectStreamChunks(stream) {
     let inputTokens = 0;
     let outputTokens = 0;
     let cacheReadTokens = 0;
+    let reasoningTokens = 0;
     for await (const chunk of stream) {
         // Extract raw parts from candidates FIRST
         // This avoids using chunk.text which triggers SDK warning when
@@ -623,6 +624,9 @@ export async function collectStreamChunks(stream) {
             // cachedContentTokenCount is OVERLAPPING (a subset already inside
             // promptTokenCount). Surface it so the call site subtracts once.
             cacheReadTokens = Math.max(cacheReadTokens, usage.cachedContentTokenCount || 0);
+            // thoughtsTokenCount (thinking tokens, billed at the output rate) is
+            // NOT part of candidatesTokenCount — surface it separately.
+            reasoningTokens = Math.max(reasoningTokens, usage.thoughtsTokenCount || 0);
         }
     }
     return {
@@ -631,6 +635,7 @@ export async function collectStreamChunks(stream) {
         inputTokens,
         outputTokens,
         cacheReadTokens,
+        reasoningTokens,
     };
 }
 /**
@@ -724,6 +729,7 @@ export async function collectStreamChunksIncremental(stream, channel) {
     let inputTokens = 0;
     let outputTokens = 0;
     let cacheReadTokens = 0;
+    let reasoningTokens = 0;
     for await (const chunk of stream) {
         const chunkRecord = chunk;
         const candidates = chunkRecord.candidates;
@@ -748,6 +754,9 @@ export async function collectStreamChunksIncremental(stream, channel) {
             // cachedContentTokenCount is OVERLAPPING (a subset already inside
             // promptTokenCount). Surface it so the call site subtracts once.
             cacheReadTokens = Math.max(cacheReadTokens, usage.cachedContentTokenCount || 0);
+            // thoughtsTokenCount (thinking tokens, billed at the output rate) is
+            // NOT part of candidatesTokenCount — surface it separately.
+            reasoningTokens = Math.max(reasoningTokens, usage.thoughtsTokenCount || 0);
         }
     }
     return {
@@ -756,6 +765,7 @@ export async function collectStreamChunksIncremental(stream, channel) {
         inputTokens,
         outputTokens,
         cacheReadTokens,
+        reasoningTokens,
     };
 }
 /**