@librechat/agents 3.2.36 → 3.2.38

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

@@ -173,6 +173,56 @@ describe('annotateMessagesForLLM', () => {
     expect(out[0].content).toBe('[ref: tool0turn0]\nplain output');
   });
 
+  it('annotates a live ref on multi-part content (prompt-cache-rewritten tool tail)', () => {
+    /**
+     * A tail tool result that prompt caching rewrote from a string into a
+     * text-block array (to host the cache_control / cachePoint marker) keeps
+     * its `_refKey` on additional_kwargs. The live-ref marker must still be
+     * projected as a leading text block; otherwise the common tool-result
+     * tail silently loses its reference annotation once cached.
+     */
+    const registry = new ToolOutputReferenceRegistry();
+    registry.set('r1', 'tool0turn0', 'raw');
+    const tm = makeToolMessage({
+      content: [
+        { type: 'text', text: 'output', cache_control: { type: 'ephemeral' } },
+      ] as unknown as ToolMessage['content'],
+      additional_kwargs: { _refKey: 'tool0turn0' },
+    });
+    const out = annotateMessagesForLLM([tm], registry, 'r1');
+    const blocks = out[0].content as Array<{
+      type: string;
+      text?: string;
+      cache_control?: unknown;
+    }>;
+    expect(blocks).toHaveLength(2);
+    expect(blocks[0]).toEqual({ type: 'text', text: '[ref: tool0turn0]' });
+    // The original block (and its cache marker) is preserved after the prefix.
+    expect(blocks[1].text).toBe('output');
+    expect(blocks[1].cache_control).toEqual({ type: 'ephemeral' });
+  });
+
+  it('annotates both live ref and unresolved on multi-part content', () => {
+    const registry = new ToolOutputReferenceRegistry();
+    registry.set('r1', 'tool0turn0', 'raw');
+    const tm = makeToolMessage({
+      content: [
+        { type: 'text', text: 'output' },
+      ] as unknown as ToolMessage['content'],
+      additional_kwargs: {
+        _refKey: 'tool0turn0',
+        _unresolvedRefs: ['tool9turn9'],
+      },
+    });
+    const out = annotateMessagesForLLM([tm], registry, 'r1');
+    const blocks = out[0].content as Array<{ type: string; text?: string }>;
+    expect(blocks.map((b) => b.text)).toEqual([
+      '[ref: tool0turn0]',
+      '[unresolved refs: tool9turn9]',
+      'output',
+    ]);
+  });
+
   it('prepends an unresolved-refs warning text block to multi-part content', () => {
     const registry = new ToolOutputReferenceRegistry();
     const tm = makeToolMessage({

package/src/tools/toolOutputReferences.ts

@@ -682,28 +682,42 @@ export function annotateMessagesForLLM(
         liveRef,
         unresolved
       );
-    } else if (
-      annotates &&
-      Array.isArray(tm.content) &&
-      unresolved.length > 0
-    ) {
-      const warningBlock = {
-        type: 'text' as const,
-        text: `[unresolved refs: ${unresolved.join(', ')}]`,
-      };
+    } else if (annotates && Array.isArray(tm.content)) {
       /**
-       * `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.
+       * Array tool content. The string annotator can't run — this notably
+       * includes a tail tool result that prompt caching rewrote from a string
+       * into a text-block array to host its `cache_control` / `cachePoint`
+       * marker (the `_refKey` survives on `additional_kwargs`). Project the
+       * same markers the string path would, as leading text blocks: the live
+       * `[ref: …]` prefix and/or the unresolved-refs warning. Without this the
+       * common tool-result tail loses its reference marker once cached.
+       *
+       * `as unknown as ToolMessage['content']` is unavoidable: LangChain's
+       * content union does not accept a freshly built mixed array literal even
+       * though the structural shape is valid at runtime. The double-cast is
+       * structurally safe — every original block is preserved and only
+       * `{ type: 'text', text }` blocks (which all providers accept) are
+       * prepended.
        */
-      nextContent = [
-        warningBlock,
-        ...tm.content,
-      ] as unknown as ToolMessage['content'];
+      const prefixBlocks: Array<{ type: 'text'; text: string }> = [];
+      if (liveRef != null) {
+        prefixBlocks.push({
+          type: 'text',
+          text: buildReferencePrefix(liveRef),
+        });
+      }
+      if (unresolved.length > 0) {
+        prefixBlocks.push({
+          type: 'text',
+          text: `[unresolved refs: ${unresolved.join(', ')}]`,
+        });
+      }
+      if (prefixBlocks.length > 0) {
+        nextContent = [
+          ...prefixBlocks,
+          ...tm.content,
+        ] as unknown as ToolMessage['content'];
+      }
     }
 
     /**

package/src/types/graph.ts

@@ -536,6 +536,8 @@ export interface LangfuseConfig {
   publicKey?: string;
   secretKey?: string;
   baseUrl?: string;
+  metadata?: Record<string, string | number | boolean | null | undefined>;
+  tags?: string[];
   toolNodeTracing?: LangfuseToolNodeTracingConfig;
   toolOutputTracing?: LangfuseToolOutputTracingConfig;
   /**