@librechat/agents 3.4.7 → 3.5.1

package/src/llm/anthropic/utils/cross-provider-reasoning.test.ts

@@ -1,383 +0,0 @@
-import { AIMessage, HumanMessage } from '@langchain/core/messages';
-import type { BaseMessage } from '@langchain/core/messages';
-import { _convertMessagesToAnthropicPayload } from './message_inputs';
-
-/**
- * Regression for cross-provider agent handoffs (e.g. Bedrock → Anthropic): a
- * Bedrock turn that used extended thinking leaves a `reasoning_content` content
- * block ({ reasoningText: { text, signature } }) in the history. The official
- * Anthropic converter has no branch for it and previously threw
- * "Unsupported message content format", crashing the handoff. Only known
- * foreign reasoning (Bedrock `reasoning_content`, Google `reasoning`, LibreChat
- * `think`) is dropped; any other unknown block still throws rather than being
- * silently omitted (real content — user media, Google code-execution — must be
- * surfaced); and a tool call carried only on `tool_calls` survives dropping its
- * reasoning sibling without being duplicated.
- */
-type AnthropicPayload = ReturnType<typeof _convertMessagesToAnthropicPayload>;
-
-/** Minimal view of a converted Anthropic content block the assertions read. */
-interface TestBlock {
-  type?: string;
-  text?: string;
-}
-
-const findAssistant = (payload: AnthropicPayload) =>
-  payload.messages.find((m) => m.role === 'assistant');
-
-const assistantBlocks = (payload: AnthropicPayload): TestBlock[] => {
-  const content = findAssistant(payload)?.content;
-  return Array.isArray(content) ? (content as TestBlock[]) : [];
-};
-
-describe('_convertMessagesToAnthropicPayload — cross-provider reasoning blocks', () => {
-  const bedrockHandoffHistory = (): BaseMessage[] => [
-    new HumanMessage('research Assort Health'),
-    new AIMessage({
-      content: [
-        {
-          type: 'reasoning_content',
-          index: 0,
-          reasoningText: {
-            text: 'Let me search Notion then hand off to the data agent.',
-            signature: 'bedrock-signature-not-valid-for-anthropic',
-          },
-        },
-        { type: 'text', text: 'Kicking off the searches now.' },
-        {
-          type: 'tool_use',
-          id: 'tooluse_abc',
-          name: 'notion-search',
-          input: { query: 'Assort Health' },
-        },
-      ],
-      tool_calls: [
-        {
-          id: 'tooluse_abc',
-          name: 'notion-search',
-          args: { query: 'Assort Health' },
-          type: 'tool_call',
-        },
-      ],
-    }),
-  ];
-
-  it('does not throw on a Bedrock reasoning_content block', () => {
-    expect(() =>
-      _convertMessagesToAnthropicPayload(bedrockHandoffHistory())
-    ).not.toThrow();
-  });
-
-  it('drops reasoning_content (incl. its foreign signature) but keeps text and tool_use', () => {
-    const payload = _convertMessagesToAnthropicPayload(bedrockHandoffHistory());
-    expect(findAssistant(payload)).toBeDefined();
-    const blocks = assistantBlocks(payload);
-
-    expect(blocks.find((b) => b.type === 'reasoning_content')).toBeUndefined();
-    expect(
-      blocks.find(
-        (b) => b.type === 'thinking' || b.type === 'redacted_thinking'
-      )
-    ).toBeUndefined();
-    expect(JSON.stringify(blocks)).not.toContain(
-      'bedrock-signature-not-valid-for-anthropic'
-    );
-
-    expect(
-      blocks.some(
-        (b) => b.type === 'text' && b.text === 'Kicking off the searches now.'
-      )
-    ).toBe(true);
-    expect(blocks.find((b) => b.type === 'tool_use')).toMatchObject({
-      type: 'tool_use',
-      id: 'tooluse_abc',
-      name: 'notion-search',
-      input: { query: 'Assort Health' },
-    });
-  });
-
-  it('drops a Google `reasoning` block without throwing', () => {
-    const history: BaseMessage[] = [
-      new HumanMessage('hi'),
-      new AIMessage({
-        content: [
-          { type: 'reasoning', reasoning: 'internal google chain of thought' },
-          { type: 'text', text: 'Hello!' },
-        ],
-      }),
-    ];
-    expect(() => _convertMessagesToAnthropicPayload(history)).not.toThrow();
-    const blocks = assistantBlocks(_convertMessagesToAnthropicPayload(history));
-    expect(blocks.find((b) => b.type === 'reasoning')).toBeUndefined();
-    expect(blocks.some((b) => b.type === 'text' && b.text === 'Hello!')).toBe(
-      true
-    );
-  });
-
-  it('drops a LibreChat `think` block without throwing', () => {
-    const history: BaseMessage[] = [
-      new HumanMessage('hi'),
-      new AIMessage({
-        content: [
-          { type: 'think', think: 'librechat serialized reasoning' },
-          { type: 'text', text: 'Done.' },
-        ],
-      }),
-    ];
-    expect(() => _convertMessagesToAnthropicPayload(history)).not.toThrow();
-    const blocks = assistantBlocks(_convertMessagesToAnthropicPayload(history));
-    expect(blocks.find((b) => b.type === 'think')).toBeUndefined();
-    expect(blocks.some((b) => b.type === 'text' && b.text === 'Done.')).toBe(
-      true
-    );
-  });
-
-  it('drops an unsigned `thinking` block (Google thinking-enabled output) on an assistant turn', () => {
-    const history: BaseMessage[] = [
-      new HumanMessage('hi'),
-      new AIMessage({
-        content: [
-          {
-            type: 'thinking',
-            thinking: 'google chain of thought, no signature',
-          },
-          { type: 'text', text: 'Answer.' },
-        ],
-      }),
-    ];
-    expect(() => _convertMessagesToAnthropicPayload(history)).not.toThrow();
-    const blocks = assistantBlocks(_convertMessagesToAnthropicPayload(history));
-    expect(blocks.find((b) => b.type === 'thinking')).toBeUndefined();
-    expect(blocks.some((b) => b.type === 'text' && b.text === 'Answer.')).toBe(
-      true
-    );
-  });
-
-  it('forwards a signed `thinking` block (Anthropic-native) unchanged', () => {
-    const history: BaseMessage[] = [
-      new HumanMessage('hi'),
-      new AIMessage({
-        content: [
-          {
-            type: 'thinking',
-            thinking: 'native reasoning',
-            signature: 'valid-sig',
-          },
-          { type: 'text', text: 'Answer.' },
-        ],
-      }),
-    ];
-    const blocks = assistantBlocks(_convertMessagesToAnthropicPayload(history));
-    expect(blocks.find((b) => b.type === 'thinking')).toMatchObject({
-      type: 'thinking',
-      thinking: 'native reasoning',
-      signature: 'valid-sig',
-    });
-  });
-
-  it('throws (not silently drops) on an unknown assistant block such as Google code execution', () => {
-    // executableCode/codeExecutionResult carry real visible content; silently
-    // dropping them on a Google → Anthropic handoff would lose evidence.
-    const history: BaseMessage[] = [
-      new HumanMessage('run some code'),
-      new AIMessage({
-        content: [
-          {
-            type: 'executableCode',
-            executableCode: { language: 'PYTHON', code: 'print(2+2)' },
-          },
-          { type: 'text', text: 'Here is the result.' },
-        ],
-      }),
-    ];
-    expect(() => _convertMessagesToAnthropicPayload(history)).toThrow(
-      'Unsupported message content format'
-    );
-  });
-
-  it('throws (not silently drops) on an unsupported user block such as media', () => {
-    const history: BaseMessage[] = [
-      new HumanMessage({
-        content: [
-          {
-            type: 'video_url',
-            video_url: { url: 'https://example.com/v.mp4' },
-          },
-          { type: 'text', text: 'what is in this video?' },
-        ],
-      }),
-    ];
-    expect(() => _convertMessagesToAnthropicPayload(history)).toThrow(
-      'Unsupported message content format'
-    );
-  });
-
-  it('does not drop a reasoning-typed block on a user turn (only assistant reasoning is dropped)', () => {
-    const history: BaseMessage[] = [
-      new HumanMessage({
-        content: [
-          { type: 'reasoning_content', reasoningText: { text: 'user text' } },
-          { type: 'text', text: 'hello' },
-        ],
-      }),
-    ];
-    expect(() => _convertMessagesToAnthropicPayload(history)).toThrow(
-      'Unsupported message content format'
-    );
-  });
-
-  it('preserves a tool call carried only on tool_calls when its reasoning sibling is dropped', () => {
-    // Mirrors a Bedrock extended-thinking turn: the tool lives only on
-    // `tool_calls`; `content` holds just the reasoning block (no tool_use).
-    const history: BaseMessage[] = [
-      new HumanMessage('research Assort Health'),
-      new AIMessage({
-        content: [
-          {
-            type: 'reasoning_content',
-            reasoningText: { text: 'I should hand off now.', signature: 'sig' },
-          },
-        ],
-        tool_calls: [
-          {
-            id: 'tooluse_transfer',
-            name: 'lc_transfer_to_data_agent',
-            args: { reason: 'need consumption data' },
-            type: 'tool_call',
-          },
-        ],
-      }),
-    ];
-    expect(() => _convertMessagesToAnthropicPayload(history)).not.toThrow();
-    const blocks = assistantBlocks(_convertMessagesToAnthropicPayload(history));
-    expect(blocks.find((b) => b.type === 'reasoning_content')).toBeUndefined();
-    expect(blocks.find((b) => b.type === 'tool_use')).toMatchObject({
-      type: 'tool_use',
-      id: 'tooluse_transfer',
-      name: 'lc_transfer_to_data_agent',
-      input: { reason: 'need consumption data' },
-    });
-    // The `_` placeholder must not linger once a real tool_use block is present.
-    expect(blocks.some((b) => b.type === 'text' && b.text === '_')).toBe(false);
-  });
-
-  it('does not duplicate a Google functionCall tool call already materialized by _formatContent', () => {
-    // _formatContent converts the `functionCall` part into a tool_use; the
-    // materialization must recognize it as represented and not append a second.
-    const history: BaseMessage[] = [
-      new HumanMessage('weather in SF?'),
-      new AIMessage({
-        content: [
-          {
-            type: 'functionCall',
-            functionCall: { name: 'get_weather', args: { city: 'SF' } },
-          },
-        ],
-        tool_calls: [
-          {
-            id: 'call_weather_1',
-            name: 'get_weather',
-            args: { city: 'SF' },
-            type: 'tool_call',
-          },
-        ],
-      }),
-    ];
-    const blocks = assistantBlocks(_convertMessagesToAnthropicPayload(history));
-    const toolUses = blocks.filter((b) => b.type === 'tool_use');
-    expect(toolUses).toHaveLength(1);
-    expect(toolUses[0]).toMatchObject({
-      type: 'tool_use',
-      id: 'call_weather_1',
-      name: 'get_weather',
-    });
-  });
-
-  it('falls back to placeholder text when reasoning was the only content', () => {
-    const history: BaseMessage[] = [
-      new HumanMessage('hi'),
-      new AIMessage({
-        content: [
-          {
-            type: 'reasoning_content',
-            reasoningText: {
-              text: 'only thinking, no visible text',
-              signature: 'sig',
-            },
-          },
-        ],
-      }),
-    ];
-    expect(() => _convertMessagesToAnthropicPayload(history)).not.toThrow();
-    const blocks = assistantBlocks(_convertMessagesToAnthropicPayload(history));
-    expect(blocks.find((b) => b.type === 'reasoning_content')).toBeUndefined();
-    expect(blocks.length).toBeGreaterThan(0);
-    expect(blocks.every((b) => b.type === 'text')).toBe(true);
-  });
-});
-
-/**
- * Regression for Opus 4.7+ "thinking omitted by default": the Messages API
- * returns a signed `thinking` block whose `thinking` text is absent (only the
- * signature carries the encrypted reasoning). Forwarding it as
- * `{ thinking: undefined, signature }` drops the field at JSON.stringify time
- * and the API rejects the replay with
- * `messages.N.content.M.thinking.thinking: Field required`. The converter must
- * coerce the missing text to '' so the required field is always present.
- */
-describe('_convertMessagesToAnthropicPayload — signed text-less thinking (Opus 4.7+ omitted)', () => {
-  interface ThinkingBlock {
-    type?: string;
-    thinking?: string;
-    signature?: string;
-    text?: string;
-  }
-
-  const signedTextlessHistory = (): BaseMessage[] => [
-    new HumanMessage('summarize the repo'),
-    new AIMessage({
-      content: [
-        { type: 'thinking', signature: 'sig-encrypted-reasoning' },
-        { type: 'text', text: 'Here is the summary.' },
-      ],
-    }),
-  ];
-
-  it('keeps the signed block and emits an empty (not undefined) thinking field', () => {
-    const payload = _convertMessagesToAnthropicPayload(signedTextlessHistory());
-    const blocks = assistantBlocks(payload) as ThinkingBlock[];
-    const thinking = blocks.find((b) => b.type === 'thinking');
-
-    expect(thinking).toBeDefined();
-    expect(thinking?.signature).toBe('sig-encrypted-reasoning');
-    expect(thinking?.thinking).toBe('');
-    expect('thinking' in (thinking as object)).toBe(true);
-  });
-
-  it('serializes the thinking field rather than dropping it (the 400 trigger)', () => {
-    const payload = _convertMessagesToAnthropicPayload(signedTextlessHistory());
-    const blocks = assistantBlocks(payload) as ThinkingBlock[];
-    const thinking = blocks.find((b) => b.type === 'thinking');
-
-    expect(JSON.stringify(thinking)).toContain('"thinking":""');
-  });
-
-  it('still drops an unsigned text-less thinking block (foreign reasoning)', () => {
-    const history: BaseMessage[] = [
-      new HumanMessage('hi'),
-      new AIMessage({
-        content: [
-          { type: 'thinking' },
-          { type: 'text', text: 'Hello!' },
-        ],
-      }),
-    ];
-    const blocks = assistantBlocks(
-      _convertMessagesToAnthropicPayload(history)
-    ) as ThinkingBlock[];
-    expect(blocks.find((b) => b.type === 'thinking')).toBeUndefined();
-    expect(
-      blocks.some((b) => b.type === 'text' && b.text === 'Hello!')
-    ).toBe(true);
-  });
-});

package/src/llm/anthropic/utils/cross-provider-server-tools.test.ts

@@ -1,110 +0,0 @@
-import { AIMessage, HumanMessage } from '@langchain/core/messages';
-import type { BaseMessage } from '@langchain/core/messages';
-import { _convertMessagesToAnthropicPayload } from './message_inputs';
-
-/**
- * Regression for cross-provider agent handoffs (Google → Anthropic): a Gemini
- * turn that used a server-side tool (URL context, Google Search) leaves
- * `toolCall`/`toolResponse` content blocks in history. The Anthropic converter
- * has no branch for them and previously threw
- * "Unsupported message content format", crashing the handoff. Only Google can
- * execute these blocks or validate their thought signatures, so they are
- * dropped on assistant turns; any other unknown block still throws.
- */
-type AnthropicPayload = ReturnType<typeof _convertMessagesToAnthropicPayload>;
-
-/** Minimal view of a converted Anthropic content block the assertions read. */
-interface TestBlock {
-  type?: string;
-  text?: string;
-}
-
-const assistantBlocks = (payload: AnthropicPayload): TestBlock[] => {
-  const content = payload.messages.find((m) => m.role === 'assistant')?.content;
-  return Array.isArray(content) ? (content as TestBlock[]) : [];
-};
-
-describe('_convertMessagesToAnthropicPayload — Google server-side tool blocks', () => {
-  it('drops toolCall/toolResponse on an assistant turn, keeping text', () => {
-    const messages: BaseMessage[] = [
-      new HumanMessage('summarize this article'),
-      new AIMessage({
-        content: [
-          {
-            type: 'toolCall',
-            thoughtSignature: 'google-signature-not-valid-for-anthropic',
-            toolCall: {
-              toolType: 'URL_CONTEXT',
-              args: { urls: ['https://example.com/report'] },
-              id: 'j7pfyr6k',
-            },
-          },
-          {
-            type: 'toolResponse',
-            toolResponse: {
-              toolType: 'URL_CONTEXT',
-              id: 'j7pfyr6k',
-              result: { status: 'SUCCESS' },
-            },
-          },
-          {
-            type: 'text',
-            text: 'The article argues for dollar-cost averaging.',
-          },
-        ],
-      }),
-    ];
-
-    expect(() => _convertMessagesToAnthropicPayload(messages)).not.toThrow();
-    const blocks = assistantBlocks(
-      _convertMessagesToAnthropicPayload(messages)
-    );
-
-    const serialized = JSON.stringify(blocks);
-    expect(serialized).not.toContain('URL_CONTEXT');
-    expect(serialized).not.toContain(
-      'google-signature-not-valid-for-anthropic'
-    );
-    expect(
-      blocks.some(
-        (b) =>
-          b.type === 'text' &&
-          b.text === 'The article argues for dollar-cost averaging.'
-      )
-    ).toBe(true);
-  });
-
-  it('emits a placeholder (not empty content) when a server-tool-only turn is fully dropped', () => {
-    const messages: BaseMessage[] = [
-      new HumanMessage('hi'),
-      new AIMessage({
-        content: [
-          {
-            type: 'toolCall',
-            toolCall: { toolType: 'URL_CONTEXT', args: { urls: [] }, id: 'x1' },
-          },
-        ],
-      }),
-    ];
-    expect(() => _convertMessagesToAnthropicPayload(messages)).not.toThrow();
-    const blocks = assistantBlocks(
-      _convertMessagesToAnthropicPayload(messages)
-    );
-    expect(blocks.length).toBeGreaterThan(0);
-  });
-
-  it('still throws on a genuinely unknown assistant block', () => {
-    const messages: BaseMessage[] = [
-      new HumanMessage('run code'),
-      new AIMessage({
-        content: [
-          { type: 'some_future_block_type', foo: 'bar' },
-          { type: 'text', text: 'done' },
-        ],
-      }),
-    ];
-    expect(() => _convertMessagesToAnthropicPayload(messages)).toThrow(
-      'Unsupported message content format'
-    );
-  });
-});