@librechat/agents 3.2.31 → 3.2.32

package/src/llm/anthropic/llm.spec.ts

@@ -3199,3 +3199,39 @@ describe('Opus 4.6', () => {
     });
   });
 });
+
+describe('Tool input survives message conversion', () => {
+  // Adapted from @langchain/anthropic's "converting messages doesn't drop tool input".
+  // Guards the core >= 1.1.46 streaming-aggregation regression where the tool_use
+  // content block's input was emptied (and re-serialization dropped it).
+  test('converting messages does not drop tool input (live)', async () => {
+    const jokeTool = {
+      name: 'generate_random_joke',
+      description: 'Generate a random joke.',
+      schema: z.object({
+        prompt: z.string().describe('The prompt to generate the joke for.'),
+      }),
+    };
+    const model = new ChatAnthropic({
+      model: 'claude-sonnet-4-5-20250929',
+      temperature: 0,
+    }).bindTools([jokeTool]);
+
+    const result = await model.invoke([
+      new HumanMessage(
+        'Generate three (3) random jokes. Use the generate_random_joke tool and call it three times before responding. This is very important.'
+      ),
+    ]);
+    expect(result.tool_calls?.length ?? 0).toBeGreaterThan(0);
+
+    const converted = _convertMessagesToAnthropicPayload([result]);
+    const toolUseBlocks = (
+      converted.messages[0].content as unknown as Array<Record<string, unknown>>
+    ).filter((block) => block.type === 'tool_use');
+    expect(toolUseBlocks.length).toBeGreaterThan(0);
+    for (const block of toolUseBlocks) {
+      expect(block.input).toBeDefined();
+      expect((block.input as Record<string, unknown>).prompt).toBeDefined();
+    }
+  });
+});

package/src/llm/anthropic/utils/message_inputs.ts

@@ -524,6 +524,17 @@ function _formatContent(message: BaseMessage) {
         return null;
       }
 
+      // Core's v1 streaming aggregation can leave a partial tool-input delta as a
+      // standalone block typed `text` carrying `input` but no `text`. The assembled
+      // input is restored on the tool_use block from `message.tool_calls`, so drop it.
+      if (
+        contentPart.type === 'text' &&
+        'input' in contentPart &&
+        !('text' in contentPart)
+      ) {
+        return null;
+      }
+
       if (isDataContentBlock(contentPart)) {
         return convertToProviderContentBlock(
           contentPart,
@@ -617,9 +628,9 @@ function _formatContent(message: BaseMessage) {
         }
 
         if (contentPartCopy.type === 'input_json_delta') {
-          // `input_json_delta` type only represents yielding partial tool inputs
-          // and is not a valid type for Anthropic messages.
-          contentPartCopy.type = 'tool_use';
+          // Orphaned partial tool-input delta with no id of its own. The assembled
+          // input is restored on the tool_use block from `message.tool_calls`; drop it.
+          return null;
         }
 
         if (
@@ -631,6 +642,37 @@ function _formatContent(message: BaseMessage) {
           contentPartCopy.type = 'server_tool_use';
         }
 
+        // Core's streaming aggregation can leave the inline tool_use input empty
+        // (the assembled arguments live in `message.tool_calls` or, for persisted
+        // messages, in sibling input_json_delta blocks). Restore it when missing.
+        if (
+          contentPartCopy.type === 'tool_use' &&
+          typeof contentPartCopy.id === 'string' &&
+          (contentPartCopy.input === '' || contentPartCopy.input == null)
+        ) {
+          const matchingToolCall = isAIMessage(message)
+            ? message.tool_calls?.find((toolCall) => toolCall.id === contentPartCopy.id)
+            : undefined;
+          if (matchingToolCall) {
+            contentPartCopy.input = matchingToolCall.args;
+          } else {
+            const blockIndex = (contentPart as Record<string, unknown>).index;
+            const merged = contentParts
+              .filter((part) => {
+                const p = part as Record<string, unknown>;
+                return (
+                  p.type === 'input_json_delta' &&
+                  p.index === blockIndex &&
+                  typeof p.input === 'string'
+                );
+              })
+              .reduce((acc, part) => acc + (part as Record<string, unknown>).input, '');
+            if (merged !== '') {
+              contentPartCopy.input = merged;
+            }
+          }
+        }
+
         if ('input' in contentPartCopy) {
           // Anthropic tool use inputs should be valid objects, when applicable.
           if (typeof contentPartCopy.input === 'string') {

package/src/llm/anthropic/utils/message_outputs.ts

@@ -203,10 +203,14 @@ export function _makeMessageChunkFromAnthropicEvent(
   ) {
     const content = [
       {
+        // No `type`: core's streaming aggregation merges this partial input into the
+        // sibling tool_use/server_tool_use block at the same index, keeping its type.
+        // A typed delta block won't merge under core >= 1.1.46 ("keep different block
+        // types separate"), which would orphan the input and empty the tool_use input.
         index: data.index,
         input: data.delta.partial_json,
-        type: data.delta.type,
-      },
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      } as any,
     ];
     return {
       chunk: new AIMessageChunk({

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);
+    });
+  });
 });