@librechat/agents 3.4.1 → 3.4.2

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

@@ -32,8 +32,13 @@ export type BaseGraphState = {
 export type AgentSubgraphState = BaseGraphState & {
     summarizationRequest?: SummarizationNodeInput;
 };
+export type SubagentGraphResult = {
+    agentId: string;
+    message?: BaseMessage;
+};
 export type MultiAgentGraphState = BaseGraphState & {
     agentMessages?: BaseMessage[];
+    subagentResult?: SubagentGraphResult;
 };
 export type IState = BaseGraphState;
 export interface AgentLogEvent {
@@ -223,9 +228,9 @@ export type StandardGraphInput = {
     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
+     * Receives a {@link SubagentUsageEvent} for every model call that reports
+     * usage metadata 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
@@ -256,9 +261,11 @@ export type StandardGraphInput = {
      * every streamed chunk event. See {@link StreamLimits}.
      */
     streamLimits?: StreamLimits;
+    /** Structured lineage for a graph executing as a subagent child. */
+    subagentExecutionContext?: SubagentExecutionContext;
 };
 export type GraphEdge = {
-    /** Agent ID, use a list for multiple sources */
+    /** Agent ID; direct edges use an array as an all-of waiting source group. */
     from: string | string[];
     /** Agent ID, use a list for multiple destinations */
     to: string | string[];
@@ -288,40 +295,180 @@ export type GraphEdge = {
      */
     promptKey?: string;
 };
+export type GraphSubagentEdge = Omit<GraphEdge, 'edgeType' | 'condition' | 'promptKey'> & {
+    edgeType: 'direct';
+    condition?: never;
+    promptKey?: never;
+};
 export type MultiAgentGraphInput = StandardGraphInput & {
     edges: GraphEdge[];
+    /** Captures the designated member's final AI turn in graph state. */
+    resultAgentId?: string;
+    /** Optional per-member Pregel budget when the outer graph has its own topology budget. */
+    memberRecursionLimit?: number;
 };
-/** Configuration for a subagent type that can be spawned by a parent agent. */
-export type SubagentConfig = {
-    /** Identifier used in the tool's `subagent_type` enum (e.g. 'researcher', 'coder'). */
+/** Lightweight identity advertised to the model for a spawnable subagent. */
+export interface SubagentDescriptor {
+    /** Stable identifier used in the tool's `subagent_type` enum (e.g. 'researcher', 'coder'). */
     type: string;
     /** Human-readable display name. */
     name: string;
     /** What this subagent specializes in — shown to the LLM. */
     description: string;
-    /** Full agent config for the child graph. Omit when `self` is true. */
-    agentInputs?: AgentInputs;
-    /** When true, reuse the parent's AgentInputs (context isolation without separate config). */
-    self?: boolean;
+    /**
+     * Opaque, versioned identity of the child configuration. Required when
+     * `resolveAgentInputs` is used and changed whenever its resolved inputs
+     * change incompatibly.
+     */
+    configId?: string;
+}
+/** Lazy descriptor with the durable configuration identity required to resolve it. */
+export interface LazySubagentDescriptor extends SubagentDescriptor {
+    configId: string;
+}
+/** Stable request identifiers exposed to a selected subagent resolver. */
+export interface SubagentResolveRequestContext {
+    conversationId?: string;
+    messageId?: string;
+    parentMessageId?: string;
+}
+/** Stable user identifiers exposed to a selected subagent resolver. */
+export interface SubagentResolveUserContext {
+    id?: string;
+    role?: string;
+    tenantId?: string;
+}
+/** Sanitized host runtime context safe for lazy subagent resolution. */
+export interface SubagentResolveConfigurable {
+    requestBody?: Readonly<SubagentResolveRequestContext>;
+    user?: Readonly<SubagentResolveUserContext>;
+    user_id?: string;
+}
+/** Runtime context supplied when a host lazily resolves a selected subagent. */
+export interface SubagentResolveContext {
+    /** Stable subagent identity selected by the model. */
+    descriptor: Readonly<LazySubagentDescriptor>;
+    /** Stable child execution identity, including across HITL reconstruction. */
+    executionId: string;
+    /** Parent run that dispatched this execution. */
+    parentRunId: string;
+    /** Parent agent that dispatched this execution. */
+    parentAgentId?: string;
+    /** Parent-side tool call that selected the subagent. */
+    parentToolCallId?: string;
+    /** Durable parent conversation thread, when supplied by the host. */
+    threadId?: string;
+    /** Parent/breaker cancellation composed for this child execution. */
+    signal: AbortSignal;
+    /** Stable, sanitized host context from the parent tool invocation. */
+    configurable?: Readonly<SubagentResolveConfigurable>;
+}
+/** Host contract for resolving a selected subagent's full graph inputs. */
+export type SubagentAgentInputsResolver = (context: SubagentResolveContext) => Promise<AgentInputs>;
+interface SubagentConfigBase extends SubagentDescriptor {
     /** Max AGENT→TOOLS cycles before forced stop (default: 25). */
     maxTurns?: number;
     /** Allow this subagent to spawn its own subagents (default: false). */
     allowNested?: boolean;
-};
-/** SubagentConfig with agentInputs guaranteed present (self-spawn resolved). */
-export type ResolvedSubagentConfig = SubagentConfig & {
+}
+export interface SubagentConfig extends SubagentConfigBase {
+    /** Full agent config for the child graph. Omit when `self` is true. */
+    agentInputs?: AgentInputs;
+    /**
+     * Resolve the full child config only after this descriptor is selected.
+     * Eager `agentInputs` take precedence when also supplied. `self` and a
+     * resolver are mutually exclusive and normalization rejects that pairing.
+     *
+     * Resolvers should rebuild inputs from the stable execution context instead
+     * of retaining request-owned state. The SDK keeps resolved inputs in memory
+     * only for the lifetime of the selected execution and supplies cancellation
+     * through `context.signal`. A reconstructed execution may invoke the
+     * resolver again, so the same `context.executionId` must produce equivalent
+     * child inputs. Durable resolver work should be idempotent on
+     * `(context.executionId, context.descriptor.configId)`.
+     */
+    resolveAgentInputs?: SubagentAgentInputsResolver;
+    /** When true, reuse the parent's AgentInputs (context isolation without separate config). */
+    self?: boolean;
+}
+export interface SingleAgentSubagentConfig extends SubagentConfig {
+    kind?: 'agent';
+    agents?: never;
+    edges?: never;
+    entryAgentId?: never;
+    resultAgentId?: never;
+}
+export interface GraphSubagentConfig extends SubagentConfigBase {
+    kind: 'graph';
+    configId?: never;
+    resolveAgentInputs?: never;
+    allowNested?: false;
+    agents: AgentInputs[];
+    /**
+     * Explicit direct DAG edges. Array-valued sources are all-of waiting edges.
+     * Relative message order between parallel branches is implementation-dependent.
+     * Prompted edges are supported in chains or on the final converged result transition.
+     */
+    edges: GraphSubagentEdge[];
+    entryAgentId: string;
+    resultAgentId: string;
+    agentInputs?: never;
+    self?: never;
+}
+/** Any configuration that can be spawned through the subagent tool. */
+export type SubagentConfigEntry = SubagentConfig | GraphSubagentConfig;
+/** Legacy single-agent config with self-spawn resolution completed. */
+export interface ResolvedSubagentConfig extends SubagentConfig {
     agentInputs: AgentInputs;
-};
+}
+/** Explicit alias for graph-aware code that needs to name the legacy variant. */
+export interface ResolvedSingleAgentSubagentConfig extends ResolvedSubagentConfig {
+    kind?: 'agent';
+    agents?: never;
+    edges?: never;
+    entryAgentId?: never;
+    resultAgentId?: never;
+}
+export type ResolvedSubagentConfigEntry = ResolvedSubagentConfig | GraphSubagentConfig;
+/** Lazy single-agent entry accepted after descriptor validation. */
+export interface LazySingleAgentSubagentConfig extends SingleAgentSubagentConfig {
+    configId: string;
+    resolveAgentInputs: SubagentAgentInputsResolver;
+    agentInputs?: never;
+    self?: never;
+}
+/** Single-agent config accepted after eager/self/lazy eligibility checks. */
+export type ExecutableSubagentConfig = ResolvedSubagentConfig | LazySingleAgentSubagentConfig;
+/** Graph-aware config accepted by the executor. Graph configs stay eager. */
+export type ExecutableSubagentConfigEntry = ExecutableSubagentConfig | GraphSubagentConfig;
 /** Lifecycle phase carried on {@link SubagentUpdateEvent}. */
 export type SubagentUpdatePhase = 'start' | 'run_step' | 'run_step_delta' | 'run_step_completed' | 'message_delta' | 'reasoning_delta' | 'stop' | 'error';
+export interface SubagentAncestryEntry {
+    readonly subagentRunId: string;
+    readonly subagentType: string;
+    readonly subagentKind: 'agent' | 'graph';
+    /** Execution subject ID; synthetic for graph subagents. */
+    readonly subagentAgentId: string;
+    readonly parentRunId: string;
+    readonly parentAgentId?: string;
+    readonly parentToolCallId?: string;
+}
+export interface SubagentExecutionContext {
+    readonly rootRunId: string;
+    readonly hookSessionId: string;
+    readonly depth: number;
+    readonly ancestry: readonly SubagentAncestryEntry[];
+}
 /**
  * Wrapper event emitted when a subagent's child graph dispatches activity.
  * Lets hosts show subagent progress in a UI surface separate from the parent
  * conversation without having to untangle events by agent ID.
  */
 export interface SubagentUpdateEvent {
-    /** Parent run ID. */
+    /** Root run ID that owns this execution tree. */
     runId: string;
+    /** Immediate parent run that spawned this child. */
+    parentRunId?: string;
     /** Child run ID (unique per subagent execution). */
     subagentRunId: string;
     /**
@@ -333,8 +480,16 @@ export interface SubagentUpdateEvent {
     parentToolCallId?: string;
     /** Subagent `type` identifier from the SubagentConfig. */
     subagentType: string;
-    /** Child agent ID assigned to this subagent execution. */
+    /** Execution shape. Omitted by older emitters. */
+    subagentKind?: 'agent' | 'graph';
+    /** Execution subject ID; synthetic for graph subagents. */
     subagentAgentId: string;
+    /** Graph member that produced this update, when attributable. */
+    memberAgentId?: string;
+    /** One-based nesting depth beneath the root graph. */
+    depth?: number;
+    /** Root-to-leaf execution lineage, without parsing composed run IDs. */
+    ancestry?: readonly SubagentAncestryEntry[];
     /** Parent agent ID that spawned this subagent. */
     parentAgentId?: string;
     /** Lifecycle phase carried by this update. */
@@ -376,10 +531,20 @@ export interface SubagentUsageEvent {
     provider?: string;
     /** Subagent `type` identifier from the SubagentConfig. */
     subagentType: string;
+    /** Execution shape. Omitted by older emitters. */
+    subagentKind?: 'agent' | 'graph';
     /** Child run ID (unique per subagent execution). */
     subagentRunId: string;
-    /** Child agent ID assigned to this subagent execution. */
+    /** Execution subject ID; synthetic for graph subagents. */
     subagentAgentId: string;
+    /** Graph member whose model call produced this usage. */
+    memberAgentId?: string;
+    /** Immediate parent run that spawned this child. */
+    parentRunId?: string;
+    /** One-based nesting depth beneath the root graph. */
+    depth?: number;
+    /** Root-to-leaf execution lineage, without parsing composed run IDs. */
+    ancestry?: readonly SubagentAncestryEntry[];
     /**
      * ROOT run ID of the host run that owns billing. For nested subagents
      * each forwarding layer rewrites this upward, so events from any depth
@@ -512,7 +677,7 @@ export interface AgentInputs {
     /** Pre-computed tool schema token count (from cache). Skips recalculation when provided. */
     toolSchemaTokens?: number;
     /** Subagent configurations for hierarchical delegation. Each defines a child agent type. */
-    subagentConfigs?: SubagentConfig[];
+    subagentConfigs?: SubagentConfigEntry[];
     /** Maximum subagent nesting depth. Default 1 means top-level agents can spawn subagents but subagents cannot nest further. */
     maxSubagentDepth?: number;
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@librechat/agents",
-  "version": "3.4.1",
+  "version": "3.4.2",
   "reova": {
     "enabled": true,
     "endpoint": "https://telemetry.reo.dev/data"
@@ -120,6 +120,8 @@
     "prepublishOnly": "npm run build",
     "build": "tsdown && tsc -p tsconfig.build.json",
     "build:dev": "tsdown",
+    "check:circular-deps": "node config/circular-deps.mjs",
+    "test:circular-deps": "node --test config/circular-deps.test.mjs",
     "sort-imports": "node scripts/sort-imports.ts",
     "sort-imports:check": "node scripts/sort-imports.ts --check",
     "start": "node dist/esm/main.js",

package/src/agents/AgentContext.ts

@@ -275,7 +275,7 @@ export class AgentContext {
   /** Original AgentInputs used to create this context — used for self-spawn subagent resolution. */
   _sourceInputs?: t.AgentInputs;
   /** Subagent configurations for hierarchical delegation. */
-  subagentConfigs?: t.SubagentConfig[];
+  subagentConfigs?: t.SubagentConfigEntry[];
   /** Maximum subagent nesting depth. */
   maxSubagentDepth?: number;
   /** Instructions for this agent */

package/src/graphs/Graph.ts

@@ -30,6 +30,10 @@ import type {
   StreamedToolCallArgTally,
   StreamDeltaEventTally,
 } from '@/llm/streamLimits';
+import type {
+  GraphFactory,
+  GraphFactoryDependencies,
+} from '@/graphs/graphFactory';
 import type { OverflowRecoveryPlan } from '@/llm/contextOverflowRecovery';
 import type { FallbackErrorContext } from '@/llm/invoke';
 import type { HookRegistry } from '@/hooks';
@@ -93,6 +97,12 @@ import {
   STREAM_LIMIT_EPOCH_KEY,
   RUN_BREAKER_SCOPE_CONFIG_KEY,
 } from '@/llm/streamLimits';
+import {
+  DEFAULT_SUBAGENT_DESCRIPTION,
+  SubagentExecutor,
+  isGraphSubagentConfig,
+  normalizeSubagentConfigEntries,
+} from '@/tools/subagent';
 import {
   Constants,
   GraphNodeKeys,
@@ -141,7 +151,7 @@ import { ToolNode as CustomToolNode, toolsCondition } from '@/tools/ToolNode';
 import { shouldTraceToolNodeForLangfuse } from '@/langfuseToolOutputTracing';
 import { createLocalCodingToolBundle } from '@/tools/local/LocalCodingTools';
 import { SUBAGENT_REPLAY_CONTROLLER } from '@/tools/subagent/SubagentReplay';
-import { SubagentExecutor, resolveSubagentConfigs } from '@/tools/subagent';
+import { applyGraphRuntimeConfig } from '@/graphs/applyGraphRuntimeConfig';
 import { partitionAndMarkBedrockToolCache } from '@/llm/bedrock/toolCache';
 import { safeDispatchCustomEvent, emitAgentLog } from '@/utils/events';
 import { createCloudflareCodingToolBundle } from '@/tools/cloudflare';
@@ -179,15 +189,21 @@ const EMPTY_PREEMPT_BOUNDARY: PreemptBoundaryResult = {
 /** Minimum relative variance before calibrated toolSchemaTokens overrides current value. */
 const CALIBRATION_VARIANCE_THRESHOLD = 0.15;
 
-function createToolHandlerRegistry(
+function createChildHandlerRegistry(
   source: HandlerRegistry | undefined
 ): HandlerRegistry | undefined {
   const toolHandler = source?.getHandler(GraphEvents.ON_TOOL_EXECUTE);
-  if (toolHandler == null) {
+  const updateHandler = source?.getHandler(GraphEvents.ON_SUBAGENT_UPDATE);
+  if (toolHandler == null && updateHandler == null) {
     return undefined;
   }
   const registry = new HandlerRegistry();
-  registry.register(GraphEvents.ON_TOOL_EXECUTE, toolHandler);
+  if (toolHandler != null) {
+    registry.register(GraphEvents.ON_TOOL_EXECUTE, toolHandler);
+  }
+  if (updateHandler != null) {
+    registry.register(GraphEvents.ON_SUBAGENT_UPDATE, updateHandler);
+  }
   return registry;
 }
 
@@ -1148,6 +1164,8 @@ export abstract class Graph<
 export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
   overrideModel?: t.ChatModel;
   private subagentModelOverride?: t.ChatModel;
+  private readonly graphFactory: GraphFactory;
+  private readonly supportsMultiAgentChildren: boolean;
   /** Optional compile options passed into workflow.compile() */
   compileOptions?: t.CompileOptions | undefined;
   /** Whether the workflow was actually compiled with a checkpointer. */
@@ -1196,6 +1214,8 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
   subagentUsageSink?: t.SubagentUsageSink;
   /** See {@link t.StandardGraphInput.subagentScope}. */
   subagentScope: boolean;
+  /** See {@link t.StandardGraphInput.subagentExecutionContext}. */
+  private readonly subagentExecutionContext?: t.SubagentExecutionContext;
   /** See {@link t.StandardGraphInput.preemption}. */
   preemption?: t.StreamPreemption;
   /**
@@ -1317,26 +1337,42 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
    */
   pendingPreemptReturn = new Set<string>();
 
-  constructor({
-    runId,
-    signal,
-    agents,
-    langfuse,
-    tokenCounter,
-    indexTokenCountMap,
-    calibrationRatio,
-    subagentUsageSink,
-    subagentScope,
-    preemption,
-    streamLimits,
-  }: t.StandardGraphInput) {
+  constructor(
+    {
+      runId,
+      signal,
+      agents,
+      langfuse,
+      tokenCounter,
+      indexTokenCountMap,
+      calibrationRatio,
+      subagentUsageSink,
+      subagentScope,
+      subagentExecutionContext,
+      preemption,
+      streamLimits,
+    }: t.StandardGraphInput,
+    dependencies?: GraphFactoryDependencies
+  ) {
     super();
+    this.supportsMultiAgentChildren = dependencies != null;
+    this.graphFactory =
+      dependencies?.graphFactory ??
+      ((request): StandardGraph => {
+        if (request.kind !== 'standard') {
+          throw new Error(
+            'A polymorphic graph factory is required for multi-agent graph construction.'
+          );
+        }
+        return new StandardGraph(request.input);
+      });
     this.runId = runId;
     this.langfuseScopeRunId = `${runId ?? 'graph'}:${nanoid()}`;
     this.signal = signal;
     this.langfuse = langfuse;
     this.subagentUsageSink = subagentUsageSink;
     this.subagentScope = subagentScope === true;
+    this.subagentExecutionContext = subagentExecutionContext;
     this.preemption = preemption;
     this.streamLimits = resolveStreamLimits(streamLimits);
 
@@ -4211,15 +4247,57 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
       agentContext.subagentConfigs.length > 0 &&
       effectiveSubagentDepth > 0
     ) {
-      const resolvedConfigs = resolveSubagentConfigs(
+      const executableConfigs = normalizeSubagentConfigEntries(
         agentContext.subagentConfigs,
         agentContext
       );
-      if (resolvedConfigs.length > 0) {
+      if (executableConfigs.length > 0) {
+        if (
+          !this.supportsMultiAgentChildren &&
+          executableConfigs.some(isGraphSubagentConfig)
+        ) {
+          throw new Error(
+            'Graph subagents require constructing the parent with createGraph() or an injected GraphFactory dependency.'
+          );
+        }
         const getParentHandlerRegistry = (): HandlerRegistry | undefined =>
           this.handlerRegistry ?? this.parentToolHandlerRegistry;
+        const createConfiguredChildGraph: GraphFactory = (request) => {
+          const childGraph = this.graphFactory(request);
+          if (this.subagentModelOverride != null) {
+            childGraph.overrideModel = this.subagentModelOverride;
+            childGraph.setSubagentModelOverride(this.subagentModelOverride);
+          }
+          const childHandlerRegistry = createChildHandlerRegistry(
+            getParentHandlerRegistry()
+          );
+          // Pure execution-ordering hint (unlike `humanInTheLoop`). It only
+          // reorders tools already in the child's direct group; it does not
+          // force a schema-only event tool onto the direct execution path.
+          applyGraphRuntimeConfig(childGraph, {
+            hookRegistry: this.hookRegistry,
+            humanInTheLoop: this.humanInTheLoop,
+            toolOutputReferences: this.toolOutputReferences,
+            eagerEventToolExecution: this.eagerEventToolExecution,
+            codeSessionToolNames: this.codeSessionToolNames,
+            interruptingToolNames: this.interruptingToolNames,
+            toolExecution: this.toolExecution,
+          });
+          if (this.humanInTheLoop?.enabled === true) {
+            childGraph.compileOptions = {
+              checkpointer: this.compileOptions?.checkpointer,
+            };
+          }
+          childGraph.parentToolHandlerRegistry = childHandlerRegistry;
+          childGraph.eventToolExecutionAvailable =
+            childHandlerRegistry?.getHandler(GraphEvents.ON_TOOL_EXECUTE) !=
+            null;
+          return childGraph;
+        };
         const executor = new SubagentExecutor({
-          configs: new Map(resolvedConfigs.map((c) => [c.type, c])),
+          configs: new Map(
+            executableConfigs.map((config) => [config.type, config])
+          ),
           parentSignal: this.signal,
           breakerScope: {
             controller: (): AbortController => this.breakerAbort,
@@ -4231,6 +4309,7 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
           parentHandlerRegistry: getParentHandlerRegistry,
           parentRunId: this.runId ?? '',
           parentAgentId: agentContext.agentId,
+          executionContext: this.subagentExecutionContext,
           langfuse: this.langfuse,
           tokenCounter: agentContext.tokenCounter,
           usageSink: this.subagentUsageSink,
@@ -4238,42 +4317,12 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
           humanInTheLoop: this.humanInTheLoop,
           checkpointer: this.compileOptions?.checkpointer,
           maxDepth: effectiveSubagentDepth,
-          createChildGraph: (input): StandardGraph => {
-            const childGraph = new StandardGraph(input);
-            if (this.subagentModelOverride != null) {
-              childGraph.overrideModel = this.subagentModelOverride;
-              childGraph.setSubagentModelOverride(this.subagentModelOverride);
-            }
-            const toolHandlerRegistry = createToolHandlerRegistry(
-              getParentHandlerRegistry()
-            );
-            childGraph.hookRegistry = this.hookRegistry;
-            childGraph.humanInTheLoop = this.humanInTheLoop;
-            if (this.humanInTheLoop?.enabled === true) {
-              childGraph.compileOptions = {
-                checkpointer: this.compileOptions?.checkpointer,
-              };
-            }
-            childGraph.toolOutputReferences = this.toolOutputReferences;
-            childGraph.eagerEventToolExecution = this.eagerEventToolExecution;
-            childGraph.codeSessionToolNames = this.codeSessionToolNames;
-            // Pure execution-ordering hint (unlike `humanInTheLoop` above).
-            // It ONLY reorders tools already in the child's direct group;
-            // it does not force a name onto the direct path (that fold-in
-            // was removed — Codex review of #294). So for a self-spawned
-            // child that scrubs inherited `graphTools` (keeping only the
-            // event `toolDefinition` / schema-only stub for a name like
-            // `ask_user_question`), the name isn't in the child's direct
-            // group and this is a no-op — the stub is still dispatched via
-            // ON_TOOL_EXECUTE, never invoked directly. Where the child DOES
-            // have the executable graphTool, the guard correctly applies.
-            childGraph.interruptingToolNames = this.interruptingToolNames;
-            childGraph.toolExecution = this.toolExecution;
-            childGraph.parentToolHandlerRegistry = toolHandlerRegistry;
-            childGraph.eventToolExecutionAvailable =
-              toolHandlerRegistry != null;
-            return childGraph;
-          },
+          createChildGraph: (input): StandardGraph =>
+            createConfiguredChildGraph({
+              kind: 'standard',
+              input,
+            }),
+          createChildGraphByKind: createConfiguredChildGraph,
         });
         this.registerSubagentExecutor(executor);
 
@@ -4286,7 +4335,7 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
             typeof input.description === 'string' &&
             input.description.trim().length > 0
               ? input.description
-              : 'No task description provided';
+              : DEFAULT_SUBAGENT_DESCRIPTION;
           const subagentType =
             typeof input.subagent_type === 'string' ? input.subagent_type : '';
           const threadId = config.configurable?.thread_id as string | undefined;
@@ -4317,6 +4366,7 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
             description,
             subagentType,
             threadId,
+            signal: config.signal,
             parentToolCallId,
             breaker: batchScope?.controller,
             /**
@@ -4330,14 +4380,15 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
               | undefined,
           });
           return result.content;
-        }, buildSubagentToolParams(resolvedConfigs));
+        }, buildSubagentToolParams(executableConfigs));
         const replayableSubagentTool = subagentTool as typeof subagentTool &
           ReplayableSubagentTool;
         replayableSubagentTool[SUBAGENT_REPLAY_CONTROLLER] = {
           getResumeManifest: (
-            parentToolCallIds
+            parentToolCallIds,
+            config
           ): Promise<SubagentResumeManifest | undefined> =>
-            executor.getResumeManifest(parentToolCallIds),
+            executor.getResumeManifest(parentToolCallIds, config),
           getSettledOutput: (
             call,
             config