@librechat/agents 3.2.31 → 3.2.33

package/src/llm/anthropic/utils/streaming-tool-input.test.ts

@@ -0,0 +1,186 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { AIMessage, HumanMessage } from '@langchain/core/messages';
+import type { BaseMessage } from '@langchain/core/messages';
+import { _convertMessagesToAnthropicPayload } from './message_inputs';
+import { _makeMessageChunkFromAnthropicEvent } from './message_outputs';
+
+/**
+ * Regression for @langchain/core >= 1.1.46 streaming aggregation: a tool call's
+ * input_json_delta is kept as a separate content block and v1-cast to a `text`
+ * block carrying `input` but no `text`, leaving the sibling tool_use block with an
+ * empty inline input. The assembled arguments live on `message.tool_calls`.
+ * Re-serializing such a message previously threw "Unsupported message content format".
+ */
+describe('_convertMessagesToAnthropicPayload — aggregated streaming tool input', () => {
+  const buildHistory = (): BaseMessage[] => [
+    new HumanMessage('what is 12345 * 6789?'),
+    new AIMessage({
+      content: [
+        { type: 'text', text: 'Let me calculate that.' },
+        // tool_use block left with empty inline input by aggregation
+        {
+          type: 'tool_use',
+          id: 'toolu_calc',
+          name: 'calculator',
+          input: '',
+          index: 0,
+        } as any,
+        // orphaned input delta, v1-cast to `text` with `input` and no `text`
+        { type: 'text', index: 0, input: '{"input": "12345 * 6789"}' } as any,
+      ],
+      tool_calls: [
+        {
+          id: 'toolu_calc',
+          name: 'calculator',
+          args: { input: '12345 * 6789' },
+          type: 'tool_call',
+        },
+      ],
+    }),
+  ];
+
+  it('does not throw on the orphaned text-with-input block', () => {
+    expect(() => _convertMessagesToAnthropicPayload(buildHistory())).not.toThrow();
+  });
+
+  it('restores tool_use input from message.tool_calls and drops the orphan block', () => {
+    const payload = _convertMessagesToAnthropicPayload(buildHistory());
+    const assistant = payload.messages.find((m: any) => m.role === 'assistant');
+    expect(assistant).toBeDefined();
+    const blocks = assistant!.content as any[];
+
+    const toolUse = blocks.find((b) => b.type === 'tool_use');
+    expect(toolUse).toMatchObject({
+      type: 'tool_use',
+      id: 'toolu_calc',
+      name: 'calculator',
+      input: { input: '12345 * 6789' },
+    });
+
+    // No leftover delta: no text block carrying `input`, no input_json_delta.
+    expect(
+      blocks.find(
+        (b) => (b.type === 'text' && 'input' in b) || b.type === 'input_json_delta'
+      )
+    ).toBeUndefined();
+
+    // The real assistant text is preserved.
+    expect(
+      blocks.some((b) => b.type === 'text' && b.text === 'Let me calculate that.')
+    ).toBe(true);
+  });
+
+  it('does not overwrite a tool_use block that already has inline input', () => {
+    const history: BaseMessage[] = [
+      new HumanMessage('hi'),
+      new AIMessage({
+        content: [
+          {
+            type: 'tool_use',
+            id: 'toolu_x',
+            name: 'calculator',
+            input: { input: '2 + 2' },
+          } as any,
+        ],
+        tool_calls: [
+          {
+            id: 'toolu_x',
+            name: 'calculator',
+            args: { input: '999' },
+            type: 'tool_call',
+          },
+        ],
+      }),
+    ];
+    const payload = _convertMessagesToAnthropicPayload(history);
+    const assistant = payload.messages.find((m: any) => m.role === 'assistant');
+    const toolUse = (assistant!.content as any[]).find((b) => b.type === 'tool_use');
+    expect(toolUse.input).toEqual({ input: '2 + 2' });
+  });
+
+  // Adapted from @langchain/anthropic's
+  // "partial tool input is correctly merged before calling Anthropic API".
+  it('merges sibling input_json_delta blocks into tool_use input (persisted, no tool_calls)', () => {
+    const messages: BaseMessage[] = [
+      new HumanMessage('What\'s the weather in Seattle tomorrow?'),
+      new AIMessage({
+        content: [
+          { type: 'text', index: 1, text: 'I need to call the get_weather tool' },
+          { type: 'tool_use', index: 2, name: 'get_weather', id: 'tool_call_id', input: '' },
+          { type: 'input_json_delta', index: 2, input: '{"city": "' },
+          { type: 'input_json_delta', index: 2, input: 'Seattle", "da' },
+          { type: 'input_json_delta', index: 2, input: 'te": "to' },
+          { type: 'input_json_delta', index: 2, input: 'morrow"}' },
+        ] as any,
+      }),
+    ];
+
+    const payload = _convertMessagesToAnthropicPayload(messages);
+    const assistant = payload.messages.find((m: any) => m.role === 'assistant');
+    const blocks = assistant!.content as any[];
+    expect(blocks.filter((b) => b.type === 'input_json_delta')).toHaveLength(0);
+    const toolUse = blocks.find((b) => b.type === 'tool_use');
+    expect(toolUse).toMatchObject({
+      type: 'tool_use',
+      name: 'get_weather',
+      id: 'tool_call_id',
+      input: { city: 'Seattle', date: 'tomorrow' },
+    });
+  });
+});
+
+describe('_makeMessageChunkFromAnthropicEvent — streamed tool input merges into content', () => {
+  const fields = { streamUsage: true, coerceContentToString: false };
+
+  it('emits input deltas without a type so aggregation merges them into the tool_use block', () => {
+    const events: any[] = [
+      {
+        type: 'content_block_start',
+        index: 0,
+        content_block: { type: 'tool_use', id: 'toolu_1', name: 'calculator', input: {} },
+      },
+      {
+        type: 'content_block_delta',
+        index: 0,
+        delta: { type: 'input_json_delta', partial_json: '{"input"' },
+      },
+      {
+        type: 'content_block_delta',
+        index: 0,
+        delta: { type: 'input_json_delta', partial_json: ': "2 + 2"}' },
+      },
+    ];
+    const chunks = events
+      .map((e) => _makeMessageChunkFromAnthropicEvent(e, fields)?.chunk)
+      .filter((c): c is NonNullable<typeof c> => c != null);
+
+    // input-delta chunks must not carry a `type` (so core merges them by index
+    // into the sibling tool_use/server_tool_use block rather than orphaning them)
+    const deltaBlocks = chunks
+      .slice(1)
+      .flatMap((c) => (Array.isArray(c.content) ? (c.content as any[]) : []))
+      .filter((b) => 'input' in b);
+    expect(deltaBlocks.length).toBeGreaterThan(0);
+    deltaBlocks.forEach((b) => expect('type' in b).toBe(false));
+
+    // aggregate the chunks the way core does during streaming
+    const merged = chunks.reduce((acc, c) => acc.concat(c));
+    const blocks = merged.content as any[];
+
+    const toolUse = blocks.find((b) => b.type === 'tool_use');
+    expect(toolUse).toMatchObject({ type: 'tool_use', id: 'toolu_1', name: 'calculator' });
+    const parsed =
+      typeof toolUse.input === 'string' ? JSON.parse(toolUse.input) : toolUse.input;
+    expect(parsed).toEqual({ input: '2 + 2' });
+
+    // no orphaned delta block survives aggregation
+    expect(blocks.filter((b) => b.type !== 'tool_use' && 'input' in b)).toHaveLength(0);
+
+    // tool_calls remain correctly aggregated
+    expect(merged.tool_calls?.[0]).toMatchObject({
+      id: 'toolu_1',
+      name: 'calculator',
+      args: { input: '2 + 2' },
+    });
+  });
+});

package/src/messages/cache.test.ts

@@ -13,6 +13,7 @@ import {
   stripBedrockCacheControl,
   addBedrockCacheControl,
   addCacheControl,
+  addCacheControlToStablePrefixMessages,
 } from './cache';
 import { _convertMessagesToOpenAIParams } from '@/llm/openai/utils';
 import { toLangChainContent } from './langchain';
@@ -767,6 +768,127 @@ describe('addBedrockCacheControl (Bedrock cache checkpoints)', () => {
   });
 });
 
+describe('synthetic skill/meta messages are not cache-anchored', () => {
+  const hasAnthropicMarker = (m: BaseMessage): boolean =>
+    Array.isArray(m.content) &&
+    m.content.some((block) => 'cache_control' in block);
+
+  const hasBedrockCachePoint = (m: BaseMessage): boolean =>
+    Array.isArray(m.content) &&
+    m.content.some((block) => 'cachePoint' in block);
+
+  const skillBody = (skillName: string, content = 'SKILL BODY'): HumanMessage =>
+    new HumanMessage({
+      content,
+      additional_kwargs: { isMeta: true, source: 'skill', skillName },
+    });
+
+  it('Anthropic: skips a trailing synthetic skill message; markers land on the real user messages', () => {
+    const messages: BaseMessage[] = [
+      new HumanMessage('First real question'),
+      new AIMessage('Answer'),
+      new HumanMessage('Second real question'),
+      skillBody('pdf-analyzer'),
+    ];
+
+    const result = addCacheControl<BaseMessage>(messages);
+
+    expect(hasAnthropicMarker(result[3])).toBe(false);
+    expect(hasAnthropicMarker(result[2])).toBe(true);
+    expect(hasAnthropicMarker(result[0])).toBe(true);
+  });
+
+  it('Anthropic: strips a stale marker from a synthetic skill message without re-adding one', () => {
+    const stale = new HumanMessage({
+      content: toLangChainContent([
+        {
+          type: 'text',
+          text: 'SKILL BODY',
+          cache_control: { type: 'ephemeral' },
+        } as MessageContentComplex,
+      ]),
+      additional_kwargs: {
+        isMeta: true,
+        source: 'skill',
+        skillName: 'pdf-analyzer',
+      },
+    });
+    const messages: BaseMessage[] = [
+      new HumanMessage('Real question'),
+      new AIMessage('Answer'),
+      stale,
+    ];
+
+    const result = addCacheControl<BaseMessage>(messages);
+
+    expect(hasAnthropicMarker(result[2])).toBe(false);
+    expect(hasAnthropicMarker(result[0])).toBe(true);
+  });
+
+  it('Anthropic: detects skill messages by additional_kwargs.source even without isMeta', () => {
+    const messages: BaseMessage[] = [
+      new HumanMessage('Real question'),
+      new AIMessage('Answer'),
+      new HumanMessage({
+        content: 'SKILL BODY',
+        additional_kwargs: { source: 'skill', skillName: 'pdf-analyzer' },
+      }),
+    ];
+
+    const result = addCacheControl<BaseMessage>(messages);
+
+    expect(hasAnthropicMarker(result[2])).toBe(false);
+    expect(hasAnthropicMarker(result[0])).toBe(true);
+  });
+
+  it('Bedrock: skips a trailing synthetic skill message; cachePoints land on the real user messages', () => {
+    const messages: BaseMessage[] = [
+      new HumanMessage('First real question'),
+      new AIMessage('Answer'),
+      new HumanMessage('Second real question'),
+      skillBody('pdf-analyzer'),
+    ];
+
+    const result = addBedrockCacheControl<BaseMessage>(messages);
+
+    expect(hasBedrockCachePoint(result[3])).toBe(false);
+    expect(hasBedrockCachePoint(result[2])).toBe(true);
+    expect(hasBedrockCachePoint(result[0])).toBe(true);
+  });
+
+  it('stable-prefix fallback: anchors the real user message, not a synthetic skill message', () => {
+    // Mirrors AgentContext's dynamic-tail path: the only assistant message is a
+    // skill-only tool call (no text), so the assistant-only pass adds no marker
+    // and the cacheable fallback runs. It must skip the reconstructed skill
+    // HumanMessage and anchor the real user message instead.
+    const messages: BaseMessage[] = [
+      new HumanMessage('Real stable question'),
+      new AIMessage({
+        content: toLangChainContent([
+          {
+            type: 'tool_use',
+            id: 'call_1',
+            name: 'skill',
+            input: { skillName: 'pdf-analyzer' },
+          } as MessageContentComplex,
+        ]),
+        tool_calls: [
+          { id: 'call_1', name: 'skill', args: { skillName: 'pdf-analyzer' } },
+        ],
+      }),
+      skillBody('pdf-analyzer'),
+    ];
+
+    const result = addCacheControlToStablePrefixMessages<BaseMessage>(
+      messages,
+      2
+    );
+
+    expect(hasAnthropicMarker(result[2])).toBe(false);
+    expect(hasAnthropicMarker(result[0])).toBe(true);
+  });
+});
+
 describe('stripAnthropicCacheControl', () => {
   it('removes cache_control fields from content blocks', () => {
     const messages: TestMsg[] = [

package/src/messages/cache.ts

@@ -182,6 +182,7 @@ export function addCacheControl<T extends AnthropicMessage | BaseMessage>(
     const needsCacheAdd =
       userMessagesModified < 2 &&
       isUserMessage &&
+      !isSyntheticMetaMessage(originalMessage) &&
       (typeof content === 'string' || hasArrayContent);
 
     // Skip messages that don't need any work
@@ -263,6 +264,26 @@ function getMessageRole(message: MessageWithContent): string | undefined {
   return undefined;
 }
 
+const SKILL_MESSAGE_SOURCE = 'skill';
+
+/**
+ * Synthetic skill/meta messages (reconstructed skill bodies, primed SKILL.md
+ * instructions) are re-injected every turn and are not stable conversation
+ * turns. They must not anchor a fresh prompt-cache marker — doing so pins the
+ * cache to a volatile/duplicated prefix. Stale markers are still stripped from
+ * them; only the *adding* of new markers is suppressed. Detected via
+ * `additional_kwargs.isMeta === true` or `additional_kwargs.source === 'skill'`.
+ */
+function isSyntheticMetaMessage(message: MessageWithContent): boolean {
+  const { additional_kwargs: kwargs } = message as {
+    additional_kwargs?: { isMeta?: unknown; source?: unknown };
+  };
+  if (kwargs == null) {
+    return false;
+  }
+  return kwargs.isMeta === true || kwargs.source === SKILL_MESSAGE_SOURCE;
+}
+
 function isCacheableConversationMessage(message: MessageWithContent): boolean {
   const role = getMessageRole(message);
   return (
@@ -305,7 +326,9 @@ function addCacheControlToRecentMessages<
     const content = originalMessage.content;
     const hasArrayContent = Array.isArray(content);
     const canAddCache =
-      cachePointsAdded < maxCachePoints && canUseMessage(originalMessage);
+      cachePointsAdded < maxCachePoints &&
+      canUseMessage(originalMessage) &&
+      !isSyntheticMetaMessage(originalMessage);
 
     if (!canAddCache && !hasArrayContent) {
       continue;
@@ -536,6 +559,7 @@ export function addBedrockCacheControl<
       isUserMessage &&
       !isToolMessage &&
       !isEmptyString &&
+      !isSyntheticMetaMessage(originalMessage) &&
       (typeof content === 'string' || hasArrayContent);
 
     if (!needsCacheAdd && !hasArrayContent && !hasSerializationProps) {

package/src/messages/format.ts

@@ -334,6 +334,10 @@ interface FormatAssistantMessageOptions {
 
 interface FormatAgentMessagesOptions {
   provider?: Providers;
+  /** Skill names already primed fresh this turn (manual/always-apply). Their
+   *  historical `skill` tool_calls are not reconstructed into a HumanMessage,
+   *  so the same SKILL.md body is not injected twice in one request. */
+  skipSkillBodyNames?: Set<string>;
 }
 
 function extractReasoningContent(
@@ -1159,6 +1163,7 @@ function extractSkillName(args: unknown): string | undefined {
  * @param indexTokenCountMap - Optional map of message indices to token counts.
  * @param tools - Optional set of tool names that are allowed in the request.
  * @param skills - Optional map of skill name to body for reconstructing skill HumanMessages.
+ * @param options - Optional formatting options (provider, skipSkillBodyNames).
  * @returns - Object containing formatted messages and updated indexTokenCountMap if provided.
  */
 export const formatAgentMessages = (
@@ -1445,7 +1450,11 @@ export const formatAgentMessages = (
     const endMessageIndex = messages.length;
 
     if (pendingSkillNames?.size != null && pendingSkillNames.size > 0) {
+      const skipSkillBodyNames = options?.skipSkillBodyNames;
       for (const skillName of pendingSkillNames) {
+        if (skipSkillBodyNames != null && skipSkillBodyNames.has(skillName)) {
+          continue;
+        }
         const body = skills?.get(skillName) ?? '';
         if (body) {
           messages.push(

package/src/messages/formatAgentMessages.skills.test.ts

@@ -410,4 +410,104 @@ describe('formatAgentMessages skill body reconstruction', () => {
       expect(assistantTotal).toBe(500);
     });
   });
+
+  describe('skipSkillBodyNames (fresh-prime dedupe)', () => {
+    const tools = new Set([Constants.SKILL_TOOL]);
+
+    const injectedSkillBodies = (
+      messages: ReturnType<typeof formatAgentMessages>['messages']
+    ) =>
+      messages.filter(
+        (m) =>
+          m instanceof HumanMessage &&
+          (m as HumanMessage).additional_kwargs.source === 'skill'
+      );
+
+    it('does NOT reconstruct body when skill name is in skipSkillBodyNames', () => {
+      const payload: TPayload = [
+        { role: 'user', content: 'Review my code' },
+        {
+          role: 'assistant',
+          content: [skillToolCall('call_1', 'code-review')],
+        },
+      ];
+
+      const { messages } = formatAgentMessages(
+        payload,
+        undefined,
+        tools,
+        skillBodies,
+        { skipSkillBodyNames: new Set(['code-review']) }
+      );
+
+      expect(injectedSkillBodies(messages)).toHaveLength(0);
+    });
+
+    it('reconstructs only names NOT in skipSkillBodyNames', () => {
+      const payload: TPayload = [
+        { role: 'user', content: 'Go' },
+        {
+          role: 'assistant',
+          content: [
+            skillToolCall('call_1', 'pdf-analyzer'),
+            skillToolCall('call_2', 'code-review'),
+          ],
+        },
+      ];
+
+      const { messages } = formatAgentMessages(
+        payload,
+        undefined,
+        tools,
+        skillBodies,
+        { skipSkillBodyNames: new Set(['code-review']) }
+      );
+
+      const injected = injectedSkillBodies(messages);
+      expect(injected).toHaveLength(1);
+      expect((injected[0] as HumanMessage).additional_kwargs.skillName).toBe(
+        'pdf-analyzer'
+      );
+    });
+
+    it('reconstructs normally when skipSkillBodyNames is empty', () => {
+      const payload: TPayload = [
+        { role: 'user', content: 'Review my code' },
+        {
+          role: 'assistant',
+          content: [skillToolCall('call_1', 'code-review')],
+        },
+      ];
+
+      const { messages } = formatAgentMessages(
+        payload,
+        undefined,
+        tools,
+        skillBodies,
+        { skipSkillBodyNames: new Set() }
+      );
+
+      expect(injectedSkillBodies(messages)).toHaveLength(1);
+    });
+
+    it('skips in the non-tools-filtering path too', () => {
+      const payload: TPayload = [
+        { role: 'user', content: 'Review my code' },
+        {
+          role: 'assistant',
+          content: [skillToolCall('call_1', 'code-review')],
+        },
+      ];
+
+      const { messages } = formatAgentMessages(
+        payload,
+        undefined,
+        undefined,
+        skillBodies,
+        { skipSkillBodyNames: new Set(['code-review']) }
+      );
+
+      expect(injectedSkillBodies(messages)).toHaveLength(0);
+    });
+  });
 });

package/src/tools/search/highlights.ts

@@ -240,7 +240,15 @@ export function expandHighlights(
         !result.highlights ||
         result.highlights.length === 0
       ) {
-        return result; // No modification needed
+        if (result.content == null && result.references == null) {
+          return result;
+        }
+        /** Raw scraped content must never leave this function — without
+         * highlights to expand, strip it instead of passing it downstream */
+        const strippedResult = { ...result };
+        delete strippedResult.content;
+        delete strippedResult.references;
+        return strippedResult;
       }
 
       // Create a shallow copy with expanded highlights

package/src/tools/search/search.ts

@@ -66,6 +66,25 @@ const chunker = {
   },
 };
 
+const DEFAULT_MAX_CONTENT_LENGTH = 50000;
+
+/** Resolves the per-source scraped content cap from config, the
+ * `SEARCH_MAX_CONTENT_LENGTH` env var, or the default (50,000 chars) */
+function resolveMaxContentLength(maxContentLength?: number): number {
+  if (maxContentLength != null && maxContentLength > 0) {
+    return maxContentLength;
+  }
+  const envValue = Number(process.env.SEARCH_MAX_CONTENT_LENGTH);
+  if (Number.isFinite(envValue) && envValue > 0) {
+    return envValue;
+  }
+  return DEFAULT_MAX_CONTENT_LENGTH;
+}
+
+function truncateContent(content: string, maxLength: number): string {
+  return content.length > maxLength ? content.slice(0, maxLength) : content;
+}
+
 function createSourceUpdateCallback(sourceMap: Map<string, t.ValidSource>) {
   return (link: string, update?: Partial<t.ValidSource>): void => {
     const source = sourceMap.get(link);
@@ -83,12 +102,14 @@ const getHighlights = async ({
   content,
   reranker,
   topResults = 5,
+  maxContentLength = DEFAULT_MAX_CONTENT_LENGTH,
   logger,
 }: {
   content: string;
   query: string;
   reranker?: BaseReranker;
   topResults?: number;
+  maxContentLength?: number;
   logger?: t.Logger;
 }): Promise<t.Highlight[] | undefined> => {
   const logger_ = logger || createDefaultLogger();
@@ -103,7 +124,9 @@ const getHighlights = async ({
   }
 
   try {
-    const documents = await chunker.splitText(content);
+    const documents = await chunker.splitText(
+      truncateContent(content, maxContentLength)
+    );
     if (Array.isArray(documents)) {
       return await reranker.rerank(query, documents, topResults);
     } else {
@@ -457,6 +480,7 @@ export const createSourceProcessor = (
     logger,
   } = config;
 
+  const maxContentLength = resolveMaxContentLength(config.maxContentLength);
   const logger_ = logger || createDefaultLogger();
   const scraper = scraperInstance;
 
@@ -475,7 +499,7 @@ export const createSourceProcessor = (
         url,
         references,
         attribution,
-        content: chunker.cleanText(content),
+        content: truncateContent(chunker.cleanText(content), maxContentLength),
       };
     }
 
@@ -498,6 +522,7 @@ export const createSourceProcessor = (
         query,
         reranker,
         content: result.content,
+        maxContentLength,
         logger: logger_,
       });
       if (onGetHighlights) {
@@ -606,7 +631,20 @@ export const createSourceProcessor = (
           images: [],
           relatedSearches: [],
         };
-      } else if (!result.data.organic) {
+      }
+
+      if (
+        result.data.topStories != null &&
+        result.data.topStories.length > numElements
+      ) {
+        /** Merged news results can far exceed the requested source count;
+         * every entry is formatted into the LLM output, so cap them up
+         * front — before any early return below and before scraping
+         * entries the cap would discard */
+        result.data.topStories = result.data.topStories.slice(0, numElements);
+      }
+
+      if (!result.data.organic) {
         return result.data;
       }