@librechat/agents 3.3.7 → 3.3.9

package/src/messages/formatAgentMessages.test.ts

@@ -11,6 +11,7 @@ import {
   convertMessagesToResponsesInput,
   convertResponsesMessageToAIMessage,
 } from '@langchain/openai';
+import type { BaseMessage } from '@langchain/core/messages';
 import type { MessageContentComplex, TPayload } from '@/types';
 import {
   convertMessagesToContent,
@@ -4782,6 +4783,119 @@ describe('formatAgentMessages', () => {
   });
 
   describe('summary boundary token count adjustment', () => {
+    /** Atomic media costs a fixed provider price the character heuristic cannot
+     *  see, so scaling by the measurable siblings alone erases it. Both shapes
+     *  collapsed a four-figure count to 1 before this guard. */
+    it.each([
+      [
+        'text before the summary',
+        { type: ContentTypes.TEXT, text: 'hello there' },
+      ],
+      [
+        'a tool call before the summary',
+        {
+          type: ContentTypes.TOOL_CALL,
+          tool_call: {
+            id: 'tc1',
+            name: 'search',
+            args: '{"q":"x"}',
+            output: 'result text',
+          },
+        },
+      ],
+    ])(
+      'skips the positional discount when retained media is unmeasurable, with %s',
+      (_label, leading) => {
+        const payload: TPayload = [
+          {
+            role: 'assistant',
+            content: [
+              leading as MessageContentComplex,
+              {
+                type: ContentTypes.SUMMARY,
+                text: 'S'.repeat(400),
+                tokenCount: 100,
+              },
+              {
+                type: 'image_url',
+                image_url: { url: 'data:image/png;base64,x' },
+              },
+            ],
+          },
+        ];
+
+        const result = formatAgentMessages(payload, { 0: 1200 });
+
+        expect(result.indexTokenCountMap?.[0]).toBe(1200);
+        expect(result.boundaryTokenAdjustment).toBeUndefined();
+      }
+    );
+
+    /** The media sits a level down, inside `tool_call.output`, where serializing
+     *  gives it a nonzero length while the token counter charges its fixed media
+     *  cost. Eligibility is decided by part type, so nesting depth is irrelevant. */
+    it('skips the positional discount when retained tool output carries media', () => {
+      const payload: TPayload = [
+        {
+          role: 'assistant',
+          content: [
+            { type: ContentTypes.TEXT, text: 'a'.repeat(4000) },
+            {
+              type: ContentTypes.SUMMARY,
+              text: 'S'.repeat(400),
+              tokenCount: 100,
+            },
+            {
+              type: ContentTypes.TOOL_CALL,
+              tool_call: {
+                id: 'tc1',
+                name: 'render',
+                args: '{}',
+                output: [
+                  {
+                    type: 'image_url',
+                    image_url: { url: 'data:image/png;base64,y' },
+                  },
+                ],
+              },
+            },
+          ],
+        },
+      ];
+
+      const result = formatAgentMessages(payload, { 0: 4000 });
+
+      const emitted = Object.values(result.indexTokenCountMap ?? {}).reduce(
+        (sum, value) => sum + value,
+        0
+      );
+      expect(emitted).toBe(4000);
+      expect(result.boundaryTokenAdjustment).toBeUndefined();
+    });
+
+    it('still proportions when every retained part is measurable', () => {
+      const payload: TPayload = [
+        {
+          role: 'assistant',
+          content: [
+            { type: ContentTypes.TEXT, text: 'a'.repeat(400) },
+            {
+              type: ContentTypes.SUMMARY,
+              text: 'S'.repeat(100),
+              tokenCount: 20,
+            },
+            { type: ContentTypes.TEXT, text: 'b'.repeat(100) },
+          ],
+        },
+      ];
+
+      const result = formatAgentMessages(payload, { 0: 600 });
+
+      expect(result.boundaryTokenAdjustment?.original).toBe(600);
+      expect(result.indexTokenCountMap?.[0]).toBeLessThan(600);
+      expect(result.indexTokenCountMap?.[0]).toBeGreaterThan(0);
+    });
+
     it('should proportion token count when thinking block is sliced off by boundary', () => {
       const thinkingText = 'x'.repeat(1000);
       const payload: TPayload = [
@@ -4815,7 +4929,10 @@ describe('formatAgentMessages', () => {
       expect(result.indexTokenCountMap?.[1]).toBe(8);
     });
 
-    it('should proportion token count when thinking + tool_use are sliced off', () => {
+    /** Reframed: a tool call anywhere in the entry now cancels the ratio, since
+     *  telling a text-bearing tool payload from a media-bearing one requires
+     *  recursing into arbitrary nested output. The entry keeps its count. */
+    it('should not proportion when a tool_use part is present', () => {
       const thinkingText = 'a'.repeat(800);
       const toolInput = JSON.stringify({ data: 'b'.repeat(400) });
       const payload: TPayload = [
@@ -4851,8 +4968,8 @@ describe('formatAgentMessages', () => {
         result.indexTokenCountMap || {}
       ).reduce((sum, v) => sum + v, 0);
 
-      expect(totalOutputTokens).toBeLessThan(200);
-      expect(totalOutputTokens).toBeGreaterThan(0);
+      expect(totalOutputTokens).toBe(2000);
+      expect(result.boundaryTokenAdjustment).toBeUndefined();
     });
 
     it('should roughly halve token count when content is evenly split around boundary', () => {
@@ -4908,7 +5025,11 @@ describe('formatAgentMessages', () => {
       expect(result.indexTokenCountMap?.[1]).toBe(10);
     });
 
-    it('should account for tool_use input size in the char-length ratio', () => {
+    /** Previously the removed `tool_use` input was counted into the denominator.
+     *  A base64 payload there serializes to a huge length while the counter
+     *  charges a fixed estimate, so the ratio dragged retained text below its
+     *  real cost. The discount is cancelled instead. */
+    it('should not use tool_use input size in the char-length ratio', () => {
       const hugeInput = JSON.stringify({ payload: 'z'.repeat(5000) });
       const payload: TPayload = [
         {
@@ -4934,8 +5055,8 @@ describe('formatAgentMessages', () => {
       expect(result.summary).toBeDefined();
 
       const adjustedTokens = result.indexTokenCountMap?.[0] ?? 0;
-      expect(adjustedTokens).toBeLessThan(100);
-      expect(adjustedTokens).toBeGreaterThan(0);
+      expect(adjustedTokens).toBe(3000);
+      expect(result.boundaryTokenAdjustment).toBeUndefined();
     });
 
     it('should handle multiple content parts after the boundary', () => {
@@ -4997,6 +5118,187 @@ describe('formatAgentMessages', () => {
     });
   });
 
+  describe('summary coverage boundary', () => {
+    const buildSummaryPart = (coverage?: {
+      retainedFromMessageId: string;
+    }) => ({
+      type: ContentTypes.SUMMARY,
+      content: [
+        { type: ContentTypes.TEXT, text: 'Summary of the earliest turns' },
+      ],
+      tokenCount: 12,
+      ...(coverage != null ? { coverage } : {}),
+    });
+
+    /** Mirrors a compaction with `retainRecent.turns: 1`: m1/m2 were refined
+     *  into the summary, m3/m4 are the retained tail, and the block itself is
+     *  persisted on the assistant message that came after all of them. */
+    const compactedPayload = (coverage?: {
+      retainedFromMessageId: string;
+    }): TPayload => [
+      { messageId: 'm1', role: 'user', content: 'Covered question' },
+      { messageId: 'm2', role: 'assistant', content: 'Covered answer' },
+      { messageId: 'm3', role: 'user', content: 'Retained question' },
+      { messageId: 'm4', role: 'assistant', content: 'Retained answer' },
+      {
+        messageId: 'm5',
+        role: 'assistant',
+        content: [
+          buildSummaryPart(coverage),
+          { type: ContentTypes.TEXT, text: 'Post-compaction reply' },
+        ],
+      },
+    ];
+
+    const textOf = (message: BaseMessage): string => {
+      const { content } = message;
+      if (typeof content === 'string') {
+        return content;
+      }
+      return (content as MessageContentComplex[])
+        .map((part) => ('text' in part ? (part as { text: string }).text : ''))
+        .join('');
+    };
+
+    it('preserves the retained tail that the summary never covered', () => {
+      const result = formatAgentMessages(
+        compactedPayload({ retainedFromMessageId: 'm3' })
+      );
+
+      expect(result.messages.map(textOf)).toEqual([
+        'Retained question',
+        'Retained answer',
+        'Post-compaction reply',
+      ]);
+      expect(result.summary!.text).toBe('Summary of the earliest turns');
+      expect(result.summary!.tokenCount).toBe(12);
+    });
+
+    it('retains the anchor message itself, dropping only what precedes it', () => {
+      const result = formatAgentMessages(
+        compactedPayload({ retainedFromMessageId: 'm4' })
+      );
+
+      expect(result.messages.map(textOf)).toEqual([
+        'Retained answer',
+        'Post-compaction reply',
+      ]);
+    });
+
+    /** Coverage mode leaves the block's entry at its full count on purpose. The
+     *  summary's cost in the reader's token units is not obtainable here — no
+     *  tokenizer reaches this function, and a figure recorded at write time is
+     *  in the writing run's units. Over-counting prunes early; under-counting
+     *  would risk an over-context request. */
+    it('does not discount the entry carrying the summary block', () => {
+      const payload: TPayload = [
+        { messageId: 'm1', role: 'user', content: 'Covered question' },
+        { messageId: 'm2', role: 'user', content: 'Retained question' },
+        {
+          messageId: 'm3',
+          role: 'assistant',
+          content: [
+            {
+              type: ContentTypes.SUMMARY,
+              content: [{ type: ContentTypes.TEXT, text: 'S'.repeat(500) }],
+              tokenCount: 120,
+              coverage: { retainedFromMessageId: 'm2' },
+            },
+            { type: ContentTypes.TEXT, text: 'Reply' },
+          ],
+        },
+      ];
+
+      const result = formatAgentMessages(payload, { 0: 5, 1: 6, 2: 1000 });
+
+      expect(result.indexTokenCountMap?.[1]).toBe(1000);
+      expect(result.boundaryTokenAdjustment).toBeUndefined();
+    });
+
+    it('keeps token counts for the retained tail and drops covered entries', () => {
+      const result = formatAgentMessages(
+        compactedPayload({ retainedFromMessageId: 'm3' }),
+        { 0: 5, 1: 6, 2: 7, 3: 8, 4: 40 }
+      );
+
+      expect(result.indexTokenCountMap?.[0]).toBe(7);
+      expect(result.indexTokenCountMap?.[1]).toBe(8);
+      expect(Object.keys(result.indexTokenCountMap ?? {})).toHaveLength(3);
+    });
+
+    it('leaves entries without summary parts untouched', () => {
+      const result = formatAgentMessages(
+        compactedPayload({ retainedFromMessageId: 'm3' }),
+        { 0: 5, 1: 6, 2: 7, 3: 8, 4: 40 }
+      );
+
+      expect(result.indexTokenCountMap?.[0]).toBe(7);
+      expect(result.indexTokenCountMap?.[1]).toBe(8);
+    });
+
+    it('falls back to positional trimming for legacy blocks without coverage', () => {
+      const result = formatAgentMessages(compactedPayload());
+
+      expect(result.messages.map(textOf)).toEqual(['Post-compaction reply']);
+      expect(result.summary!.text).toBe('Summary of the earliest turns');
+    });
+
+    it('falls back to positional trimming when coverage cannot be resolved', () => {
+      const result = formatAgentMessages(
+        compactedPayload({ retainedFromMessageId: 'pruned-from-payload' })
+      );
+
+      expect(result.messages.map(textOf)).toEqual(['Post-compaction reply']);
+    });
+
+    it('ignores an anchor pointing past its own block', () => {
+      const result = formatAgentMessages([
+        ...compactedPayload({ retainedFromMessageId: 'm6' }),
+        { messageId: 'm6', role: 'user', content: 'Later question' },
+      ]);
+
+      expect(result.messages.map(textOf)).toEqual([
+        'Post-compaction reply',
+        'Later question',
+      ]);
+    });
+
+    it('applies last-summary-wins across mixed coverage and legacy blocks', () => {
+      const payload: TPayload = [
+        { messageId: 'm1', role: 'user', content: 'Covered question' },
+        {
+          messageId: 'm2',
+          role: 'assistant',
+          content: [
+            {
+              type: ContentTypes.SUMMARY,
+              text: 'Older summary',
+              tokenCount: 3,
+            },
+            { type: ContentTypes.TEXT, text: 'Older tail' },
+          ],
+        },
+        { messageId: 'm3', role: 'user', content: 'Retained question' },
+        {
+          messageId: 'm4',
+          role: 'assistant',
+          content: [
+            buildSummaryPart({ retainedFromMessageId: 'm3' }),
+            { type: ContentTypes.TEXT, text: 'Newest reply' },
+          ],
+        },
+      ];
+
+      const result = formatAgentMessages(payload);
+
+      expect(result.messages.map(textOf)).toEqual([
+        'Retained question',
+        'Newest reply',
+      ]);
+      expect(result.summary!.text).toBe('Summary of the earliest turns');
+    });
+  });
+
   describe('cross-run summary token accounting', () => {
     it('should conserve tokens: summary boundary excludes pre-boundary messages from the map', () => {
       const payload: TPayload = [

package/src/messages/injected.test.ts

@@ -34,7 +34,7 @@ describe('convertInjectedMessages', () => {
 
   it('carries isMeta, source and skillName only when set', () => {
     const [bare] = convertInjectedMessages([{ role: 'user', content: 'x' }]);
-    expect(bare.additional_kwargs).toEqual({ role: 'user' });
+    expect(bare.additional_kwargs).toEqual({ role: 'user', injected: true });
 
     const [full] = convertInjectedMessages([
       {
@@ -47,12 +47,29 @@ describe('convertInjectedMessages', () => {
     ]);
     expect(full.additional_kwargs).toEqual({
       role: 'user',
+      injected: true,
       isMeta: true,
       source: 'steer',
       skillName: 'writing',
     });
   });
 
+  /** Both marker fields are optional on `InjectedMessage`, so consumers that
+   *  must tell in-run context from payload-replayed messages — compaction
+   *  coverage anchors — cannot rely on them. `injected` is unconditional. */
+  it('always records injected provenance, whatever the caller supplied', () => {
+    const converted = convertInjectedMessages([
+      { role: 'user', content: 'bare' },
+      { role: 'system', content: 'hook output', source: 'hook' },
+      { role: 'user', content: 'injected steer', source: 'steer' },
+    ]);
+
+    expect(converted).toHaveLength(3);
+    for (const message of converted) {
+      expect(message.additional_kwargs.injected).toBe(true);
+    }
+  });
+
   it('passes multimodal content through as a content array', () => {
     const [converted] = convertInjectedMessages([
       {

package/src/messages/injected.ts

@@ -2,8 +2,8 @@
 import { HumanMessage } from '@langchain/core/messages';
 import type { BaseMessage } from '@langchain/core/messages';
 import type { InjectedMessage } from '@/types/tools';
-import { ContentTypes } from '@/common';
 import { toLangChainContent } from './langchain';
+import { ContentTypes } from '@/common';
 
 /**
  * Converts `InjectedMessage` instances to LangChain `HumanMessage` objects.
@@ -56,8 +56,15 @@ export function convertInjectedMessages(
     if (isEmptyInjectedContent(msg.content)) {
       continue;
     }
+    /** Provenance, recorded here because this is the only place that knows it.
+     *  `isMeta` and `source` are both optional on `InjectedMessage`, so a bare
+     *  entry is otherwise indistinguishable from a message replayed out of the
+     *  payload — and downstream consumers such as compaction coverage need to
+     *  know that this message has no persisted source ID to name. Kept separate
+     *  from `isMeta`, which carries UI and cache meaning of its own. */
     const additional_kwargs: Record<string, unknown> = {
       role: msg.role,
+      injected: true,
     };
     if (msg.isMeta != null) additional_kwargs.isMeta = msg.isMeta;
     if (msg.source != null) additional_kwargs.source = msg.source;

package/src/messages/prune.ts

@@ -1403,7 +1403,18 @@ function createBoundedTruncationValue(
     _originalChars: originalChars,
   };
   if (JSON.stringify(emptyEnvelope).length > normalizedMaxChars) {
-    return null;
+    /**
+     * Even the empty envelope overflows the cap, so no preview survives —
+     * but the result must still be a JSON OBJECT, never `null`. This value
+     * replaces a `tool_use.input` / tool-call `args` on messages that are
+     * mutated IN PLACE into graph state (`preFlightTruncateToolCallInputs`),
+     * and Anthropic rejects a replayed non-object input with a 400
+     * (`tool_use.input: Input should be an object`). Observed live: a tight
+     * summarization budget shrank the cap below the envelope, nulled a
+     * retained calculator call's input and args, and the next model call
+     * failed on replay.
+     */
+    return {};
   }
 
   let low = 0;

package/src/prompts/activityLabel.ts

@@ -33,6 +33,26 @@ export function truncateForLabel(value: string, maxLength: number): string {
   return value.slice(0, Math.max(0, maxLength - 1)) + '…';
 }
 
+/**
+ * Reduces a committed label to bounded single-line data.
+ *
+ * Sections in this prompt are delimited by blank lines, so a label carrying
+ * embedded newlines could otherwise forge an apparent entries section or
+ * `Header:` cue. Unlike every other input here, previous labels re-enter
+ * the prompt on EVERY later batch, so one malformed result — plain model
+ * noncompliance, or injection surfacing through a tool result — would
+ * persistently steer unrelated later labels rather than affecting one. The
+ * clip bounds the same way `lastAssistantText` and reasoning excerpts are
+ * bounded: oversized headers must not inflate later requests past the fast
+ * model's window and starve the run of labels entirely.
+ */
+function sanitizePreviousLabel(label: string): string {
+  return truncateForLabel(
+    label.replace(/\s+/g, ' ').trim(),
+    PREVIOUS_LABEL_LIMIT
+  );
+}
+
 const ABORT_SERIALIZATION = Symbol('abort-label-serialization');
 
 /**
@@ -76,6 +96,11 @@ function serializeForLabel(value: unknown, limit: number): string {
 
 const INPUT_CONTEXT_LIMIT = 200;
 const MAX_THINKING_EXCERPTS = 4;
+const MAX_PREVIOUS_LABELS = 3;
+/** Per-label bound. A header is 5-9 words; anything past this is
+ *  noncompliance or payload, and previous labels are the one input that
+ *  RE-ENTERS the prompt on every later batch of the run. */
+const PREVIOUS_LABEL_LIMIT = 200;
 /** A label is 5-9 words; no batch needs more than this many entries to
  *  produce one, and the cap keeps a 200-call programmatic batch from
  *  building an enormous prompt out of per-field-bounded pieces. */
@@ -86,6 +111,13 @@ export type BuildActivityLabelPromptParams = {
   charLimit: number;
   thinkingExcerpts?: string[];
   lastAssistantText?: string;
+  /**
+   * Headers already committed for earlier batches in this run, in run order
+   * with the most recent last. Rendered ahead of the block context so the
+   * label continues the run's story instead of restating a line the user is
+   * already reading. Capped at {@link MAX_PREVIOUS_LABELS}.
+   */
+  previousLabels?: string[];
   /**
    * Resolved tool-output tracing policy. The label prompt becomes Langfuse
    * generation input, so outputs/errors excluded from tracing (global
@@ -104,6 +136,7 @@ export function buildActivityLabelPrompt({
   charLimit,
   thinkingExcerpts,
   lastAssistantText,
+  previousLabels,
   redaction,
 }: BuildActivityLabelPromptParams): string {
   const clip = truncateForLabel;
@@ -116,6 +149,28 @@ export function buildActivityLabelPrompt({
     redaction != null &&
     (redaction.enabled === false || redaction.redactedToolNames.size > 0);
   const sections: string[] = [];
+  /** Previous labels are free-form model prose too, and per-agent overlays
+   *  mean an earlier header may have been generated under ANOTHER agent's
+   *  weaker policy — so they share the excerpts' wholesale drop rather than
+   *  letting a handoff leak a looser agent's phrasing into this trace. */
+  if (
+    !excerptsRedacted &&
+    previousLabels != null &&
+    previousLabels.length > 0
+  ) {
+    const recent = previousLabels
+      .slice(-MAX_PREVIOUS_LABELS)
+      .map(sanitizePreviousLabel)
+      /** A label that sanitizes to nothing carries no story to continue;
+       *  rendering it would leave a bare bullet implying a missing header. */
+      .filter((label) => label.length > 0);
+    if (recent.length > 0) {
+      sections.push(
+        'Previous headers in this run (most recent last):\n' +
+          recent.map((label) => `- ${label}`).join('\n')
+      );
+    }
+  }
   /** Intent text is free-form assistant prose that can quote a redacted
    *  tool result just as reasoning can, so it shares the excerpts' fate. */
   if (
@@ -144,7 +199,14 @@ export function buildActivityLabelPrompt({
     const shown = entries.slice(0, MAX_PROMPT_ENTRIES);
     const omitted = entries.length - shown.length;
     sections.push(
-      'Tool calls:\n' +
+      /** Frames the list as reference material, not the thing to
+       *  transcribe. Ported from LibreChat's fallback builder (its
+       *  runtime.ts documents that without this the model "hands back a
+       *  transcription" of the list) after the eval harness measured it
+       *  across three independent sweeps: fewer template-redundancy and
+       *  length violations than a bare `Tool calls:` heading, with no
+       *  per-case regressions (agents #360). */
+      'What it called, and what came back (do not restate these):\n' +
         shown
           .map((entry) => {
             const input = clip(
@@ -172,6 +234,9 @@ export function buildActivityLabelPrompt({
           : '')
     );
   }
-  sections.push('Label:');
+  /** The fallback builder's terminal cue, measured alongside the heading
+   *  (same sweeps). The default system prompt already describes the
+   *  output as "the header of a collapsed activity group". */
+  sections.push('Header:');
   return sections.join('\n\n');
 }