@juspay/neurolink 10.6.3 → 10.6.5

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,
     };
 }
 /**

package/dist/providers/googleVertex.js

@@ -1469,11 +1469,14 @@ export class GoogleVertexProvider extends BaseProvider {
         // into a provider "prompt too long" rejection mid-loop.
         const contextGuard = createContextGuard(getContextWindowSize("vertex", modelName));
         let hitContextLimit = false;
-        // Track token usage across all steps
-        // promptTokenCount is typically in the final chunk, candidatesTokenCount accumulates
+        // Track token usage across all steps. Every loop step is a separate
+        // billed API call, so per-step usage is folded into these turn totals
+        // after each step's chunk drain — assigning them directly from chunk
+        // metadata would record only the last step of a multi-step tool loop.
         let totalInputTokens = 0;
         let totalOutputTokens = 0;
         let totalCacheReadTokens = 0;
+        let totalReasoningTokens = 0;
         // Track text parts as they arrive from the SDK so the returned async
         // iterable yields multiple chunks instead of a single buffered chunk.
         // The CLI's chunk-count smoke test asserts > 1 stream chunks for any
@@ -1557,6 +1560,18 @@ export class GoogleVertexProvider extends BaseProvider {
                     // lastFinishReason) — drives the single MALFORMED_FUNCTION_CALL
                     // retry below.
                     let stepFinishReason;
+                    // Per-step usage trackers for WRITE-THROUGH accumulation: within a
+                    // step's chunk stream the counts are latest-wins (promptTokenCount
+                    // arrives once in the final chunk; candidates/thoughts counts are
+                    // cumulative across chunks), so each chunk folds only the DELTA
+                    // over this step's previous value into the turn totals. The totals
+                    // are therefore correct at every point mid-drain — a step killed
+                    // mid-stream (abort / turn deadline / stall watchdog) still counts
+                    // the billed tokens it already reported.
+                    let stepInputTokens = 0;
+                    let stepOutputTokens = 0;
+                    let stepCacheReadTokens = 0;
+                    let stepReasoningTokens = 0;
                     for await (const chunk of stream) {
                         turnClock.noteProgress();
                         // Extract raw parts from candidates FIRST
@@ -1591,18 +1606,34 @@ export class GoogleVertexProvider extends BaseProvider {
                             // Take the latest promptTokenCount (usually only in final chunk)
                             if (usageMetadata.promptTokenCount !== undefined &&
                                 usageMetadata.promptTokenCount > 0) {
-                                totalInputTokens = usageMetadata.promptTokenCount;
+                                totalInputTokens +=
+                                    usageMetadata.promptTokenCount - stepInputTokens;
+                                stepInputTokens = usageMetadata.promptTokenCount;
                                 // Feed the context guard the REAL prompt size of this call.
                                 contextGuard.noteUsage(usageMetadata.promptTokenCount, usageMetadata.candidatesTokenCount ?? 0);
                                 // cachedContentTokenCount is OVERLAPPING (a subset already inside
-                                // promptTokenCount). Clamp to the prompt count so a later uncached
-                                // step resets it to 0 instead of leaving a stale cached value.
-                                totalCacheReadTokens = Math.min(usageMetadata.cachedContentTokenCount ?? 0, usageMetadata.promptTokenCount);
+                                // promptTokenCount). Clamp to the prompt count so an uncached
+                                // step reports 0 instead of a stale cached value.
+                                const chunkCacheReadTokens = Math.min(usageMetadata.cachedContentTokenCount ?? 0, usageMetadata.promptTokenCount);
+                                totalCacheReadTokens +=
+                                    chunkCacheReadTokens - stepCacheReadTokens;
+                                stepCacheReadTokens = chunkCacheReadTokens;
                             }
                             // Take the latest candidatesTokenCount (accumulates through chunks)
                             if (usageMetadata.candidatesTokenCount !== undefined &&
                                 usageMetadata.candidatesTokenCount > 0) {
-                                totalOutputTokens = usageMetadata.candidatesTokenCount;
+                                totalOutputTokens +=
+                                    usageMetadata.candidatesTokenCount - stepOutputTokens;
+                                stepOutputTokens = usageMetadata.candidatesTokenCount;
+                            }
+                            // thoughtsTokenCount (thinking tokens, billed at the output
+                            // rate) is NOT part of candidatesTokenCount — Gemini reports
+                            // totalTokenCount = prompt + candidates + thoughts.
+                            if (usageMetadata.thoughtsTokenCount !== undefined &&
+                                usageMetadata.thoughtsTokenCount > 0) {
+                                totalReasoningTokens +=
+                                    usageMetadata.thoughtsTokenCount - stepReasoningTokens;
+                                stepReasoningTokens = usageMetadata.thoughtsTokenCount;
                             }
                         }
                     }
@@ -1991,6 +2022,7 @@ export class GoogleVertexProvider extends BaseProvider {
                         incrementalTextChunks.push(synth.text);
                         totalInputTokens += synth.inputTokens;
                         totalOutputTokens += synth.outputTokens;
+                        totalReasoningTokens += synth.reasoningTokens ?? 0;
                         if (synth.finishReason) {
                             lastFinishReason = synth.finishReason;
                         }
@@ -2069,11 +2101,22 @@ export class GoogleVertexProvider extends BaseProvider {
             rawFinishReason: lastFinishReason,
             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 (totalTokenCount = prompt +
+                // candidates + thoughts), so they are folded into `output` — that is
+                // what calculateCost bills at the output rate — with `reasoning`
+                // reporting the thinking subset.
+                output: totalOutputTokens + totalReasoningTokens,
+                total: adjustedInputTokens +
+                    totalCacheReadTokens +
+                    totalOutputTokens +
+                    totalReasoningTokens,
                 ...(totalCacheReadTokens > 0 && {
                     cacheReadTokens: totalCacheReadTokens,
                 }),
+                ...(totalReasoningTokens > 0 && {
+                    reasoning: totalReasoningTokens,
+                }),
             },
             toolCalls: externalToolCalls.map((tc) => ({
                 toolName: tc.toolName,
@@ -2409,11 +2452,14 @@ export class GoogleVertexProvider extends BaseProvider {
         // into a provider "prompt too long" rejection mid-loop.
         const contextGuard = createContextGuard(getContextWindowSize("vertex", modelName));
         let hitContextLimit = false;
-        // Track token usage across all steps
-        // promptTokenCount is typically in the final chunk, candidatesTokenCount accumulates
+        // Track token usage across all steps. Every loop step is a separate
+        // billed API call, so per-step usage is folded into these turn totals
+        // after each step's chunk drain — assigning them directly from chunk
+        // metadata would record only the last step of a multi-step tool loop.
         let totalInputTokens = 0;
         let totalOutputTokens = 0;
         let totalCacheReadTokens = 0;
+        let totalReasoningTokens = 0;
         // Abort scaffolding (mirrors executeNativeAnthropicStream). The native
         // Gemini SDK cancels via config.abortSignal, so drive an internal
         // AbortController: the caller's signal and the turn clock's watchdogs
@@ -2488,6 +2534,18 @@ export class GoogleVertexProvider extends BaseProvider {
                     // lastFinishReason) — drives the single MALFORMED_FUNCTION_CALL
                     // retry below.
                     let stepFinishReason;
+                    // Per-step usage trackers for WRITE-THROUGH accumulation: within a
+                    // step's chunk stream the counts are latest-wins (promptTokenCount
+                    // arrives once in the final chunk; candidates/thoughts counts are
+                    // cumulative across chunks), so each chunk folds only the DELTA
+                    // over this step's previous value into the turn totals. The totals
+                    // are therefore correct at every point mid-drain — a step killed
+                    // mid-stream (abort / turn deadline / stall watchdog) still counts
+                    // the billed tokens it already reported.
+                    let stepInputTokens = 0;
+                    let stepOutputTokens = 0;
+                    let stepCacheReadTokens = 0;
+                    let stepReasoningTokens = 0;
                     // Collect all chunks from stream
                     for await (const chunk of stream) {
                         turnClock.noteProgress();
@@ -2518,18 +2576,34 @@ export class GoogleVertexProvider extends BaseProvider {
                             // Take the latest promptTokenCount (usually only in final chunk)
                             if (usageMetadata.promptTokenCount !== undefined &&
                                 usageMetadata.promptTokenCount > 0) {
-                                totalInputTokens = usageMetadata.promptTokenCount;
+                                totalInputTokens +=
+                                    usageMetadata.promptTokenCount - stepInputTokens;
+                                stepInputTokens = usageMetadata.promptTokenCount;
                                 // Feed the context guard the REAL prompt size of this call.
                                 contextGuard.noteUsage(usageMetadata.promptTokenCount, usageMetadata.candidatesTokenCount ?? 0);
                                 // cachedContentTokenCount is OVERLAPPING (a subset already inside
-                                // promptTokenCount). Clamp to the prompt count so a later uncached
-                                // step resets it to 0 instead of leaving a stale cached value.
-                                totalCacheReadTokens = Math.min(usageMetadata.cachedContentTokenCount ?? 0, usageMetadata.promptTokenCount);
+                                // promptTokenCount). Clamp to the prompt count so an uncached
+                                // step reports 0 instead of a stale cached value.
+                                const chunkCacheReadTokens = Math.min(usageMetadata.cachedContentTokenCount ?? 0, usageMetadata.promptTokenCount);
+                                totalCacheReadTokens +=
+                                    chunkCacheReadTokens - stepCacheReadTokens;
+                                stepCacheReadTokens = chunkCacheReadTokens;
                             }
                             // Take the latest candidatesTokenCount (accumulates through chunks)
                             if (usageMetadata.candidatesTokenCount !== undefined &&
                                 usageMetadata.candidatesTokenCount > 0) {
-                                totalOutputTokens = usageMetadata.candidatesTokenCount;
+                                totalOutputTokens +=
+                                    usageMetadata.candidatesTokenCount - stepOutputTokens;
+                                stepOutputTokens = usageMetadata.candidatesTokenCount;
+                            }
+                            // thoughtsTokenCount (thinking tokens, billed at the output
+                            // rate) is NOT part of candidatesTokenCount — Gemini reports
+                            // totalTokenCount = prompt + candidates + thoughts.
+                            if (usageMetadata.thoughtsTokenCount !== undefined &&
+                                usageMetadata.thoughtsTokenCount > 0) {
+                                totalReasoningTokens +=
+                                    usageMetadata.thoughtsTokenCount - stepReasoningTokens;
+                                stepReasoningTokens = usageMetadata.thoughtsTokenCount;
                             }
                         }
                     }
@@ -2912,6 +2986,7 @@ export class GoogleVertexProvider extends BaseProvider {
                         finalText = synth.text;
                         totalInputTokens += synth.inputTokens;
                         totalOutputTokens += synth.outputTokens;
+                        totalReasoningTokens += synth.reasoningTokens ?? 0;
                         if (synth.finishReason) {
                             lastFinishReason = synth.finishReason;
                         }
@@ -2974,12 +3049,26 @@ export class GoogleVertexProvider extends BaseProvider {
             stepsUsed: step,
             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 (totalTokenCount = prompt +
+                // candidates + thoughts), so they are folded into `output` — that is
+                // what calculateCost bills at the output rate — with `reasoning`
+                // reporting the thinking subset.
+                output: totalOutputTokens + totalReasoningTokens,
+                total: adjustedInputTokens +
+                    totalCacheReadTokens +
+                    totalOutputTokens +
+                    totalReasoningTokens,
                 ...(totalCacheReadTokens > 0 && {
                     cacheReadTokens: totalCacheReadTokens,
                 }),
+                ...(totalReasoningTokens > 0 && {
+                    reasoning: totalReasoningTokens,
+                }),
             },
+            ...(totalReasoningTokens > 0 && {
+                reasoningTokens: totalReasoningTokens,
+            }),
             responseTime,
             toolsUsed: externalToolCalls.map((tc) => tc.toolName),
             toolExecutions: resolveToolExecutionRecords(options, externalToolExecutions),
@@ -3016,7 +3105,7 @@ export class GoogleVertexProvider extends BaseProvider {
         // Already aborted — never issue the synth request (would add +300s after a
         // blown budget). Return empty so the caller maps to the graceful message.
         if (abortSignal?.aborted) {
-            return { text: "", inputTokens: 0, outputTokens: 0 };
+            return { text: "", inputTokens: 0, outputTokens: 0, reasoningTokens: 0 };
         }
         try {
             // Shallow clone so the loop's config is never mutated; dropping the
@@ -3053,6 +3142,7 @@ export class GoogleVertexProvider extends BaseProvider {
                 let finishReason;
                 let inputTokens = 0;
                 let outputTokens = 0;
+                let reasoningTokens = 0;
                 for await (const chunk of stream) {
                     const chunkRecord = chunk;
                     const candidates = chunkRecord.candidates;
@@ -3075,18 +3165,28 @@ export class GoogleVertexProvider extends BaseProvider {
                             usageMetadata.candidatesTokenCount > 0) {
                             outputTokens = usageMetadata.candidatesTokenCount;
                         }
+                        if (usageMetadata.thoughtsTokenCount !== undefined &&
+                            usageMetadata.thoughtsTokenCount > 0) {
+                            reasoningTokens = usageMetadata.thoughtsTokenCount;
+                        }
                     }
                 }
                 const text = parts
                     .filter((part) => typeof part.text === "string")
                     .map((part) => part.text)
                     .join("");
-                return { text, finishReason, inputTokens, outputTokens };
+                return {
+                    text,
+                    finishReason,
+                    inputTokens,
+                    outputTokens,
+                    reasoningTokens,
+                };
             })(), timeoutMs, "Gemini synthesis call timed out");
         }
         catch (error) {
             logger.warn("[GoogleVertex] Tools-disabled synthesis call failed; falling back to placeholder", { error: error instanceof Error ? error.message : String(error) });
-            return { text: "", inputTokens: 0, outputTokens: 0 };
+            return { text: "", inputTokens: 0, outputTokens: 0, reasoningTokens: 0 };
         }
     }
     /**
@@ -3651,7 +3751,14 @@ export class GoogleVertexProvider extends BaseProvider {
                         turnCacheUsage.creation1h += stepCacheCreation1h;
                         usage.input += response.usage?.input_tokens || 0;
                         usage.output += response.usage?.output_tokens || 0;
-                        usage.total = usage.input + usage.output;
+                        // Anthropic's input_tokens is only the UNCACHED remainder; cache
+                        // reads/writes are billed tokens reported separately, so the
+                        // total must include them (matches proxyTracer + anthropic.ts).
+                        usage.total =
+                            usage.input +
+                                usage.output +
+                                turnCacheUsage.read +
+                                turnCacheUsage.creation;
                         lastStopReason = response.stop_reason;
                         // Feed the context guard the FULL prompt size of this call
                         // (uncached input + cache reads/writes).
@@ -4102,7 +4209,6 @@ export class GoogleVertexProvider extends BaseProvider {
                             activeStream = undefined;
                             usage.input += response.usage?.input_tokens || 0;
                             usage.output += response.usage?.output_tokens || 0;
-                            usage.total = usage.input + usage.output;
                             turnCacheUsage.read +=
                                 response.usage?.cache_read_input_tokens ?? 0;
                             turnCacheUsage.creation +=
@@ -4111,6 +4217,13 @@ export class GoogleVertexProvider extends BaseProvider {
                                 response.usage?.cache_creation?.ephemeral_5m_input_tokens ?? 0;
                             turnCacheUsage.creation1h +=
                                 response.usage?.cache_creation?.ephemeral_1h_input_tokens ?? 0;
+                            // Total counts cache reads/writes — input_tokens is only the
+                            // uncached remainder.
+                            usage.total =
+                                usage.input +
+                                    usage.output +
+                                    turnCacheUsage.read +
+                                    turnCacheUsage.creation;
                             lastStopReason = response.stop_reason;
                             const forcedFinalResult = response.content.find((block) => block.type === "tool_use" && block.name === "final_result");
                             if (forcedFinalResult) {
@@ -4196,7 +4309,6 @@ export class GoogleVertexProvider extends BaseProvider {
                                 activeStream = undefined;
                                 usage.input += response.usage?.input_tokens || 0;
                                 usage.output += response.usage?.output_tokens || 0;
-                                usage.total = usage.input + usage.output;
                                 turnCacheUsage.read +=
                                     response.usage?.cache_read_input_tokens ?? 0;
                                 turnCacheUsage.creation +=
@@ -4207,6 +4319,13 @@ export class GoogleVertexProvider extends BaseProvider {
                                 turnCacheUsage.creation1h +=
                                     response.usage?.cache_creation?.ephemeral_1h_input_tokens ??
                                         0;
+                                // Total counts cache reads/writes — input_tokens is only the
+                                // uncached remainder.
+                                usage.total =
+                                    usage.input +
+                                        usage.output +
+                                        turnCacheUsage.read +
+                                        turnCacheUsage.creation;
                                 lastStopReason = response.stop_reason;
                                 const backstopText = response.content
                                     .filter((block) => block.type === "text")
@@ -5408,7 +5527,13 @@ export class GoogleVertexProvider extends BaseProvider {
             usage: {
                 input: totalInputTokens,
                 output: totalOutputTokens,
-                total: totalInputTokens + totalOutputTokens,
+                // Anthropic's input_tokens is only the UNCACHED remainder; cache
+                // reads/writes are billed tokens reported separately, so the total
+                // must include them (matches proxyTracer + anthropic.ts).
+                total: totalInputTokens +
+                    totalOutputTokens +
+                    totalCacheReadTokens +
+                    totalCacheCreationTokens,
                 ...(totalCacheReadTokens > 0 && {
                     cacheReadTokens: totalCacheReadTokens,
                 }),

package/dist/providers/litellm.js

@@ -283,12 +283,23 @@ export class LiteLLMProvider extends OpenAIChatCompletionsProvider {
         };
         return {
             onUsage: (usage) => {
-                span.setAttribute("gen_ai.usage.input_tokens", usage.promptTokens);
+                // promptTokens is the uncached remainder — the attribute reports the
+                // full prompt (uncached + cache read/creation), and the cache fields
+                // let calculateCost price tiers.
+                span.setAttribute("gen_ai.usage.input_tokens", usage.promptTokens +
+                    (usage.cacheReadTokens ?? 0) +
+                    (usage.cacheCreationTokens ?? 0));
                 span.setAttribute("gen_ai.usage.output_tokens", usage.completionTokens);
-                const cost = calculateCost(this.providerName, this.modelName, {
+                const cost = calculateCost(this.providerName, modelId, {
                     input: usage.promptTokens,
                     output: usage.completionTokens,
                     total: usage.totalTokens,
+                    ...(usage.cacheReadTokens
+                        ? { cacheReadTokens: usage.cacheReadTokens }
+                        : {}),
+                    ...(usage.cacheCreationTokens
+                        ? { cacheCreationTokens: usage.cacheCreationTokens }
+                        : {}),
                 });
                 if (cost && cost > 0) {
                     span.setAttribute("neurolink.cost", cost);

package/dist/providers/openAI.js

@@ -157,12 +157,23 @@ export class OpenAIProvider extends OpenAIChatCompletionsProvider {
         };
         return {
             onUsage: (usage) => {
-                span.setAttribute("gen_ai.usage.input_tokens", usage.promptTokens);
+                // promptTokens is the uncached remainder — the attribute reports the
+                // full prompt (uncached + cache read/creation), and the cache fields
+                // let calculateCost price tiers.
+                span.setAttribute("gen_ai.usage.input_tokens", usage.promptTokens +
+                    (usage.cacheReadTokens ?? 0) +
+                    (usage.cacheCreationTokens ?? 0));
                 span.setAttribute("gen_ai.usage.output_tokens", usage.completionTokens);
-                const cost = calculateCost(this.providerName, this.modelName, {
+                const cost = calculateCost(this.providerName, modelId, {
                     input: usage.promptTokens,
                     output: usage.completionTokens,
                     total: usage.totalTokens,
+                    ...(usage.cacheReadTokens
+                        ? { cacheReadTokens: usage.cacheReadTokens }
+                        : {}),
+                    ...(usage.cacheCreationTokens
+                        ? { cacheCreationTokens: usage.cacheCreationTokens }
+                        : {}),
                 });
                 if (cost && cost > 0) {
                     span.setAttribute("neurolink.cost", cost);

package/dist/providers/openaiChatCompletionsBase.js

@@ -505,8 +505,21 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
                     usage: {
                         inputTokens: {
                             total: json.usage?.prompt_tokens,
-                            noCache: json.usage?.prompt_tokens,
-                            cacheRead: undefined,
+                            // cached_tokens is OVERLAPPING (a subset of prompt_tokens), so
+                            // noCache is the remainder and cacheRead is clamped to the
+                            // prompt total — some gateways report inconsistent usage where
+                            // cached_tokens exceeds prompt_tokens (mirrors the
+                            // reasoning_tokens clamp on the output side below).
+                            noCache: json.usage?.prompt_tokens !== undefined &&
+                                json.usage?.prompt_tokens_details?.cached_tokens !== undefined
+                                ? Math.max(0, json.usage.prompt_tokens -
+                                    json.usage.prompt_tokens_details.cached_tokens)
+                                : json.usage?.prompt_tokens,
+                            cacheRead: json.usage?.prompt_tokens !== undefined &&
+                                json.usage?.prompt_tokens_details?.cached_tokens !== undefined
+                                ? Math.min(json.usage.prompt_tokens_details.cached_tokens, json.usage.prompt_tokens)
+                                : json.usage?.prompt_tokens_details?.cached_tokens,
+                            // OpenAI-style APIs do not report cache writes.
                             cacheWrite: undefined,
                         },
                         outputTokens: {
@@ -727,9 +740,33 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
     }
     async runStreamLoop(args) {
         const { maxSteps, modelId, url, fetchImpl, abortSignal, options, conversation, openAITools, openAIToolChoice, toolsRecord, toolNameFromWire, emitter, toolsUsed, toolExecutionSummaries, pushChunk, resolveUsage, resolveFinish, } = args;
+        // Hoisted above the try so the catch can resolve the usage accumulated
+        // by steps that completed BEFORE the failure — those steps were billed.
+        let stepFinish = null;
+        let stepUsage;
+        // Aggregated DeferredUsage from whatever accumulated in stepUsage.
+        // prompt_tokens is OVERLAPPING with cached_tokens (a subset), so the
+        // uncached remainder goes in promptTokens and the cached part in
+        // cacheReadTokens — the non-overlapping convention extractTokenUsage
+        // and calculateCost expect. reasoning_tokens stays a subset of
+        // completionTokens (informational).
+        const toDeferredUsage = () => {
+            const promptTokens = stepUsage?.prompt_tokens ?? 0;
+            const completionTokens = stepUsage?.completion_tokens ?? 0;
+            const cachedTokens = Math.min(stepUsage?.prompt_tokens_details?.cached_tokens ?? 0, promptTokens);
+            // Clamped like cached_tokens above: reasoning is a SUBSET of
+            // completion_tokens, but some gateways report inconsistent values.
+            const reasoningTokens = Math.min(Math.max(0, stepUsage?.completion_tokens_details?.reasoning_tokens ?? 0), completionTokens);
+            return {
+                promptTokens: promptTokens - cachedTokens,
+                completionTokens,
+                // Gateways that omit total_tokens must not collapse to 0.
+                totalTokens: stepUsage?.total_tokens || promptTokens + completionTokens,
+                ...(cachedTokens > 0 ? { cacheReadTokens: cachedTokens } : {}),
+                ...(reasoningTokens > 0 ? { reasoningTokens } : {}),
+            };
+        };
         try {
-            let stepFinish = null;
-            let stepUsage;
             // May grow mid-turn: hydrated tools with wire-unsafe names need
             // reverse-mapping even when the initial name set required none.
             let effectiveToolNameFromWire = toolNameFromWire;
@@ -787,11 +824,7 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
                     options,
                 });
             }
-            resolveUsage({
-                promptTokens: stepUsage?.prompt_tokens ?? 0,
-                completionTokens: stepUsage?.completion_tokens ?? 0,
-                totalTokens: stepUsage?.total_tokens ?? 0,
-            });
+            resolveUsage(toDeferredUsage());
             resolveFinish(stepFinish ?? "stop");
             pushChunk({ done: true });
             return {
@@ -803,7 +836,9 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
             logger.error(`${this.providerName}: Stream error`, {
                 error: err instanceof Error ? err.message : String(err),
             });
-            resolveUsage({ promptTokens: 0, completionTokens: 0, totalTokens: 0 });
+            // Steps that completed before the failure were billed — report them
+            // instead of zeroing the whole turn.
+            resolveUsage(toDeferredUsage());
             resolveFinish("error");
             pushChunk({ done: true });
             throw err;

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, DeferredUsage, Tool } from "../types/index.js";
+import type { OpenAICompatBuildBodyArgs, OpenAICompatChatMessage, OpenAICompatChatRequest, OpenAICompatChatTool, OpenAICompatMessage, OpenAICompatMessageContent, OpenAICompatResponseFormat, OpenAICompatSSEResult, OpenAICompatStreamChunk, OpenAICompatToolChoiceWire, OpenAICompatUsage, OpenAICompatV3CallToolChoice, OpenAICompatV3CallTools, DeferredUsage, Tool } from "../types/index.js";
 export declare const stripTrailingSlash: (s: string) => string;
 /**
  * Build a bijective original ↔ wire tool-name map. Returns undefined when
@@ -71,16 +71,4 @@ export declare const createChunkQueue: () => {
     pushChunk: (c: OpenAICompatStreamChunk) => void;
     nextChunk: () => Promise<OpenAICompatStreamChunk>;
 };
-export declare const mergeUsage: (a: {
-    prompt_tokens?: number;
-    completion_tokens?: number;
-    total_tokens?: number;
-} | undefined, b: {
-    prompt_tokens?: number;
-    completion_tokens?: number;
-    total_tokens?: number;
-} | undefined) => {
-    prompt_tokens?: number;
-    completion_tokens?: number;
-    total_tokens?: number;
-} | undefined;
+export declare const mergeUsage: (a: OpenAICompatUsage | undefined, b: OpenAICompatUsage | undefined) => OpenAICompatUsage | undefined;