@juspay/neurolink 10.6.3 → 10.6.5

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