@librechat/agents 3.1.76 → 3.1.77

package/dist/types/hooks/types.d.ts

@@ -7,7 +7,7 @@ import type { BaseMessage } from '@langchain/core/messages';
  * `docs/hooks-design-report.md` §3.2 for the mapping to existing
  * `@librechat/agents` emission points.
  */
-export declare const HOOK_EVENTS: readonly ["RunStart", "UserPromptSubmit", "PreToolUse", "PostToolUse", "PostToolUseFailure", "PermissionDenied", "SubagentStart", "SubagentStop", "Stop", "StopFailure", "PreCompact", "PostCompact"];
+export declare const HOOK_EVENTS: readonly ["RunStart", "UserPromptSubmit", "PreToolUse", "PostToolUse", "PostToolUseFailure", "PostToolBatch", "PermissionDenied", "SubagentStart", "SubagentStop", "Stop", "StopFailure", "PreCompact", "PostCompact"];
 export type HookEvent = (typeof HOOK_EVENTS)[number];
 /** Tool-gating decision; executeHooks folds with `deny > ask > allow` precedence. */
 export type ToolDecision = 'allow' | 'deny' | 'ask';
@@ -75,6 +75,40 @@ export interface PostToolUseFailureHookInput extends BaseHookInput {
     stepId?: string;
     turn?: number;
 }
+/**
+ * Per-tool result snapshot included in a `PostToolBatch` event. Mirrors
+ * the data PostToolUse / PostToolUseFailure get individually, but the
+ * batch view lets a single hook see the whole set so it can inject one
+ * consolidated convention/audit message rather than N per-tool ones.
+ */
+export interface PostToolBatchEntry {
+    toolName: string;
+    toolInput: Record<string, unknown>;
+    toolUseId: string;
+    stepId?: string;
+    turn?: number;
+    /** Successful tool output, present only when `status === 'success'`. */
+    toolOutput?: unknown;
+    /** Error message, present only when `status === 'error'`. */
+    error?: string;
+    status: 'success' | 'error';
+}
+/**
+ * Fires once after every tool call in a single batch finishes (including
+ * any that were rejected via HITL). Lets a hook react to the batch as a
+ * whole — useful for "inject conventions once for the whole batch", batch
+ * audit logging, or coordinating cleanup that depends on knowing the full
+ * result set rather than streaming each tool's result independently.
+ *
+ * Order: fires AFTER all per-tool PostToolUse / PostToolUseFailure hooks
+ * for the same batch have completed, BEFORE the next model call. Pass an
+ * `additionalContext` to inject context for that next model turn.
+ */
+export interface PostToolBatchHookInput extends BaseHookInput {
+    hook_event_name: 'PostToolBatch';
+    /** All tool calls (and their outcomes) from this batch, in batch order. */
+    entries: PostToolBatchEntry[];
+}
 export interface PermissionDeniedHookInput extends BaseHookInput {
     hook_event_name: 'PermissionDenied';
     toolName: string;
@@ -128,7 +162,7 @@ export interface PostCompactHookInput extends BaseHookInput {
     messagesAfterCount: number;
 }
 /** Discriminated union of every hook input shape. */
-export type HookInput = RunStartHookInput | UserPromptSubmitHookInput | PreToolUseHookInput | PostToolUseHookInput | PostToolUseFailureHookInput | PermissionDeniedHookInput | SubagentStartHookInput | SubagentStopHookInput | StopHookInput | StopFailureHookInput | PreCompactHookInput | PostCompactHookInput;
+export type HookInput = RunStartHookInput | UserPromptSubmitHookInput | PreToolUseHookInput | PostToolUseHookInput | PostToolUseFailureHookInput | PostToolBatchHookInput | PermissionDeniedHookInput | SubagentStartHookInput | SubagentStopHookInput | StopHookInput | StopFailureHookInput | PreCompactHookInput | PostCompactHookInput;
 /** Compile-time map from event name to its input shape. */
 export type HookInputByEvent = {
     RunStart: RunStartHookInput;
@@ -136,6 +170,7 @@ export type HookInputByEvent = {
     PreToolUse: PreToolUseHookInput;
     PostToolUse: PostToolUseHookInput;
     PostToolUseFailure: PostToolUseFailureHookInput;
+    PostToolBatch: PostToolBatchHookInput;
     PermissionDenied: PermissionDeniedHookInput;
     SubagentStart: SubagentStartHookInput;
     SubagentStop: SubagentStopHookInput;
@@ -155,6 +190,56 @@ export interface BaseHookOutput {
     preventContinuation?: boolean;
     /** Reason reported alongside `preventContinuation`. */
     stopReason?: string;
+    /**
+     * Marks this hook output as fire-and-forget for INFLUENCE only.
+     * When `true`, the SDK skips every other field on this output —
+     * `decision`, `additionalContext`, `updatedInput`,
+     * `preventContinuation`, `allowedDecisions`, `updatedOutput` are
+     * all ignored. The hook's return value cannot block, modify, or
+     * inject context, so it's safe to use for pure side effects
+     * (logging, metrics, webhooks).
+     *
+     * Important caveat: the hook's CALLBACK promise is still awaited
+     * by `executeHooks` (subject to the matcher's timeout and the
+     * default `DEFAULT_HOOK_TIMEOUT_MS`). The SDK does not
+     * speculatively detach hooks based on output shape, because the
+     * shape is only known after the promise resolves. For TRUE
+     * fire-and-forget where the agent doesn't wait at all, the hook
+     * body should detach its side effect itself and return
+     * immediately:
+     *
+     * @example
+     * ```ts
+     * async (input) => {
+     *   // Detach the slow work — the SDK awaits this hook's
+     *   // returned promise, which resolves immediately because we
+     *   // don't `await` the side effect.
+     *   void sendToLoggingService(input).catch(console.error);
+     *   return { async: true };
+     * };
+     * ```
+     *
+     * @example WRONG — the agent will block on the webhook
+     * ```ts
+     * async (input) => {
+     *   await sendToLoggingService(input);  // ← awaited, blocks
+     *   return { async: true };  // returning async:true doesn't undo the await
+     * };
+     * ```
+     *
+     * Mirrors Claude Code Agent SDK's `async` output, with the same
+     * "detach inside the hook body" pattern.
+     */
+    async?: boolean;
+    /**
+     * Optional advisory timeout in milliseconds for the background work
+     * a host has detached inside an `async: true` hook body. The SDK
+     * does not enforce this (the hook's own AbortSignal handling does)
+     * but the field is preserved on the wire so downstream
+     * observability can surface long-running side effects. Ignored
+     * unless `async` is true.
+     */
+    asyncTimeout?: number;
 }
 export type RunStartHookOutput = BaseHookOutput;
 export interface UserPromptSubmitHookOutput extends BaseHookOutput {
@@ -175,6 +260,19 @@ export interface PreToolUseHookOutput extends BaseHookOutput {
      * `updatedInput` to one hook per matcher to avoid confusing precedence.
      */
     updatedInput?: Record<string, unknown>;
+    /**
+     * Restricts which decisions the host UI is allowed to surface for this
+     * tool call when the hook returns `decision: 'ask'`. Pass to lock a
+     * tool down to a subset of `'approve' | 'reject' | 'edit' | 'respond'`
+     * — for example, `['approve', 'reject']` to forbid the user from
+     * editing the tool's args or substituting a custom response.
+     *
+     * The values flow into the resulting interrupt's
+     * `review_configs[i].allowed_decisions`. Omitting the field keeps the
+     * SDK default (all four decisions advertised). Last-writer-wins in
+     * registration order, same precedence rules as `updatedInput`.
+     */
+    allowedDecisions?: ReadonlyArray<'approve' | 'reject' | 'edit' | 'respond'>;
 }
 export interface PostToolUseHookOutput extends BaseHookOutput {
     /**
@@ -186,6 +284,7 @@ export interface PostToolUseHookOutput extends BaseHookOutput {
     updatedOutput?: unknown;
 }
 export type PostToolUseFailureHookOutput = BaseHookOutput;
+export type PostToolBatchHookOutput = BaseHookOutput;
 export type PermissionDeniedHookOutput = BaseHookOutput;
 export interface SubagentStartHookOutput extends BaseHookOutput {
     decision?: ToolDecision;
@@ -206,6 +305,7 @@ export type HookOutputByEvent = {
     PreToolUse: PreToolUseHookOutput;
     PostToolUse: PostToolUseHookOutput;
     PostToolUseFailure: PostToolUseFailureHookOutput;
+    PostToolBatch: PostToolBatchHookOutput;
     PermissionDenied: PermissionDeniedHookOutput;
     SubagentStart: SubagentStartHookOutput;
     SubagentStop: SubagentStopHookOutput;
@@ -215,7 +315,7 @@ export type HookOutputByEvent = {
     PostCompact: PostCompactHookOutput;
 };
 /** Superset output shape used by the executor's fold loop. */
-export type HookOutput = RunStartHookOutput | UserPromptSubmitHookOutput | PreToolUseHookOutput | PostToolUseHookOutput | PostToolUseFailureHookOutput | PermissionDeniedHookOutput | SubagentStartHookOutput | SubagentStopHookOutput | StopHookOutput | StopFailureHookOutput | PreCompactHookOutput | PostCompactHookOutput;
+export type HookOutput = RunStartHookOutput | UserPromptSubmitHookOutput | PreToolUseHookOutput | PostToolUseHookOutput | PostToolUseFailureHookOutput | PostToolBatchHookOutput | PermissionDeniedHookOutput | SubagentStartHookOutput | SubagentStopHookOutput | StopHookOutput | StopFailureHookOutput | PreCompactHookOutput | PostCompactHookOutput;
 /**
  * A hook callback is a plain async function registered against a specific
  * event. The `signal` is always supplied by `executeHooks` and combines the
@@ -297,6 +397,12 @@ export interface AggregatedHookResult {
      * hook per matcher to avoid subtle precedence bugs.
      */
     updatedInput?: Record<string, unknown>;
+    /**
+     * Restricted decision set from a `PreToolUse` hook. Same last-writer-wins
+     * semantics as `updatedInput`. Surfaces to the interrupt payload's
+     * `review_configs[i].allowed_decisions`.
+     */
+    allowedDecisions?: ReadonlyArray<'approve' | 'reject' | 'edit' | 'respond'>;
     /**
      * Replacement tool output from a `PostToolUse` hook.
      *

package/dist/types/index.d.ts

@@ -23,8 +23,17 @@ export * from './tools/search';
 export * from './common';
 export * from './utils';
 export * from './hooks';
+export * from './hitl';
 export type * from './types';
 export * from './langchain';
+/**
+ * HITL primitives re-exported from `@langchain/langgraph` so hosts that
+ * build durable checkpoint savers, dispatch `Command({ resume })`, or
+ * detect interrupts can do so against the same langgraph instance the
+ * SDK was compiled against — avoiding accidental dual-version drift.
+ */
+export { Command, INTERRUPT, interrupt, MemorySaver, BaseCheckpointSaver, isInterrupted, } from '@langchain/langgraph';
+export type { Interrupt } from '@langchain/langgraph';
 export { CustomOpenAIClient } from './llm/openai';
 export { ChatOpenRouter } from './llm/openrouter';
 export type { OpenRouterReasoning, OpenRouterReasoningEffort, ChatOpenRouterCallOptions, } from './llm/openrouter';

package/dist/types/llm/openai/index.d.ts

@@ -1,17 +1,20 @@
 import { AzureOpenAI as AzureOpenAIClient } from 'openai';
 import { ChatXAI as OriginalChatXAI } from '@langchain/xai';
 import { ChatGenerationChunk } from '@langchain/core/outputs';
+import { AIMessageChunk } from '@langchain/core/messages';
 import { ChatDeepSeek as OriginalChatDeepSeek } from '@langchain/deepseek';
 import { CallbackManagerForLLMRun } from '@langchain/core/callbacks/manager';
 import { OpenAIClient, ChatOpenAI as OriginalChatOpenAI, AzureChatOpenAI as OriginalAzureChatOpenAI } from '@langchain/openai';
 import type { HeaderValue, HeadersLike } from './types';
 import type { BaseMessage } from '@langchain/core/messages';
 import type { BindToolsInput } from '@langchain/core/language_models/chat_models';
+import type { ChatResult } from '@langchain/core/outputs';
 import type { ChatXAIInput } from '@langchain/xai';
 import type * as t from '@langchain/openai';
 export declare function isHeaders(headers: unknown): headers is Headers;
 export declare function normalizeHeaders(headers: HeadersLike): Record<string, HeaderValue | readonly HeaderValue[]>;
 type OpenAICoreRequestOptions = OpenAIClient.RequestOptions;
+type OpenAICompletionParam = OpenAIClient.Chat.Completions.ChatCompletionMessageParam;
 type LibreChatOpenAIFields = t.ChatOpenAIFields & {
     _lc_stream_delay?: number;
     includeReasoningContent?: boolean;
@@ -82,8 +85,22 @@ export declare class ChatDeepSeek extends OriginalChatDeepSeek {
     });
     get exposedClient(): CustomOpenAIClient;
     static lc_name(): 'LibreChatDeepSeek';
+    protected _convertDeepSeekMessages(messages: BaseMessage[]): OpenAICompletionParam[];
+    _generate(messages: BaseMessage[], options: this['ParsedCallOptions'], runManager?: CallbackManagerForLLMRun): Promise<ChatResult>;
     _getClientOptions(options?: OpenAICoreRequestOptions): OpenAICoreRequestOptions;
     _streamResponseChunks(messages: BaseMessage[], options: this['ParsedCallOptions'], runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;
+    /** Parses raw `<think>` fallback tags across chunks and emits sanitized DeepSeek stream chunks. */
+    protected _streamResponseChunksWithReasoning(messages: BaseMessage[], options: this['ParsedCallOptions'], runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;
+    protected _streamResponseChunksFromReasoningMessages(messages: BaseMessage[], options: this['ParsedCallOptions']): AsyncGenerator<ChatGenerationChunk>;
+    protected _createDeepSeekStreamChunk(chunk: ChatGenerationChunk, content: string, additionalKwargs?: AIMessageChunk['additional_kwargs'], text?: string): ChatGenerationChunk;
+    protected _createDeepSeekReasoningStreamChunk(chunk: ChatGenerationChunk, reasoningContent: string): ChatGenerationChunk;
+    protected _yieldDeepSeekReasoningText(chunk: ChatGenerationChunk, reasoningContent: string, runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;
+    protected _yieldDeepSeekStreamChunk(chunk: ChatGenerationChunk, runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;
+    protected _getDeepSeekTokenIndices(chunk: ChatGenerationChunk): {
+        prompt: number;
+        completion: number;
+    } | undefined;
+    protected _getDeepSeekPartialTagSplitIndex(text: string, tag: string): number;
 }
 /** xAI-specific usage metadata type */
 export interface XAIUsageMetadata extends OpenAIClient.Completions.CompletionUsage {

package/dist/types/run.d.ts

@@ -1,4 +1,5 @@
 import './instrumentation';
+import { Command } from '@langchain/langgraph';
 import type { MessageContentComplex, BaseMessage } from '@langchain/core/messages';
 import type { RunnableConfig } from '@langchain/core/runnables';
 import type * as t from '@/types';
@@ -10,6 +11,7 @@ export declare class Run<_T extends t.BaseGraphState> {
     private tokenCounter?;
     private handlerRegistry?;
     private hookRegistry?;
+    private humanInTheLoop?;
     private toolOutputReferences?;
     private indexTokenCountMap?;
     calibrationRatio: number;
@@ -18,9 +20,70 @@ export declare class Run<_T extends t.BaseGraphState> {
     returnContent: boolean;
     private skipCleanup;
     private _streamResult;
+    /**
+     * Captured interrupt payload typed as `unknown` because the SDK
+     * does not validate the runtime shape — custom graph nodes can
+     * raise interrupts with arbitrary payloads (not just the SDK's
+     * `HumanInterruptPayload` union). The public `getInterrupt<T>()`
+     * lets callers assert the type they expect.
+     */
+    private _interrupt;
+    private _haltedReason;
     private constructor();
     private createLegacyGraph;
     private createMultiAgentGraph;
+    /**
+     * When the host opted into HITL via `humanInTheLoop: { enabled: true }`
+     * and did not supply a checkpointer, install an in-memory `MemorySaver`
+     * so `interrupt()` can persist checkpoints and `Command({ resume })`
+     * can rebuild state. The fallback is intentionally process-local:
+     * production hosts that need durable resumption across processes /
+     * restarts must provide their own checkpointer (Redis, Postgres, etc.)
+     * on `compileOptions.checkpointer`.
+     *
+     * No-op when HITL is off (the default — omitted, or
+     * `{ enabled: false }`) or the host already supplied a checkpointer
+     * of their own. See `HumanInTheLoopConfig` JSDoc for the rationale
+     * behind the default-off stance.
+     */
+    private applyHITLCheckpointerFallback;
+    /**
+     * Run RunStart + UserPromptSubmit hooks before the graph stream
+     * begins, accumulate any `additionalContext` strings into the input
+     * messages, and short-circuit when a hook signals the run should not
+     * proceed (deny / ask decision on the prompt, or `preventContinuation`
+     * on either hook).
+     *
+     * Returns `true` when the caller should bail with `undefined` (run
+     * was halted before any model call); returns `false` to proceed
+     * into the stream loop.
+     *
+     * ## Side effects
+     *
+     * On the success path:
+     *   - Mutates `stateInputs.messages` in place to append a
+     *     consolidated `HumanMessage` carrying any hook
+     *     `additionalContext` strings. Safe because the host owns the
+     *     array and `processStream` is the only consumer until LangGraph
+     *     reads it.
+     *
+     * On the halt path (returning `true`):
+     *   - Sets `this._haltedReason` so callers (and the eventual host)
+     *     can distinguish a hook-driven halt from a natural completion.
+     *   - Calls `registry.clearSession(this.id)` and
+     *     `registry.clearHaltSignal(this.id)` because no resume is
+     *     expected from a pre-stream halt — the run never entered the
+     *     graph, so the session/halt state for this run would otherwise
+     *     leak to the next `processStream` invocation on the same
+     *     registry. Other concurrent runs on the same registry are
+     *     untouched (halt signals are scoped per session id).
+     *   - Sets `config.callbacks = undefined` to drop the callback
+     *     references the caller built (langfuse handler, custom event
+     *     handler, etc.) since they won't be exercised. Mirrors the
+     *     equivalent cleanup the `processStream` `finally` block does
+     *     on the natural-completion path.
+     */
+    private runPreStreamHooks;
     static create<T extends t.BaseGraphState>(config: t.RunConfig): Promise<Run<T>>;
     getRunMessages(): BaseMessage[] | undefined;
     /**
@@ -37,7 +100,60 @@ export declare class Run<_T extends t.BaseGraphState> {
      * and processes them through our handler registry instead of EventStreamCallbackHandler
      */
     private createCustomEventCallback;
-    processStream(inputs: t.IState, callerConfig: Partial<RunnableConfig> & {
+    processStream(inputs: t.IState | Command, callerConfig: Partial<RunnableConfig> & {
+        version: 'v1' | 'v2';
+        run_id?: string;
+    }, streamOptions?: t.EventStreamOptions): Promise<MessageContentComplex[] | undefined>;
+    /**
+     * Returns the pending interrupt captured during the most recent
+     * `processStream` (or `resume`) invocation. `undefined` when the run
+     * either has not been streamed yet or completed without pausing.
+     *
+     * Hosts call this immediately after `processStream` returns to decide
+     * whether the run is awaiting human input. Persist the returned
+     * descriptor (alongside `thread_id` and the agent run config) so a
+     * later `resume(decisions)` can rebuild the run.
+     *
+     * The default `TPayload` is the SDK's `HumanInterruptPayload` union
+     * (`tool_approval` / `ask_user_question`), suitable for the common
+     * case where interrupts come from the built-in ToolNode or
+     * `askUserQuestion()` helper. Hosts that raise custom interrupts
+     * from custom graph nodes pass their own type — the SDK does not
+     * validate the runtime shape, it just transports whatever the
+     * `interrupt()` call carried. When in doubt, narrow with the
+     * `isToolApprovalInterrupt` / `isAskUserQuestionInterrupt` type
+     * guards (which accept `unknown`) before reading variant-specific
+     * fields.
+     */
+    getInterrupt<TPayload = t.HumanInterruptPayload>(): t.RunInterruptResult<TPayload> | undefined;
+    /**
+     * Returns the reason a hook halted the run via
+     * `preventContinuation: true`, or `undefined` if no hook halted.
+     *
+     * Hosts inspect this after `processStream` returns to distinguish a
+     * natural completion (`undefined`) from a hook-driven halt (a
+     * truthy string). Independent from `getInterrupt()` — a halted run
+     * has no interrupt; an interrupted run has no halt reason.
+     */
+    getHaltReason(): string | undefined;
+    /**
+     * Resume a paused HITL run with the value the user (or whatever
+     * decided the interrupt) supplied. The default `TResume` covers the
+     * `tool_approval` interrupt (the common case): an array of decisions
+     * in `action_requests` order, or a record keyed by `tool_call_id`.
+     *
+     * For other interrupt types (e.g., `ask_user_question` →
+     * `AskUserQuestionResolution`, or any custom interrupt a host raises
+     * from a custom node), pass the type parameter and the SDK forwards
+     * the value through unchanged. LangGraph delivers it as the return
+     * value of the original `interrupt()` call inside the paused node.
+     *
+     * The host MUST construct this Run with the same `thread_id` and the
+     * same checkpointer as the original paused run; LangGraph rebuilds
+     * graph state from the checkpoint and re-enters the interrupted node
+     * from the start.
+     */
+    resume<TResume = t.ToolApprovalDecision[] | t.ToolApprovalDecisionMap>(resumeValue: TResume, callerConfig: Partial<RunnableConfig> & {
         version: 'v1' | 'v2';
         run_id?: string;
     }, streamOptions?: t.EventStreamOptions): Promise<MessageContentComplex[] | undefined>;

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

@@ -47,6 +47,12 @@ export declare class ToolNode<T = any> extends RunnableCallable<T, T> {
     private maxToolResultChars;
     /** Hook registry for PreToolUse/PostToolUse lifecycle hooks */
     private hookRegistry?;
+    /**
+     * Run-scoped HITL config. When `enabled`, `ask` decisions from
+     * PreToolUse hooks raise a LangGraph `interrupt()` instead of being
+     * treated as fail-closed denies.
+     */
+    private humanInTheLoop?;
     /**
      * Registry of tool outputs keyed by `tool<idx>turn<turn>`.
      *
@@ -67,7 +73,7 @@ export declare class ToolNode<T = any> extends RunnableCallable<T, T> {
      * other's in-flight state.
      */
     private anonBatchCounter;
-    constructor({ tools, toolMap, name, tags, errorHandler, toolCallStepIds, handleToolErrors, loadRuntimeTools, toolRegistry, sessions, eventDrivenMode, agentId, directToolNames, maxContextTokens, maxToolResultChars, hookRegistry, toolOutputReferences, toolOutputRegistry, }: t.ToolNodeConstructorParams);
+    constructor({ tools, toolMap, name, tags, errorHandler, toolCallStepIds, handleToolErrors, loadRuntimeTools, toolRegistry, sessions, eventDrivenMode, agentId, directToolNames, maxContextTokens, maxToolResultChars, hookRegistry, humanInTheLoop, toolOutputReferences, toolOutputRegistry, }: t.ToolNodeConstructorParams);
     /**
      * Returns the run-scoped tool output registry, or `undefined` when
      * the feature is disabled.
@@ -155,6 +161,25 @@ export declare class ToolNode<T = any> extends RunnableCallable<T, T> {
      *    ToolMessages (appended AFTER to respect provider ordering).
      */
     private dispatchToolEvents;
+    /**
+     * Fires the `PostToolBatch` hook (if registered) and appends the
+     * accumulated batch-level `additionalContext` strings to `injected`
+     * as a single `HumanMessage`. Entries are materialized in the
+     * original `toolCalls` order so hooks correlating outcomes by
+     * position (as the type docs promise) see exactly the sequence
+     * the model emitted, regardless of when each individual outcome
+     * was recorded into the map (deny synchronous, approved
+     * post-execution, respond on resume).
+     *
+     * The PostToolBatch hook's `additionalContexts` flow into the same
+     * batch accumulator per-tool hooks already use, so a single
+     * batch-level convention message can be injected through one path.
+     *
+     * Mutates `batchAdditionalContexts` (push from batch hook) and
+     * `injected` (push the consolidated HumanMessage). The caller owns
+     * those arrays and consumes them right after this returns.
+     */
+    private dispatchPostToolBatchAndInjectContext;
     private dispatchStepCompleted;
     /**
      * Converts InjectedMessage instances to LangChain HumanMessage objects.