@illuma-ai/agents 1.1.28 → 1.3.1

package/dist/cjs/graphs/Graph.cjs

@@ -29,10 +29,14 @@ var contextPressure = require('../utils/contextPressure.cjs');
 var toolDiscoveryCache = require('../utils/toolDiscoveryCache.cjs');
 var pruneCalibration = require('../utils/pruneCalibration.cjs');
 var fileManifest = require('../utils/fileManifest.cjs');
+var errors = require('../utils/errors.cjs');
 var providers = require('../llm/providers.cjs');
 var ToolNode = require('../tools/ToolNode.cjs');
 var index = require('../llm/openai/index.cjs');
 var events = require('../utils/events.cjs');
+var logging = require('../utils/logging.cjs');
+var toolCallNormalization = require('../utils/toolCallNormalization.cjs');
+var finishReasons = require('../utils/finishReasons.cjs');
 var schema = require('../tools/schema.cjs');
 var validate = require('../schemas/validate.cjs');
 var AgentContext = require('../agents/AgentContext.cjs');
@@ -797,7 +801,7 @@ class StandardGraph extends Graph {
             const resolved = agentContext.resolveStructuredOutputMode();
             method = resolved.method;
             if (resolved.warnings.length > 0) {
-                console.warn('[Graph] Structured output mode warnings:', resolved.warnings);
+                logging.mwarn('[Graph] Structured output mode warnings:', resolved.warnings);
             }
         }
         else {
@@ -820,7 +824,7 @@ class StandardGraph extends Graph {
             const { schema: prepared, warnings } = validate.prepareSchemaForProvider(schema, provider, structuredOutputConfig.strict !== false);
             preparedSchema = prepared;
             if (warnings.length > 0) {
-                console.warn('[Graph] Schema preparation warnings:', warnings);
+                logging.mwarn('[Graph] Schema preparation warnings:', warnings);
             }
         }
         // Use withStructuredOutput to bind the schema
@@ -890,7 +894,7 @@ class StandardGraph extends Graph {
                 const errorMessage = typeof handleErrors === 'string'
                     ? handleErrors
                     : `The response did not match the expected schema. Error: ${lastError.message}. Please try again with a valid response.`;
-                console.warn(`[Graph] Structured output attempt ${attempts} failed: ${lastError.message}. Retrying...`);
+                logging.mwarn(`[Graph] Structured output attempt ${attempts} failed: ${lastError.message}. Retrying...`);
                 // Add the error as a human message for context
                 finalMessages = [
                     ...finalMessages,
@@ -1040,7 +1044,7 @@ class StandardGraph extends Graph {
             const cachedDiscoveries = this._toolDiscoveryCache.getNewDiscoveries(messages$1);
             if (cachedDiscoveries.length > 0) {
                 agentContext.markToolsAsDiscovered(cachedDiscoveries);
-                console.debug(`[Graph:ToolDiscovery] Cached ${cachedDiscoveries.length} new tools (total: ${this._toolDiscoveryCache.size})`);
+                logging.mlog(`[Graph:ToolDiscovery] Cached ${cachedDiscoveries.length} new tools (total: ${this._toolDiscoveryCache.size})`);
             }
             const toolsForBinding = agentContext.getToolsForBinding();
             // PERF: Detect subsequent ReAct iterations (tool results present in messages)
@@ -1059,8 +1063,8 @@ class StandardGraph extends Graph {
                     clientOptions: effectiveClientOptions,
                 });
             // DEBUG: Log which model and tools each agent uses during handoff
-            console.debug(`[createCallModel] Agent "${agentId}" invoking LLM | provider=${agentContext.provider} | ` +
-                `model=${effectiveClientOptions?.model ?? 'default'} | ` +
+            logging.mlog(`[createCallModel] Agent "${agentId}" invoking LLM | provider=${agentContext.provider} | ` +
+                `model=${effectiveClientOptions.model ?? 'default'} | ` +
                 `toolsForBinding=${toolsForBinding?.length ?? 0} | ` +
                 `toolNames=[${(toolsForBinding ?? []).map((t) => t.name ?? 'unknown').join(', ')}]`);
             if (agentContext.systemRunnable) {
@@ -1072,7 +1076,15 @@ class StandardGraph extends Graph {
             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$1;
             // ====================================================================
             // PRE-PRUNING DELEGATION CHECK
@@ -1138,13 +1150,13 @@ class StandardGraph extends Graph {
                     const oldMessages = messages$1.slice(messages$1[0]?.getType() === 'system' ? 1 : 0, Math.max(1, messages$1.length - recentTurnCount));
                     if (oldMessages.length > 0) {
                         this._summaryInFlight = true;
-                        console.debug(`[Graph:ProactiveSummary] Context at ${utilization.toFixed(1)}% (threshold ${threshold}%) — summarizing ${oldMessages.length} older msgs in background`);
+                        logging.mlog(`[Graph:ProactiveSummary] Context at ${utilization.toFixed(1)}% (threshold ${threshold}%) — summarizing ${oldMessages.length} older msgs in background`);
                         agentContext
                             .summarizeCallback(oldMessages)
                             .then((updated) => {
                             if (updated != null && updated !== '') {
                                 this._cachedRunSummary = updated;
-                                console.debug(`[Graph:ProactiveSummary] Background summary ready (len=${updated.length})`);
+                                logging.mlog(`[Graph:ProactiveSummary] Background summary ready (len=${updated.length})`);
                             }
                         })
                             .catch((err) => {
@@ -1320,7 +1332,7 @@ class StandardGraph extends Graph {
                     viewIdx++;
                 }
                 agentContext.indexTokenCountMap = viewTokenMap;
-                console.debug(`[Graph:Compaction] ${messages$1.length}→${viewParts.length} msgs | ` +
+                logging.mlog(`[Graph:Compaction] ${messages$1.length}→${viewParts.length} msgs | ` +
                     `compacted=${compactedMessages.length} window=${recentMessages.length} | ` +
                     `summary=${summarySource} | budget=${usedTokens}/${recentBudget}` +
                     (fileManifestTokens > 0
@@ -1334,7 +1346,7 @@ class StandardGraph extends Graph {
                     if (shouldSummarize) {
                         if (this._summaryInFlight) {
                             this._pendingMessagesToRefine.push(...compactedMessages);
-                            console.debug(`[Graph:Compaction] Summary in-flight, queued ${compactedMessages.length} msgs (pending=${this._pendingMessagesToRefine.length})`);
+                            logging.mlog(`[Graph:Compaction] Summary in-flight, queued ${compactedMessages.length} msgs (pending=${this._pendingMessagesToRefine.length})`);
                         }
                         else {
                             this._summaryInFlight = true;
@@ -1375,7 +1387,7 @@ class StandardGraph extends Graph {
             const { messages: dedupedMessages, removedCount } = dedup.deduplicateSystemMessages(messagesToUse);
             if (removedCount > 0) {
                 messagesToUse = dedupedMessages;
-                console.debug(`[Graph:Dedup] Removed ${removedCount} duplicate system message(s)`);
+                logging.mlog(`[Graph:Dedup] Removed ${removedCount} duplicate system message(s)`);
             }
             let finalMessages = messagesToUse;
             if (agentContext.useLegacyContent) {
@@ -1539,18 +1551,12 @@ class StandardGraph extends Graph {
                 }, config);
             }
             catch (primaryError) {
-                // Check if this is a "input too long" error from Bedrock/Anthropic
-                const errorMessage = primaryError.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.message;
+                const isInputTooLongError = errors.isLikelyContextOverflowError(errorMessage);
                 // Log when we detect the error
                 if (isInputTooLongError) {
-                    console.warn('[Graph] Detected input too long error:', errorMessage.substring(0, 200));
-                    console.warn('[Graph] Checking emergency pruning conditions:', {
+                    logging.mwarn('[Graph] Detected input too long error:', errorMessage.substring(0, 200));
+                    logging.mwarn('[Graph] Checking emergency pruning conditions:', {
                         hasPruneMessages: !!agentContext.pruneMessages,
                         hasTokenCounter: !!agentContext.tokenCounter,
                         maxContextTokens: agentContext.maxContextTokens,
@@ -1570,12 +1576,12 @@ class StandardGraph extends Graph {
                         if (result)
                             break; // Exit if we got a result
                         const reducedMaxTokens = Math.floor(agentContext.maxContextTokens * reductionFactor);
-                        console.warn(`[Graph] Input too long. Retrying with ${reductionFactor * 100}% context (${reducedMaxTokens} tokens)...`);
+                        logging.mwarn(`[Graph] Input too long. Retrying with ${reductionFactor * 100}% context (${reducedMaxTokens} tokens)...`);
                         // Build fresh indexTokenCountMap if missing/incomplete
                         // This is needed when messages were dynamically added without updating the token map
                         let tokenMapForPruning = agentContext.indexTokenCountMap;
                         if (Object.keys(tokenMapForPruning).length < messages$1.length) {
-                            console.warn('[Graph] Building fresh token count map for emergency pruning...');
+                            logging.mwarn('[Graph] Building fresh token count map for emergency pruning...');
                             tokenMapForPruning = {};
                             for (let i = 0; i < messages$1.length; i++) {
                                 tokenMapForPruning[i] = agentContext.tokenCounter(messages$1[i]);
@@ -1595,7 +1601,7 @@ class StandardGraph extends Graph {
                         });
                         // Skip if we can't fit any messages
                         if (reducedMessages.length === 0) {
-                            console.warn(`[Graph] Cannot fit any messages at ${reductionFactor * 100}% reduction, trying next level...`);
+                            logging.mwarn(`[Graph] Cannot fit any messages at ${reductionFactor * 100}% reduction, trying next level...`);
                             continue;
                         }
                         // Calculate how many messages were pruned and estimate context timeframe
@@ -1650,12 +1656,10 @@ If I seem to be missing something we discussed earlier, just give me a quick rem
                             console.info(`[Graph] ✅ Retry successful at ${reductionFactor * 100}% with ${reducedMessages.length} messages (reduced from ${finalMessages.length})`);
                         }
                         catch (retryError) {
-                            const retryErrorMsg = retryError.message.toLowerCase();
-                            const stillTooLong = retryErrorMsg.includes('too long') ||
-                                retryErrorMsg.includes('context length') ||
-                                retryErrorMsg.includes('validationexception');
+                            const retryErrorMsg = retryError.message;
+                            const stillTooLong = errors.isLikelyContextOverflowError(retryErrorMsg);
                             if (stillTooLong && reductionFactor > 0.1) {
-                                console.warn(`[Graph] Still too long at ${reductionFactor * 100}%, trying more aggressive pruning...`);
+                                logging.mwarn(`[Graph] Still too long at ${reductionFactor * 100}%, trying more aggressive pruning...`);
                             }
                             else {
                                 console.error(`[Graph] Retry at ${reductionFactor * 100}% failed:`, retryError.message);
@@ -1715,6 +1719,20 @@ 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 = toolCallNormalization.normalizeMessageToolCalls(responseMessage, allowedNames);
+                    if (rewrote) {
+                        logging.mlog(`[Graph] normalized tool_call names on agent "${agentId}" response`);
+                    }
+                }
+            }
             const toolCalls = responseMessage
                 ?.tool_calls;
             const hasToolCalls = Array.isArray(toolCalls) && toolCalls.length > 0;
@@ -1801,12 +1819,20 @@ If I seem to be missing something we discussed earlier, just give me a quick rem
                 const meta = finalMsg.response_metadata;
                 // Bedrock streaming nests stopReason inside messageStop: { stopReason: '...' }
                 const messageStop = meta.messageStop;
-                this.lastFinishReason =
-                    meta.finish_reason ?? // OpenAI/Azure
-                        meta.stop_reason ?? // Anthropic direct API
-                        meta.stopReason ?? // Bedrock invoke (non-streaming)
-                        messageStop?.stopReason ?? // Bedrock streaming
-                        meta.finishReason; // VertexAI/Google
+                const nextReason = meta.finish_reason ?? // OpenAI/Azure
+                    meta.stop_reason ?? // Anthropic direct API
+                    meta.stopReason ?? // Bedrock invoke (non-streaming)
+                    messageStop?.stopReason ?? // Bedrock streaming
+                    meta.finishReason; // 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 (!finishReasons.isTruncationReason(this.lastFinishReason)) {
+                    this.lastFinishReason = nextReason;
+                }
             }
             this.cleanupSignalListener();
             // DEFERRED STRUCTURED OUTPUT: When the agent has tools AND structured output configured,
@@ -1854,7 +1880,7 @@ If I seem to be missing something we discussed earlier, just give me a quick rem
                         // but we couldn't format the output as structured JSON.
                         // Return the unstructured text response from attemptInvoke.
                         console.error('[Graph] Deferred structured output failed after successful tool use:', structuredError);
-                        console.warn('[Graph] Falling back to unstructured response from tool-use phase');
+                        logging.mwarn('[Graph] Falling back to unstructured response from tool-use phase');
                         return result;
                     }
                 }
@@ -1870,7 +1896,10 @@ If I seem to be missing something we discussed earlier, just give me a quick rem
         const agentNode = `${AGENT}${agentId}`;
         const toolNode = `${TOOLS}${agentId}`;
         const routeMessage = (state, config) => {
-            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 ToolNode.toolsCondition(state, toolNode, this.invokedToolIds);
         };
         const StateAnnotation = langgraph.Annotation.Root({
@@ -1908,10 +1937,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 langgraph.StateGraph(StateAnnotation)
             .addNode(this.defaultAgentId, agentNode, { ends: [langgraph.END] })
             .addEdge(langgraph.START, this.defaultAgentId)
-            .compile();
+            .compile(this.compileOptions);
         return workflow;
     }
     /**
@@ -1982,12 +2017,16 @@ 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(`[dispatchRunStep] Could not resolve agentId from metadata.langgraph_node="${metadata.langgraph_node}": ${_e.message}`);
+                logging.mlog(`[dispatchRunStep] Could not resolve agentId from metadata.langgraph_node="${metadata.langgraph_node}": ${_e.message}`);
             }
         }
         this.contentData.push(runStep);
         this.contentIndexMap.set(stepId, runStep.index);
-        await events.safeDispatchCustomEvent(_enum.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 events.safeDispatchCustomEvent(_enum.GraphEvents.ON_RUN_STEP, runStep);
         return stepId;
     }
     async handleToolCallCompleted(data, metadata, omitOutput) {
@@ -2095,7 +2134,7 @@ If I seem to be missing something we discussed earlier, just give me a quick rem
             throw new Error('No config provided');
         }
         if (!data.id) {
-            console.warn('No Tool ID provided for Tool Error');
+            logging.mwarn('No Tool ID provided for Tool Error');
             return;
         }
         const stepId = graph.toolCallStepIds.get(data.id) ?? '';
@@ -2143,7 +2182,10 @@ If I seem to be missing something we discussed earlier, just give me a quick rem
             id,
             delta,
         };
-        await events.safeDispatchCustomEvent(_enum.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 events.safeDispatchCustomEvent(_enum.GraphEvents.ON_RUN_STEP_DELTA, runStepDelta);
     }
     async dispatchMessageDelta(id, delta) {
         if (!this.config) {
@@ -2153,7 +2195,8 @@ If I seem to be missing something we discussed earlier, just give me a quick rem
             id,
             delta,
         };
-        await events.safeDispatchCustomEvent(_enum.GraphEvents.ON_MESSAGE_DELTA, messageDelta, this.config);
+        // See dispatchRunStep note.
+        await events.safeDispatchCustomEvent(_enum.GraphEvents.ON_MESSAGE_DELTA, messageDelta);
     }
     dispatchReasoningDelta = async (stepId, delta) => {
         if (!this.config) {
@@ -2163,7 +2206,8 @@ If I seem to be missing something we discussed earlier, just give me a quick rem
             id: stepId,
             delta,
         };
-        await events.safeDispatchCustomEvent(_enum.GraphEvents.ON_REASONING_DELTA, reasoningDelta, this.config);
+        // See dispatchRunStep note.
+        await events.safeDispatchCustomEvent(_enum.GraphEvents.ON_REASONING_DELTA, reasoningDelta);
     };
 }