@librechat/agents 3.2.34 → 3.2.36

package/dist/types/agents/AgentContext.d.ts

@@ -1,9 +1,9 @@
 import { SystemMessage } from '@langchain/core/messages';
 import type { UsageMetadata, BaseMessage } from '@langchain/core/messages';
 import type { RunnableConfig, Runnable } from '@langchain/core/runnables';
-import type { createPruneMessages } from '@/messages';
 import type * as t from '@/types';
 import { ContentTypes, Providers } from '@/common';
+import { createPruneMessages } from '@/messages';
 /**
  * Encapsulates agent-specific state that can vary between agents in a multi-agent system
  */
@@ -60,6 +60,11 @@ export declare class AgentContext {
     dynamicInstructionTokens: number;
     /** Token count for tool schemas only. */
     toolSchemaTokens: number;
+    /** Per-tool schema token counts (post-multiplier), keyed by tool name.
+     *  `undefined` when not calculated (e.g. cached aggregate schema tokens). */
+    toolTokenCounts?: Record<string, number>;
+    /** Names of counted tools that are deferred (`defer_loading`) and discovered. */
+    deferredToolNames: string[];
     /** Running calibration ratio from the pruner — persisted across runs via contextMeta. */
     calibrationRatio: number;
     /** Provider-observed instruction overhead from the pruner's best-variance turn. */
@@ -330,9 +335,8 @@ export declare class AgentContext {
      * Returns a structured breakdown of how the context token budget is consumed.
      * Useful for diagnostics when context overflow or pruning issues occur.
      *
-     * Note: `toolCount` reflects discoveries immediately, but `toolSchemaTokens`
-     * is a snapshot taken during `calculateInstructionTokens` and is not
-     * recomputed when `markToolsAsDiscovered` is called mid-run.
+     * Note: `markToolsAsDiscovered` re-triggers `calculateInstructionTokens`,
+     * so `toolSchemaTokens`/`toolTokenCounts` refresh before the next call.
      */
     getTokenBudgetBreakdown(messages?: BaseMessage[]): t.TokenBudgetBreakdown;
     /**
@@ -340,6 +344,35 @@ export declare class AgentContext {
      * for inclusion in error messages and diagnostics.
      */
     formatTokenBudgetBreakdown(messages?: BaseMessage[]): string;
+    /**
+     * Projects the context-usage snapshot for an arbitrary message set WITHOUT
+     * invoking the model — the pre-send / page-load / window-switch counterpart to
+     * the live `ON_CONTEXT_USAGE` snapshot. Runs the same pruner + budget math the
+     * graph uses (`createPruneMessages` → `getTokenBudgetBreakdown` →
+     * `syncBudgetDerivedFields`) so projected numbers match a real call. Returns
+     * null when the context lacks the tokenizer or window needed to prune. Omits
+     * the live post-format reconciliation (provider-specific, invoke-time) — a
+     * small, acceptable delta for a pre-send estimate.
+     *
+     * Safe to call off the hot path: the supplied `messages` are never mutated
+     * (each is passed as a clone — the pruner both replaces tool-result slots and
+     * unshifts reasoning blocks into AI content arrays in place), and this
+     * context's own state is untouched apart from refreshing stale instruction
+     * counts (idempotent, exactly what a real call does). Token counts are
+     * recounted for the supplied messages (the context's `indexTokenCountMap` is
+     * keyed to the live run's branch and would missum an arbitrary branch) unless
+     * the caller passes a map it guarantees matches. Calibration is NOT re-derived
+     * from this context's live usage (a fresh pruner would compare the prior
+     * call's provider input against the whole projected branch); the learned
+     * `calibrationRatio` is applied as a static seed, and callers may override it
+     * with a persisted ratio via `opts.calibrationRatio`.
+     */
+    projectContextUsage(messages: BaseMessage[], opts?: {
+        runId?: string;
+        agentId?: string;
+        calibrationRatio?: number;
+        indexTokenCountMap?: Record<string, number | undefined>;
+    }): t.ContextUsageEvent | null;
     /**
      * Updates the last-call usage with data from the most recent LLM response.
      * Unlike `currentUsage` which accumulates, this captures only the single call.

package/dist/types/agents/projection.d.ts

@@ -0,0 +1,26 @@
+import type { BaseMessage } from '@langchain/core/messages';
+import type * as t from '@/types';
+export interface ProjectAgentContextUsageParams {
+    /** Same `AgentInputs` a run is built from (instructions, tools, model, window). */
+    agent: t.AgentInputs;
+    /** Branch messages to project, in send order (no leading system message). */
+    messages: BaseMessage[];
+    tokenCounter: t.TokenCounter;
+    /** Per-message counts aligned to `messages` (e.g. from `formatAgentMessages`).
+     *  When omitted, counts are recounted via `tokenCounter`. */
+    indexTokenCountMap?: Record<string, number>;
+    /** Provider-calibrated ratio from a prior snapshot, applied as a static seed. */
+    calibrationRatio?: number;
+    runId?: string;
+    agentId?: string;
+}
+/**
+ * Projects a pre-send context-usage snapshot for a branch under an agent config
+ * WITHOUT invoking the model — the host-side (page-load / branch-switch /
+ * window-switch) counterpart to the live `ON_CONTEXT_USAGE` event. Builds a
+ * throwaway `AgentContext` from the same `AgentInputs` a run uses, awaits its
+ * instruction/tool token accounting, then runs the shared pruner + budget math
+ * via `AgentContext.projectContextUsage` (which never mutates the supplied
+ * messages). Returns null when the config has no tokenizer or context window.
+ */
+export declare function projectAgentContextUsage({ agent, messages, tokenCounter, indexTokenCountMap, calibrationRatio, runId, agentId, }: ProjectAgentContextUsageParams): Promise<t.ContextUsageEvent | null>;

package/dist/types/common/enum.d.ts

@@ -29,6 +29,8 @@ export declare enum GraphEvents {
     ON_SUBAGENT_UPDATE = "on_subagent_update",
     /** [Custom] Diagnostic logging event for context management observability */
     ON_AGENT_LOG = "on_agent_log",
+    /** [Custom] Per-model-call context window usage snapshot (post-prune token budget) */
+    ON_CONTEXT_USAGE = "on_context_usage",
     /** Custom event, emitted by system */
     ON_CUSTOM_EVENT = "on_custom_event",
     /** Emitted when a chat model starts processing. */
@@ -140,6 +142,17 @@ export declare enum Constants {
     /** Anthropic server tool ID prefix (web_search, code_execution, etc.) */
     ANTHROPIC_SERVER_TOOL_PREFIX = "srvtoolu_",
     SKILL_TOOL = "skill",
+    /**
+     * Callback-metadata keys stamped by `attemptInvoke` /
+     * `tryFallbackProviders` carrying the provider (SDK `Providers` enum
+     * value) and configured model that actually served a model invocation.
+     * Unlike `ls_provider` — which derived providers inherit from their base
+     * class (e.g. DeepSeek/OpenRouter report `'openai'`) — these reflect the
+     * SDK's own routing, including fallback-provider calls. Consumed by the
+     * subagent usage-capture handler to tag billing events.
+     */
+    INVOKED_PROVIDER = "__invoked_provider",
+    INVOKED_MODEL = "__invoked_model",
     READ_FILE = "read_file",
     BASH_TOOL = "bash_tool",
     BASH_PROGRAMMATIC_TOOL_CALLING = "run_tools_with_bash",

package/dist/types/graphs/Graph.d.ts

@@ -179,7 +179,14 @@ export declare class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode>
     agentContexts: Map<string, AgentContext>;
     /** Default agent ID to use */
     defaultAgentId: string;
-    constructor({ runId, signal, agents, langfuse, tokenCounter, indexTokenCountMap, calibrationRatio, }: t.StandardGraphInput);
+    /**
+     * Host sink for model usage emitted inside subagent child runs. Threaded
+     * into each `SubagentExecutor` this graph creates (and from there into
+     * child graphs, so nested subagents report too). See
+     * {@link t.StandardGraphInput.subagentUsageSink}.
+     */
+    subagentUsageSink?: t.SubagentUsageSink;
+    constructor({ runId, signal, agents, langfuse, tokenCounter, indexTokenCountMap, calibrationRatio, subagentUsageSink, }: t.StandardGraphInput);
     resetValues(keepContent?: boolean): void;
     clearHeavyState(): void;
     getRunStep(stepId: string): t.RunStep | undefined;

package/dist/types/index.d.ts

@@ -4,6 +4,7 @@ export * from './splitStream';
 export * from './events';
 export * from './messages';
 export * from './graphs';
+export * from './agents/projection';
 export * from './summarization';
 export * from './tools/Calculator';
 export * from './tools/CodeExecutor';

package/dist/types/llm/invoke.d.ts

@@ -3,8 +3,8 @@ import type { RunnableConfig } from '@langchain/core/runnables';
 import type { BaseMessage } from '@langchain/core/messages';
 import type { ToolOutputReferenceRegistry } from '@/tools/toolOutputReferences';
 import type * as t from '@/types';
-import { ChatModelStreamHandler } from '@/stream';
 import { Providers } from '@/common';
+import { ChatModelStreamHandler } from '@/stream';
 /**
  * Context passed to `attemptInvoke`. Matches the subset of Graph that
  * `ChatModelStreamHandler.handle` needs *plus* the explicit

package/dist/types/messages/budget.d.ts

@@ -0,0 +1,11 @@
+import type * as t from '@/types';
+/**
+ * Reconciles a context-usage breakdown's instruction/available/message fields
+ * from the pruner's budget metrics. `messageTokens` and `availableForMessages`
+ * are DERIVED from `contextBudget` / `effectiveInstructionTokens` /
+ * `remainingContextTokens` rather than summed from the index map — that map is
+ * keyed by pre-prune indices, so summing it over the kept context would missum.
+ * Shared by the live snapshot path (`Graph.createCallModel`) and the pre-send
+ * projection (`AgentContext.projectContextUsage`) so both yield identical numbers.
+ */
+export declare function syncBudgetDerivedFields(usage: t.ContextUsageEvent): void;

package/dist/types/messages/cache.d.ts

@@ -3,6 +3,13 @@ import type { AnthropicMessage } from '@/types/messages';
 type MessageWithContent = {
     content?: string | MessageContentComplex[];
 };
+/**
+ * Clones a message with new content. For LangChain BaseMessage instances,
+ * constructs a proper class instance so that `instanceof` checks are preserved
+ * in downstream code (e.g., ensureThinkingBlockInMessages).
+ * For plain objects (AnthropicMessage), uses object spread.
+ */
+export declare function cloneMessage<T extends MessageWithContent>(message: T, content: string | MessageContentComplex[]): T;
 /**
  * Anthropic API: Adds cache control to the appropriate user messages in the payload.
  * Strips ALL existing cache control (both Anthropic and Bedrock formats) from all messages,

package/dist/types/messages/content.d.ts

@@ -1,4 +1,9 @@
 import type { BaseMessage } from '@langchain/core/messages';
+/**
+ * Whether {@link formatContentStrings} will flatten this message's content:
+ * a human/ai/system message whose content is an array of text-only blocks.
+ */
+export declare const isLegacyConvertible: (message: BaseMessage) => boolean;
 /**
  * Formats an array of messages for LangChain, making sure all content fields are strings
  * @param {Array<HumanMessage | AIMessage | SystemMessage | ToolMessage>} payload - The array of messages to format.

package/dist/types/messages/index.d.ts

@@ -1,6 +1,7 @@
 export * from './core';
 export * from './ids';
 export * from './prune';
+export * from './budget';
 export * from './format';
 export * from './cache';
 export * from './anthropicToolCache';

package/dist/types/messages/prune.d.ts

@@ -220,4 +220,8 @@ export declare function createPruneMessages(factoryParams: PruneMessagesFactoryP
     originalToolContent?: Map<number, string>;
     calibrationRatio?: number;
     resolvedInstructionOverhead?: number;
+    /** Usable budget this call: maxTokens minus output reserve */
+    contextBudget?: number;
+    /** Calibrated instruction overhead actually applied this call */
+    effectiveInstructionTokens?: number;
 };

package/dist/types/run.d.ts

@@ -15,6 +15,7 @@ export declare class Run<_T extends t.BaseGraphState> {
     private toolOutputReferences?;
     private eagerEventToolExecution?;
     private toolExecution?;
+    private subagentUsageSink?;
     private indexTokenCountMap?;
     calibrationRatio: number;
     graphRunnable?: t.CompiledStateWorkflow;

package/dist/types/tools/search/format.d.ts

@@ -1,5 +1,8 @@
 import type * as t from './types';
-export declare function formatResultsForLLM(turn: number, results: t.SearchResultData): {
+/** Resolves the per-search highlight budget from config, the
+ *  `SEARCH_MAX_LLM_OUTPUT_CHARS` env var, or the default (50,000 chars). */
+export declare function resolveMaxLLMOutputChars(maxOutputChars?: number): number;
+export declare function formatResultsForLLM(turn: number, results: t.SearchResultData, maxOutputChars?: number): {
     output: string;
     references: t.ResultReference[];
 };

package/dist/types/tools/search/types.d.ts

@@ -189,6 +189,13 @@ export type SafeSearchLevel = 0 | 1 | 2;
 export type Logger = WinstonLogger;
 export interface SearchToolConfig extends SearchConfig, ProcessSourcesConfig, FirecrawlConfig {
     tavilyScraperOptions?: TavilyScraperConfig;
+    /** Max chars of highlight content this tool feeds the MODEL per search (the
+     * dominant, otherwise-unbounded part of the output). Distinct from
+     * `maxContentLength`, which caps scraped/reranked content per source — full
+     * content always remains in the `WEB_SEARCH` artifact. Defaults to 50,000;
+     * also configurable via the `SEARCH_MAX_LLM_OUTPUT_CHARS` env var. Hosts that
+     * know the context window (e.g. LibreChat) pass a window-relative value. */
+    maxOutputChars?: number;
     logger?: Logger;
     safeSearch?: SafeSearchLevel;
     jinaApiKey?: string;

package/dist/types/tools/subagent/SubagentExecutor.d.ts

@@ -1,5 +1,5 @@
 import type { BaseMessage } from '@langchain/core/messages';
-import type { AgentInputs, StandardGraphInput, ResolvedSubagentConfig, SubagentConfig, TokenCounter } from '@/types';
+import type { AgentInputs, StandardGraphInput, ResolvedSubagentConfig, SubagentConfig, SubagentUsageSink, TokenCounter } from '@/types';
 import type { HookRegistry } from '@/hooks';
 import type { AgentContext } from '@/agents/AgentContext';
 import type { StandardGraph } from '@/graphs/Graph';
@@ -88,6 +88,15 @@ export type SubagentExecutorOptions = {
      * post-`createWorkflow`, so `createAgentNode` must capture lazily).
      */
     parentHandlerRegistry?: HandlerRegistry | (() => HandlerRegistry | undefined);
+    /**
+     * Receives a usage event for every model call the child run makes. The
+     * child workflow executes via `invoke()` with a detached callbacks array,
+     * so its `on_chat_model_end` events never reach the parent's handler
+     * registry — without this sink, child token usage is invisible to the
+     * host (unbilled model calls). Forwarded into the child graph's input so
+     * nested subagents report through the same sink.
+     */
+    usageSink?: SubagentUsageSink;
 };
 export declare class SubagentExecutor {
     private readonly configs;
@@ -99,6 +108,7 @@ export declare class SubagentExecutor {
     private readonly tokenCounter?;
     private readonly maxDepth;
     private readonly createChildGraph;
+    private readonly usageSink?;
     private readonly resolveParentHandlerRegistry?;
     constructor(options: SubagentExecutorOptions);
     /** Snapshot of the parent's registry at the moment a subagent is dispatched. */

package/dist/types/types/graph.d.ts

@@ -1,4 +1,4 @@
-import type { BaseMessage, AIMessageChunk, SystemMessage } from '@langchain/core/messages';
+import type { BaseMessage, AIMessageChunk, SystemMessage, UsageMetadata } from '@langchain/core/messages';
 import type { BindToolsInput } from '@langchain/core/language_models/chat_models';
 import type { START, StateGraph, StateGraphArgs } from '@langchain/langgraph';
 import type { RunnableConfig, Runnable } from '@langchain/core/runnables';
@@ -7,10 +7,10 @@ import type { GoogleAIToolType } from '@langchain/google-common';
 import type { SummarizationNodeInput, SummarizeCompleteEvent, SummarizationConfig, SummarizeStartEvent, SummarizeDeltaEvent } from '@/types/summarize';
 import type { ToolMap, ToolEndEvent, GenericTool, LCTool, ToolExecuteBatchRequest } from '@/types/tools';
 import type { RunStep, RunStepDeltaEvent, MessageDeltaEvent, ReasoningDeltaEvent } from '@/types/stream';
+import type { TokenCounter, TokenBudgetBreakdown } from '@/types/run';
 import type { Providers, Callback, GraphNodeKeys } from '@/common';
 import type { StandardGraph, MultiAgentGraph } from '@/graphs';
 import type { ClientOptions } from '@/types/llm';
-import type { TokenCounter } from '@/types/run';
 /** Interface for bound model with stream and invoke methods */
 export interface ChatModel {
     stream?: (messages: BaseMessage[], config?: RunnableConfig) => Promise<AsyncIterable<AIMessageChunk>>;
@@ -44,8 +44,31 @@ export interface AgentLogEvent {
     runId?: string;
     agentId?: string;
 }
+/**
+ * Per-model-call context window usage snapshot, dispatched after pruning and
+ * before the model invocation. Dispatched once per `callModel` invocation:
+ * fallback retries reuse the snapshot since the prompt is identical — budget
+ * numbers reflect the primary provider's tokenizer, and the calibration
+ * ratio self-corrects from whichever provider reports usage.
+ */
+export interface ContextUsageEvent {
+    runId?: string;
+    agentId?: string;
+    /** Structural token budget snapshot from AgentContext.getTokenBudgetBreakdown */
+    breakdown: TokenBudgetBreakdown;
+    /** Usable budget this call: maxContextTokens minus output reserve */
+    contextBudget?: number;
+    /** Calibrated instruction overhead actually applied this call */
+    effectiveInstructionTokens?: number;
+    /** Calibrated message tokens before pruning (excluding instructions) */
+    prePruneContextTokens?: number;
+    /** Tokens still free after instructions + pruned messages */
+    remainingContextTokens?: number;
+    /** EMA ratio of provider-reported vs locally estimated token counts */
+    calibrationRatio?: number;
+}
 export interface EventHandler {
-    handle(event: string, data: StreamEventData | ModelEndData | RunStep | RunStepDeltaEvent | MessageDeltaEvent | ReasoningDeltaEvent | SummarizeStartEvent | SummarizeDeltaEvent | SummarizeCompleteEvent | SubagentUpdateEvent | AgentLogEvent | ToolExecuteBatchRequest | {
+    handle(event: string, data: StreamEventData | ModelEndData | RunStep | RunStepDeltaEvent | MessageDeltaEvent | ReasoningDeltaEvent | SummarizeStartEvent | SummarizeDeltaEvent | SummarizeCompleteEvent | SubagentUpdateEvent | AgentLogEvent | ContextUsageEvent | ToolExecuteBatchRequest | {
         result: ToolEndEvent;
     }, metadata?: Record<string, unknown>, graph?: StandardGraph | MultiAgentGraph): void | Promise<void>;
 }
@@ -199,6 +222,17 @@ export type StandardGraphInput = {
     tokenCounter?: TokenCounter;
     indexTokenCountMap?: Record<string, number>;
     calibrationRatio?: number;
+    /**
+     * Receives a {@link SubagentUsageEvent} for every model call made inside
+     * a subagent child run spawned from this graph (including nested
+     * subagents and child-side summarization calls). Child graphs run via
+     * `invoke()` outside the host's `streamEvents` loop, so their
+     * `on_chat_model_end` events never reach the run's handler registry —
+     * this sink is the only way hosts can observe child token usage for
+     * billing/accounting. Parent-graph model calls are NOT reported here;
+     * they already flow through the registry's `CHAT_MODEL_END` handler.
+     */
+    subagentUsageSink?: SubagentUsageSink;
 };
 export type GraphEdge = {
     /** Agent ID, use a list for multiple sources */
@@ -289,6 +323,58 @@ export interface SubagentUpdateEvent {
     /** ISO timestamp for ordering / display. */
     timestamp: string;
 }
+/**
+ * Token usage for a single model call made inside a subagent child run.
+ * Emitted through {@link SubagentUsageSink} as each call completes, so
+ * hosts can bill child-run model usage that never reaches the parent
+ * run's `CHAT_MODEL_END` handler (child graphs execute via `invoke()`
+ * outside the host's `streamEvents` loop).
+ */
+export interface SubagentUsageEvent {
+    /** Usage metadata reported by the child's model call. */
+    usage: UsageMetadata;
+    /**
+     * Model that produced this usage. Per-call `ls_model_name` from the
+     * model's callback metadata when available (covers child-side
+     * summarization or any call that differs from the configured model),
+     * then the fallback-invocation's configured model (`INVOKED_MODEL`
+     * metadata), then the subagent config's `clientOptions` model.
+     */
+    model?: string;
+    /**
+     * Provider that actually served this call — the SDK `Providers` enum
+     * value stamped per-invocation by `attemptInvoke` (`INVOKED_PROVIDER`
+     * metadata), so fallback-served calls are attributed to the fallback
+     * provider, not the configured primary. Falls back to the subagent
+     * config's provider. Never LangSmith's `ls_provider` string — derived
+     * providers inherit that from their base class, and hosts key
+     * pricing/cache semantics off the enum.
+     */
+    provider?: string;
+    /** Subagent `type` identifier from the SubagentConfig. */
+    subagentType: string;
+    /** Child run ID (unique per subagent execution). */
+    subagentRunId: string;
+    /** Child agent ID assigned to this subagent execution. */
+    subagentAgentId: string;
+    /**
+     * ROOT run ID of the host run that owns billing. For nested subagents
+     * each forwarding layer rewrites this upward, so events from any depth
+     * surface with the outermost run's ID — never an intermediate
+     * `*_sub_*` child id (use {@link subagentRunId} to identify the
+     * emitting child).
+     */
+    runId: string;
+}
+/**
+ * Host-provided callback receiving {@link SubagentUsageEvent}s. Invoked as
+ * each child model call completes. May return a promise — the executor
+ * awaits each dispatch (so all usage is recorded before the child's result
+ * resolves to the parent) and swallows both synchronous throws and
+ * rejections; implementations should still be cheap, as they sit on the
+ * child's model-call path.
+ */
+export type SubagentUsageSink = (event: SubagentUsageEvent) => void | Promise<void>;
 export type LangfuseToolOutputTracingConfig = {
     /**
      * Whether tool outputs should be exported to Langfuse. Defaults to

package/dist/types/types/run.d.ts

@@ -111,6 +111,15 @@ export type RunConfig = {
      */
     langfuse?: g.LangfuseConfig;
     customHandlers?: Record<string, g.EventHandler>;
+    /**
+     * Receives token usage for every model call made inside subagent child
+     * runs (including nested subagents). Child graphs execute via `invoke()`
+     * outside this run's `streamEvents` loop, so their model-end events never
+     * reach `customHandlers` — without this sink, child usage is invisible to
+     * the host. Parent-graph calls are not reported here; they flow through
+     * the registered `CHAT_MODEL_END` handler as usual.
+     */
+    subagentUsageSink?: g.SubagentUsageSink;
     /**
      * Pre-constructed hook registry for this run. Hooks fire at lifecycle
      * points in `processStream` (RunStart, UserPromptSubmit, Stop,
@@ -225,6 +234,10 @@ export type TokenBudgetBreakdown = {
     messageTokens: number;
     /** Tokens available for messages after instructions. */
     availableForMessages: number;
+    /** Per-tool schema token counts (post-multiplier), keyed by tool name. */
+    toolTokenCounts?: Record<string, number>;
+    /** Names of counted tools that are deferred (`defer_loading`) and discovered. */
+    deferredToolNames?: string[];
 };
 export type EventStreamOptions = {
     callbacks?: g.ClientCallbacks;

package/dist/types/utils/tokens.d.ts

@@ -15,6 +15,13 @@ export declare function estimateAnthropicImageTokens(width: number, height: numb
 export declare function estimateOpenAIImageTokens(width: number, height: number, detail?: string): number;
 export declare function encodingForModel(model: string): EncodingName;
 export declare function getTokenCountForMessage(message: BaseMessage, getTokenCount: (text: string) => number, encoding?: EncodingName): number;
+/**
+ * Largest-remainder apportionment: scales each count by `multiplier` and
+ * distributes the rounding remainder so the results sum exactly to
+ * `targetTotal`. Keeps per-item breakdowns reconciled with an aggregate
+ * computed as a single rounded product of the summed raw counts.
+ */
+export declare function apportionTokenCounts(rawCounts: Record<string, number>, multiplier: number, targetTotal: number): Record<string, number>;
 /**
  * Creates a token counter function using the specified encoding.
  * Lazily loads the encoding data on first use via dynamic import.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@librechat/agents",
-  "version": "3.2.34",
+  "version": "3.2.36",
   "main": "./dist/cjs/main.cjs",
   "module": "./dist/esm/main.mjs",
   "types": "./dist/types/index.d.ts",