@illuma-ai/agents 1.1.28 → 1.3.1

package/src/common/__tests__/spawnPath.test.ts

@@ -0,0 +1,110 @@
+import {
+  SPAWN_PATH_SEP,
+  MAX_NESTING_DEPTH,
+  buildSpawnPath,
+  spawnPathDepth,
+  parentSpawnPath,
+  spawnPathParts,
+  leafSpawnKey,
+  isAncestorSpawnPath,
+} from '../spawnPath';
+
+describe('spawnPath utilities', () => {
+  describe('constants', () => {
+    it('exports a slash separator', () => {
+      expect(SPAWN_PATH_SEP).toBe('/');
+    });
+    it('default max nesting depth is 5', () => {
+      expect(MAX_NESTING_DEPTH).toBe(5);
+    });
+  });
+
+  describe('buildSpawnPath', () => {
+    it('returns key as-is when parent is empty/null/undefined', () => {
+      expect(buildSpawnPath('', 'a')).toBe('a');
+      expect(buildSpawnPath(null, 'a')).toBe('a');
+      expect(buildSpawnPath(undefined, 'a')).toBe('a');
+    });
+    it('appends key to parent with separator', () => {
+      expect(buildSpawnPath('a', 'b')).toBe('a/b');
+      expect(buildSpawnPath('a/b', 'c')).toBe('a/b/c');
+    });
+    it('throws on empty key', () => {
+      expect(() => buildSpawnPath('a', '')).toThrow(/empty key/);
+    });
+  });
+
+  describe('spawnPathDepth', () => {
+    it('root is depth 0', () => {
+      expect(spawnPathDepth('')).toBe(0);
+      expect(spawnPathDepth(null)).toBe(0);
+      expect(spawnPathDepth(undefined)).toBe(0);
+    });
+    it('single segment is depth 1', () => {
+      expect(spawnPathDepth('a')).toBe(1);
+    });
+    it('multi segment counts segments', () => {
+      expect(spawnPathDepth('a/b')).toBe(2);
+      expect(spawnPathDepth('a/b/c/d')).toBe(4);
+    });
+    it('ignores empty segments from stray separators', () => {
+      expect(spawnPathDepth('a//b')).toBe(2);
+      expect(spawnPathDepth('/a/b')).toBe(2);
+    });
+  });
+
+  describe('parentSpawnPath', () => {
+    it('root returns null', () => {
+      expect(parentSpawnPath('')).toBeNull();
+      expect(parentSpawnPath(null)).toBeNull();
+    });
+    it('single segment returns empty (root)', () => {
+      expect(parentSpawnPath('a')).toBe('');
+    });
+    it('multi segment drops last', () => {
+      expect(parentSpawnPath('a/b')).toBe('a');
+      expect(parentSpawnPath('a/b/c')).toBe('a/b');
+    });
+  });
+
+  describe('spawnPathParts', () => {
+    it('empty path returns empty array', () => {
+      expect(spawnPathParts('')).toEqual([]);
+      expect(spawnPathParts(null)).toEqual([]);
+    });
+    it('splits segments', () => {
+      expect(spawnPathParts('a/b/c')).toEqual(['a', 'b', 'c']);
+    });
+  });
+
+  describe('leafSpawnKey', () => {
+    it('root returns null', () => {
+      expect(leafSpawnKey('')).toBeNull();
+    });
+    it('returns last segment', () => {
+      expect(leafSpawnKey('a')).toBe('a');
+      expect(leafSpawnKey('a/b/c')).toBe('c');
+    });
+  });
+
+  describe('isAncestorSpawnPath', () => {
+    it('root is ancestor of any non-root path', () => {
+      expect(isAncestorSpawnPath('', 'a')).toBe(true);
+      expect(isAncestorSpawnPath('', 'a/b')).toBe(true);
+    });
+    it('root is not ancestor of root', () => {
+      expect(isAncestorSpawnPath('', '')).toBe(false);
+    });
+    it('strict ancestor detection', () => {
+      expect(isAncestorSpawnPath('a', 'a/b')).toBe(true);
+      expect(isAncestorSpawnPath('a/b', 'a/b/c')).toBe(true);
+      expect(isAncestorSpawnPath('a', 'a')).toBe(false);
+    });
+    it('sibling is not ancestor', () => {
+      expect(isAncestorSpawnPath('a/b', 'a/c')).toBe(false);
+    });
+    it('partial-prefix is not ancestor (must respect segment boundary)', () => {
+      expect(isAncestorSpawnPath('ab', 'abc')).toBe(false);
+    });
+  });
+});

package/src/common/index.ts

@@ -1,4 +1,5 @@
 // src/common/index.ts
 export * from './enum';
 export * from './constants';
+export * from './spawnPath';
 export * from '../tools/approval/constants';

package/src/common/spawnPath.ts

@@ -0,0 +1,101 @@
+/**
+ * spawnPath — hierarchical invocation identity for nested multi-agent orchestration.
+ *
+ * A spawnPath is a slash-separated chain of spawnKeys from the root of the current
+ * agent invocation to the current spawn. The root agent has an empty spawnPath;
+ * each handoff/transfer/sequence that spawns a new subgraph appends a new spawnKey.
+ *
+ * Examples:
+ *   ""                               → primary agent (no spawn)
+ *   "call_abc"                       → first-level handoff child
+ *   "call_abc/call_def"              → grandchild (depth 2)
+ *   "call_abc/call_def/call_ghi"     → depth 3
+ *
+ * These utilities are the single source of truth for path manipulation across:
+ *   - @illuma-ai/agents (MultiAgentGraph, HandoffRegistry, callbacks)
+ *   - host api (initialize.js, callbacks.js, ExecutionTrace writes)
+ *   - host client (subagent store, sidebar rendering)
+ *
+ * See docs/multi-agent-nesting-architecture.md for the full design.
+ */
+
+/** Separator between spawnKeys in a spawnPath. Chosen so that the path looks
+ * like a filesystem/URL path, which makes it easy to read in logs and traces. */
+export const SPAWN_PATH_SEP = '/';
+
+/** Hard cap on nested multi-agent invocations. Prevents runaway recursion.
+ * Can be overridden at the host api layer via MULTI_AGENT_MAX_NESTING_DEPTH. */
+export const MAX_NESTING_DEPTH = 5;
+
+/**
+ * Append a spawnKey to a parent spawnPath.
+ *
+ * @param parent - Parent spawnPath (may be undefined/null/empty for root)
+ * @param key    - spawnKey to append
+ * @returns New spawnPath string
+ */
+export function buildSpawnPath(
+  parent: string | undefined | null,
+  key: string
+): string {
+  if (!key) {
+    throw new Error('[spawnPath] buildSpawnPath called with empty key');
+  }
+  if (parent == null || parent === '') return key;
+  return `${parent}${SPAWN_PATH_SEP}${key}`;
+}
+
+/**
+ * Compute the depth of a spawnPath.
+ * Root (empty) → 0; single-segment → 1; etc.
+ */
+export function spawnPathDepth(path: string | undefined | null): number {
+  if (path == null || path === '') return 0;
+  return path.split(SPAWN_PATH_SEP).filter(Boolean).length;
+}
+
+/**
+ * Return the parent spawnPath, or null if the input is already root.
+ *
+ * - parentSpawnPath("a/b/c") === "a/b"
+ * - parentSpawnPath("a") === ""
+ * - parentSpawnPath("") === null
+ */
+export function parentSpawnPath(
+  path: string | undefined | null
+): string | null {
+  if (path == null || path === '') return null;
+  const parts = path.split(SPAWN_PATH_SEP).filter(Boolean);
+  if (parts.length <= 1) return '';
+  return parts.slice(0, -1).join(SPAWN_PATH_SEP);
+}
+
+/** Split a spawnPath into its constituent spawnKey segments. */
+export function spawnPathParts(path: string | undefined | null): string[] {
+  if (path == null || path === '') return [];
+  return path.split(SPAWN_PATH_SEP).filter(Boolean);
+}
+
+/**
+ * Return the last spawnKey in a spawnPath (the "current" spawn).
+ * Returns null for root.
+ */
+export function leafSpawnKey(path: string | undefined | null): string | null {
+  const parts = spawnPathParts(path);
+  return parts.length === 0 ? null : parts[parts.length - 1];
+}
+
+/**
+ * True if `ancestor` is a strict ancestor of `descendant`. Root ("") is
+ * ancestor of everything except itself.
+ */
+export function isAncestorSpawnPath(
+  ancestor: string | undefined | null,
+  descendant: string | undefined | null
+): boolean {
+  const a = ancestor ?? '';
+  const d = descendant ?? '';
+  if (a === d) return false;
+  if (a === '') return d !== '';
+  return d.startsWith(a + SPAWN_PATH_SEP);
+}

package/src/graphs/Graph.ts

@@ -79,6 +79,10 @@ import { getChatModelClass, manualToolStreamProviders } from '@/llm/providers';
 import { ToolNode as CustomToolNode, toolsCondition } from '@/tools/ToolNode';
 import { ChatOpenAI, AzureChatOpenAI } from '@/llm/openai';
 import { safeDispatchCustomEvent } from '@/utils/events';
+import { mlog, mwarn } from '@/utils/logging';
+import { normalizeMessageToolCalls } from '@/utils/toolCallNormalization';
+import { isTruncationReason } from '@/utils/finishReasons';
+import { isLikelyContextOverflowError } from '@/utils/errors';
 import {
   detectDocuments,
   shouldInjectMultiDocHint,
@@ -1144,10 +1148,7 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
       const resolved = agentContext.resolveStructuredOutputMode();
       method = resolved.method;
       if (resolved.warnings.length > 0) {
-        console.warn(
-          '[Graph] Structured output mode warnings:',
-          resolved.warnings
-        );
+        mwarn('[Graph] Structured output mode warnings:', resolved.warnings);
       }
     } else {
       // Legacy fallback: use the old mode-based resolution
@@ -1172,7 +1173,7 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
       );
       preparedSchema = prepared;
       if (warnings.length > 0) {
-        console.warn('[Graph] Schema preparation warnings:', warnings);
+        mwarn('[Graph] Schema preparation warnings:', warnings);
       }
     }
 
@@ -1264,7 +1265,7 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
             ? handleErrors
             : `The response did not match the expected schema. Error: ${lastError.message}. Please try again with a valid response.`;
 
-        console.warn(
+        mwarn(
           `[Graph] Structured output attempt ${attempts} failed: ${lastError.message}. Retrying...`
         );
 
@@ -1467,7 +1468,7 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
         this._toolDiscoveryCache.getNewDiscoveries(messages);
       if (cachedDiscoveries.length > 0) {
         agentContext.markToolsAsDiscovered(cachedDiscoveries);
-        console.debug(
+        mlog(
           `[Graph:ToolDiscovery] Cached ${cachedDiscoveries.length} new tools (total: ${this._toolDiscoveryCache.size})`
         );
       }
@@ -1498,11 +1499,11 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
         });
 
       // DEBUG: Log which model and tools each agent uses during handoff
-      console.debug(
+      mlog(
         `[createCallModel] Agent "${agentId}" invoking LLM | provider=${agentContext.provider} | ` +
-        `model=${(effectiveClientOptions as Record<string, unknown>)?.model ?? 'default'} | ` +
-        `toolsForBinding=${toolsForBinding?.length ?? 0} | ` +
-        `toolNames=[${(toolsForBinding ?? []).map((t) => (t as { name?: string }).name ?? 'unknown').join(', ')}]`,
+          `model=${(effectiveClientOptions as Record<string, unknown>).model ?? 'default'} | ` +
+          `toolsForBinding=${toolsForBinding?.length ?? 0} | ` +
+          `toolNames=[${(toolsForBinding ?? []).map((t) => (t as { name?: string }).name ?? 'unknown').join(', ')}]`
       );
 
       if (agentContext.systemRunnable) {
@@ -1515,7 +1516,15 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
       if (!config.signal) {
         config.signal = this.signal;
       }
-      this.config = config;
+      // First-writer-wins: `this.config` is used ONLY as a "has a run started"
+      // existence flag by the dispatch* methods (they never read its value —
+      // they read the current RunnableConfig from LangChain AsyncLocalStorage).
+      // Unconditionally reassigning here races across concurrent child
+      // subgraph.invoke() calls under parallel multi-agent handoffs; the last
+      // writer wins, and any dispatch firing between writes would historically
+      // have been tagged with the wrong child's metadata. Keeping the first
+      // write pinned makes this a true flag, eliminating the race.
+      this.config ??= config;
 
       let messagesToUse = messages;
 
@@ -1619,7 +1628,7 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
 
           if (oldMessages.length > 0) {
             this._summaryInFlight = true;
-            console.debug(
+            mlog(
               `[Graph:ProactiveSummary] Context at ${utilization.toFixed(1)}% (threshold ${threshold}%) — summarizing ${oldMessages.length} older msgs in background`
             );
 
@@ -1628,7 +1637,7 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
               .then((updated) => {
                 if (updated != null && updated !== '') {
                   this._cachedRunSummary = updated;
-                  console.debug(
+                  mlog(
                     `[Graph:ProactiveSummary] Background summary ready (len=${updated.length})`
                   );
                 }
@@ -1838,7 +1847,7 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
         }
         agentContext.indexTokenCountMap = viewTokenMap;
 
-        console.debug(
+        mlog(
           `[Graph:Compaction] ${messages.length}→${viewParts.length} msgs | ` +
             `compacted=${compactedMessages.length} window=${recentMessages.length} | ` +
             `summary=${summarySource} | budget=${usedTokens}/${recentBudget}` +
@@ -1862,7 +1871,7 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
           if (shouldSummarize) {
             if (this._summaryInFlight) {
               this._pendingMessagesToRefine.push(...compactedMessages);
-              console.debug(
+              mlog(
                 `[Graph:Compaction] Summary in-flight, queued ${compactedMessages.length} msgs (pending=${this._pendingMessagesToRefine.length})`
               );
             } else {
@@ -1915,7 +1924,7 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
         deduplicateSystemMessages(messagesToUse);
       if (removedCount > 0) {
         messagesToUse = dedupedMessages;
-        console.debug(
+        mlog(
           `[Graph:Dedup] Removed ${removedCount} duplicate system message(s)`
         );
       }
@@ -2039,7 +2048,6 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
         );
       }
 
-
       // Get model info for analytics
       const bedrockOpts = agentContext.clientOptions as
         | t.BedrockAnthropicClientOptions
@@ -2141,23 +2149,16 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
           config
         );
       } catch (primaryError) {
-        // Check if this is a "input too long" error from Bedrock/Anthropic
-        const errorMessage = (primaryError as Error).message.toLowerCase();
-        const isInputTooLongError =
-          errorMessage.includes('too long') ||
-          errorMessage.includes('input is too long') ||
-          errorMessage.includes('context length') ||
-          errorMessage.includes('maximum context') ||
-          errorMessage.includes('validationexception') ||
-          errorMessage.includes('prompt is too long');
+        const errorMessage = (primaryError as Error).message;
+        const isInputTooLongError = isLikelyContextOverflowError(errorMessage);
 
         // Log when we detect the error
         if (isInputTooLongError) {
-          console.warn(
+          mwarn(
             '[Graph] Detected input too long error:',
             errorMessage.substring(0, 200)
           );
-          console.warn('[Graph] Checking emergency pruning conditions:', {
+          mwarn('[Graph] Checking emergency pruning conditions:', {
             hasPruneMessages: !!agentContext.pruneMessages,
             hasTokenCounter: !!agentContext.tokenCounter,
             maxContextTokens: agentContext.maxContextTokens,
@@ -2182,7 +2183,7 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
             const reducedMaxTokens = Math.floor(
               agentContext.maxContextTokens! * reductionFactor
             );
-            console.warn(
+            mwarn(
               `[Graph] Input too long. Retrying with ${reductionFactor * 100}% context (${reducedMaxTokens} tokens)...`
             );
 
@@ -2190,7 +2191,7 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
             // This is needed when messages were dynamically added without updating the token map
             let tokenMapForPruning = agentContext.indexTokenCountMap;
             if (Object.keys(tokenMapForPruning).length < messages.length) {
-              console.warn(
+              mwarn(
                 '[Graph] Building fresh token count map for emergency pruning...'
               );
               tokenMapForPruning = {};
@@ -2215,7 +2216,7 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
 
             // Skip if we can't fit any messages
             if (reducedMessages.length === 0) {
-              console.warn(
+              mwarn(
                 `[Graph] Cannot fit any messages at ${reductionFactor * 100}% reduction, trying next level...`
               );
               continue;
@@ -2291,14 +2292,11 @@ If I seem to be missing something we discussed earlier, just give me a quick rem
                 `[Graph] ✅ Retry successful at ${reductionFactor * 100}% with ${reducedMessages.length} messages (reduced from ${finalMessages.length})`
               );
             } catch (retryError) {
-              const retryErrorMsg = (retryError as Error).message.toLowerCase();
-              const stillTooLong =
-                retryErrorMsg.includes('too long') ||
-                retryErrorMsg.includes('context length') ||
-                retryErrorMsg.includes('validationexception');
+              const retryErrorMsg = (retryError as Error).message;
+              const stillTooLong = isLikelyContextOverflowError(retryErrorMsg);
 
               if (stillTooLong && reductionFactor > 0.1) {
-                console.warn(
+                mwarn(
                   `[Graph] Still too long at ${reductionFactor * 100}%, trying more aggressive pruning...`
                 );
               } else {
@@ -2370,6 +2368,27 @@ If I seem to be missing something we discussed earlier, just give me a quick rem
        * handled everything — both paths become no-ops.
        */
       const responseMessage = result.messages?.[0];
+
+      // Tool-call name normalization — catches LLM output that names tools
+      // with wrong delimiters (outlook/operations), prefixes
+      // (functions.outlook_operations), case drift, counter suffixes, or
+      // empty names recoverable from the tool_call id. Mutates in place so
+      // the downstream ToolNode dispatch sees the corrected names.
+      if (responseMessage && agentContext.toolMap) {
+        const allowedNames = new Set(Object.keys(agentContext.toolMap));
+        if (allowedNames.size > 0) {
+          const rewrote = normalizeMessageToolCalls(
+            responseMessage,
+            allowedNames
+          );
+          if (rewrote) {
+            mlog(
+              `[Graph] normalized tool_call names on agent "${agentId}" response`
+            );
+          }
+        }
+      }
+
       const toolCalls = (responseMessage as AIMessageChunk | undefined)
         ?.tool_calls;
       const hasToolCalls = Array.isArray(toolCalls) && toolCalls.length > 0;
@@ -2485,12 +2504,22 @@ If I seem to be missing something we discussed earlier, just give me a quick rem
         const messageStop = meta.messageStop as
           | Record<string, unknown>
           | undefined;
-        this.lastFinishReason =
+        const nextReason =
           (meta.finish_reason as string | undefined) ?? // OpenAI/Azure
           (meta.stop_reason as string | undefined) ?? // Anthropic direct API
           (meta.stopReason as string | undefined) ?? // Bedrock invoke (non-streaming)
           (messageStop?.stopReason as string | undefined) ?? // Bedrock streaming
           (meta.finishReason as string | undefined); // VertexAI/Google
+
+        // Sticky on truncation: a single Graph instance is reused across
+        // every scoped-subgraph inner node invocation (see MultiAgentGraph
+        // buildScopedSubgraph). If an earlier inner node hit max_tokens
+        // but a later inner node finished cleanly, the host's continuation layer
+        // would miss the truncation signal unless we preserve it. Keep the
+        // truncation reason pinned so the outer caller can retry.
+        if (!isTruncationReason(this.lastFinishReason)) {
+          this.lastFinishReason = nextReason;
+        }
       }
 
       this.cleanupSignalListener();
@@ -2553,7 +2582,7 @@ If I seem to be missing something we discussed earlier, just give me a quick rem
               '[Graph] Deferred structured output failed after successful tool use:',
               structuredError
             );
-            console.warn(
+            mwarn(
               '[Graph] Falling back to unstructured response from tool-use phase'
             );
             return result;
@@ -2578,7 +2607,10 @@ If I seem to be missing something we discussed earlier, just give me a quick rem
       state: t.BaseGraphState,
       config?: RunnableConfig
     ): string => {
-      this.config = config;
+      // First-writer-wins — see note in createCallModel. `this.config` is an
+      // existence flag only; assigning unconditionally would race under
+      // parallel child subgraph.invoke().
+      this.config ??= config;
       return toolsCondition(state, toolNode, this.invokedToolIds);
     };
 
@@ -2623,10 +2655,16 @@ If I seem to be missing something we discussed earlier, just give me a quick rem
         default: () => [],
       }),
     });
+    // Pass compileOptions (including the HITL checkpointer) to the OUTER
+    // workflow — not just the inner agent subgraph. hasInterrupts() calls
+    // getState() on the outer compiled graph; without a checkpointer here,
+    // getState reports zero tasks and the HITL interrupt/resume loop breaks
+    // out immediately even though interrupt() fired correctly inside the
+    // agent subgraph.
     const workflow = new StateGraph(StateAnnotation)
       .addNode(this.defaultAgentId, agentNode, { ends: [END] })
       .addEdge(START, this.defaultAgentId)
-      .compile();
+      .compile(this.compileOptions as unknown as never);
 
     return workflow;
   }
@@ -2709,7 +2747,7 @@ If I seem to be missing something we discussed earlier, just give me a quick rem
         }
       } catch (_e) {
         /** If we can't get agent context, that's okay - agentId remains undefined */
-        console.debug(
+        mlog(
           `[dispatchRunStep] Could not resolve agentId from metadata.langgraph_node="${(metadata as Record<string, unknown>).langgraph_node}": ${(_e as Error).message}`
         );
       }
@@ -2717,11 +2755,11 @@ If I seem to be missing something we discussed earlier, just give me a quick rem
 
     this.contentData.push(runStep);
     this.contentIndexMap.set(stepId, runStep.index);
-    await safeDispatchCustomEvent(
-      GraphEvents.ON_RUN_STEP,
-      runStep,
-      this.config
-    );
+    // Pass undefined so safeDispatchCustomEvent resolves the runnable config
+    // from LangChain's AsyncLocalStorage. Using the shared `this.config` would
+    // race across concurrent child subgraph.invoke calls under parallel
+    // multi-agent handoffs and tag events with the wrong child's spawnKey.
+    await safeDispatchCustomEvent(GraphEvents.ON_RUN_STEP, runStep);
     return stepId;
   }
 
@@ -2862,7 +2900,7 @@ If I seem to be missing something we discussed earlier, just give me a quick rem
     }
 
     if (!data.id) {
-      console.warn('No Tool ID provided for Tool Error');
+      mwarn('No Tool ID provided for Tool Error');
       return;
     }
 
@@ -2927,11 +2965,10 @@ If I seem to be missing something we discussed earlier, just give me a quick rem
       id,
       delta,
     };
-    await safeDispatchCustomEvent(
-      GraphEvents.ON_RUN_STEP_DELTA,
-      runStepDelta,
-      this.config
-    );
+    // See dispatchRunStep note: do not pass `this.config`. The implicit
+    // AsyncLocalStorage config is the correct per-async-branch source under
+    // parallel handoffs.
+    await safeDispatchCustomEvent(GraphEvents.ON_RUN_STEP_DELTA, runStepDelta);
   }
 
   async dispatchMessageDelta(id: string, delta: t.MessageDelta): Promise<void> {
@@ -2942,11 +2979,8 @@ If I seem to be missing something we discussed earlier, just give me a quick rem
       id,
       delta,
     };
-    await safeDispatchCustomEvent(
-      GraphEvents.ON_MESSAGE_DELTA,
-      messageDelta,
-      this.config
-    );
+    // See dispatchRunStep note.
+    await safeDispatchCustomEvent(GraphEvents.ON_MESSAGE_DELTA, messageDelta);
   }
 
   dispatchReasoningDelta = async (
@@ -2960,10 +2994,10 @@ If I seem to be missing something we discussed earlier, just give me a quick rem
       id: stepId,
       delta,
     };
+    // See dispatchRunStep note.
     await safeDispatchCustomEvent(
       GraphEvents.ON_REASONING_DELTA,
-      reasoningDelta,
-      this.config
+      reasoningDelta
     );
   };
 }