@librechat/agents 3.1.71-dev.0 → 3.1.71-dev.1

package/dist/esm/tools/ToolNode.mjs

@@ -10,7 +10,7 @@ import { RunnableCallable } from '../utils/run.mjs';
 import 'ai-tokenizer';
 import 'zod-to-json-schema';
 import { executeHooks } from '../hooks/executeHooks.mjs';
-import { ToolOutputReferenceRegistry, annotateToolOutputWithReference, buildReferenceKey } from './toolOutputReferences.mjs';
+import { ToolOutputReferenceRegistry, buildReferenceKey } from './toolOutputReferences.mjs';
 
 /**
  * Helper to check if a value is a Send object
@@ -300,13 +300,17 @@ class ToolNode extends RunnableCallable {
                 const isError = toolMsg.status === 'error';
                 if (isError) {
                     /**
-                     * Error ToolMessages bypass registration/annotation but must
-                     * still carry the unresolved-refs hint so the LLM can
-                     * self-correct when its reference key caused the failure.
+                     * Error ToolMessages bypass registration but still stamp the
+                     * unresolved-refs hint into `additional_kwargs` so the lazy
+                     * annotation transform surfaces it to the LLM, letting the
+                     * model self-correct when its reference key caused the
+                     * failure. Persisted `content` stays clean.
                      */
-                    if (unresolvedRefs.length > 0 &&
-                        typeof toolMsg.content === 'string') {
-                        toolMsg.content = this.applyOutputReference(runId, toolMsg.content, toolMsg.content, undefined, unresolvedRefs);
+                    if (unresolvedRefs.length > 0) {
+                        toolMsg.additional_kwargs = {
+                            ...toolMsg.additional_kwargs,
+                            _unresolvedRefs: unresolvedRefs,
+                        };
                     }
                     return toolMsg;
                 }
@@ -314,7 +318,14 @@ class ToolNode extends RunnableCallable {
                     if (typeof toolMsg.content === 'string') {
                         const rawContent = toolMsg.content;
                         const llmContent = truncateToolResultContent(rawContent, this.maxToolResultChars);
-                        toolMsg.content = this.applyOutputReference(runId, llmContent, rawContent, refKey, unresolvedRefs);
+                        toolMsg.content = llmContent;
+                        const refMeta = this.recordOutputReference(runId, rawContent, refKey, unresolvedRefs);
+                        if (refMeta != null) {
+                            toolMsg.additional_kwargs = {
+                                ...toolMsg.additional_kwargs,
+                                ...refMeta,
+                            };
+                        }
                     }
                     else {
                         /**
@@ -322,22 +333,16 @@ class ToolNode extends RunnableCallable {
                          * image). Known limitation: we cannot register under a
                          * reference key because there's no canonical serialized
                          * form. Warn once per tool per run when the caller
-                         * intended to register.
-                         *
-                         * Still surface unresolved-ref warnings so the LLM gets
-                         * the self-correction signal that the string and error
-                         * paths already emit. Prepended as a leading text block
-                         * to keep the original content ordering intact.
+                         * intended to register. The unresolved-refs hint is still
+                         * stamped as metadata; the lazy transform prepends a text
+                         * block at request time so the LLM gets the self-correction
+                         * signal.
                          */
-                        if (unresolvedRefs.length > 0 && Array.isArray(toolMsg.content)) {
-                            const warningBlock = {
-                                type: 'text',
-                                text: `[unresolved refs: ${unresolvedRefs.join(', ')}]`,
+                        if (unresolvedRefs.length > 0) {
+                            toolMsg.additional_kwargs = {
+                                ...toolMsg.additional_kwargs,
+                                _unresolvedRefs: unresolvedRefs,
                             };
-                            toolMsg.content = [
-                                warningBlock,
-                                ...toolMsg.content,
-                            ];
                         }
                         if (refKey != null &&
                             this.toolOutputRegistry.claimWarnOnce(runId, call.name)) {
@@ -351,12 +356,15 @@ class ToolNode extends RunnableCallable {
             }
             const rawContent = typeof output === 'string' ? output : JSON.stringify(output);
             const truncated = truncateToolResultContent(rawContent, this.maxToolResultChars);
-            const content = this.applyOutputReference(runId, truncated, rawContent, refKey, unresolvedRefs);
+            const refMeta = this.recordOutputReference(runId, rawContent, refKey, unresolvedRefs);
             return new ToolMessage({
                 status: 'success',
                 name: tool.name,
-                content,
+                content: truncated,
                 tool_call_id: call.id,
+                ...(refMeta != null && {
+                    additional_kwargs: refMeta,
+                }),
             });
         }
         catch (_e) {
@@ -400,51 +408,64 @@ class ToolNode extends RunnableCallable {
                     });
                 }
             }
-            let errorContent = `Error: ${e.message}\n Please fix your mistakes.`;
-            if (unresolvedRefs.length > 0) {
-                errorContent = this.applyOutputReference(runId, errorContent, errorContent, undefined, unresolvedRefs);
-            }
+            const errorContent = `Error: ${e.message}\n Please fix your mistakes.`;
+            const refMeta = unresolvedRefs.length > 0
+                ? this.recordOutputReference(runId, errorContent, undefined, unresolvedRefs)
+                : undefined;
             return new ToolMessage({
                 status: 'error',
                 content: errorContent,
                 name: call.name,
                 tool_call_id: call.id ?? '',
+                ...(refMeta != null && {
+                    additional_kwargs: refMeta,
+                }),
             });
         }
     }
     /**
-     * Finalizes the LLM-visible content for a tool call and (when a
-     * `refKey` is provided) registers the full, raw output under that
-     * key.
+     * Registers the full, raw output under `refKey` (when provided) and
+     * builds the per-message ref metadata stamped onto the resulting
+     * `ToolMessage.additional_kwargs`. The metadata is read at LLM-
+     * request time by `annotateMessagesForLLM` to produce a transient
+     * annotated copy of the message — the persisted `content` itself
+     * stays clean.
      *
-     * @param llmContent  The content string the LLM will see. This is
-     *   the already-truncated, post-hook view; the annotation is
-     *   applied on top of it.
      * @param registryContent  The full, untruncated output to store in
      *   the registry so `{{tool<i>turn<n>}}` substitutions deliver the
      *   complete payload. Ignored when `refKey` is undefined.
      * @param refKey  Precomputed `tool<i>turn<n>` key, or undefined when
      *   the output is not to be registered (errors, disabled feature,
      *   unavailable batch/turn).
-     * @param unresolved  Placeholder keys that did not resolve; appended
-     *   as `[unresolved refs: …]` so the LLM can self-correct.
-     *
-     * `refKey` is passed in (rather than built from `this.currentTurn`)
-     * so parallel `invoke()` calls on the same ToolNode cannot race on
-     * the shared turn field.
+     * @param unresolved  Placeholder keys that did not resolve; surfaced
+     *   to the LLM lazily so it can self-correct.
+     * @returns A `ToolMessageRefMetadata` object when there is anything
+     *   to stamp, otherwise `undefined`.
      */
-    applyOutputReference(runId, llmContent, registryContent, refKey, unresolved) {
+    recordOutputReference(runId, registryContent, refKey, unresolved) {
         if (this.toolOutputRegistry != null && refKey != null) {
             this.toolOutputRegistry.set(runId, refKey, registryContent);
         }
-        /**
-         * `annotateToolOutputWithReference` handles both the ref-key and
-         * unresolved-refs cases together so JSON-object outputs stay
-         * parseable: unresolved refs land in an `_unresolved_refs` field
-         * instead of as a trailing text line that would break
-         * `JSON.parse` for downstream consumers.
-         */
-        return annotateToolOutputWithReference(llmContent, refKey, unresolved);
+        if (refKey == null && unresolved.length === 0)
+            return undefined;
+        const meta = {};
+        if (refKey != null) {
+            meta._refKey = refKey;
+            /**
+             * Stamp the registry scope alongside the key so the lazy
+             * annotation transform can look up the right bucket. Anonymous
+             * invocations get a synthetic per-batch scope (`\0anon-<n>`)
+             * that `attemptInvoke` cannot derive from
+             * `config.configurable.run_id` — without this, anonymous-run
+             * refs would silently fail registry lookup and the LLM would
+             * never see `[ref: …]` markers for outputs that were registered.
+             */
+            if (runId != null)
+                meta._refScope = runId;
+        }
+        if (unresolved.length > 0)
+            meta._unresolvedRefs = unresolved;
+        return meta;
     }
     /**
      * Builds code session context for injection into event-driven tool calls.
@@ -779,19 +800,24 @@ class ToolNode extends RunnableCallable {
                 if (result.status === 'error') {
                     contentString = `Error: ${result.errorMessage ?? 'Unknown error'}\n Please fix your mistakes.`;
                     /**
-                     * Error results bypass registration/annotation but must still
-                     * carry the unresolved-refs hint so the LLM can self-correct
-                     * when its reference key caused the failure.
+                     * Error results bypass registration but stamp the
+                     * unresolved-refs hint into `additional_kwargs` so the lazy
+                     * annotation transform surfaces it to the LLM at request
+                     * time, letting the model self-correct when its reference
+                     * key caused the failure. Persisted `content` stays clean.
                      */
                     const unresolved = unresolvedByCallId.get(result.toolCallId) ?? [];
-                    if (unresolved.length > 0) {
-                        contentString = this.applyOutputReference(registryRunId, contentString, contentString, undefined, unresolved);
-                    }
+                    const errorRefMeta = unresolved.length > 0
+                        ? this.recordOutputReference(registryRunId, contentString, undefined, unresolved)
+                        : undefined;
                     toolMessage = new ToolMessage({
                         status: 'error',
                         content: contentString,
                         name: toolName,
                         tool_call_id: result.toolCallId,
+                        ...(errorRefMeta != null && {
+                            additional_kwargs: errorRefMeta,
+                        }),
                     });
                     if (hasFailureHook) {
                         await executeHooks({
@@ -853,13 +879,16 @@ class ToolNode extends RunnableCallable {
                         turn != null
                         ? buildReferenceKey(batchIndex, turn)
                         : undefined;
-                    contentString = this.applyOutputReference(registryRunId, contentString, registryRaw, refKey, unresolved);
+                    const successRefMeta = this.recordOutputReference(registryRunId, registryRaw, refKey, unresolved);
                     toolMessage = new ToolMessage({
                         status: 'success',
                         name: toolName,
                         content: contentString,
                         artifact: result.artifact,
                         tool_call_id: result.toolCallId,
+                        ...(successRefMeta != null && {
+                            additional_kwargs: successRefMeta,
+                        }),
                     });
                 }
                 this.dispatchStepCompleted(result.toolCallId, toolName, request?.args ?? {}, contentString, config, request?.turn);