@librechat/agents 3.4.6 → 3.5.0

package/src/llm/bedrock/streamSealDispatch.test.ts

@@ -1,331 +0,0 @@
-import { expect, test, describe, jest } from '@jest/globals';
-import { HumanMessage, AIMessageChunk } from '@langchain/core/messages';
-import type { CallbackManagerForLLMRun } from '@langchain/core/callbacks/manager';
-import type { ChatGenerationChunk } from '@langchain/core/outputs';
-import {
-  STREAMED_TOOL_CALL_SEAL_METADATA_KEY,
-  STREAMED_TOOL_CALL_ADAPTER_METADATA_KEY,
-  BEDROCK_CONVERSE_STREAMED_TOOL_CALL_ADAPTER,
-} from '@/tools/streamedToolCallSeals';
-import { CustomChatBedrockConverse } from './index';
-
-/**
- * Registered stream handlers consume chunks through `handleLLMNewToken`
- * callback events, not the yielded generator (`attemptInvoke` skips manual
- * dispatch when a handler is registered). These tests drive the Converse
- * stream loop with a stubbed client and assert that toolUse start and stop
- * seal chunks reach BOTH paths.
- */
-describe('Converse stream seal dispatch', () => {
-  async function runStream(
-    events: Array<Record<string, unknown>>,
-    modelFields: Record<string, unknown> = {}
-  ): Promise<{
-    yielded: AIMessageChunk[];
-    dispatched: AIMessageChunk[];
-  }> {
-    const model = new CustomChatBedrockConverse({
-      model: 'anthropic.claude-3-5-sonnet-20240620-v1:0',
-      region: 'us-east-1',
-      credentials: { accessKeyId: 'test', secretAccessKey: 'test' },
-      ...modelFields,
-    });
-
-    (model as unknown as { client: { send: unknown } }).client.send = jest.fn(
-      async () => ({
-        stream: (async function* () {
-          yield* events;
-        })(),
-      })
-    );
-
-    const dispatched: AIMessageChunk[] = [];
-    const runManager = {
-      handleLLMNewToken: jest.fn(
-        async (
-          _token: string,
-          _idx?: unknown,
-          _runId?: unknown,
-          _parentRunId?: unknown,
-          _tags?: unknown,
-          fields?: { chunk?: ChatGenerationChunk }
-        ) => {
-          const message = fields?.chunk?.message;
-          if (message instanceof AIMessageChunk) {
-            dispatched.push(message);
-          }
-        }
-      ),
-    } as unknown as CallbackManagerForLLMRun;
-
-    const yielded: AIMessageChunk[] = [];
-    for await (const chunk of model._streamResponseChunks(
-      [new HumanMessage('hi')],
-      {} as Parameters<CustomChatBedrockConverse['_streamResponseChunks']>[1],
-      runManager
-    )) {
-      if (chunk.message instanceof AIMessageChunk) {
-        yielded.push(chunk.message);
-      }
-    }
-    return { yielded, dispatched };
-  }
-
-  const toolUseEvents = [
-    {
-      contentBlockStart: {
-        contentBlockIndex: 1,
-        start: { toolUse: { toolUseId: 'call_1', name: 'weather' } },
-      },
-    },
-    {
-      contentBlockDelta: {
-        contentBlockIndex: 1,
-        delta: { toolUse: { input: '{"city":"NYC"}' } },
-      },
-    },
-    { contentBlockStop: { contentBlockIndex: 1 } },
-  ];
-
-  test('dispatches toolUse start and stop seal chunks to callbacks', async () => {
-    const { yielded, dispatched } = await runStream(toolUseEvents);
-
-    const sealOf = (m: AIMessageChunk): unknown =>
-      (m.response_metadata as Record<string, unknown>)[
-        STREAMED_TOOL_CALL_SEAL_METADATA_KEY
-      ];
-
-    expect(yielded.some((m) => sealOf(m) != null)).toBe(true);
-
-    expect(dispatched).toHaveLength(3);
-    expect(dispatched[0].tool_call_chunks).toMatchObject([
-      { id: 'call_1', name: 'weather', index: 1 },
-    ]);
-    expect(dispatched[1].tool_call_chunks).toMatchObject([
-      { args: '{"city":"NYC"}', index: 1 },
-    ]);
-    expect(sealOf(dispatched[2])).toEqual({ kind: 'single', index: 1 });
-    expect(
-      (dispatched[2].response_metadata as Record<string, unknown>)[
-        STREAMED_TOOL_CALL_ADAPTER_METADATA_KEY
-      ]
-    ).toBe(BEDROCK_CONVERSE_STREAMED_TOOL_CALL_ADAPTER);
-  });
-
-  test('does not emit seal chunks when guardrails are configured', async () => {
-    const { yielded, dispatched } = await runStream(toolUseEvents, {
-      guardrailConfig: {
-        guardrailIdentifier: 'guardrail_1',
-        guardrailVersion: '1',
-      },
-    });
-
-    const hasSeal = (m: AIMessageChunk): boolean =>
-      (m.response_metadata as Record<string, unknown>)[
-        STREAMED_TOOL_CALL_SEAL_METADATA_KEY
-      ] != null;
-
-    // Guardrails can reject the turn at messageStop after contentBlockStop,
-    // so no eager seal may be emitted — but tool chunks still stream.
-    expect(yielded.some(hasSeal)).toBe(false);
-    expect(dispatched.some(hasSeal)).toBe(false);
-    expect(dispatched).toHaveLength(2);
-    expect(dispatched[0].tool_call_chunks).toMatchObject([
-      { id: 'call_1', name: 'weather', index: 1 },
-    ]);
-  });
-
-  test('does not emit seal chunks for non-toolUse block stops', async () => {
-    const { yielded, dispatched } = await runStream([
-      {
-        contentBlockDelta: {
-          contentBlockIndex: 0,
-          delta: { text: 'hello' },
-        },
-      },
-      { contentBlockStop: { contentBlockIndex: 0 } },
-    ]);
-
-    const hasSeal = (m: AIMessageChunk): boolean =>
-      (m.response_metadata as Record<string, unknown>)[
-        STREAMED_TOOL_CALL_SEAL_METADATA_KEY
-      ] != null;
-
-    expect(yielded.some(hasSeal)).toBe(false);
-    expect(dispatched.some(hasSeal)).toBe(false);
-    expect(dispatched).toHaveLength(1);
-  });
-
-  test('paces visible text deltas with configured stream delay', async () => {
-    const setTimeoutSpy = jest.spyOn(globalThis, 'setTimeout');
-
-    try {
-      const { yielded, dispatched } = await runStream(
-        [
-          {
-            contentBlockDelta: {
-              contentBlockIndex: 0,
-              delta: { text: 'hello' },
-            },
-          },
-          {
-            contentBlockDelta: {
-              contentBlockIndex: 0,
-              delta: { text: ' world' },
-            },
-          },
-        ],
-        { _lc_stream_delay: 35 }
-      );
-
-      expect(yielded.map((m) => m.content)).toEqual(['hello', ' world']);
-      expect(dispatched.map((m) => m.content)).toEqual(['hello', ' world']);
-
-      const timeoutDelays = setTimeoutSpy.mock.calls
-        .map(([, delay]) => delay)
-        .filter((delay): delay is number => typeof delay === 'number');
-      expect(timeoutDelays.some((delay) => delay > 0 && delay <= 35)).toBe(
-        true
-      );
-    } finally {
-      setTimeoutSpy.mockRestore();
-    }
-  });
-
-  test('splits large text deltas at Anthropic stream boundaries', async () => {
-    const { yielded, dispatched } = await runStream(
-      [
-        {
-          contentBlockDelta: {
-            contentBlockIndex: 0,
-            delta: { text: 'alpha beta gamma' },
-          },
-        },
-      ],
-      { _lc_stream_delay: 1 }
-    );
-
-    expect(yielded.map((m) => m.content)).toEqual(['alpha ', 'beta ', 'gamma']);
-    expect(dispatched.map((m) => m.content)).toEqual([
-      'alpha ',
-      'beta ',
-      'gamma',
-    ]);
-  });
-
-  test('paces visible reasoning deltas with configured stream delay', async () => {
-    const setTimeoutSpy = jest.spyOn(globalThis, 'setTimeout');
-
-    try {
-      const { yielded, dispatched } = await runStream(
-        [
-          {
-            contentBlockDelta: {
-              contentBlockIndex: 0,
-              delta: { reasoningContent: { text: 'One' } },
-            },
-          },
-          {
-            contentBlockDelta: {
-              contentBlockIndex: 0,
-              delta: { reasoningContent: { text: 'Two' } },
-            },
-          },
-        ],
-        { _lc_stream_delay: 35 }
-      );
-
-      expect(yielded.map((m) => m.additional_kwargs.reasoning_content)).toEqual(
-        ['One', 'Two']
-      );
-      expect(
-        dispatched.map((m) => m.additional_kwargs.reasoning_content)
-      ).toEqual(['One', 'Two']);
-
-      const timeoutDelays = setTimeoutSpy.mock.calls
-        .map(([, delay]) => delay)
-        .filter((delay): delay is number => typeof delay === 'number');
-      expect(timeoutDelays.some((delay) => delay > 0 && delay <= 35)).toBe(
-        true
-      );
-    } finally {
-      setTimeoutSpy.mockRestore();
-    }
-  });
-
-  test('emits toolUse seal chunks without pacing delay while text is paced', async () => {
-    const model = new CustomChatBedrockConverse({
-      model: 'anthropic.claude-3-5-sonnet-20240620-v1:0',
-      region: 'us-east-1',
-      credentials: { accessKeyId: 'test', secretAccessKey: 'test' },
-      _lc_stream_delay: 60,
-    });
-
-    (model as unknown as { client: { send: unknown } }).client.send = jest.fn(
-      async () => ({
-        stream: (async function* () {
-          yield {
-            contentBlockDelta: {
-              contentBlockIndex: 0,
-              delta: { text: 'alpha beta' },
-            },
-          };
-          yield {
-            contentBlockStart: {
-              contentBlockIndex: 1,
-              start: { toolUse: { toolUseId: 'call_1', name: 'weather' } },
-            },
-          };
-          yield {
-            contentBlockDelta: {
-              contentBlockIndex: 1,
-              delta: { toolUse: { input: '{"city":"NYC"}' } },
-            },
-          };
-          yield { contentBlockStop: { contentBlockIndex: 1 } };
-        })(),
-      })
-    );
-
-    const arrivals: { isSeal: boolean; hasText: boolean; at: number }[] = [];
-    for await (const chunk of model._streamResponseChunks(
-      [new HumanMessage('hi')],
-      {} as Parameters<CustomChatBedrockConverse['_streamResponseChunks']>[1],
-      undefined
-    )) {
-      const message = chunk.message as AIMessageChunk;
-      arrivals.push({
-        isSeal:
-          (message.response_metadata as Record<string, unknown>)[
-            STREAMED_TOOL_CALL_SEAL_METADATA_KEY
-          ] != null,
-        hasText: chunk.text !== '',
-        at: Date.now(),
-      });
-    }
-
-    const lastText = [...arrivals].reverse().find((entry) => entry.hasText);
-    const seal = arrivals.find((entry) => entry.isSeal);
-    expect(lastText).toBeDefined();
-    expect(seal).toBeDefined();
-    expect((seal as { at: number }).at).toBeGreaterThanOrEqual(
-      (lastText as { at: number }).at
-    );
-    expect(
-      (seal as { at: number }).at - (lastText as { at: number }).at
-    ).toBeLessThan(45);
-  });
-
-  test('defaults to 25ms adaptive smoothing with 0 disabling', () => {
-    const base = {
-      model: 'anthropic.claude-3-5-sonnet-20240620-v1:0',
-      region: 'us-east-1',
-      credentials: { accessKeyId: 'test', secretAccessKey: 'test' },
-    };
-    expect(new CustomChatBedrockConverse(base)._lc_stream_delay).toBe(25);
-    expect(
-      new CustomChatBedrockConverse({ ...base, _lc_stream_delay: 0 })
-        ._lc_stream_delay
-    ).toBe(0);
-  });
-});

package/src/llm/bedrock/toolCache.test.ts

@@ -1,194 +0,0 @@
-import { tool } from '@langchain/core/tools';
-import type { Tool } from '@aws-sdk/client-bedrock-runtime';
-import type { GraphTools } from '@/types';
-import {
-  insertBedrockToolCachePoint,
-  partitionAndMarkBedrockToolCache,
-} from './toolCache';
-
-type OpenAITool = {
-  type: 'function';
-  function: {
-    name: string;
-    description?: string;
-    parameters?: object;
-  };
-};
-
-type CreateOpenAIToolOptions = {
-  description?: string;
-  omitDescription?: boolean;
-};
-
-function createOpenAITool(
-  name: string,
-  options: CreateOpenAIToolOptions = {}
-): OpenAITool {
-  const functionDefinition: OpenAITool['function'] = {
-    name,
-    parameters: {
-      type: 'object',
-      properties: {},
-    },
-  };
-  const description = options.description ?? `${name} description`;
-  if (options.omitDescription !== true) {
-    functionDefinition.description = description;
-  }
-
-  return {
-    type: 'function',
-    function: functionDefinition,
-  };
-}
-
-function toolName(entry: Tool): string {
-  if ('cachePoint' in entry) {
-    return 'cachePoint';
-  }
-  return entry.toolSpec?.name ?? 'missing';
-}
-
-function toolNames(tools: Tool[] | undefined): string[] {
-  return (tools ?? []).map(toolName);
-}
-
-function getToolSpec(entry: Tool): Tool.ToolSpecMember['toolSpec'] {
-  expect(entry).toHaveProperty('toolSpec');
-  return (entry as Tool.ToolSpecMember).toolSpec;
-}
-
-describe('partitionAndMarkBedrockToolCache', () => {
-  it('inserts the Bedrock cache point after the last static tool', () => {
-    const tools = [
-      createOpenAITool('static_one'),
-      createOpenAITool('static_two'),
-      createOpenAITool('dynamic_one'),
-    ] as GraphTools;
-
-    const marked = partitionAndMarkBedrockToolCache(
-      tools,
-      (name) => name === 'dynamic_one'
-    ) as Tool[];
-    const result = insertBedrockToolCachePoint({ tools: marked }, false);
-
-    expect(toolNames(result?.tools)).toEqual([
-      'static_one',
-      'static_two',
-      'cachePoint',
-      'dynamic_one',
-    ]);
-    expect(JSON.stringify(result?.tools)).not.toContain(
-      '__lc_bedrock_cache_point_after'
-    );
-  });
-
-  it('converts LangChain tools to Bedrock tool specs before marking', () => {
-    const staticTool = tool(async () => 'static', {
-      name: 'static_tool',
-      description: 'Static tool',
-      schema: {
-        type: 'object',
-        properties: {},
-      },
-    });
-    const dynamicTool = tool(async () => 'dynamic', {
-      name: 'dynamic_tool',
-      description: 'Dynamic tool',
-      schema: {
-        type: 'object',
-        properties: {},
-      },
-    });
-
-    const marked = partitionAndMarkBedrockToolCache(
-      [dynamicTool, staticTool] as GraphTools,
-      (name) => name === 'dynamic_tool'
-    ) as Tool[];
-    const result = insertBedrockToolCachePoint({ tools: marked }, false);
-
-    expect(toolNames(result?.tools)).toEqual([
-      'static_tool',
-      'cachePoint',
-      'dynamic_tool',
-    ]);
-  });
-
-  it('does not add a cache point when every tool is deferred', () => {
-    const tools = [createOpenAITool('dynamic_one')] as GraphTools;
-    const marked = partitionAndMarkBedrockToolCache(
-      tools,
-      () => true
-    ) as Tool[];
-    const result = insertBedrockToolCachePoint({ tools: marked }, false);
-
-    expect(toolNames(result?.tools)).toEqual(['dynamic_one']);
-    expect(JSON.stringify(result?.tools)).not.toContain(
-      '__lc_bedrock_skip_tool_cache'
-    );
-  });
-
-  it('can fall back to caching all directly-bound tools', () => {
-    const result = insertBedrockToolCachePoint(
-      {
-        tools: [
-          {
-            toolSpec: {
-              name: 'direct_tool',
-              description: 'Direct tool',
-              inputSchema: { json: { type: 'object', properties: {} } },
-            },
-          },
-        ],
-      },
-      true
-    );
-
-    expect(toolNames(result?.tools)).toEqual(['direct_tool', 'cachePoint']);
-  });
-
-  it('omits empty OpenAI tool descriptions when converting for Bedrock', () => {
-    const tools = [
-      createOpenAITool('missing_description', { omitDescription: true }),
-      createOpenAITool('empty_description', { description: '' }),
-      createOpenAITool('described_tool'),
-    ] as GraphTools;
-
-    const marked = partitionAndMarkBedrockToolCache(
-      tools,
-      () => false
-    ) as Tool[];
-    const result = insertBedrockToolCachePoint({ tools: marked }, false);
-    const convertedTools = result?.tools ?? [];
-
-    expect(getToolSpec(convertedTools[0])).not.toHaveProperty('description');
-    expect(getToolSpec(convertedTools[1])).not.toHaveProperty('description');
-    expect(getToolSpec(convertedTools[2]).description).toBe(
-      'described_tool description'
-    );
-  });
-
-  it('normalizes an existing tool cache point to the resolved 1h ttl', () => {
-    const result = insertBedrockToolCachePoint(
-      {
-        tools: [
-          {
-            toolSpec: {
-              name: 'direct_tool',
-              description: 'Direct tool',
-              inputSchema: { json: { type: 'object', properties: {} } },
-            },
-          },
-          { cachePoint: { type: 'default' } },
-        ] as Tool[],
-      },
-      false,
-      '1h'
-    );
-    const cachePoints = (result?.tools ?? []).filter(
-      (t): t is Tool.CachePointMember => 'cachePoint' in t
-    );
-    expect(cachePoints).toHaveLength(1);
-    expect(cachePoints[0].cachePoint).toEqual({ type: 'default', ttl: '1h' });
-  });
-});

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

@@ -1,131 +0,0 @@
-import { AIMessage, HumanMessage } from '@langchain/core/messages';
-import type { BaseMessage } from '@langchain/core/messages';
-import { convertToConverseMessages } from './message_inputs';
-
-/**
- * Mirror of the Anthropic-side cross-provider reasoning fix, for the reverse
- * handoff (Anthropic → Bedrock). An Anthropic extended-thinking turn leaves
- * `thinking`/`redacted_thinking` blocks in history; the Bedrock Converse
- * converter has no branch for them and previously threw
- * "Unsupported content block type: thinking", crashing the handoff. Bedrock's
- * native reasoning is `reasoning_content` (still converted); foreign reasoning
- * (`thinking`/`redacted_thinking`/`reasoning`/`think`) is dropped on assistant
- * turns, while any other unknown block still throws rather than being silently
- * omitted.
- */
-type ConverseResult = ReturnType<typeof convertToConverseMessages>;
-
-/** Minimal view of a converted Bedrock Converse content block the assertions read. */
-interface ConverseBlock {
-  text?: string;
-  reasoningContent?: { reasoningText?: { text?: string; signature?: string } };
-  toolUse?: {
-    toolUseId?: string;
-    name?: string;
-    input?: Record<string, string>;
-  };
-}
-
-const assistantContent = (result: ConverseResult): ConverseBlock[] => {
-  const msg = result.converseMessages.find((m) => m.role === 'assistant');
-  return (msg?.content ?? []) as ConverseBlock[];
-};
-
-describe('convertToConverseMessages — cross-provider reasoning (Anthropic → Bedrock)', () => {
-  it('drops Anthropic thinking/redacted_thinking on an assistant turn, keeping text and tool calls', () => {
-    const messages: BaseMessage[] = [
-      new HumanMessage('research Assort Health'),
-      new AIMessage({
-        content: [
-          {
-            type: 'thinking',
-            thinking: 'Let me hand off to the data agent.',
-            signature: 'anthropic-signature-not-valid-for-bedrock',
-          },
-          { type: 'redacted_thinking', data: 'redacted-blob' },
-          { type: 'text', text: 'Handing off now.' },
-        ],
-        tool_calls: [
-          {
-            id: 'tooluse_transfer',
-            name: 'lc_transfer_to_data_agent',
-            args: { reason: 'need consumption data' },
-            type: 'tool_call',
-          },
-        ],
-      }),
-    ];
-
-    expect(() => convertToConverseMessages(messages)).not.toThrow();
-    const content = assistantContent(convertToConverseMessages(messages));
-
-    expect(content.find((b) => b.reasoningContent != null)).toBeUndefined();
-    expect(JSON.stringify(content)).not.toContain(
-      'anthropic-signature-not-valid-for-bedrock'
-    );
-    expect(JSON.stringify(content)).not.toContain('redacted-blob');
-
-    expect(content.some((b) => b.text === 'Handing off now.')).toBe(true);
-    const toolUse = content.find((b) => b.toolUse != null);
-    expect(toolUse?.toolUse).toMatchObject({
-      toolUseId: 'tooluse_transfer',
-      name: 'lc_transfer_to_data_agent',
-      input: { reason: 'need consumption data' },
-    });
-  });
-
-  it('emits a placeholder (not empty content) when a reasoning-only turn is fully dropped', () => {
-    const messages: BaseMessage[] = [
-      new HumanMessage('hi'),
-      new AIMessage({
-        content: [
-          { type: 'thinking', thinking: 'only thinking, no other content' },
-        ],
-      }),
-    ];
-    expect(() => convertToConverseMessages(messages)).not.toThrow();
-    const content = assistantContent(convertToConverseMessages(messages));
-    expect(content.length).toBeGreaterThan(0);
-    expect(content.find((b) => b.reasoningContent != null)).toBeUndefined();
-    expect(content.every((b) => typeof b.text === 'string')).toBe(true);
-  });
-
-  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(() => convertToConverseMessages(messages)).toThrow(
-      'Unsupported content block type'
-    );
-  });
-
-  it('still converts Bedrock-native reasoning_content (not dropped)', () => {
-    const messages: BaseMessage[] = [
-      new HumanMessage('hi'),
-      new AIMessage({
-        content: [
-          {
-            type: 'reasoning_content',
-            reasoningText: {
-              text: 'native bedrock reasoning',
-              signature: 'sig',
-            },
-          },
-          { type: 'text', text: 'answer' },
-        ],
-      }),
-    ];
-    const content = assistantContent(convertToConverseMessages(messages));
-    const reasoning = content.find((b) => b.reasoningContent != null);
-    expect(reasoning).toBeDefined();
-    expect(reasoning?.reasoningContent?.reasoningText?.text).toBe(
-      'native bedrock reasoning'
-    );
-  });
-});