@juspay/neurolink 12.23.1 → 12.23.3

package/dist/core/nativeGenerateLoop.js

@@ -215,9 +215,19 @@ export async function runNativeGenerateLoop(args, toolExecutionSummaries) {
             rawFinishReason = shaped.raw ?? rawFinishReason;
         }
         const usage = res.usage;
-        inputTokens += readTotal(usage?.inputTokens);
         outputTokens += readTotal(usage?.outputTokens);
         const inShaped = usage?.inputTokens;
+        // `total` on the shaped input-tokens object is cache-INCLUSIVE (noCache +
+        // cacheRead + cacheWrite). Accumulating it into `inputTokens` — while ALSO
+        // accumulating cacheRead/cacheWrite below — double-billed every cached
+        // token: once folded into `input`, once again as the flat cache fields
+        // `calculateCost` prices separately. `noCache` is the disjoint figure
+        // `calculateCost` expects; fall back to the inclusive total only when a
+        // provider hasn't populated `noCache` (i.e. it never reports cache usage).
+        inputTokens +=
+            typeof inShaped?.noCache === "number"
+                ? inShaped.noCache
+                : readTotal(usage?.inputTokens);
         cacheReadTokens += inShaped?.cacheRead ?? 0;
         cacheWriteTokens += inShaped?.cacheWrite ?? 0;
         const calls = parts.filter((p) => p.type === "tool-call");

package/dist/providers/anthropic/client.js

@@ -1564,7 +1564,13 @@ export class AnthropicProvider extends BaseProvider {
             usage: {
                 input: loop.inputTokens,
                 output: loop.outputTokens,
-                total: loop.inputTokens + loop.outputTokens,
+                // `inputTokens` is now the disjoint (uncached) figure, so cache
+                // tokens must be added back in to keep `total` billing-complete —
+                // they are additive on top of input under Anthropic's convention.
+                total: loop.inputTokens +
+                    loop.outputTokens +
+                    loop.cacheReadTokens +
+                    loop.cacheWriteTokens,
                 ...(loop.cacheReadTokens
                     ? { cacheReadTokens: loop.cacheReadTokens }
                     : {}),

package/dist/providers/openaiChatCompletionsBase.js

@@ -1055,7 +1055,14 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
             usage: {
                 input: inputTokens,
                 output: outputTokens,
-                total: inputTokens + outputTokens,
+                // `inputTokens` is the disjoint (uncached) figure — doGenerate
+                // already subtracts the overlapping prompt_tokens_details.cached_tokens
+                // subset before handing it to the loop — so cache tokens must be
+                // added back in here to keep `total` billing-complete.
+                total: inputTokens +
+                    outputTokens +
+                    loop.cacheReadTokens +
+                    loop.cacheWriteTokens,
                 // doGenerate reads prompt_tokens_details.cached_tokens, and the loop
                 // carries the counters out; discarding them here billed cached input
                 // at the full rate in calculateCost and made cache effectiveness
@@ -1492,10 +1499,18 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
                 if (!loopPromise) {
                     const input = part.usage.inputTokens.total ?? 0;
                     const output = part.usage.outputTokens.total ?? 0;
+                    // `total` is cache-INCLUSIVE (OpenAI-style prompt_tokens), so the
+                    // cached portion has to be split out here the same way
+                    // doGenerate/toDeferredUsage do — otherwise this branch bills the
+                    // cached tokens at the full input rate instead of the cheaper
+                    // cacheRead rate. Clamped like the other call sites in this file
+                    // in case a gateway reports cacheRead > total.
+                    const cacheRead = Math.min(part.usage.inputTokens.cacheRead ?? 0, input);
                     resolveUsage({
-                        promptTokens: input,
+                        promptTokens: input - cacheRead,
                         completionTokens: output,
                         totalTokens: input + output,
+                        ...(cacheRead > 0 ? { cacheReadTokens: cacheRead } : {}),
                     });
                     resolveFinish(part.finishReason.unified);
                 }