@illuma-ai/agents 1.5.1 → 2.1.1

package/dist/cjs/tools/ToolNode.cjs

@@ -87,7 +87,7 @@ class ToolNode extends run.RunnableCallable {
     hookRegistry;
     /**
      * Tool output reference registry threaded down from Run / Graph
-     * (PR #114). When set, dispatchToolEvents resolves
+     * (upstream PR #114). When set, dispatchToolEvents resolves
      * `{{tool<i>turn<n>}}` placeholders in args before invoking each tool
      * and stores successful outputs under their stable reference keys for
      * subsequent calls in the same run to pipe through.
@@ -269,7 +269,7 @@ class ToolNode extends run.RunnableCallable {
     /**
      * Runs a single tool call with error handling.
      *
-     * @param batchContext  Optional per-batch context (PR #117).
+     * @param batchContext  Optional per-batch context (upstream PR #117).
      *   Threaded from `run()` for tool output reference annotation. The
      *   `batchScopeId` field carries an anonymous synthetic scope when the
      *   caller has no `run_id`, so concurrent batches don't collide on the
@@ -456,7 +456,7 @@ class ToolNode extends run.RunnableCallable {
                 minReductionPercent: 10, // Only apply TOON when clearly beneficial
             });
             /**
-             * Tool output reference metadata (PR #117). Register the
+             * Tool output reference metadata (upstream PR #117). Register the
              * raw, untruncated content so future `{{...}}` substitutions deliver
              * the full payload, and stamp `_refKey` / `_refScope` /
              * `_unresolvedRefs` into `additional_kwargs` for the lazy
@@ -605,17 +605,78 @@ class ToolNode extends run.RunnableCallable {
                 // parsePartialJson failed — fall through to field-level extraction
             }
         }
-        // Field-level recovery: extract missing fields from the raw buffer
+        // Field-level recovery: extract missing fields from the raw buffer.
+        //
+        // Only attempt this when `parsedArgs` is missing top-level keys that
+        // appear at depth 0 in the raw JSON. The previous implementation walked
+        // EVERY `"key":` match the regex found — including keys nested inside
+        // arrays/objects like `steps[].options[].label` — and tried to "recover"
+        // them as top-level fields. That produced confusing log spam (false
+        // positives like `recoveredFields=[question,label,value]` for a clean
+        // multi-step `ask_user` call) and could inject stray top-level fields
+        // into `args` for downstream tool execution.
         const parsedArgs = typeof args === 'object' ? { ...args } : {};
         const recoveredFields = [];
-        // Extract field names from the raw JSON string
-        const fieldPattern = /"([^"]+)"\s*:/g;
-        let match;
-        const rawFieldNames = [];
-        while ((match = fieldPattern.exec(rawArgs)) !== null) {
-            rawFieldNames.push(match[1]);
+        /**
+         * Extract only TOP-LEVEL keys from the raw JSON. Walks the buffer
+         * tracking brace/bracket depth so nested keys are skipped.
+         */
+        const topLevelKeys = [];
+        let depth = 0;
+        let inString = false;
+        let escaped = false;
+        let i = 0;
+        while (i < rawArgs.length) {
+            const ch = rawArgs[i];
+            if (escaped) {
+                escaped = false;
+                i++;
+                continue;
+            }
+            if (inString) {
+                if (ch === '\\')
+                    escaped = true;
+                else if (ch === '"')
+                    inString = false;
+                i++;
+                continue;
+            }
+            if (ch === '"') {
+                // Possible key — only count if at depth 1 (inside the outer object)
+                const start = i + 1;
+                let j = start;
+                while (j < rawArgs.length) {
+                    const c = rawArgs[j];
+                    if (c === '\\') {
+                        j += 2;
+                        continue;
+                    }
+                    if (c === '"')
+                        break;
+                    j++;
+                }
+                if (j < rawArgs.length) {
+                    // Skip whitespace after closing quote and check for ':'
+                    let k = j + 1;
+                    while (k < rawArgs.length && /\s/.test(rawArgs[k]))
+                        k++;
+                    if (depth === 1 && rawArgs[k] === ':') {
+                        topLevelKeys.push(rawArgs.slice(start, j));
+                    }
+                    i = j + 1;
+                    continue;
+                }
+                inString = true;
+                i++;
+                continue;
+            }
+            if (ch === '{' || ch === '[')
+                depth++;
+            else if (ch === '}' || ch === ']')
+                depth--;
+            i++;
         }
-        for (const fieldName of rawFieldNames) {
+        for (const fieldName of topLevelKeys) {
             if (parsedArgs[fieldName] == null ||
                 parsedArgs[fieldName] === '' ||
                 parsedArgs[fieldName] === undefined) {
@@ -787,6 +848,10 @@ class ToolNode extends run.RunnableCallable {
             // Dispatch ON_RUN_STEP_COMPLETED via custom event (same path as dispatchToolEvents)
             const stepId = this.toolCallStepIds?.get(toolCallId) ?? '';
             if (!stepId) {
+                // eslint-disable-next-line no-console
+                console.warn(`[ToolNode.handleRunToolCompletions] missing stepId for toolCallId=${toolCallId} ` +
+                    `name=${call.name} — ON_RUN_STEP_COMPLETED skipped, output will not be persisted. ` +
+                    `If this is a resumed HITL tool call, verify Graph.resetValues preserves toolCallStepIds when keepContent=true.`);
                 continue;
             }
             const contentString = typeof toolMessage.content === 'string'
@@ -953,7 +1018,7 @@ class ToolNode extends run.RunnableCallable {
             }
         }
         /**
-         * Tool output reference resolution (PR #114): walk each call's
+         * Tool output reference resolution (upstream PR #114): walk each call's
          * args and substitute `{{tool<i>turn<n>}}` placeholders with the stored
          * raw output. Captured here BEFORE request shaping so the substituted
          * args flow through the rest of the dispatch unchanged.
@@ -1111,7 +1176,7 @@ class ToolNode extends run.RunnableCallable {
                         ? result.content
                         : JSON.stringify(result.content);
                 /**
-                 * Tool output reference — lazy annotation (PRs #114 + #117).
+                 * Tool output reference — lazy annotation (upstream PRs #114 + #117).
                  * Register the raw output under `tool<idx>turn<turn>` in the
                  * registry but leave `ToolMessage.content` clean. Stamp the ref
                  * metadata into `additional_kwargs` instead. The lazy