@librechat/agents 3.1.71-dev.1 → 3.1.72

package/src/tools/__tests__/annotateMessagesForLLM.test.ts

@@ -12,12 +12,14 @@ function makeToolMessage(fields: {
   name?: string;
   tool_call_id?: string;
   status?: 'success' | 'error';
+  artifact?: unknown;
   additional_kwargs?: Record<string, unknown>;
 }): ToolMessage {
   return new ToolMessage({
     name: fields.name ?? 'echo',
     tool_call_id: fields.tool_call_id ?? 'tc1',
     status: fields.status ?? 'success',
+    artifact: fields.artifact,
     additional_kwargs: fields.additional_kwargs,
     content: fields.content,
   });
@@ -190,6 +192,31 @@ describe('annotateMessagesForLLM', () => {
     expect(blocks[2].type).toBe('image_url');
   });
 
+  it('preserves artifact on the projected ToolMessage', () => {
+    /**
+     * Hosts attach `artifact` to ToolMessages via the
+     * `content_and_artifact` response format (e.g. code execution
+     * sessions, MCP tools that return structured side-data). The
+     * projection must round-trip the artifact untouched so downstream
+     * consumers (audit logs, code-session tracking) keep working.
+     */
+    const registry = new ToolOutputReferenceRegistry();
+    registry.set('r1', 'tool0turn0', 'raw');
+    const artifact = {
+      session_id: 'abc',
+      files: [{ id: 'f1', name: 'a.txt' }],
+    };
+    const tm = makeToolMessage({
+      content: 'output',
+      artifact,
+      additional_kwargs: { _refKey: 'tool0turn0' },
+    });
+    const out = annotateMessagesForLLM([tm], registry, 'r1');
+    const projected = out[0] as ToolMessage;
+    expect(projected.artifact).toBe(artifact);
+    expect(projected.content).toBe('[ref: tool0turn0]\noutput');
+  });
+
   it('does not mutate the original ToolMessage instance or its content', () => {
     const registry = new ToolOutputReferenceRegistry();
     registry.set('r1', 'tool0turn0', 'raw');
@@ -404,6 +431,39 @@ describe('annotateMessagesForLLM', () => {
     expect((out[0] as ToolMessage).additional_kwargs._refKey).toBeUndefined();
   });
 
+  it('skips a ToolMessage whose additional_kwargs is a primitive without throwing', () => {
+    /**
+     * The `in` operator throws `TypeError` on primitives, so without
+     * a runtime object guard, a hydrated ToolMessage carrying e.g.
+     * `additional_kwargs: 'not-an-object'` (from a buggy serializer)
+     * would crash `attemptInvoke` before the provider call. Verify
+     * we skip that message and process subsequent live-ref messages
+     * normally.
+     */
+    const registry = new ToolOutputReferenceRegistry();
+    registry.set('r1', 'tool0turn0', 'raw');
+
+    const malformed = new ToolMessage({
+      name: 'echo',
+      tool_call_id: 'mal',
+      status: 'success',
+      content: 'malformed-output',
+    });
+    /* Force a primitive past LangChain's typed setter via a cast. */
+    (malformed as unknown as { additional_kwargs: unknown }).additional_kwargs =
+      'not-an-object' as unknown;
+
+    const live = makeToolMessage({
+      content: 'live-output',
+      additional_kwargs: { _refKey: 'tool0turn0' },
+    });
+
+    const out = annotateMessagesForLLM([malformed, live], registry, 'r1');
+    /* Malformed message passes through unchanged; live ref still annotates. */
+    expect(out[0]).toBe(malformed);
+    expect(out[1].content).toBe('[ref: tool0turn0]\nlive-output');
+  });
+
   it('treats stale _refKey but live unresolved as unresolved-only', () => {
     const registry = new ToolOutputReferenceRegistry();
     const tm = makeToolMessage({

package/src/tools/toolOutputReferences.ts

@@ -642,16 +642,19 @@ export function annotateMessagesForLLM(
     /**
      * `additional_kwargs` is untyped at the LangChain layer
      * (`Record<string, unknown>`), so persisted or client-supplied
-     * ToolMessages can carry arbitrary shapes under our framework
-     * keys. Treat them as untrusted input and coerce defensively
-     * before any array operation — a malformed field on a single
-     * hydrated message must not crash `attemptInvoke` before the
-     * provider call.
+     * ToolMessages can carry arbitrary shapes — including primitives
+     * (a malformed serializer might write a string, or `null`).
+     * Guard with a runtime object check before the `in` probes
+     * because the `in` operator throws `TypeError` on primitives.
+     * A single malformed message must never crash the provider call
+     * path; skip its annotation/strip and continue.
      */
-    const meta = m.additional_kwargs as Record<string, unknown> | undefined;
-    const hasRefKey = meta != null && '_refKey' in meta;
-    const hasRefScope = meta != null && '_refScope' in meta;
-    const hasUnresolvedField = meta != null && '_unresolvedRefs' in meta;
+    const rawMeta = m.additional_kwargs as unknown;
+    if (rawMeta == null || typeof rawMeta !== 'object') continue;
+    const meta = rawMeta as Record<string, unknown>;
+    const hasRefKey = '_refKey' in meta;
+    const hasRefScope = '_refScope' in meta;
+    const hasUnresolvedField = '_unresolvedRefs' in meta;
     if (!hasRefKey && !hasRefScope && !hasUnresolvedField) continue;
 
     const refKey = readRefKey(meta);
@@ -688,6 +691,15 @@ export function annotateMessagesForLLM(
         type: 'text' as const,
         text: `[unresolved refs: ${unresolved.join(', ')}]`,
       };
+      /**
+       * `as unknown as ToolMessage['content']` is unavoidable here:
+       * LangChain's content union (`MessageContentComplex[] |
+       * DataContentBlock[] | string`) does not accept a freshly built
+       * mixed array literal even though the structural shape is valid
+       * at runtime. The double-cast is structurally safe — we
+       * preserve every block from `tm.content` and prepend a single
+       * `{ type: 'text', text }` block that all providers accept.
+       */
       nextContent = [
         warningBlock,
         ...tm.content,