@librechat/agents 3.9.2 → 3.9.3

package/src/graphs/MultiAgentGraph.ts

@@ -33,6 +33,7 @@ import {
   HARD_MAX_TOOL_RESULT_CHARS,
 } from '@/utils/truncation';
 import { withInstructionlessHandoffCue } from '@/messages/handoffCue';
+import { HandoffRouting, handoffStateAnnotation } from './handoff';
 import { serializeToolContentBounded } from '@/utils/toolContent';
 import { Constants, MULTI_AGENT_GRAPH_RUN_NAME } from '@/common';
 import { StandardGraph } from './Graph';
@@ -337,6 +338,7 @@ export class MultiAgentGraph extends StandardGraph {
   private handoffSourceIds = new Set<string>();
   private readonly resultAgentId?: string;
   private readonly memberRecursionLimit?: number;
+  private reachableAgentIds?: Set<string>;
   private handoffPromptLabels: Map<string, Set<string>> = new Map();
   /**
    * Map of agentId to parallel group info.
@@ -379,9 +381,115 @@ export class MultiAgentGraph extends StandardGraph {
     this.categorizeEdges();
     this.validateCommandRoutedDirectEdges();
     this.analyzeGraph();
+    if (input.entryAgentId != null) {
+      if (!this.agentContexts.has(input.entryAgentId)) {
+        throw new Error(
+          `MultiAgentGraph: unknown entryAgentId "${input.entryAgentId}"`
+        );
+      }
+      this.startingNodes = new Set([input.entryAgentId]);
+      this.defaultAgentId = input.entryAgentId;
+      this.computeParallelCapability();
+      this.reachableAgentIds = this.resolveEntryReachability(
+        input.entryAgentId
+      );
+    }
+    if (
+      input.maxHandoffs != null &&
+      (!Number.isSafeInteger(input.maxHandoffs) || input.maxHandoffs < 0)
+    ) {
+      throw new Error(
+        'MultiAgentGraph: maxHandoffs must be a non-negative safe integer'
+      );
+    }
+    const directDestinations = new Map<string, Set<string>>();
+    for (const edge of this.directEdges) {
+      if (edge.handoffScope != null)
+        throw new Error('handoffScope is only valid on handoff edges');
+      for (const source of Array.isArray(edge.from) ? edge.from : [edge.from]) {
+        const targets = directDestinations.get(source) ?? new Set<string>();
+        for (const target of Array.isArray(edge.to) ? edge.to : [edge.to])
+          targets.add(target);
+        directDestinations.set(source, targets);
+      }
+    }
+    this.handoffRouting = new HandoffRouting(
+      this.startingNodes.values().next().value ?? this.defaultAgentId,
+      input.maxHandoffs,
+      this.startingNodes.size > 1 ||
+        [...directDestinations.values()].some((targets) => targets.size > 1)
+    );
+    this.validateHandoffScopes();
     this.createHandoffTools();
   }
 
+  private validateHandoffScopes(): void {
+    const scopes = new Map<string, string>();
+    for (const edge of this.handoffEdges) {
+      const scope = edge.handoffScope ?? 'turn';
+      if (!['turn', 'conversation'].includes(scope))
+        throw new Error('Invalid handoffScope');
+      for (const source of Array.isArray(edge.from) ? edge.from : [edge.from]) {
+        const destinations = Array.isArray(edge.to) ? edge.to : [edge.to];
+        const targets =
+          edge.condition != null ? ['conditional_transfer'] : destinations;
+        for (const target of targets) {
+          const key = JSON.stringify([source, target]);
+          const previous = scopes.get(key);
+          if (previous != null && previous !== scope)
+            throw new Error(
+              'Conflicting handoffScope for the same transfer tool'
+            );
+          scopes.set(key, scope);
+        }
+      }
+    }
+  }
+
+  private resolveEntryReachability(entryAgentId: string): Set<string> {
+    const reachable = new Set([entryAgentId]);
+    const direct = new Set(this.directEdges);
+    const outgoing = new Map<string, t.GraphEdge[]>();
+    const remaining = new Map<t.GraphEdge, number>();
+    for (const edge of this.edges) {
+      const sources = new Set(
+        Array.isArray(edge.from) ? edge.from : [edge.from]
+      );
+      remaining.set(edge, direct.has(edge) ? sources.size : 1);
+      for (const source of sources) {
+        const edges = outgoing.get(source) ?? [];
+        edges.push(edge);
+        outgoing.set(source, edges);
+      }
+    }
+    const queue = [entryAgentId];
+    for (let i = 0; i < queue.length; i++) {
+      for (const edge of outgoing.get(queue[i]) ?? []) {
+        const pending = remaining.get(edge) ?? 0;
+        if (pending === 0) continue;
+        remaining.set(edge, pending - 1);
+        if (pending > 1) continue;
+        for (const target of Array.isArray(edge.to) ? edge.to : [edge.to]) {
+          if (reachable.has(target)) continue;
+          reachable.add(target);
+          queue.push(target);
+        }
+      }
+    }
+    for (const edge of this.directEdges) {
+      const sources = Array.isArray(edge.from) ? edge.from : [edge.from];
+      if (
+        sources.some((source) => reachable.has(source)) &&
+        !sources.every((source) => reachable.has(source))
+      ) {
+        throw new Error(
+          'entryAgentId cannot satisfy a grouped direct edge prerequisite'
+        );
+      }
+    }
+    return reachable;
+  }
+
   /**
    * Fails fast when an edge references an agent that is not in
    * `agentContexts`. Without this check, the underlying LangGraph
@@ -762,6 +870,11 @@ export class MultiAgentGraph extends StandardGraph {
               destination = Array.isArray(result) ? result[0] : destinations[0];
             }
 
+            if (!destinations.includes(destination)) {
+              throw new Error(
+                `Conditional handoff selected undeclared destination "${destination}"`
+              );
+            }
             const handoffInstructions = getHandoffInstructions(
               input,
               promptKey,
@@ -789,7 +902,15 @@ export class MultiAgentGraph extends StandardGraph {
 
             return new Command({
               goto: destination,
-              update: { messages: state.messages.concat(toolMessage) },
+              update: {
+                messages: state.messages.concat(toolMessage),
+                handoffRequest: {
+                  sourceAgentId,
+                  targetAgentId: destination,
+                  toolCallId,
+                  scope: edge.handoffScope ?? 'turn',
+                },
+              },
               graph: Command.PARENT,
             });
           },
@@ -926,7 +1047,15 @@ export class MultiAgentGraph extends StandardGraph {
 
               return new Command({
                 goto: destination,
-                update: { messages: filteredMessages },
+                update: {
+                  messages: filteredMessages,
+                  handoffRequest: {
+                    sourceAgentId,
+                    targetAgentId: destination,
+                    toolCallId,
+                    scope: edge.handoffScope ?? 'turn',
+                  },
+                },
                 graph: Command.PARENT,
               });
             },
@@ -1274,6 +1403,7 @@ export class MultiAgentGraph extends StandardGraph {
         default: () => undefined,
       }),
       runStepState: this.createRunStepStateAnnotation(),
+      handoffState: handoffStateAnnotation(),
     });
 
     const builder = new StateGraph(StateAnnotation);
@@ -1298,9 +1428,16 @@ export class MultiAgentGraph extends StandardGraph {
     const agentIds =
       summarizeOnlyAgentId != null
         ? [summarizeOnlyAgentId]
-        : [...this.agentContexts.keys()];
+        : [...(this.reachableAgentIds ?? this.agentContexts.keys())];
     const handoffEdges = summarizeOnlyAgentId != null ? [] : this.handoffEdges;
-    const directEdges = summarizeOnlyAgentId != null ? [] : this.directEdges;
+    const directEdges =
+      summarizeOnlyAgentId != null
+        ? []
+        : this.directEdges.filter((edge) => {
+          if (this.reachableAgentIds == null) return true;
+          const sources = Array.isArray(edge.from) ? edge.from : [edge.from];
+          return sources.every((id) => this.reachableAgentIds!.has(id));
+        });
 
     // Add all agents as complete subgraphs
     for (const agentId of agentIds) {
@@ -1348,6 +1485,7 @@ export class MultiAgentGraph extends StandardGraph {
         state: t.MultiAgentGraphState,
         config?: LangGraphRunnableConfig
       ): Promise<t.MultiAgentGraphState | Command> => {
+        this.handoffRouting?.restore(state.handoffState);
         let result: t.MultiAgentGraphState;
         let inputMessages = state.messages;
         const agentContext = this.agentContexts.get(agentId);

package/src/graphs/handoff.ts

@@ -0,0 +1,263 @@
+import { nanoid } from 'nanoid';
+import { Annotation, Command, Send } from '@langchain/langgraph';
+import type { BaseChannel, OverwriteValue } from '@langchain/langgraph';
+import type { RunnableConfig } from '@langchain/core/runnables';
+import type {
+  BaseGraphState,
+  HandoffOutcome,
+  HandoffState,
+  HandoffTransition,
+} from '@/types/graph';
+
+function isSupportedVersion(version: number): boolean {
+  return version === 1;
+}
+
+function isSend(value: string | Send): value is Send {
+  return typeof value !== 'string' && value.lg_name === 'Send';
+}
+
+export type HandoffRequest = Pick<
+  HandoffTransition,
+  'sourceAgentId' | 'targetAgentId' | 'toolCallId' | 'scope'
+>;
+
+type HandoffUpdate = Partial<BaseGraphState> & {
+  handoffRequest?: HandoffRequest;
+};
+
+function sameTransition(a: HandoffTransition, b: HandoffTransition): boolean {
+  return (
+    a.id === b.id &&
+    a.sourceAgentId === b.sourceAgentId &&
+    a.targetAgentId === b.targetAgentId &&
+    a.toolCallId === b.toolCallId &&
+    a.scope === b.scope &&
+    a.depth === b.depth
+  );
+}
+
+/** Union by identity makes checkpoint replay idempotent and parallel merges commutative. */
+export function mergeHandoffState(
+  current: HandoffState | undefined,
+  update: HandoffState | undefined
+): HandoffState | undefined {
+  if (update == null) return current;
+  if (current == null) return update;
+  if (current.executionId !== update.executionId) {
+    throw new Error('Cannot merge handoffs from different logical turns');
+  }
+  if (
+    current.entryAgentId !== update.entryAgentId ||
+    current.maxHandoffs !== update.maxHandoffs
+  ) {
+    throw new Error('Conflicting handoff checkpoint configuration');
+  }
+  const transitions = new Map(
+    current.transitions.map((item) => [item.id, item])
+  );
+  for (const transition of update.transitions) {
+    const existing = transitions.get(transition.id);
+    if (existing != null && !sameTransition(existing, transition)) {
+      throw new Error('Conflicting replayed handoff transition');
+    }
+    transitions.set(transition.id, transition);
+  }
+  return {
+    ...current,
+    parallel: current.parallel || update.parallel,
+    historyComplete:
+      current.historyComplete !== false && update.historyComplete !== false,
+    transitions: [...transitions.values()].sort(
+      (a, b) => a.depth - b.depth || a.id.localeCompare(b.id)
+    ),
+  };
+}
+
+export function handoffStateAnnotation(): BaseChannel<
+  HandoffState | undefined,
+  HandoffState | OverwriteValue<HandoffState | undefined> | undefined
+  > {
+  return Annotation<HandoffState | undefined>({
+    reducer: mergeHandoffState,
+    default: () => undefined,
+  });
+}
+
+export class HandoffLimitError extends Error {
+  constructor(readonly limit: number) {
+    super(`Agent handoff limit (${limit}) reached`);
+    this.name = 'HandoffLimitError';
+  }
+}
+
+/** One owner per graph, never shared with isolated child executions. */
+export class HandoffRouting {
+  private state: HandoffState;
+
+  constructor(
+    private readonly entryAgentId: string,
+    private readonly maxHandoffs: number | undefined,
+    private readonly parallel: boolean
+  ) {
+    this.state = this.freshState();
+  }
+
+  private freshState(): HandoffState {
+    return {
+      version: 1,
+      executionId: nanoid(),
+      entryAgentId: this.entryAgentId,
+      ...(this.maxHandoffs == null ? {} : { maxHandoffs: this.maxHandoffs }),
+      transitions: [],
+      parallel: this.parallel,
+    };
+  }
+
+  start(): HandoffState {
+    this.state = this.freshState();
+    return this.snapshot();
+  }
+
+  resume(state: HandoffState | undefined): void {
+    if (state != null) {
+      this.restore(state);
+      return;
+    }
+    if (this.maxHandoffs != null) {
+      throw new Error(
+        'Cannot enforce a handoff budget on a legacy checkpoint without routing state'
+      );
+    }
+    this.state = { ...this.state, historyComplete: false };
+  }
+
+  restore(state: HandoffState | undefined): void {
+    if (state == null) return;
+    if (!isSupportedVersion(state.version))
+      throw new Error('Unsupported handoff checkpoint version');
+    if (
+      state.entryAgentId !== this.entryAgentId ||
+      state.maxHandoffs !== this.maxHandoffs
+    ) {
+      throw new Error('Cannot resume with a different handoff entry or budget');
+    }
+    if (this.state.executionId !== state.executionId) {
+      if (this.state.transitions.length > 0) {
+        throw new Error('Cannot resume a different handoff execution');
+      }
+      this.state = {
+        ...state,
+        transitions: state.transitions.map((item) => ({ ...item })),
+      };
+      return;
+    }
+    this.state = mergeHandoffState(this.state, state)!;
+  }
+
+  snapshot(): HandoffState {
+    return {
+      ...this.state,
+      transitions: this.state.transitions.map((item) => ({ ...item })),
+    };
+  }
+
+  /** Called after tools settle but before Commands can schedule recipients. */
+  finalize(
+    commands: Command[],
+    input: BaseGraphState,
+    config: RunnableConfig
+  ): void {
+    this.restore(input.handoffState);
+    const updates: HandoffUpdate[] = [];
+    let parallel = this.state.parallel;
+    for (const command of commands) {
+      if (command.graph !== Command.PARENT) continue;
+      const sends = Array.isArray(command.goto)
+        ? command.goto.filter(isSend)
+        : [];
+      parallel ||= sends.length > 1;
+      if (sends.length > 0) {
+        for (const send of sends) updates.push(send.args as HandoffUpdate);
+      } else if (command.update != null) {
+        updates.push(command.update as HandoffUpdate);
+      }
+    }
+    const accepted = new Map(
+      this.state.transitions.map((item) => [item.id, item])
+    );
+    const requests = updates.filter((update) => update.handoffRequest != null);
+    if (requests.length === 0) return;
+    const depth =
+      input.handoffState?.transitions.length ?? this.state.transitions.length;
+    const lastMessage = input.messages.at(-1);
+    for (const update of requests) {
+      const request = update.handoffRequest!;
+      const id = JSON.stringify([
+        this.state.executionId,
+        config.configurable?.checkpoint_ns ?? '',
+        request.sourceAgentId,
+        lastMessage?.id ?? input.messages.length,
+        request.toolCallId,
+      ]);
+      const transition = { ...request, id, depth };
+      const existing = accepted.get(id);
+      if (
+        existing != null &&
+        (existing.targetAgentId !== transition.targetAgentId ||
+          existing.scope !== transition.scope)
+      )
+        throw new Error('Handoff replay changed its destination or scope');
+      accepted.set(id, existing ?? transition);
+    }
+    if (this.maxHandoffs != null && accepted.size > this.maxHandoffs) {
+      throw new HandoffLimitError(this.maxHandoffs);
+    }
+    this.state = {
+      ...this.state,
+      transitions: [...accepted.values()],
+      parallel,
+    };
+    for (const update of requests) delete update.handoffRequest;
+    for (const command of commands) {
+      if (command.graph !== Command.PARENT) continue;
+      command.update = {
+        ...(command.update as HandoffUpdate),
+        handoffState: this.snapshot(),
+      };
+      if (!Array.isArray(command.goto)) continue;
+      command.goto = command.goto.map((destination) =>
+        isSend(destination)
+          ? new Send(destination.node, {
+            ...destination.args,
+            handoffState: this.snapshot(),
+          })
+          : destination
+      );
+    }
+  }
+
+  outcome(reason?: string): HandoffOutcome {
+    const state = this.snapshot();
+    const base = {
+      executionId: state.executionId,
+      entryAgentId: state.entryAgentId,
+      transitions: state.transitions,
+    };
+    if (reason != null) return { ...base, status: 'incomplete', reason };
+    if (state.historyComplete === false)
+      return { ...base, status: 'incomplete', reason: 'legacy_checkpoint' };
+    const persistent = state.transitions.filter(
+      (item) => item.scope === 'conversation'
+    );
+    if (persistent.length === 0) return { ...base, status: 'unchanged' };
+    if (state.parallel) return { ...base, status: 'ambiguous' };
+    const last = persistent.reduce((a, b) => (a.depth > b.depth ? a : b));
+    return {
+      ...base,
+      status: 'candidate',
+      agentId: last.targetAgentId,
+      transitionId: last.id,
+    };
+  }
+}

package/src/graphs/index.ts

@@ -2,3 +2,5 @@ export * from './Graph';
 export * from './MultiAgentGraph';
 export * from './createGraph';
 export type * from './graphFactory';
+
+export { HandoffLimitError } from './handoff';

package/src/run.ts

@@ -111,6 +111,7 @@ import { initializeLangfuseTracing } from './instrumentation';
 import { seedRunInitialSessions } from '@/utils/toolSessions';
 import { getTraceIdSeed } from '@/langfuseRuntimeContext';
 import { resolveClientOptionsModel } from '@/llm/request';
+import { HandoffLimitError } from '@/graphs/handoff';
 import { createGraph } from '@/graphs/createGraph';
 import { isFadingTier } from '@/messages/fading';
 import { resolveMaxSeals } from '@/llm/preempt';
@@ -291,6 +292,7 @@ function getInterruptHookSessionId(payload: unknown): string | undefined {
 type InterruptStateSnapshot = {
   config?: RunnableConfig;
   values?: {
+    handoffState?: t.HandoffState;
     messages?: BaseMessage[];
     runStepState?: t.RunStepResumeState;
   };
@@ -512,6 +514,7 @@ export class Run<_T extends t.BaseGraphState> {
   /** Distinguishes sibling forks started from the same explicit checkpoint. */
   private checkpointForkSeq = 0;
   private _haltedReason: string | undefined;
+  private _handoffOutcome?: t.HandoffOutcome;
 
   private constructor(config: Partial<t.RunConfig>) {
     const runId = config.runId ?? '';
@@ -683,7 +686,7 @@ export class Run<_T extends t.BaseGraphState> {
   private createMultiAgentGraph(
     config: t.MultiAgentGraphConfig
   ): t.CompiledStateWorkflow {
-    const { agents, edges, compileOptions } = config;
+    const { agents, edges, compileOptions, entryAgentId, maxHandoffs } = config;
 
     const multiAgentGraph = createGraph({
       kind: 'multi-agent',
@@ -691,6 +694,8 @@ export class Run<_T extends t.BaseGraphState> {
         runId: this.id,
         agents,
         edges,
+        entryAgentId,
+        maxHandoffs,
         langfuse: this.langfuse,
         tokenCounter: this.tokenCounter,
         indexTokenCountMap: this.indexTokenCountMap,
@@ -1237,6 +1242,7 @@ export class Run<_T extends t.BaseGraphState> {
     }
     const graphRunnable = this.graphRunnable;
     const graph = this.Graph;
+    this._handoffOutcome = undefined;
 
     /**
      * `Command` inputs (`Command({ resume, update?, goto? })`) are
@@ -1347,6 +1353,7 @@ export class Run<_T extends t.BaseGraphState> {
             checkpointId === '' ? 0 : ++this.checkpointForkSeq,
           ]);
       graph.resetValues(streamOptions?.keepContent, checkpointScope);
+      graph.handoffRouting?.start();
       graph.startStopContinuationExecution(nanoid());
     }
     this._interrupt = undefined;
@@ -1482,9 +1489,18 @@ export class Run<_T extends t.BaseGraphState> {
 
     const consumeStream = async (): Promise<void> => {
       let streamInputs: t.IState | Command = inputs;
-      if (!isResume && this.hasCheckpointer) {
+      if (!isResume && graph.handoffRouting != null) {
         streamInputs = {
           ...(inputs as t.IState),
+          handoffState: graph.handoffRouting.snapshot(),
+        };
+      }
+      if (!isResume && this.hasCheckpointer) {
+        streamInputs = {
+          ...(streamInputs as t.IState),
+          ...(graph.handoffRouting == null
+            ? {}
+            : { handoffState: new Overwrite(graph.handoffRouting.snapshot()) }),
           runStepState: new Overwrite(graph.createRunStepResumeState()),
         } as unknown as t.IState;
       } else if (overwriteLegacyResumeState) {
@@ -1679,6 +1695,7 @@ export class Run<_T extends t.BaseGraphState> {
                 ? injected
                 : [...graph.messages, ...injected],
               runStepState: graph.createRunStepResumeState(),
+              handoffState: graph.handoffRouting?.snapshot(),
             };
             streamConfig = completedSegmentConfig;
             continue;
@@ -1716,6 +1733,8 @@ export class Run<_T extends t.BaseGraphState> {
     } catch (err) {
       terminalAt = Date.now();
       streamThrew = true;
+      if (err instanceof HandoffLimitError)
+        this._haltedReason = 'handoff_limit';
       await langfuseHandler?.handleChainError(
         err instanceof Error ? err : new Error(String(err)),
         this.id
@@ -1860,6 +1879,13 @@ export class Run<_T extends t.BaseGraphState> {
        * `HumanInTheLoopConfig` JSDoc.
        */
       const awaitingResume = this.isAwaitingResume(streamThrew);
+      this._handoffOutcome = graph.handoffRouting?.outcome(
+        this.getHandoffIncompleteReason(
+          streamThrew,
+          awaitingResume,
+          config.signal
+        )
+      );
       if (!this.skipCleanup && !awaitingResume) {
         this.Graph.clearHeavyState();
       }
@@ -1921,6 +1947,31 @@ export class Run<_T extends t.BaseGraphState> {
     return this._haltedReason;
   }
 
+  private getHandoffIncompleteReason(
+    streamThrew: boolean,
+    awaitingResume: boolean,
+    signal?: AbortSignal
+  ): string | undefined {
+    if (this._haltedReason != null) return this._haltedReason;
+    if (signal?.aborted === true || this.Graph?.signal?.aborted === true) {
+      return 'aborted';
+    }
+    if (streamThrew) return 'error';
+    if (awaitingResume) return 'interrupted';
+    if (this.Graph?.subagentScope === true) return 'subagent';
+    return undefined;
+  }
+
+  /** Execution evidence only. The host must authorize and durably commit a candidate. */
+  getHandoffOutcome(): t.HandoffOutcome | undefined {
+    const outcome = this._handoffOutcome;
+    if (outcome == null) return undefined;
+    return {
+      ...outcome,
+      transitions: outcome.transitions.map((item) => ({ ...item })),
+    };
+  }
+
   /**
    * Resume a paused HITL run with the value the user (or whatever
    * decided the interrupt) supplied. The default `TResume` covers the
@@ -2134,6 +2185,7 @@ export class Run<_T extends t.BaseGraphState> {
     const snapshot = await workflow.getState(callerConfig as RunnableConfig, {
       subgraphs: true,
     });
+    this.Graph?.handoffRouting?.resume(snapshot.values?.handoffState);
     const persistedInterrupt = getFirstPersistedInterrupt(snapshot);
     if (persistedInterrupt == null) {
       return;

package/src/tools/ToolNode.ts

@@ -974,8 +974,10 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
    * other's in-flight state.
    */
   private anonBatchCounter: number = 0;
+  private handoffRouting?: t.ToolNodeOptions['handoffRouting'];
 
   constructor({
+    handoffRouting,
     tools,
     toolMap,
     name,
@@ -1219,6 +1221,7 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
     this.runLangfuse = runLangfuse;
     this.agentLangfuse = agentLangfuse;
     this.toolMap = toolMap ?? new Map(tools.map((tool) => [tool.name, tool]));
+    this.handoffRouting = handoffRouting;
     this.toolCallStepIds = toolCallStepIds;
     this.handleToolErrors = handleToolErrors ?? this.handleToolErrors;
     this.loadRuntimeTools = loadRuntimeTools;
@@ -3221,10 +3224,7 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
 
   private retainCodeSessionInputsFromRequests(
     requests: Iterable<t.ToolCallRequest>,
-    baselineByRequestId: ReadonlyMap<
-      string,
-      ReadonlyMap<string, string>
-    >
+    baselineByRequestId: ReadonlyMap<string, ReadonlyMap<string, string>>
   ): void {
     if (!this.sessions) {
       return;
@@ -5140,8 +5140,9 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
         call.id == null
           ? undefined
           : baseContext.resolvedArgsByCallId?.get(call.id);
-      const codeSessionBaseline =
-        baseContext.codeSessionBaselineByCallId?.get(call.id ?? '');
+      const codeSessionBaseline = baseContext.codeSessionBaselineByCallId?.get(
+        call.id ?? ''
+      );
       const result: SettledDirectToolResult = {
         proposal: structuredClone({
           name: call.name,
@@ -6073,6 +6074,13 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
     if (replayBatchKey != null) {
       this.settledDirectResultsByBatch.delete(replayBatchKey);
     }
+    if (!Array.isArray(input) && !this.isSendInput(input)) {
+      this.handoffRouting?.finalize(
+        combinedOutputs.filter(isCommand),
+        input as t.BaseGraphState,
+        config
+      );
+    }
     return combinedOutputs as T;
   }