@juspay/neurolink 11.13.0 → 11.13.2

package/dist/lib/utils/tokenEstimation.js

@@ -1,187 +0,0 @@
-/**
- * Token Estimation Utilities
- *
- * Provides character-based token estimation with per-provider adjustment
- * multipliers. Uses the same approach as Continue (gpt-tokenizer baseline
- * + provider multipliers) but without requiring a tokenizer dependency.
- *
- * Multiplier sources: Continue project's getAdjustedTokenCount.ts
- * - Anthropic: 1.23x (Anthropic tokenizer produces ~23% more tokens)
- * - Google (AI Studio / Vertex): 1.18x
- * - Mistral/Codestral: 1.26x
- * - OpenAI/GPT: 1.0x (baseline)
- */
-/** Characters per token for English text */
-export const CHARS_PER_TOKEN = 4;
-/** Characters per token for code */
-export const CODE_CHARS_PER_TOKEN = 3;
-/**
- * Safety margin: additive fraction of baseTokens added to the provider-adjusted estimate.
- * Using additive margin prevents compounding with provider multipliers.
- *
- * Old behavior: baseTokens * providerMultiplier * 1.15  (compounding)
- *   e.g. Anthropic: baseTokens * 1.23 * 1.15 = baseTokens * 1.4145
- * New behavior: baseTokens * providerMultiplier + baseTokens * 0.05  (additive)
- *   e.g. Anthropic: baseTokens * 1.23 + baseTokens * 0.05 = baseTokens * 1.28
- */
-export const TOKEN_SAFETY_MARGIN_ADDITIVE = 0.05;
-/** @deprecated Use TOKEN_SAFETY_MARGIN_ADDITIVE instead. Kept for backward compatibility. */
-export const TOKEN_SAFETY_MARGIN = 1.15;
-/** Message framing overhead in tokens (role + delimiters) */
-export const TOKENS_PER_MESSAGE = 4;
-/** Conversation-level overhead in tokens */
-export const TOKENS_PER_CONVERSATION = 24;
-/** Image token estimate (flat) */
-export const IMAGE_TOKEN_ESTIMATE = 1_024;
-/**
- * Chars charged for a value that cannot be serialized for estimation (V8 max
- * string length). Deliberately large: such a value is enormous by definition,
- * and under-charging it would defeat the budget check it feeds.
- */
-const OVERSIZED_VALUE_FALLBACK_CHARS = 200_000;
-/**
- * Per-provider token multipliers.
- * Applied on top of the base GPT-style character estimate.
- */
-const PROVIDER_MULTIPLIERS = {
-    anthropic: 1.23,
-    "google-ai": 1.18,
-    vertex: 1.18,
-    mistral: 1.26,
-    openai: 1.0,
-    azure: 1.0,
-    bedrock: 1.23, // Bedrock is mostly Anthropic models
-    ollama: 1.0,
-    litellm: 1.0,
-    huggingface: 1.0,
-    sagemaker: 1.0,
-};
-/**
- * Get the token multiplier for a given provider.
- */
-export function getProviderMultiplier(provider) {
-    if (!provider) {
-        return 1.0;
-    }
-    return PROVIDER_MULTIPLIERS[provider] ?? 1.0;
-}
-/**
- * Estimate token count for a string.
- *
- * @param text - Input text
- * @param provider - Optional provider for multiplier adjustment
- * @param isCode - Whether the text is code (uses CODE_CHARS_PER_TOKEN)
- * @returns Estimated token count
- */
-export function estimateTokens(text, provider, isCode) {
-    if (!text || text.length === 0) {
-        return 0;
-    }
-    const charsPerToken = isCode ? CODE_CHARS_PER_TOKEN : CHARS_PER_TOKEN;
-    const baseTokens = Math.ceil(text.length / charsPerToken);
-    const multiplier = getProviderMultiplier(provider);
-    // Apply provider multiplier and additive safety margin separately
-    // This prevents compounding (e.g. Anthropic: 1.23 * 1.15 = 1.41x was too aggressive)
-    const providerAdjusted = baseTokens * multiplier;
-    const safetyBuffer = baseTokens * TOKEN_SAFETY_MARGIN_ADDITIVE;
-    return Math.ceil(providerAdjusted + safetyBuffer);
-}
-/**
- * Serialize an arbitrary value for estimation. Never throws: `JSON.stringify`
- * raises RangeError once a value exceeds V8's max string length, and a tool
- * argument blob is exactly the shape that gets there. A payload that large is
- * charged at the fallback size rather than aborting the estimate (and with it
- * the whole turn).
- */
-function serializeForEstimate(value) {
-    if (typeof value === "string") {
-        return value;
-    }
-    try {
-        return JSON.stringify(value) ?? "";
-    }
-    catch {
-        return "x".repeat(OVERSIZED_VALUE_FALLBACK_CHARS);
-    }
-}
-/**
- * Estimate token count for a single ChatMessage.
- * Includes message framing overhead.
- *
- * Counts `content` AND `args`. A `tool_call` is persisted with an EMPTY
- * `content` and its entire payload in `args` (see flushPendingToolData),
- * so a content-only estimate scored a 39 KB Write call at ~28 tokens against a
- * real cost near 9,750 — the budget checker, the compaction trigger and the
- * summarization threshold were all blind to the single largest source of
- * context growth in an agentic session.
- *
- * `result` is deliberately NOT counted: `result.result` is re-hydrated FROM
- * `content` at read time (redisConversationMemoryManager), so counting both
- * double-bills the same bytes. Only `result.error`, which has no counterpart in
- * `content`, is included.
- */
-export function estimateMessageTokens(message, provider) {
-    let contentStr = "";
-    if (message.content) {
-        if (typeof message.content === "string") {
-            contentStr = message.content;
-        }
-        else {
-            try {
-                contentStr = JSON.stringify(message.content);
-            }
-            catch {
-                // Fallback for circular references or non-serializable content
-                contentStr = String(message.content);
-            }
-        }
-    }
-    let total = estimateTokens(contentStr, provider) + TOKENS_PER_MESSAGE;
-    const args = message.args;
-    if (args) {
-        total += estimateTokens(serializeForEstimate(args), provider);
-    }
-    const resultError = message.result?.error;
-    if (resultError) {
-        total += estimateTokens(serializeForEstimate(resultError), provider);
-    }
-    return total;
-}
-/**
- * Estimate total token count for an array of messages.
- * Includes conversation-level overhead.
- */
-export function estimateMessagesTokens(messages, provider) {
-    if (!messages || messages.length === 0) {
-        return 0;
-    }
-    const messageTokens = messages.reduce((sum, msg) => sum + estimateMessageTokens(msg, provider), 0);
-    return messageTokens + TOKENS_PER_CONVERSATION;
-}
-/**
- * Truncate text to fit within a token budget.
- * Tries to cut at sentence or word boundaries.
- *
- * @param text - Input text
- * @param maxTokens - Maximum tokens allowed
- * @param provider - Optional provider for multiplier
- * @returns Truncated text with "..." suffix if truncated
- */
-export function truncateToTokenBudget(text, maxTokens, provider) {
-    if (estimateTokens(text, provider) <= maxTokens) {
-        return { text, truncated: false };
-    }
-    const multiplier = getProviderMultiplier(provider);
-    // Use additive safety margin: effective multiplier = multiplier + additive margin
-    const effectiveMultiplier = multiplier + TOKEN_SAFETY_MARGIN_ADDITIVE;
-    const maxChars = Math.floor((maxTokens / effectiveMultiplier) * CHARS_PER_TOKEN);
-    if (maxChars <= 0) {
-        return { text: "", truncated: true };
-    }
-    // Try to cut at sentence boundary
-    const candidate = text.slice(0, maxChars);
-    const lastSentence = Math.max(candidate.lastIndexOf(". "), candidate.lastIndexOf("! "), candidate.lastIndexOf("? "), candidate.lastIndexOf("\n"));
-    const cutPoint = lastSentence > maxChars * 0.5 ? lastSentence + 1 : maxChars;
-    return { text: text.slice(0, cutPoint) + "...", truncated: true };
-}
-//# sourceMappingURL=tokenEstimation.js.map

package/dist/lib/utils/tokenLimits.d.ts

@@ -1,53 +0,0 @@
-/**
- * Provider-specific token limit utilities
- * Provides safe maxTokens values based on provider and model capabilities
- */
-import { PROVIDER_MAX_TOKENS } from "../core/constants.js";
-/**
- * Get the safe maximum tokens for a provider and model
- */
-export declare function getSafeMaxTokens(provider: keyof typeof PROVIDER_MAX_TOKENS | string, model?: string, requestedMaxTokens?: number): number | undefined;
-/**
- * Maximum output tokens supported by a given Anthropic Claude model.
- *
- * The native Vertex+Claude and native Anthropic message paths send `max_tokens`
- * straight to the Anthropic API, which returns 400 if the value exceeds the
- * model's published output ceiling. (The AI-SDK path clamps automatically;
- * these native paths do not.) This table lets those paths default to the
- * model's real ceiling — 64K for Sonnet/Haiku 4.x, 32K for Opus 4.x — instead of
- * the legacy 4096 that silently truncated large structured responses.
- *
- * Unknown identifiers fall back to a safe modern floor (8192).
- */
-export declare function getClaudeMaxOutputTokens(model: string | undefined): number;
-/**
- * Resolve the `max_tokens` to send on a native Anthropic/Claude request: honour
- * the caller's value but clamp it to the model's published ceiling, and default
- * to that ceiling when the caller did not specify one. Prevents both silent
- * truncation (the legacy 4096 default) and 400s from over-large requests.
- */
-export declare function resolveClaudeMaxTokens(model: string | undefined, requested?: number): number;
-/**
- * Validate if maxTokens is safe for a provider/model combination
- */
-export declare function validateMaxTokens(provider: keyof typeof PROVIDER_MAX_TOKENS | string, model?: string, maxTokens?: number): {
-    isValid: boolean;
-    recommendedMaxTokens?: number;
-    warning?: string;
-};
-/**
- * Get provider-specific token limit recommendations
- */
-export declare function getTokenLimitRecommendations(provider: string): {
-    conservative: number;
-    balanced: number;
-    maximum: number;
-    models: Record<string, number>;
-};
-/**
- * Get all provider limits summary
- */
-export declare function getAllProviderLimits(): Record<string, {
-    default: number;
-    models: Record<string, number>;
-}>;

package/dist/lib/utils/tokenLimits.js

@@ -1,236 +0,0 @@
-/**
- * Provider-specific token limit utilities
- * Provides safe maxTokens values based on provider and model capabilities
- */
-import { getRuntimeOutputCeiling } from "../constants/contextWindows.js";
-import { PROVIDER_MAX_TOKENS } from "../core/constants.js";
-import { logger } from "./logger.js";
-import { hasRestrictedOutputLimit, RESTRICTED_OUTPUT_TOKEN_LIMIT, } from "./modelDetection.js";
-// Restricted-model detection (Gemini 3.x + image-gen models capped at 32768
-// output tokens) lives in modelDetection.ts. Importing the canonical helper
-// keeps both call sites on one definition; the previous local copy used
-// case-sensitive substring matches and could miss identifiers like
-// "Gemini-3-Pro" which the canonical anchored, case-insensitive regex matches.
-/**
- * Get the safe maximum tokens for a provider and model
- */
-export function getSafeMaxTokens(provider, model, requestedMaxTokens) {
-    // CRITICAL: Gemini 3 models AND image generation models have a hard limit of 32768 output tokens
-    // This check must happen FIRST, before any other logic, because these models
-    // will reject requests with maxOutputTokens > 32768
-    const isRestrictedModel = model ? hasRestrictedOutputLimit(model) : false;
-    if (isRestrictedModel) {
-        // Explicit undefined/null check so a caller-supplied 0 is preserved
-        // (truthy guards would treat 0 as "unset" and silently fall back to the cap).
-        if (requestedMaxTokens !== undefined &&
-            requestedMaxTokens !== null &&
-            requestedMaxTokens > RESTRICTED_OUTPUT_TOKEN_LIMIT) {
-            logger.warn(`Requested maxTokens ${requestedMaxTokens} exceeds ${model} limit of ${RESTRICTED_OUTPUT_TOKEN_LIMIT}. Using ${RESTRICTED_OUTPUT_TOKEN_LIMIT} instead.`);
-            return RESTRICTED_OUTPUT_TOKEN_LIMIT;
-        }
-        // If no maxTokens specified, use the restricted limit as default
-        if (requestedMaxTokens === undefined || requestedMaxTokens === null) {
-            return RESTRICTED_OUTPUT_TOKEN_LIMIT;
-        }
-        // Otherwise, use the requested value (it's within limits, including 0)
-        return requestedMaxTokens;
-    }
-    // Runtime-discovered output ceiling (e.g. LiteLLM /model/info
-    // max_output_tokens): the serving infrastructure's own number for the
-    // deployed model, authoritative over the static per-provider table. This
-    // both clamps over-large requests to the real cap AND replaces the static
-    // provider default for callers that pass no maxTokens — the litellm
-    // blanket default (128000) is a context-window-sized value that slashed
-    // usable input on total-context backends. Checked AFTER the
-    // restricted-model branch so hard caps proven at the origin API (Gemini 3
-    // / image models) still win over a proxy that over-advertises them.
-    const runtimeCeiling = getRuntimeOutputCeiling(provider, model);
-    if (runtimeCeiling !== undefined) {
-        if (requestedMaxTokens === undefined || requestedMaxTokens === null) {
-            return runtimeCeiling;
-        }
-        if (requestedMaxTokens > runtimeCeiling) {
-            logger.warn(`Requested maxTokens ${requestedMaxTokens} exceeds the advertised ` +
-                `${provider}/${model} output ceiling of ${runtimeCeiling}. Using ${runtimeCeiling} instead.`);
-            return runtimeCeiling;
-        }
-        return requestedMaxTokens;
-    }
-    // Get provider-specific limits
-    const providerLimits = PROVIDER_MAX_TOKENS[provider];
-    if (!providerLimits) {
-        logger.warn(`Unknown provider ${provider}, no token limits enforced`);
-        // Explicit undefined/null check so a caller-supplied 0 is preserved
-        // (truthy guard would silently drop 0 here as it does in the restricted branch).
-        if (requestedMaxTokens === undefined || requestedMaxTokens === null) {
-            return undefined;
-        }
-        return requestedMaxTokens;
-    }
-    // Get model-specific limit or provider default
-    let maxLimit;
-    if (model &&
-        typeof providerLimits === "object" &&
-        providerLimits[model]) {
-        maxLimit = providerLimits[model];
-    }
-    else if (typeof providerLimits === "object" &&
-        providerLimits.default) {
-        maxLimit = providerLimits.default;
-    }
-    else if (typeof providerLimits === "number") {
-        maxLimit = providerLimits;
-    }
-    else {
-        maxLimit = PROVIDER_MAX_TOKENS.default;
-    }
-    // If no specific maxTokens requested, return the provider limit.
-    // Use explicit undefined/null so a caller-supplied 0 is preserved
-    // (matches the restricted-model branch above).
-    if (requestedMaxTokens === undefined || requestedMaxTokens === null) {
-        return maxLimit;
-    }
-    // If requested maxTokens exceeds the limit, use the limit and warn
-    if (requestedMaxTokens > maxLimit) {
-        logger.warn(`Requested maxTokens ${requestedMaxTokens} exceeds ${provider}/${model} limit of ${maxLimit}. Using ${maxLimit} instead.`);
-        return maxLimit;
-    }
-    // Use the requested value if it's within limits
-    return requestedMaxTokens;
-}
-/**
- * Maximum output tokens supported by a given Anthropic Claude model.
- *
- * The native Vertex+Claude and native Anthropic message paths send `max_tokens`
- * straight to the Anthropic API, which returns 400 if the value exceeds the
- * model's published output ceiling. (The AI-SDK path clamps automatically;
- * these native paths do not.) This table lets those paths default to the
- * model's real ceiling — 64K for Sonnet/Haiku 4.x, 32K for Opus 4.x — instead of
- * the legacy 4096 that silently truncated large structured responses.
- *
- * Unknown identifiers fall back to a safe modern floor (8192).
- */
-export function getClaudeMaxOutputTokens(model) {
-    const m = (model ?? "").toLowerCase();
-    // Claude 4.x family: Opus 4.x = 32K, Sonnet/Haiku 4.x = 64K.
-    if (/opus[-_.]?4/.test(m)) {
-        return 32000;
-    }
-    if (/sonnet[-_.]?4/.test(m) || /haiku[-_.]?4/.test(m)) {
-        return 64000;
-    }
-    // Claude 3.7 Sonnet supports 64K output.
-    if (/3[-_.]?7[-_.]?sonnet/.test(m)) {
-        return 64000;
-    }
-    // Claude 3.5 Sonnet / Haiku → 8192.
-    if (/3[-_.]?5[-_.]?(sonnet|haiku)/.test(m)) {
-        return 8192;
-    }
-    // Claude 3 Opus / Sonnet / Haiku → 4096.
-    if (/claude-3-(opus|sonnet|haiku)/.test(m) || /3[-_.]?opus/.test(m)) {
-        return 4096;
-    }
-    // Bare family aliases (latest of a family) → assume the modern ceiling.
-    if (m.includes("opus")) {
-        return 32000;
-    }
-    if (m.includes("sonnet") || m.includes("haiku")) {
-        return 64000;
-    }
-    return 8192;
-}
-/**
- * Resolve the `max_tokens` to send on a native Anthropic/Claude request: honour
- * the caller's value but clamp it to the model's published ceiling, and default
- * to that ceiling when the caller did not specify one. Prevents both silent
- * truncation (the legacy 4096 default) and 400s from over-large requests.
- */
-export function resolveClaudeMaxTokens(model, requested) {
-    const ceiling = getClaudeMaxOutputTokens(model);
-    if (requested !== undefined && requested !== null && requested > 0) {
-        return Math.min(requested, ceiling);
-    }
-    return ceiling;
-}
-/**
- * Validate if maxTokens is safe for a provider/model combination
- */
-export function validateMaxTokens(provider, model, maxTokens) {
-    const safeMaxTokens = getSafeMaxTokens(provider, model, maxTokens);
-    if (!maxTokens) {
-        return {
-            isValid: true,
-            recommendedMaxTokens: safeMaxTokens,
-        };
-    }
-    // If no limits are defined, validation always passes
-    if (safeMaxTokens === undefined) {
-        return {
-            isValid: true,
-            recommendedMaxTokens: maxTokens,
-        };
-    }
-    const isValid = maxTokens <= safeMaxTokens;
-    return {
-        isValid,
-        recommendedMaxTokens: safeMaxTokens,
-        warning: !isValid
-            ? `maxTokens ${maxTokens} exceeds ${provider}/${model} limit of ${safeMaxTokens}`
-            : undefined,
-    };
-}
-/**
- * Get provider-specific token limit recommendations
- */
-export function getTokenLimitRecommendations(provider) {
-    const providerLimits = PROVIDER_MAX_TOKENS[provider];
-    if (!providerLimits || typeof providerLimits === "number") {
-        const limit = typeof providerLimits === "number"
-            ? providerLimits
-            : PROVIDER_MAX_TOKENS.default;
-        return {
-            conservative: Math.floor(limit * 0.5),
-            balanced: Math.floor(limit * 0.75),
-            maximum: limit,
-            models: {},
-        };
-    }
-    const modelLimits = Object.entries(providerLimits)
-        .filter(([key]) => key !== "default")
-        .map(([_, limit]) => limit);
-    const maxLimit = Math.max(...modelLimits, providerLimits.default || 0);
-    const minLimit = Math.min(...modelLimits, providerLimits.default || maxLimit);
-    return {
-        conservative: Math.floor(minLimit * 0.5),
-        balanced: Math.floor(((minLimit + maxLimit) / 2) * 0.75),
-        maximum: maxLimit,
-        models: Object.fromEntries(Object.entries(providerLimits).filter(([key]) => key !== "default")),
-    };
-}
-/**
- * Get all provider limits summary
- */
-export function getAllProviderLimits() {
-    const result = {};
-    for (const [provider, limits] of Object.entries(PROVIDER_MAX_TOKENS)) {
-        if (provider === "default") {
-            continue;
-        }
-        if (typeof limits === "number") {
-            result[provider] = {
-                default: limits,
-                models: {},
-            };
-        }
-        else {
-            const { default: defaultLimit, ...models } = limits;
-            result[provider] = {
-                default: defaultLimit || PROVIDER_MAX_TOKENS.default,
-                models: models,
-            };
-        }
-    }
-    return result;
-}
-//# sourceMappingURL=tokenLimits.js.map

package/dist/lib/utils/tokenUtils.d.ts

@@ -1,101 +0,0 @@
-/**
- * Centralized token usage extraction utilities
- * Handles multiple provider formats and optional fields
- *
- * Consolidates token extraction logic from:
- * - GenerationHandler.ts
- * - analytics.ts
- * - streamAnalytics.ts
- */
-import type { TokenUsage, RawUsageObject, TokenExtractionOptions } from "../types/index.js";
-/**
- * Extract input token count from various provider formats
- * Priority: input > inputTokens > promptTokens
- */
-export declare function extractInputTokens(usage: RawUsageObject): number;
-/**
- * Extract output token count from various provider formats
- * Priority: output > outputTokens > completionTokens
- */
-export declare function extractOutputTokens(usage: RawUsageObject): number;
-/**
- * Extract total token count from various provider formats
- * Falls back to input + output if total is not provided
- */
-export declare function extractTotalTokens(usage: RawUsageObject, input: number, output: number): number;
-/**
- * Extract reasoning/thinking token count from various provider formats
- * Supports: reasoningTokens, thinkingTokens, reasoning_tokens, reasoning
- */
-export declare function extractReasoningTokens(usage: RawUsageObject): number | undefined;
-/**
- * Extract cache creation token count from various provider formats
- * Supports: cacheCreationInputTokens, cacheCreationTokens, and the ai@6
- * normalized `inputTokenDetails.cacheWriteTokens` (the only shape the native
- * direct-Anthropic path reports through generateText).
- */
-export declare function extractCacheCreationTokens(usage: RawUsageObject): number | undefined;
-/**
- * Extract cache read token count from various provider formats
- * Supports: cacheReadInputTokens, cacheReadTokens, and the ai@6 normalized
- * shapes — flat `cachedInputTokens` and nested
- * `inputTokenDetails.cacheReadTokens` (the only shapes the native
- * direct-Anthropic path reports through generateText).
- */
-export declare function extractCacheReadTokens(usage: RawUsageObject): number | undefined;
-/**
- * Extract cache read token count from the OVERLAPPING-convention nested path
- * used by OpenAI / DeepSeek / NIM / OpenAI-compatible providers:
- * `usage.prompt_tokens_details.cached_tokens`.
- *
- * Unlike {@link extractCacheReadTokens} (non-overlapping Anthropic/Vertex
- * convention where cache tokens are reported SEPARATELY from input), the value
- * returned here is a SUBSET already included in `prompt_tokens`. Callers that
- * use this value MUST subtract it from `input` to avoid double-counting.
- */
-export declare function extractCachedInputTokensOverlapping(usage: RawUsageObject): number | undefined;
-/**
- * Calculate cache savings percentage
- *
- * This represents the percentage of input tokens served from cache.
- * For Anthropic, cache read tokens cost 0.1x, so actual cost savings = cacheSavingsPercent * 0.9
- * For other providers, cost savings may vary based on their cache pricing.
- *
- * @param cacheReadTokens Number of tokens read from cache
- * @param inputTokens Number of non-cached input tokens
- * @returns Percentage of tokens served from cache (0-100), or undefined if no cache usage
- */
-export declare function calculateCacheSavingsPercent(cacheReadTokens: number | undefined, inputTokens: number): number | undefined;
-/**
- * Extract token usage from various provider response formats
- *
- * Handles multiple input formats:
- * - BaseProvider normalized format (input/output/total)
- * - AI SDK format (inputTokens/outputTokens/totalTokens)
- * - OpenAI/Mistral format (promptTokens/completionTokens)
- * - Nested usage objects
- *
- * Also extracts optional fields:
- * - Cache creation and read tokens (Anthropic-style)
- * - Reasoning/thinking tokens (OpenAI o1, Anthropic, Google)
- * - Cache savings percentage
- *
- * @param result Raw usage object from provider response
- * @param options Extraction options
- * @returns Normalized TokenUsage object
- */
-export declare function extractTokenUsage(result: RawUsageObject | undefined | null, options?: TokenExtractionOptions): TokenUsage;
-/**
- * Create a default/empty TokenUsage object
- * Useful for error handling and fallback scenarios
- */
-export declare function createEmptyTokenUsage(): TokenUsage;
-/**
- * Check if a TokenUsage object has any non-zero values
- */
-export declare function hasTokenUsage(usage: TokenUsage): boolean;
-/**
- * Merge two TokenUsage objects by summing their values
- * Useful for aggregating usage across multiple calls
- */
-export declare function mergeTokenUsage(a: TokenUsage, b: TokenUsage): TokenUsage;