@librechat/agents 3.3.8 → 3.3.10

package/dist/esm/tools/handlers.mjs

@@ -4,8 +4,8 @@ import { getMessageId } from "../messages/ids.mjs";
 import "../messages/index.mjs";
 import { coerceAnthropicSearchResults, isAnthropicWebSearchResult } from "./search/anthropic.mjs";
 import { formatResultsForLLM } from "./search/format.mjs";
-import { ToolMessage } from "@langchain/core/messages";
 import { nanoid } from "nanoid";
+import { ToolMessage } from "@langchain/core/messages";
 //#region src/tools/handlers.ts
 async function handleToolCallChunks({ graph, stepKey, toolCallChunks, metadata }) {
 	let prevStepId;

package/dist/esm/tools/search/tool.mjs

@@ -1,8 +1,8 @@
 import "../../common/enum.mjs";
 import "../../common/index.mjs";
+import { INTENT_PROPERTY } from "../intentArg.mjs";
 import { createDefaultLogger } from "./utils.mjs";
 import { formatResultsForLLM } from "./format.mjs";
-import { INTENT_PROPERTY } from "../intentArg.mjs";
 import { WebSearchToolDescription, WebSearchToolName, countrySchema, dateSchema, imagesSchema, newsSchema, querySchema, videosSchema } from "./schema.mjs";
 import { createSearchAPI, createSourceProcessor } from "./search.mjs";
 import { createKeenableScraper } from "./keenable-scraper.mjs";

package/dist/esm/tools/subagent/SubagentExecutor.mjs

@@ -2,9 +2,9 @@ import "../../common/enum.mjs";
 import "../../common/index.mjs";
 import { executeHooks } from "../../hooks/executeHooks.mjs";
 import "../../hooks/index.mjs";
+import { nanoid } from "nanoid";
 import { BaseCallbackHandler } from "@langchain/core/callbacks/base";
 import { HumanMessage } from "@langchain/core/messages";
-import { nanoid } from "nanoid";
 //#region src/tools/subagent/SubagentExecutor.ts
 const DEFAULT_MAX_TURNS = 25;
 const RECURSION_MULTIPLIER = 3;

package/dist/esm/utils/index.mjs

@@ -1,10 +1,10 @@
 import "./misc.mjs";
 import "./truncation.mjs";
 import "./tokens.mjs";
-import "./graph.mjs";
+import "./errors.mjs";
 import "./llm.mjs";
+import "./graph.mjs";
 import "./handlers.mjs";
 import "./run.mjs";
 import "./schema.mjs";
-import "./errors.mjs";
 export {};

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

@@ -451,6 +451,8 @@ export declare class AgentContext {
     updateLastCallUsage(usage: Partial<UsageMetadata>): void;
     /** Marks token data as stale before a new LLM call. */
     markTokensStale(): void;
+    /** Returns a snapshot of the deferred tools discovered in this context. */
+    getDiscoveredTools(): string[];
     /**
      * Marks tools as discovered via tool search.
      * Discovered tools will be included in the next model binding.

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

@@ -15,6 +15,8 @@ export declare abstract class Graph<T extends t.BaseGraphState = t.BaseGraphStat
         currentToolMap?: t.ToolMap;
     }): CustomToolNode<T> | ToolNode<T>;
     abstract getRunMessages(): BaseMessage[] | undefined;
+    /** Returns a snapshot of deferred tools discovered by this graph. */
+    getDiscoveredTools(_agentId?: string): string[];
     abstract getContentParts(): t.MessageContentComplex[] | undefined;
     abstract generateStepId(stepKey: string): [string, number];
     abstract getKeyList(metadata: Record<string, unknown> | undefined): (string | number | undefined)[];
@@ -110,6 +112,15 @@ export declare abstract class Graph<T extends t.BaseGraphState = t.BaseGraphStat
     eagerEventToolUsageCount: Map<string, number>;
     private eagerEventToolUsageCountsByAgentId;
     eagerEventToolCallChunks: Map<string, t.EagerEventToolCallChunkState>;
+    /**
+     * Per-run eager prestart circuit breaker, shared by reference with every
+     * ToolNode this graph compiles. When a prestarted execution's args turn
+     * out to differ from the final request, ToolNode records the tool name
+     * here and the stream handler stops prestarting that tool for the rest of
+     * the run — the retry then executes normally instead of re-diverging in a
+     * loop (LibreChat#14371).
+     */
+    eagerEventToolSuppressions: Set<string>;
     /**
      * Run-scoped execution backend for built-in code tools. Defaults to the
      * remote Code API sandbox when unset.
@@ -192,11 +203,23 @@ export declare class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode>
     messages: BaseMessage[];
     /** Cached run messages preserved before clearHeavyState() so getRunMessages() works after cleanup. */
     private cachedRunMessages?;
+    /** Per-agent discovery snapshots preserved before contexts are reset on cleanup. */
+    private cachedDiscoveredTools?;
     /** Ids of AI turns the agent node returned THIS run; see isRunProducedMessage. */
     protected runProducedAiMessageIds: Set<string>;
     /** Checkpoint scope whose messages match index-keyed tool snapshots. */
     private originalToolContentCheckpointScope?;
     runId: string | undefined;
+    /**
+     * Identity used to stamp Langfuse runtime scopes and handlers (see
+     * `LangfuseRuntimeContext.runId`). Carries an opaque per-instance
+     * component: public run ids are unrestricted and may repeat across
+     * concurrently executing runs (retries, duplicate submissions,
+     * tenant-local message ids), and equal stamps would let those runs adopt
+     * each other's scopes. One graph instance = one execution's stamp, shared
+     * by the stream handler and every graph-level scope of that execution.
+     */
+    readonly langfuseScopeRunId: string;
     /**
      * Boundary between historical messages (loaded from conversation state)
      * and messages produced during the current run.  Set once in the state
@@ -329,6 +352,7 @@ export declare class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode>
     private getBaseKeyList;
     checkKeyList(keyList: (string | number | undefined)[]): boolean;
     getRunMessages(): BaseMessage[] | undefined;
+    getDiscoveredTools(agentId?: string): string[];
     /**
      * True when THIS RUN produced `message` — the provenance the handoff cue
      * gate needs. Tracked as an id set rather than inferred from `startIndex`

package/dist/types/hitl/askUserQuestion.d.ts

@@ -52,4 +52,14 @@ import type { AskUserQuestionRequest, AskUserQuestionResolution } from '@/types/
  *   });
  * ```
  */
-export declare function askUserQuestion(question: AskUserQuestionRequest): AskUserQuestionResolution;
+export declare function askUserQuestion(question: AskUserQuestionRequest, options?: {
+    /**
+     * The calling tool's `tool_call_id`, surfaced on the interrupt payload
+     * as `tool_call_id` so hosts can attribute the question (and answer) to
+     * the exact tool-call content part. Tool bodies created with
+     * `tool(fn, …)` receive it as `config.toolCall.id` — LangChain stamps
+     * the full ToolCall onto the config when a tool is invoked with one.
+     * Optional: positional hosts and custom nodes can omit it.
+     */
+    toolCallId?: string;
+}): AskUserQuestionResolution;

package/dist/types/langfuse.d.ts

@@ -1,5 +1,8 @@
 import { CallbackHandler } from '@langfuse/langchain';
+import type { ResolvedLangfuseToolOutputTracingConfig } from '@/langfuseRuntimeContext';
 import type * as t from '@/types';
+import { hasLangfuseConfigCredentials, hasLangfuseEnvCredentials, hasLangfuseEnvConfig } from '@/langfuseConfig';
+export { hasLangfuseConfigCredentials, hasLangfuseEnvCredentials, hasLangfuseEnvConfig, };
 export type LangfuseTraceMetadata = Record<string, string>;
 export type LangfuseTraceAttributes = Record<string, string | number | boolean>;
 type LangfuseConfigTraceAttributes = NonNullable<t.LangfuseConfig['librechatTraceAttributes']>;
@@ -9,6 +12,18 @@ type LangfuseHandlerParams = {
     traceMetadata?: LangfuseTraceMetadata;
     tags?: string[];
     traceIdSeed?: string;
+    /** Identity of the run this handler traces; ambient runtime scopes are
+     *  only adopted when stamped with the same run (see
+     *  `LangfuseRuntimeContext.runId`). */
+    runId?: string;
+    /** The run's resolved tool-output policy — for multi-agent streams the
+     *  conservative aggregate across agents, which `this.langfuse` (the
+     *  primary agent's config) cannot reproduce. Applied when a foreign
+     *  scope's policy is rejected. */
+    toolOutputTracing?: ResolvedLangfuseToolOutputTracingConfig;
+    /** The run's propagated trace name, re-propagated when a foreign scope's
+     *  attributes are cleared. */
+    traceName?: string;
 };
 type AgentLangfuseHandlerParams = LangfuseHandlerParams & {
     langfuse?: t.LangfuseConfig;
@@ -16,10 +31,6 @@ type AgentLangfuseHandlerParams = LangfuseHandlerParams & {
 type LangfuseAttributeParams = AgentLangfuseHandlerParams & {
     traceName?: string;
 };
-export declare function hasLangfuseConfigCredentials(langfuse?: t.LangfuseConfig): langfuse is t.LangfuseConfig & {
-    publicKey: string;
-    secretKey: string;
-};
 export declare function isExplicitLangfuseConfig(langfuse?: t.LangfuseConfig): boolean;
 export declare function createLibreChatTraceAttributes(attributes: LangfuseConfigTraceAttributes): LangfuseTraceAttributes;
 export declare function createLangfuseTraceMetadata({ messageId, parentMessageId, agentId, agentName, }: {
@@ -29,15 +40,12 @@ export declare function createLangfuseTraceMetadata({ messageId, parentMessageId
     agentName?: unknown;
 }): LangfuseTraceMetadata;
 export declare function getLangfuseTraceName(traceMetadata?: LangfuseTraceMetadata, fallback?: string): string;
-export declare function hasLangfuseEnvConfig(): boolean;
-export declare function hasLangfuseEnvCredentials(): boolean;
 export declare function shouldCreateLangfuseHandler(langfuse?: t.LangfuseConfig): boolean;
 export declare function createLegacyLangfuseHandler(params: LangfuseHandlerParams): CallbackHandler;
-export declare function createLangfuseHandler({ langfuse, userId, sessionId, traceMetadata, tags, traceIdSeed, }: AgentLangfuseHandlerParams): CallbackHandler | undefined;
+export declare function createLangfuseHandler({ langfuse, userId, sessionId, traceMetadata, tags, traceIdSeed, runId, toolOutputTracing, traceName, }: AgentLangfuseHandlerParams): CallbackHandler | undefined;
 export declare function withLangfuseAttributes<T>(params: LangfuseAttributeParams, action: () => T): T;
 export declare function hasExplicitLangfuseConfig(contexts: Iterable<{
     langfuse?: t.LangfuseConfig;
 }>): boolean;
 export declare function isLangfuseCallbackHandler(value: unknown): boolean;
 export declare function disposeLangfuseHandler(value: unknown): Promise<void>;
-export {};

package/dist/types/langfuseConfig.d.ts

@@ -2,6 +2,12 @@ import type { ResolvedLangfuseToolOutputTracingConfig } from '@/langfuseRuntimeC
 import type * as t from '@/types';
 export declare const LANGFUSE_TOOL_OUTPUT_REDACTION_TEXT = "[tool output redacted]";
 export declare function normalizeToolName(name: string): string;
+export declare function hasLangfuseConfigCredentials(langfuse?: t.LangfuseConfig): langfuse is t.LangfuseConfig & {
+    publicKey: string;
+    secretKey: string;
+};
+export declare function hasLangfuseEnvCredentials(): boolean;
+export declare function hasLangfuseEnvConfig(): boolean;
 export declare function hasToolOutputTracingConfig(runLangfuse?: t.LangfuseConfig, agentLangfuse?: t.LangfuseConfig): boolean;
 export declare function resolveToolOutputTracingConfig(runLangfuse?: t.LangfuseConfig, agentLangfuse?: t.LangfuseConfig): ResolvedLangfuseToolOutputTracingConfig;
 export declare function resolveLangfuseConfig(runLangfuse?: t.LangfuseConfig, agentLangfuse?: t.LangfuseConfig): t.LangfuseConfig | undefined;

package/dist/types/langfuseRuntimeContext.d.ts

@@ -9,6 +9,22 @@ export type LangfuseRuntimeContext = {
     langfuse?: t.LangfuseConfig;
     traceIdSeed?: string;
     toolOutputTracing?: ResolvedLangfuseToolOutputTracingConfig;
+    /**
+     * Identity of the run this scope belongs to. LangChain executes
+     * non-awaited callbacks on a shared background queue
+     * (`@langchain/core` `consumeCallback`, a process-wide `p-queue` with
+     * concurrency 1), so a callback can run inside a DIFFERENT concurrent
+     * run's async context. Handlers compare this id against their own run to
+     * decide whether an ambient scope is theirs to adopt.
+     */
+    runId?: string;
+    /**
+     * Identity of the agent whose overlay this scope carries, for per-agent
+     * scopes inside a run. Fan-out agents execute concurrently with distinct
+     * Langfuse overlays, so handlers additionally compare this against the
+     * agent a callback reports via its inherited `langgraph_node` metadata.
+     */
+    agentId?: string;
 };
 export declare function hasLangfuseRuntimeContextValue(context: LangfuseRuntimeContext): boolean;
 /** sha256(seed) -> first 32 hex chars; matches `@langfuse/tracing` `createTraceId`. */
@@ -16,11 +32,21 @@ export declare function traceIdFromSeed(seed: string): string;
 export declare function getLangfuseRuntimeContext(): LangfuseRuntimeContext | undefined;
 export declare function getLangfuseRuntimeConfig(): t.LangfuseConfig | undefined;
 export declare function getTraceIdSeed(): string | undefined;
+export declare function getLangfuseScopeRunId(): string | undefined;
+export declare function getLangfuseScopeAgentId(): string | undefined;
 export declare function getLangfuseRuntimeToolOutputTracingConfig(): ResolvedLangfuseToolOutputTracingConfig | undefined;
 /**
  * Runs `fn` with a merged Langfuse runtime context. Undefined fields inherit
  * from the parent scope; callers intentionally cannot clear parent values by
- * passing `undefined`.
+ * passing `undefined` — use `replaceLangfuseRuntimeContext` when the parent
+ * scope must NOT leak through (a foreign concurrent run's scope).
  */
 export declare function runWithLangfuseRuntimeContext<T>(context: LangfuseRuntimeContext, fn: () => T): T;
+/**
+ * Runs `fn` with EXACTLY the provided context — the surrounding scope's
+ * fields do not leak through. A rejected foreign run's explicit destination
+ * or seed must not survive via merge inheritance when this run has none of
+ * its own (env-credential runs, non-deterministic runs).
+ */
+export declare function replaceLangfuseRuntimeContext<T>(context: LangfuseRuntimeContext, fn: () => T): T;
 export declare function runWithTraceIdSeed<T>(seed: string | undefined, fn: () => T): T;

package/dist/types/langfuseRuntimeScope.d.ts

@@ -6,12 +6,27 @@ export type ResolveLangfuseRuntimeScopeParams = {
     runLangfuse?: t.LangfuseConfig;
     langfuseOverlay?: t.LangfuseConfig;
     traceIdSeed?: string;
+    runId?: string;
+    agentId?: string;
+};
+export type LangfuseRuntimeScopeOptions = {
+    /** Replace the surrounding scope entirely instead of merging with it:
+     *  fields absent from `scope` are CLEARED rather than inherited. Required
+     *  when rejecting a foreign concurrent run's scope, whose explicit values
+     *  must not survive merge inheritance. */
+    replace?: boolean;
 };
 export declare function getOtelLangfuseConfig(activeContext: Context): t.LangfuseConfig | undefined;
 export declare function getOtelTraceIdSeed(activeContext: Context): string | undefined;
 export declare function getOtelToolOutputTracingConfig(activeContext: Context): ResolvedLangfuseToolOutputTracingConfig | undefined;
 export declare function resolveLangfuseConfigForSpan(activeContext: Context): t.LangfuseConfig | undefined;
 export declare function resolveTraceIdSeedForSpan(activeContext: Context): string | undefined;
+/** The run identity the active scope belongs to (see
+ *  `LangfuseRuntimeContext.runId`), or `undefined` for unstamped scopes. */
+export declare function resolveLangfuseScopeRunId(activeContext: Context): string | undefined;
+/** The agent identity of a per-agent overlay scope (see
+ *  `LangfuseRuntimeContext.agentId`), or `undefined` for run-level scopes. */
+export declare function resolveLangfuseScopeAgentId(activeContext: Context): string | undefined;
 export declare function resolveToolOutputTracingConfigForSpan(activeContext: Context): ResolvedLangfuseToolOutputTracingConfig | undefined;
-export declare function withLangfuseRuntimeScope<T>(scope: LangfuseRuntimeScope, action: () => T): T;
-export declare function resolveLangfuseRuntimeScope({ runLangfuse, langfuseOverlay, traceIdSeed, }: ResolveLangfuseRuntimeScopeParams): LangfuseRuntimeScope;
+export declare function withLangfuseRuntimeScope<T>(scope: LangfuseRuntimeScope, action: () => T, options?: LangfuseRuntimeScopeOptions): T;
+export declare function resolveLangfuseRuntimeScope({ runLangfuse, langfuseOverlay, traceIdSeed, runId, agentId, }: ResolveLangfuseRuntimeScopeParams): LangfuseRuntimeScope;

package/dist/types/langfuseSpanRegistry.d.ts

@@ -0,0 +1,17 @@
+import type { LangfuseSpanProcessorParams } from '@langfuse/otel';
+import type { Span } from '@opentelemetry/api';
+import type * as t from '@/types';
+export declare function registerLangfuseManagedSpan(span: Span, destinationKey: string): void;
+export declare function getLangfuseManagedSpanDestination(span: Span): string | undefined;
+export declare function getLangfuseSpanProcessorParams(langfuse?: t.LangfuseConfig): LangfuseSpanProcessorParams | undefined;
+/**
+ * Identity of an export destination (project credentials + endpoint +
+ * environment) only. Processor-level policies like `toolOutputTracing` are
+ * deliberately excluded: two spans exporting to the same project under
+ * different redaction settings still share a destination and may parent one
+ * another.
+ */
+export declare function getLangfuseDestinationKey(params: LangfuseSpanProcessorParams): string;
+/** The export destination a run with this config resolves to, or `undefined`
+ *  when no Langfuse destination is configured. */
+export declare function resolveLangfuseDestinationKey(langfuse?: t.LangfuseConfig): string | undefined;

package/dist/types/langfuseTraceShaping.d.ts

@@ -11,7 +11,8 @@ export declare function shouldDropLangfuseSpan(spanName: string): boolean;
  * Reshapes spans per Langfuse-team feedback before export:
  * - `agent=<id>` / `tools=<id>` node names carry the ephemeral agent id
  *   (`provider__model`) — strip it so switching models doesn't break
- *   name-based logic (item 1).
+ *   name-based logic (item 1). The outer workflow node is named with the
+ *   bare agent id; ephemeral ids reduce to their stable sender name.
  * - LLM generation spans keep the provider client class name (`ChatOpenAI`,
  *   `AzureChatOpenAI`, …); rename them to a provider-agnostic `llm` so the
  *   name reflects the operation, not the model (the model stays on the

package/dist/types/llm/anthropic/utils/message_inputs.d.ts

@@ -16,6 +16,7 @@ import { AnthropicMessageCreateParams, AnthropicToolResponse } from '../types';
  */
 export declare function normalizeAnthropicToolCallId(id: string): string;
 export declare function normalizeAnthropicToolCallId(id: string | undefined): string | undefined;
+export declare function coerceAnthropicToolUseInput(input: unknown): Record<string, unknown>;
 export declare function _convertLangChainToolCallToAnthropic(toolCall: ToolCall): AnthropicToolResponse;
 /**
  * Formats messages as a prompt for the model.

package/dist/types/run.d.ts

@@ -102,6 +102,13 @@ export declare class Run<_T extends t.BaseGraphState> {
     private runPreStreamHooks;
     static create<T extends t.BaseGraphState>(config: t.RunConfig): Promise<Run<T>>;
     getRunMessages(): BaseMessage[] | undefined;
+    /**
+     * Returns a defensive snapshot of tools discovered by the current run.
+     * Pass an agent id for that context, or omit it for the ordered union across
+     * contexts. Interrupted state is available immediately for host persistence;
+     * completed runs retain their final snapshot through graph cleanup.
+     */
+    getDiscoveredTools(agentId?: string): string[];
     /**
      * Returns the current calibration ratio (EMA of provider-vs-estimate token ratios).
      * Hosts should persist this value and pass it back as `RunConfig.calibrationRatio`

package/dist/types/session/types.d.ts

@@ -35,6 +35,7 @@ export interface SerializedSessionMessage {
     name?: string;
     toolCallId?: string;
     toolCalls?: JsonValue;
+    invalidToolCalls?: JsonValue;
     usageMetadata?: JsonObject;
 }
 export type SessionMessageEntry = SessionEntryBase<'message', {

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

@@ -129,6 +129,12 @@ export declare class ToolNode<T = any> extends RunnableCallable<T, T> {
     private eagerEventToolExecutions?;
     /** Shared per-run per-tool turn counter used by eager and normal event dispatch. */
     private eagerEventToolUsageCount?;
+    /**
+     * Shared per-run eager prestart circuit breaker. Tool names added here
+     * (when a prestarted execution's args mismatch the final request) are no
+     * longer prestarted by the stream handler for the rest of the run.
+     */
+    private eagerEventToolSuppressions?;
     /** Agent ID for event-driven mode */
     private agentId?;
     /**
@@ -194,7 +200,7 @@ export declare class ToolNode<T = any> extends RunnableCallable<T, T> {
      * other's in-flight state.
      */
     private anonBatchCounter;
-    constructor({ tools, toolMap, name, tags, trace, runLangfuse, agentLangfuse, errorHandler, toolCallStepIds, handleToolErrors, loadRuntimeTools, toolRegistry, sessions, eventDrivenMode, eagerEventToolExecution, eagerEventToolExecutions, eagerEventToolUsageCount, agentId, executingAgentId, directToolNames, interruptingToolNames, codeSessionToolNames, maxContextTokens, maxToolResultChars, hookRegistry, humanInTheLoop, toolOutputReferences, toolOutputRegistry, toolExecution, fileCheckpointer, }: t.ToolNodeConstructorParams);
+    constructor({ tools, toolMap, name, tags, trace, runLangfuse, agentLangfuse, errorHandler, toolCallStepIds, handleToolErrors, loadRuntimeTools, toolRegistry, sessions, eventDrivenMode, eagerEventToolExecution, eagerEventToolExecutions, eagerEventToolUsageCount, eagerEventToolSuppressions, agentId, executingAgentId, directToolNames, interruptingToolNames, codeSessionToolNames, maxContextTokens, maxToolResultChars, hookRegistry, humanInTheLoop, toolOutputReferences, toolOutputRegistry, toolExecution, fileCheckpointer, }: t.ToolNodeConstructorParams);
     invoke(input: any, options?: Partial<RunnableConfig>): Promise<any>;
     /**
      * Returns the run-scoped tool output registry, or `undefined` when

package/dist/types/types/hitl.d.ts

@@ -151,6 +151,14 @@ export interface AskUserQuestionRequest {
 export interface AskUserQuestionInterruptPayload {
     type: 'ask_user_question';
     question: AskUserQuestionRequest;
+    /**
+     * The `tool_call_id` of the ask-tool call that raised this interrupt,
+     * when the tool body supplied it (see `askUserQuestion`'s `options`).
+     * Lets hosts attribute the question — and later the answer — to the
+     * exact tool-call content part instead of guessing by position, which
+     * mislabels cards when a model emits several ask calls in one turn.
+     */
+    tool_call_id?: string;
 }
 /**
  * Discriminated union of every interrupt payload the SDK raises. New

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

@@ -69,6 +69,28 @@ export type EagerEventToolCallChunkState = {
     argsText: string;
     index?: number;
     lastArgsFragment?: string;
+    /**
+     * Cumulative length of every observed args fragment — the length of the
+     * plain in-order concatenation that LangChain's `AIMessageChunk.concat`
+     * performs to build the final tool call. Every reconciliation branch in
+     * `mergeToolCallArgsText` (and the repeat-fragment dedupe) produces text no
+     * longer than plain concatenation, with equality exactly when every merge
+     * was a pure append — so `argsText.length === rawArgsLength` proves
+     * `argsText` IS the canonical accumulation the final request will carry.
+     * Tracking only the length keeps cumulative/restating streams from
+     * retaining every prefix (quadratic growth) while still letting seal-time
+     * prestart verify the snapshot.
+     */
+    rawArgsLength?: number;
+    /**
+     * The non-empty args fragment carried by a chunk whose explicit adapter
+     * seal covered this call. Some adapters restate the finished call's full
+     * args on the seal chunk (OpenAI Responses `function_call_arguments.done`);
+     * only such a restatement may override the canonical-accumulation check at
+     * seal time. Pure-signal seals (Bedrock `contentBlockStop`, `args: ''`)
+     * never set this.
+     */
+    sealedArgsFragment?: string;
 };
 export type ToolNodeOptions = {
     name?: string;
@@ -146,6 +168,14 @@ export type ToolNodeOptions = {
     eagerEventToolExecutions?: Map<string, EagerEventToolExecution>;
     /** Shared per-run per-tool turn counter used by eager and normal event dispatch. */
     eagerEventToolUsageCount?: Map<string, number>;
+    /**
+     * Shared per-run circuit breaker for eager prestart. When a prestarted
+     * execution's args turn out to differ from the final request ("changed
+     * after eager execution started"), the ToolNode adds the tool name here
+     * and the stream handler stops prestarting that tool for the remainder of
+     * the run, so the model's retry executes normally instead of looping.
+     */
+    eagerEventToolSuppressions?: Set<string>;
     /**
      * Hook registry for PreToolUse/PostToolUse/PostToolUseFailure/
      * PermissionDenied lifecycle hooks. Fires for **every** tool the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@librechat/agents",
-  "version": "3.3.8",
+  "version": "3.3.10",
   "main": "./dist/cjs/main.cjs",
   "module": "./dist/esm/main.mjs",
   "types": "./dist/types/index.d.ts",
@@ -199,7 +199,9 @@
     "re": "bun run clean && bun install && rm -rf ./dist && turbo build",
     "lint": "eslint \"{,!(node_modules|venv)/**/}*.{js,jsx,ts,tsx}\" --fix",
     "format": "prettier --write .",
-    "audit": "npm audit --omit=dev"
+    "audit": "npm audit --omit=dev",
+    "label:eval": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/activity-labels/run.ts",
+    "label:rescore": "node ./src/scripts/activity-labels/rescore.cjs"
   },
   "overrides": {
     "@langchain/openai": "1.5.5",
@@ -224,17 +226,17 @@
     "@langchain/google-gauth": "2.2.0",
     "@langchain/google-genai": "2.2.0",
     "@langchain/google-vertexai": "2.2.0",
-    "@langchain/langgraph": "^1.4.6",
+    "@langchain/langgraph": "1.4.8",
     "@langchain/mistralai": "^1.2.0",
     "@langchain/openai": "1.5.5",
     "@langchain/textsplitters": "^1.0.1",
     "@langchain/xai": "^1.4.3",
+    "@langfuse/core": "^5.4.1",
     "@langfuse/langchain": "^5.4.1",
     "@langfuse/otel": "^5.4.1",
     "@langfuse/tracing": "^5.4.1",
     "@opentelemetry/context-async-hooks": "^2.9.0",
     "@opentelemetry/sdk-node": "^0.220.0",
-    "@scarf/scarf": "^1.4.0",
     "@types/diff": "^7.0.2",
     "ai-tokenizer": "^1.0.6",
     "axios": "^1.18.1",
@@ -246,6 +248,7 @@
     "nanoid": "^3.3.7",
     "okapibm25": "^1.4.1",
     "openai": "^6.46.0",
+    "reo-census": "^1.2.9",
     "uuid": "^11.1.1"
   },
   "peerDependencies": {