@juspay/neurolink 10.6.4 → 10.6.5

package/dist/providers/openaiChatCompletionsClient.js

@@ -673,9 +673,28 @@ export const mergeUsage = (a, b) => {
     if (!b) {
         return a;
     }
+    // Sum the nested details too — narrowing to the three flat scalars here
+    // silently dropped cached_tokens / reasoning_tokens the first time two
+    // steps were merged (single-step streams passed the object through
+    // untouched, so the loss only showed up in multi-step tool loops).
+    const cachedTokens = (a.prompt_tokens_details?.cached_tokens ?? 0) +
+        (b.prompt_tokens_details?.cached_tokens ?? 0);
+    const reasoningTokens = (a.completion_tokens_details?.reasoning_tokens ?? 0) +
+        (b.completion_tokens_details?.reasoning_tokens ?? 0);
+    // A step that omits total_tokens contributes its prompt+completion sum
+    // instead of 0 — otherwise one totals-reporting step next to one that
+    // omits it yields a nonzero-but-partial aggregate that downstream
+    // consumers trust over their own prompt+completion fallback.
+    const stepTotal = (u) => u.total_tokens || (u.prompt_tokens ?? 0) + (u.completion_tokens ?? 0);
     return {
         prompt_tokens: (a.prompt_tokens ?? 0) + (b.prompt_tokens ?? 0),
         completion_tokens: (a.completion_tokens ?? 0) + (b.completion_tokens ?? 0),
-        total_tokens: (a.total_tokens ?? 0) + (b.total_tokens ?? 0),
+        total_tokens: stepTotal(a) + stepTotal(b),
+        ...(cachedTokens > 0
+            ? { prompt_tokens_details: { cached_tokens: cachedTokens } }
+            : {}),
+        ...(reasoningTokens > 0
+            ? { completion_tokens_details: { reasoning_tokens: reasoningTokens } }
+            : {}),
     };
 };

package/dist/providers/sagemaker/language-model.js

@@ -7,7 +7,7 @@
 import { randomUUID } from "crypto";
 import { SageMakerRuntimeClient } from "./client.js";
 import { handleSageMakerError } from "./errors.js";
-import { estimateTokenUsage, createSageMakerStream } from "./streaming.js";
+import { estimateTokenUsage, createSageMakerStream, parseUsageFromResponseBody, } from "./streaming.js";
 import { createAdaptiveSemaphore } from "./adaptive-semaphore.js";
 import { logger } from "../../utils/logger.js";
 /**
@@ -140,8 +140,10 @@ export class SageMakerLanguageModel {
             const generatedText = this.extractTextFromResponse(responseBody);
             // Extract tool calls if present (Phase 4 enhancement)
             const toolCalls = this.extractToolCallsFromResponse(responseBody);
-            // Calculate token usage
-            const usage = estimateTokenUsage(promptText, generatedText);
+            // Prefer the endpoint's REAL token counts; only fall back to the
+            // char-heuristic estimate when the response reports none.
+            const usage = parseUsageFromResponseBody(responseBody) ??
+                estimateTokenUsage(promptText, generatedText);
             // Determine finish reason based on response content
             let finishReason = "stop";
             if (toolCalls && toolCalls.length > 0) {

package/dist/providers/sagemaker/parsers.js

@@ -276,10 +276,13 @@ export class HuggingFaceStreamParser extends BaseStreamingParser {
             return undefined;
         }
         const tokens = details.tokens;
+        const promptTokens = Number(tokens.input) || 0;
+        const completionTokens = Number(tokens.generated) || 0;
         return {
-            promptTokens: Number(tokens.input) || 0,
-            completionTokens: Number(tokens.generated) || 0,
-            total: Number(tokens.total) || 0,
+            promptTokens,
+            completionTokens,
+            // Endpoints that omit the total must not report 0 next to real counts.
+            total: Number(tokens.total) || promptTokens + completionTokens,
         };
     }
     mapFinishReason(reason) {
@@ -447,10 +450,13 @@ export class LlamaStreamParser extends BaseStreamingParser {
         return toolCall;
     }
     parseLlamaUsage(usage) {
+        const promptTokens = Number(usage.prompt_tokens) || 0;
+        const completionTokens = Number(usage.completion_tokens) || 0;
         return {
-            promptTokens: Number(usage.prompt_tokens) || 0,
-            completionTokens: Number(usage.completion_tokens) || 0,
-            total: Number(usage.total_tokens) || 0,
+            promptTokens,
+            completionTokens,
+            // Endpoints that omit total_tokens must not report 0 next to real counts.
+            total: Number(usage.total_tokens) || promptTokens + completionTokens,
         };
     }
     mapFinishReason(reason) {
@@ -569,10 +575,13 @@ export class CustomStreamParser extends BaseStreamingParser {
     }
     parseCustomUsage(data) {
         const usage = (data.usage || data.tokens || {});
+        const promptTokens = Number(usage.prompt_tokens || usage.input_tokens) || 0;
+        const completionTokens = Number(usage.completion_tokens || usage.output_tokens) || 0;
         return {
-            promptTokens: Number(usage.prompt_tokens || usage.input_tokens) || 0,
-            completionTokens: Number(usage.completion_tokens || usage.output_tokens) || 0,
-            total: Number(usage.total_tokens) || 0,
+            promptTokens,
+            completionTokens,
+            // Endpoints that omit total_tokens must not report 0 next to real counts.
+            total: Number(usage.total_tokens) || promptTokens + completionTokens,
         };
     }
 }

package/dist/providers/sagemaker/streaming.d.ts

@@ -29,6 +29,15 @@ export declare function createSyntheticStream(text: string, usage: SageMakerUsag
     onChunk?: (chunk: SageMakerStreamChunk) => void;
     onComplete?: (usage: SageMakerUsage) => void;
 }): Promise<ReadableStream<unknown>>;
+/**
+ * Extract REAL token usage from a complete (non-streaming) SageMaker
+ * response body when the endpoint reports it. Covers the OpenAI-compatible
+ * shape (vLLM / TGI-OpenAI: usage.prompt_tokens/completion_tokens), the
+ * generic input_tokens/output_tokens shape, and the HuggingFace TGI shape
+ * (details.tokens.input/generated). Returns undefined when no real counts
+ * are present so callers can fall back to estimateTokenUsage.
+ */
+export declare function parseUsageFromResponseBody(body: Record<string, unknown> | Array<Record<string, unknown>>): SageMakerUsage | undefined;
 /**
  * Estimate token usage from text content
  *

package/dist/providers/sagemaker/streaming.js

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

package/dist/types/common.d.ts

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

package/dist/types/openaiCompatible.d.ts

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

package/dist/types/providers.d.ts

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

package/dist/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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "10.6.4",
+  "version": "10.6.5",
   "packageManager": "pnpm@10.15.1",
   "description": "TypeScript AI SDK with 24+ LLM providers behind one consistent API. MCP-native (connect any MCP server), voice TTS/STT/realtime, RAG, agents, memory, context compaction. OpenAI · Anthropic · Gemini · Bedrock · Azure · Ollama · DeepSeek · NVIDIA NIM and more.",
   "author": {
@@ -104,6 +104,7 @@
     "test:google-native": "npx tsx test/continuous-test-suite-google-native.ts",
     "test:gemini-abort": "npx tsx test/continuous-test-suite-gemini-abort.ts",
     "test:anthropic-cap": "npx tsx test/continuous-test-suite-anthropic-cap.ts",
+    "test:token-usage": "npx tsx test/continuous-test-suite-token-usage.ts",
     "test:tts": "npx tsx test/continuous-test-suite-tts.ts",
     "test:voice": "npx tsx test/continuous-test-suite-voice.ts",
     "test:voice-server": "npx tsx test/continuous-test-suite-voice-server.ts",