@librechat/agents 3.3.7 → 3.3.9

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

@@ -1,8 +1,14 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { AIMessage, HumanMessage } from '@langchain/core/messages';
+import type { ToolCall } from '@langchain/core/messages/tool';
 import type { BaseMessage } from '@langchain/core/messages';
-import { _convertMessagesToAnthropicPayload } from './message_inputs';
+import type {
+  AnthropicMessageCreateParams,
+  AnthropicServerToolUseBlockParam,
+  AnthropicToolUseBlockParam,
+} from '@/llm/anthropic/types';
 import { _makeMessageChunkFromAnthropicEvent } from './message_outputs';
+import { _convertMessagesToAnthropicPayload } from './message_inputs';
 
 /**
  * Regression for @langchain/core >= 1.1.46 streaming aggregation: a tool call's
@@ -40,7 +46,9 @@ describe('_convertMessagesToAnthropicPayload — aggregated streaming tool input
   ];
 
   it('does not throw on the orphaned text-with-input block', () => {
-    expect(() => _convertMessagesToAnthropicPayload(buildHistory())).not.toThrow();
+    expect(() =>
+      _convertMessagesToAnthropicPayload(buildHistory())
+    ).not.toThrow();
   });
 
   it('restores tool_use input from message.tool_calls and drops the orphan block', () => {
@@ -60,13 +68,16 @@ describe('_convertMessagesToAnthropicPayload — aggregated streaming tool input
     // 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'
+        (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.')
+      blocks.some(
+        (b) => b.type === 'text' && b.text === 'Let me calculate that.'
+      )
     ).toBe(true);
   });
 
@@ -94,7 +105,9 @@ describe('_convertMessagesToAnthropicPayload — aggregated streaming tool input
     ];
     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');
+    const toolUse = (assistant!.content as any[]).find(
+      (b) => b.type === 'tool_use'
+    );
     expect(toolUse.input).toEqual({ input: '2 + 2' });
   });
 
@@ -105,8 +118,18 @@ describe('_convertMessagesToAnthropicPayload — aggregated streaming tool input
       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: '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' },
@@ -129,6 +152,145 @@ describe('_convertMessagesToAnthropicPayload — aggregated streaming tool input
   });
 });
 
+/**
+ * Regression for the summarization-CI flake: context-pressure truncation
+ * (`preFlightTruncateToolCallInputs` under a tight budget) used to null BOTH a
+ * tool_use block's inline `input` and its `tool_calls` args in graph state.
+ * Replaying that message shipped `"input": null` and Anthropic rejected the
+ * request with 400 `tool_use.input: Input should be an object`. The payload
+ * conversion must never emit a non-object input, whatever shape history is in.
+ */
+describe('_convertMessagesToAnthropicPayload — non-object tool_use input replay', () => {
+  /** History shapes context-pressure truncation can leave behind in state. */
+  type DegradedToolInput = string | Record<string, unknown> | null | undefined;
+
+  const buildHistory = (
+    input: DegradedToolInput,
+    args: DegradedToolInput
+  ): BaseMessage[] => [
+    new HumanMessage('What is 9 * 9?'),
+    new AIMessage({
+      content: [{ type: 'tool_use', id: 'toolu_x', name: 'calculator', input }],
+      tool_calls: [
+        {
+          id: 'toolu_x',
+          name: 'calculator',
+          args: args as ToolCall['args'],
+          type: 'tool_call',
+        },
+      ],
+    }),
+  ];
+
+  const findAssistantBlock = (
+    payload: AnthropicMessageCreateParams,
+    type: 'tool_use' | 'server_tool_use'
+  ): AnthropicToolUseBlockParam | AnthropicServerToolUseBlockParam => {
+    const assistant = payload.messages.find((m) => m.role === 'assistant');
+    const content = assistant?.content;
+    const block = (Array.isArray(content) ? content : []).find(
+      (b): b is AnthropicToolUseBlockParam | AnthropicServerToolUseBlockParam =>
+        b.type === type
+    );
+    expect(block).toBeDefined();
+    return block!;
+  };
+
+  const getToolUse = (
+    history: BaseMessage[]
+  ): AnthropicToolUseBlockParam | AnthropicServerToolUseBlockParam =>
+    findAssistantBlock(_convertMessagesToAnthropicPayload(history), 'tool_use');
+
+  it('ships an empty object when input and args were both truncated to null', () => {
+    const toolUse = getToolUse(buildHistory(null, null));
+    expect(toolUse.input).toEqual({});
+  });
+
+  it('restores object args when only the inline input was nulled', () => {
+    const toolUse = getToolUse(buildHistory(null, { input: '9 * 9' }));
+    expect(toolUse.input).toEqual({ input: '9 * 9' });
+  });
+
+  it('restores intact args when the inline input degraded to an empty object', () => {
+    // Asymmetric truncation: the raw string input serializes longer than the
+    // args object, so a near-envelope cap can degrade the inline input to {}
+    // while the tool_calls mirror survives. Replay must prefer the mirror.
+    const toolUse = getToolUse(
+      buildHistory({}, { input: '670592745 / 99991' })
+    );
+    expect(toolUse.input).toEqual({ input: '670592745 / 99991' });
+  });
+
+  it('ships an empty object when the inline input is {} and args were nulled too', () => {
+    const toolUse = getToolUse(buildHistory({}, null));
+    expect(toolUse.input).toEqual({});
+  });
+
+  it('coerces non-object inputs on the srvtoolu_ server-tool normalization branch', () => {
+    const cases: Array<[DegradedToolInput, Record<string, unknown>]> = [
+      ['123', {}],
+      ['[1,2]', {}],
+      ['{"query": "x"}', { query: 'x' }],
+      [null, {}],
+    ];
+    for (const [raw, expected] of cases) {
+      const history: BaseMessage[] = [
+        new HumanMessage('search'),
+        new AIMessage({
+          content: [
+            {
+              type: 'server_tool_use',
+              id: 'srvtoolu_abc',
+              name: 'web_search',
+              input: raw,
+            },
+          ],
+        }),
+      ];
+      const block = findAssistantBlock(
+        _convertMessagesToAnthropicPayload(history),
+        'server_tool_use'
+      );
+      expect(block.input).toEqual(expected);
+    }
+  });
+
+  it('coerces a string input that parses to a non-object', () => {
+    for (const raw of ['123', '[1,2]', '"text"', 'null']) {
+      const toolUse = getToolUse(buildHistory(raw, undefined));
+      expect(toolUse.input).toEqual({});
+    }
+  });
+
+  it('still parses a complete JSON-object string input', () => {
+    const toolUse = getToolUse(buildHistory('{"input": "9 * 9"}', undefined));
+    expect(toolUse.input).toEqual({ input: '9 * 9' });
+  });
+
+  it('coerces non-object args on the string-content tool_calls path', () => {
+    const history: BaseMessage[] = [
+      new HumanMessage('What is 9 * 9?'),
+      new AIMessage({
+        content: '',
+        tool_calls: [
+          {
+            id: 'toolu_x',
+            name: 'calculator',
+            args: null as unknown as ToolCall['args'],
+            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({});
+  });
+});
+
 describe('_makeMessageChunkFromAnthropicEvent — streamed tool input merges into content', () => {
   const fields = { streamUsage: true, coerceContentToString: false };
 
@@ -137,7 +299,12 @@ describe('_makeMessageChunkFromAnthropicEvent — streamed tool input merges int
       {
         type: 'content_block_start',
         index: 0,
-        content_block: { type: 'tool_use', id: 'toolu_1', name: 'calculator', input: {} },
+        content_block: {
+          type: 'tool_use',
+          id: 'toolu_1',
+          name: 'calculator',
+          input: {},
+        },
       },
       {
         type: 'content_block_delta',
@@ -168,13 +335,21 @@ describe('_makeMessageChunkFromAnthropicEvent — streamed tool input merges int
     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' });
+    expect(toolUse).toMatchObject({
+      type: 'tool_use',
+      id: 'toolu_1',
+      name: 'calculator',
+    });
     const parsed =
-      typeof toolUse.input === 'string' ? JSON.parse(toolUse.input) : toolUse.input;
+      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);
+    expect(
+      blocks.filter((b) => b.type !== 'tool_use' && 'input' in b)
+    ).toHaveLength(0);
 
     // tool_calls remain correctly aggregated
     expect(merged.tool_calls?.[0]).toMatchObject({

package/src/llm/bedrock/utils/message_inputs.test.ts

@@ -79,6 +79,120 @@ describe('convertToConverseMessages — Anthropic tool replay', () => {
   });
 });
 
+/**
+ * Bedrock Converse requires `toolUse.input` to be a JSON object. History can
+ * carry non-object values: pre-3.x context-pressure truncation persisted
+ * `null` onto both a block's inline input and its `tool_calls` args (see the
+ * Anthropic-replay fix in PR #369), and Anthropic-shaped inline blocks keep
+ * the raw streamed JSON string. These must coerce — never ship as-is, never
+ * throw the whole request away.
+ */
+describe('convertToConverseMessages — non-object toolUse input coercion', () => {
+  const toolUseBlocks = (result: ConverseResult): ConverseBlock[] =>
+    assistantContent(result).filter((b) => b.toolUse != null);
+
+  it('coerces null args to {} when materializing from tool_calls', () => {
+    const messages: BaseMessage[] = [
+      new HumanMessage('What is 9 * 9?'),
+      new AIMessage({
+        content: toLangChainContent([
+          {
+            type: 'tool_use',
+            id: 'call_null',
+            name: 'calculator',
+            input: null,
+          },
+        ]),
+        tool_calls: [
+          {
+            id: 'call_null',
+            name: 'calculator',
+            args: null as never,
+          },
+        ],
+      }),
+    ];
+
+    const [block] = toolUseBlocks(convertToConverseMessages(messages));
+    expect(block.toolUse?.input).toEqual({});
+  });
+
+  it('parses a complete raw-string input on an unmirrored inline block instead of throwing', () => {
+    const messages: BaseMessage[] = [
+      new HumanMessage('Search'),
+      new AIMessage({
+        content: toLangChainContent([
+          {
+            type: 'tool_use',
+            id: 'call_str',
+            name: 'search',
+            input: '{"query": "test"}',
+          },
+        ]),
+        tool_calls: [],
+      }),
+    ];
+
+    expect(() => convertToConverseMessages(messages)).not.toThrow();
+    const [block] = toolUseBlocks(convertToConverseMessages(messages));
+    expect(block.toolUse?.input).toEqual({ query: 'test' });
+  });
+
+  it('degrades non-object inline inputs (partial string, number-string, null) to {}', () => {
+    for (const input of ['{"query": "tru', '123', null]) {
+      const messages: BaseMessage[] = [
+        new HumanMessage('Search'),
+        new AIMessage({
+          content: toLangChainContent([
+            { type: 'tool_use', id: 'call_bad', name: 'search', input },
+          ]),
+          tool_calls: [],
+        }),
+      ];
+
+      const [block] = toolUseBlocks(convertToConverseMessages(messages));
+      expect(block.toolUse?.input).toEqual({});
+    }
+  });
+
+  it('still rejects a tool_use block missing its id or name', () => {
+    const messages: BaseMessage[] = [
+      new HumanMessage('Search'),
+      new AIMessage({
+        content: toLangChainContent([
+          { type: 'tool_use', name: 'search', input: { query: 'x' } },
+        ]),
+        tool_calls: [],
+      }),
+    ];
+
+    expect(() => convertToConverseMessages(messages)).toThrow(
+      'Invalid Anthropic tool_use content block'
+    );
+  });
+
+  it('coerces null args on the v1 tool_call and tool_calls fallback paths', () => {
+    const messages: BaseMessage[] = [
+      new HumanMessage('Run both'),
+      new AIMessage({
+        content: toLangChainContent([
+          { type: 'tool_call', id: 'v1_block', name: 'search', args: null },
+        ]),
+        tool_calls: [
+          { id: 'v1_fallback', name: 'lookup', args: null as never },
+        ],
+        response_metadata: { output_version: 'v1' },
+      }),
+    ];
+
+    const blocks = toolUseBlocks(convertToConverseMessages(messages));
+    expect(blocks).toHaveLength(2);
+    for (const block of blocks) {
+      expect(block.toolUse?.input).toEqual({});
+    }
+  });
+});
+
 describe('convertToConverseMessages — native Bedrock reasoning serialization', () => {
   it('drops a signature-only reasoning block, keeping text and tool calls', () => {
     const messages: BaseMessage[] = [
@@ -491,9 +605,9 @@ describe('convertToConverseMessages — user-role run merging', () => {
       'toolResult' in block ? 'toolResult' : 'text'
     );
     expect(blockKinds).toEqual(['toolResult', 'text']);
-    expect(
-      (merged.content ?? []).find((block) => 'text' in block)?.text
-    ).toBe('Actually, focus on the second result.');
+    expect((merged.content ?? []).find((block) => 'text' in block)?.text).toBe(
+      'Actually, focus on the second result.'
+    );
   });
 
   it('still merges adjacent tool-result-only turns', () => {
@@ -513,7 +627,9 @@ describe('convertToConverseMessages — user-role run merging', () => {
 
     expect(converseMessages.map((m) => m.role)).toEqual(['assistant', 'user']);
     const toolResultIds = (converseMessages[1].content ?? [])
-      .map((block) => ('toolResult' in block ? block.toolResult?.toolUseId : undefined))
+      .map((block) =>
+        'toolResult' in block ? block.toolResult?.toolUseId : undefined
+      )
       .filter(Boolean);
     expect(toolResultIds).toEqual(['call_1', 'call_2']);
   });

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

@@ -684,6 +684,33 @@ function convertSystemMessageToConverseMessage(
 /**
  * Convert an AI message to a Bedrock message.
  */
+/**
+ * Bedrock Converse requires `toolUse.input` to be a JSON object document.
+ * History can carry non-object values: streaming leaves the raw partial-JSON
+ * string on Anthropic-shaped inline blocks, and context-pressure truncation
+ * (pre-3.x `createBoundedTruncationValue`) could persist `null` onto BOTH a
+ * block's inline input and its `tool_calls` args. A string is parsed when it
+ * forms a complete JSON object; every other shape degrades to `{}` — the call
+ * already executed, so the replayed input is informational. Twin of
+ * `coerceAnthropicToolUseInput` in the Anthropic fork; duplicated so each
+ * fork stays self-contained against its upstream.
+ */
+function coerceBedrockToolUseInput(input: unknown): Record<string, unknown> {
+  let candidate: unknown = input;
+  if (typeof candidate === 'string') {
+    try {
+      candidate = JSON.parse(candidate);
+    } catch {
+      return {};
+    }
+  }
+  return typeof candidate === 'object' &&
+    candidate !== null &&
+    !Array.isArray(candidate)
+    ? (candidate as Record<string, unknown>)
+    : {};
+}
+
 function convertAIMessageToConverseMessage(msg: BaseMessage): BedrockMessage {
   // Check for v1 format from other providers (PR #9766 fix)
   const responseMetadata = msg.response_metadata as
@@ -731,9 +758,7 @@ function convertAIMessageToConverseMessage(msg: BaseMessage): BedrockMessage {
         }
         if (
           typeof toolUse.id !== 'string' ||
-          typeof toolUse.name !== 'string' ||
-          toolUse.input == null ||
-          typeof toolUse.input !== 'object'
+          typeof toolUse.name !== 'string'
         ) {
           throw new Error('Invalid Anthropic tool_use content block');
         }
@@ -741,7 +766,7 @@ function convertAIMessageToConverseMessage(msg: BaseMessage): BedrockMessage {
           toolUse: {
             toolUseId: toolUse.id,
             name: toolUse.name,
-            input: toolUse.input as Record<string, unknown>,
+            input: coerceBedrockToolUseInput(toolUse.input),
           },
         } as BedrockContentBlock);
       } else if (block.type === 'reasoning_content') {
@@ -804,7 +829,7 @@ function convertAIMessageToConverseMessage(msg: BaseMessage): BedrockMessage {
         toolUse: {
           toolUseId: toolCall.id,
           name: toolCall.name,
-          input: toolCall.args as Record<string, unknown>,
+          input: coerceBedrockToolUseInput(toolCall.args),
         },
       }));
     assistantMsg.content = [
@@ -862,7 +887,7 @@ function convertFromV1ToChatBedrockConverseMessage(
           toolUse: {
             toolUseId: toolCall.id,
             name: toolCall.name,
-            input: toolCall.args as Record<string, unknown>,
+            input: coerceBedrockToolUseInput(toolCall.args),
           },
         } as BedrockContentBlock);
       } else if (block.type === 'reasoning') {
@@ -914,7 +939,7 @@ function convertFromV1ToChatBedrockConverseMessage(
           toolUse: {
             toolUseId: tc.id,
             name: tc.name,
-            input: tc.args as Record<string, unknown>,
+            input: coerceBedrockToolUseInput(tc.args),
           },
         } as BedrockContentBlock);
       }