@librechat/agents 3.4.6 → 3.5.0

package/src/messages/__tests__/tools.test.ts

@@ -1,473 +0,0 @@
-// src/messages/__tests__/tools.test.ts
-import {
-  AIMessageChunk,
-  ToolMessage,
-  HumanMessage,
-} from '@langchain/core/messages';
-import type { BaseMessage } from '@langchain/core/messages';
-import { extractToolDiscoveries, hasToolSearchInCurrentTurn } from '../tools';
-import { Constants } from '@/common';
-
-describe('Tool Discovery Functions', () => {
-  /**
-   * Helper to create an AIMessageChunk with tool calls
-   */
-  const createAIMessage = (
-    content: string,
-    toolCalls: Array<{
-      id: string;
-      name: string;
-      args: Record<string, unknown>;
-    }>
-  ): AIMessageChunk => {
-    return new AIMessageChunk({
-      content,
-      tool_calls: toolCalls.map((tc) => ({
-        id: tc.id,
-        name: tc.name,
-        args: tc.args,
-        type: 'tool_call' as const,
-      })),
-    });
-  };
-
-  /**
-   * Helper to create a ToolMessage (tool search result)
-   */
-  const createToolSearchResult = (
-    toolCallId: string,
-    discoveredTools: string[]
-  ): ToolMessage => {
-    return new ToolMessage({
-      content: `Found ${discoveredTools.length} tools`,
-      tool_call_id: toolCallId,
-      name: Constants.TOOL_SEARCH,
-      artifact: {
-        tool_references: discoveredTools.map((name) => ({
-          tool_name: name,
-          match_score: 0.9,
-          matched_field: 'description',
-          snippet: 'Test snippet',
-        })),
-        metadata: {
-          total_searched: 10,
-          pattern: 'test',
-        },
-      },
-    });
-  };
-
-  /**
-   * Helper to create a regular ToolMessage (non-search)
-   */
-  const createRegularToolMessage = (
-    toolCallId: string,
-    name: string,
-    content: string
-  ): ToolMessage => {
-    return new ToolMessage({
-      content,
-      tool_call_id: toolCallId,
-      name,
-    });
-  };
-
-  describe('extractToolDiscoveries', () => {
-    it('extracts tool names from a single tool search result', () => {
-      const messages: BaseMessage[] = [
-        new HumanMessage('Search for database tools'),
-        createAIMessage('Searching...', [
-          {
-            id: 'call_1',
-            name: Constants.TOOL_SEARCH,
-            args: { pattern: 'database' },
-          },
-        ]),
-        createToolSearchResult('call_1', ['database_query', 'database_insert']),
-      ];
-
-      const result = extractToolDiscoveries(messages);
-
-      expect(result).toEqual(['database_query', 'database_insert']);
-    });
-
-    it('extracts tool names from multiple tool search results in same turn', () => {
-      const messages: BaseMessage[] = [
-        new HumanMessage('Search for tools'),
-        createAIMessage('Searching...', [
-          {
-            id: 'call_1',
-            name: Constants.TOOL_SEARCH,
-            args: { pattern: 'database' },
-          },
-          {
-            id: 'call_2',
-            name: Constants.TOOL_SEARCH,
-            args: { pattern: 'file' },
-          },
-        ]),
-        createToolSearchResult('call_1', ['database_query']),
-        createToolSearchResult('call_2', ['file_read', 'file_write']),
-      ];
-
-      const result = extractToolDiscoveries(messages);
-
-      expect(result).toEqual(['database_query', 'file_read', 'file_write']);
-    });
-
-    it('returns empty array when no messages', () => {
-      const result = extractToolDiscoveries([]);
-      expect(result).toEqual([]);
-    });
-
-    it('returns empty array when last message is not a ToolMessage', () => {
-      const messages: BaseMessage[] = [
-        new HumanMessage('Hello'),
-        createAIMessage('Hi there!', []),
-      ];
-
-      const result = extractToolDiscoveries(messages);
-
-      expect(result).toEqual([]);
-    });
-
-    it('returns empty array when no AI message with tool calls found', () => {
-      const messages: BaseMessage[] = [
-        new HumanMessage('Hello'),
-        new ToolMessage({
-          content: 'Some result',
-          tool_call_id: 'orphan_call',
-          name: Constants.TOOL_SEARCH,
-        }),
-      ];
-
-      const result = extractToolDiscoveries(messages);
-
-      expect(result).toEqual([]);
-    });
-
-    it('ignores tool search results from previous turns', () => {
-      const messages: BaseMessage[] = [
-        // Turn 1: Previous search
-        new HumanMessage('Search for old tools'),
-        createAIMessage('Searching...', [
-          {
-            id: 'old_call',
-            name: Constants.TOOL_SEARCH,
-            args: { pattern: 'old' },
-          },
-        ]),
-        createToolSearchResult('old_call', ['old_tool_1', 'old_tool_2']),
-        // Turn 2: Current turn
-        new HumanMessage('Search for new tools'),
-        createAIMessage('Searching again...', [
-          {
-            id: 'new_call',
-            name: Constants.TOOL_SEARCH,
-            args: { pattern: 'new' },
-          },
-        ]),
-        createToolSearchResult('new_call', ['new_tool']),
-      ];
-
-      const result = extractToolDiscoveries(messages);
-
-      // Should only return tools from current turn
-      expect(result).toEqual(['new_tool']);
-    });
-
-    it('ignores non-search tool results', () => {
-      const messages: BaseMessage[] = [
-        new HumanMessage('Do some work'),
-        createAIMessage('Working...', [
-          {
-            id: 'search_call',
-            name: Constants.TOOL_SEARCH,
-            args: { pattern: 'test' },
-          },
-          { id: 'other_call', name: 'get_weather', args: { city: 'NYC' } },
-        ]),
-        createToolSearchResult('search_call', ['found_tool']),
-        createRegularToolMessage('other_call', 'get_weather', '{"temp": 72}'),
-      ];
-
-      const result = extractToolDiscoveries(messages);
-
-      expect(result).toEqual(['found_tool']);
-    });
-
-    it('handles empty tool_references in artifact', () => {
-      const messages: BaseMessage[] = [
-        new HumanMessage('Search'),
-        createAIMessage('Searching...', [
-          {
-            id: 'call_1',
-            name: Constants.TOOL_SEARCH,
-            args: { pattern: 'xyz' },
-          },
-        ]),
-        new ToolMessage({
-          content: 'No tools found',
-          tool_call_id: 'call_1',
-          name: Constants.TOOL_SEARCH,
-          artifact: {
-            tool_references: [],
-            metadata: { total_searched: 10, pattern: 'xyz' },
-          },
-        }),
-      ];
-
-      const result = extractToolDiscoveries(messages);
-
-      expect(result).toEqual([]);
-    });
-
-    it('handles missing artifact', () => {
-      const messages: BaseMessage[] = [
-        new HumanMessage('Search'),
-        createAIMessage('Searching...', [
-          {
-            id: 'call_1',
-            name: Constants.TOOL_SEARCH,
-            args: { pattern: 'test' },
-          },
-        ]),
-        new ToolMessage({
-          content: 'Error occurred',
-          tool_call_id: 'call_1',
-          name: Constants.TOOL_SEARCH,
-          // No artifact
-        }),
-      ];
-
-      const result = extractToolDiscoveries(messages);
-
-      expect(result).toEqual([]);
-    });
-
-    it('ignores tool messages with wrong tool_call_id', () => {
-      const messages: BaseMessage[] = [
-        new HumanMessage('Search'),
-        createAIMessage('Searching...', [
-          {
-            id: 'call_1',
-            name: Constants.TOOL_SEARCH,
-            args: { pattern: 'test' },
-          },
-        ]),
-        // This has a different tool_call_id that doesn't match the AI message
-        createToolSearchResult('wrong_id', ['should_not_appear']),
-        createToolSearchResult('call_1', ['correct_tool']),
-      ];
-
-      const result = extractToolDiscoveries(messages);
-
-      expect(result).toEqual(['correct_tool']);
-    });
-
-    it('only looks at messages after the latest AI parent', () => {
-      const messages: BaseMessage[] = [
-        // First AI message with search
-        createAIMessage('First search', [
-          {
-            id: 'first_call',
-            name: Constants.TOOL_SEARCH,
-            args: { pattern: 'first' },
-          },
-        ]),
-        createToolSearchResult('first_call', ['first_tool']),
-        // Second AI message - this is the "latest AI parent" for the last tool message
-        createAIMessage('Second search', [
-          {
-            id: 'second_call',
-            name: Constants.TOOL_SEARCH,
-            args: { pattern: 'second' },
-          },
-        ]),
-        createToolSearchResult('second_call', ['second_tool']),
-      ];
-
-      const result = extractToolDiscoveries(messages);
-
-      // Should only find second_tool (from the turn of the latest AI parent)
-      expect(result).toEqual(['second_tool']);
-    });
-  });
-
-  describe('hasToolSearchInCurrentTurn', () => {
-    it('returns true when current turn has tool search results', () => {
-      const messages: BaseMessage[] = [
-        new HumanMessage('Search'),
-        createAIMessage('Searching...', [
-          {
-            id: 'call_1',
-            name: Constants.TOOL_SEARCH,
-            args: { pattern: 'test' },
-          },
-        ]),
-        createToolSearchResult('call_1', ['found_tool']),
-      ];
-
-      const result = hasToolSearchInCurrentTurn(messages);
-
-      expect(result).toBe(true);
-    });
-
-    it('returns false when no messages', () => {
-      const result = hasToolSearchInCurrentTurn([]);
-      expect(result).toBe(false);
-    });
-
-    it('returns false when last message is not a ToolMessage', () => {
-      const messages: BaseMessage[] = [
-        new HumanMessage('Hello'),
-        createAIMessage('Hi!', []),
-      ];
-
-      const result = hasToolSearchInCurrentTurn(messages);
-
-      expect(result).toBe(false);
-    });
-
-    it('returns false when no AI parent found', () => {
-      const messages: BaseMessage[] = [
-        new HumanMessage('Hello'),
-        new ToolMessage({
-          content: 'Result',
-          tool_call_id: 'orphan',
-          name: Constants.TOOL_SEARCH,
-        }),
-      ];
-
-      const result = hasToolSearchInCurrentTurn(messages);
-
-      expect(result).toBe(false);
-    });
-
-    it('returns false when current turn has no tool search (only other tools)', () => {
-      const messages: BaseMessage[] = [
-        new HumanMessage('Get weather'),
-        createAIMessage('Getting weather...', [
-          { id: 'call_1', name: 'get_weather', args: { city: 'NYC' } },
-        ]),
-        createRegularToolMessage('call_1', 'get_weather', '{"temp": 72}'),
-      ];
-
-      const result = hasToolSearchInCurrentTurn(messages);
-
-      expect(result).toBe(false);
-    });
-
-    it('returns true even with mixed tool types in current turn', () => {
-      const messages: BaseMessage[] = [
-        new HumanMessage('Search and get weather'),
-        createAIMessage('Working...', [
-          {
-            id: 'search_call',
-            name: Constants.TOOL_SEARCH,
-            args: { pattern: 'test' },
-          },
-          { id: 'weather_call', name: 'get_weather', args: { city: 'NYC' } },
-        ]),
-        createRegularToolMessage('weather_call', 'get_weather', '{"temp": 72}'),
-        createToolSearchResult('search_call', ['found_tool']),
-      ];
-
-      const result = hasToolSearchInCurrentTurn(messages);
-
-      expect(result).toBe(true);
-    });
-
-    it('returns false for tool search from previous turn', () => {
-      const messages: BaseMessage[] = [
-        // Previous turn with search
-        createAIMessage('Searching...', [
-          {
-            id: 'old_call',
-            name: Constants.TOOL_SEARCH,
-            args: { pattern: 'old' },
-          },
-        ]),
-        createToolSearchResult('old_call', ['old_tool']),
-        // Current turn without search
-        new HumanMessage('Get weather now'),
-        createAIMessage('Getting weather...', [
-          { id: 'weather_call', name: 'get_weather', args: { city: 'NYC' } },
-        ]),
-        createRegularToolMessage('weather_call', 'get_weather', '{"temp": 72}'),
-      ];
-
-      const result = hasToolSearchInCurrentTurn(messages);
-
-      expect(result).toBe(false);
-    });
-  });
-
-  describe('Integration: extractToolDiscoveries + hasToolSearchInCurrentTurn', () => {
-    it('hasToolSearchInCurrentTurn is true when extractToolDiscoveries returns results', () => {
-      const messages: BaseMessage[] = [
-        new HumanMessage('Search'),
-        createAIMessage('Searching...', [
-          {
-            id: 'call_1',
-            name: Constants.TOOL_SEARCH,
-            args: { pattern: 'test' },
-          },
-        ]),
-        createToolSearchResult('call_1', ['tool_a', 'tool_b']),
-      ];
-
-      const hasSearch = hasToolSearchInCurrentTurn(messages);
-      const discoveries = extractToolDiscoveries(messages);
-
-      expect(hasSearch).toBe(true);
-      expect(discoveries.length).toBeGreaterThan(0);
-    });
-
-    it('both return empty/false for non-search turns', () => {
-      const messages: BaseMessage[] = [
-        new HumanMessage('Get weather'),
-        createAIMessage('Getting...', [
-          { id: 'call_1', name: 'get_weather', args: { city: 'NYC' } },
-        ]),
-        createRegularToolMessage('call_1', 'get_weather', '{"temp": 72}'),
-      ];
-
-      const hasSearch = hasToolSearchInCurrentTurn(messages);
-      const discoveries = extractToolDiscoveries(messages);
-
-      expect(hasSearch).toBe(false);
-      expect(discoveries).toEqual([]);
-    });
-
-    it('hasToolSearchInCurrentTurn can be used as quick check before extraction', () => {
-      const messagesWithSearch: BaseMessage[] = [
-        new HumanMessage('Search'),
-        createAIMessage('Searching...', [
-          {
-            id: 'call_1',
-            name: Constants.TOOL_SEARCH,
-            args: { pattern: 'test' },
-          },
-        ]),
-        createToolSearchResult('call_1', ['tool_a']),
-      ];
-
-      const messagesWithoutSearch: BaseMessage[] = [
-        new HumanMessage('Hello'),
-        createAIMessage('Hi!', []),
-      ];
-
-      // Pattern: quick check first, then extract only if needed
-      if (hasToolSearchInCurrentTurn(messagesWithSearch)) {
-        const discoveries = extractToolDiscoveries(messagesWithSearch);
-        expect(discoveries).toEqual(['tool_a']);
-      }
-
-      if (hasToolSearchInCurrentTurn(messagesWithoutSearch)) {
-        // This should not execute
-        expect(true).toBe(false);
-      }
-    });
-  });
-});

package/src/messages/alternation.test.ts

@@ -1,212 +0,0 @@
-import { AIMessage, HumanMessage } from '@langchain/core/messages';
-import { Providers } from '@/common';
-import {
-  coalesceAdjacentUserTurns,
-  strictAlternationProviders,
-} from './alternation';
-
-describe('strictAlternationProviders', () => {
-  it('covers the providers that reject consecutive user turns', () => {
-    expect(strictAlternationProviders.has(Providers.BEDROCK)).toBe(true);
-    expect(strictAlternationProviders.has(Providers.MISTRAL)).toBe(true);
-    expect(strictAlternationProviders.has(Providers.MISTRALAI)).toBe(true);
-  });
-
-  it('leaves providers that accept them alone', () => {
-    expect(strictAlternationProviders.has(Providers.ANTHROPIC)).toBe(false);
-    expect(strictAlternationProviders.has(Providers.OPENAI)).toBe(false);
-    expect(strictAlternationProviders.has(Providers.GOOGLE)).toBe(false);
-  });
-});
-
-describe('coalesceAdjacentUserTurns', () => {
-  it('leaves an already-alternating run untouched, returning the SAME array', () => {
-    const messages = [
-      new HumanMessage({ content: 'question' }),
-      new AIMessage({ content: 'answer' }),
-      new HumanMessage({ content: 'follow-up' }),
-    ];
-    const result = coalesceAdjacentUserTurns(messages);
-    /**
-     * Identity, not just equality: the pass runs twice for a primary
-     * Bedrock/Mistral call (createCallModel, then the attemptInvoke funnel),
-     * so the normalized second pass must not reallocate a context-sized
-     * array — and origin tracking early-exits on `before === after`.
-     */
-    expect(result).toBe(messages);
-  });
-
-  it('is idempotent by identity: re-coalescing merged output is a no-op', () => {
-    const once = coalesceAdjacentUserTurns([
-      new HumanMessage({ content: 'steer 1' }),
-      new HumanMessage({ content: 'steer 2' }),
-    ]);
-    expect(once).toHaveLength(1);
-    expect(coalesceAdjacentUserTurns(once)).toBe(once);
-  });
-
-  /** A boundary that drains two steers, which is the ordinary queue case. */
-  it('merges a run of consecutive human turns', () => {
-    const result = coalesceAdjacentUserTurns([
-      new HumanMessage({ content: 'question' }),
-      new AIMessage({ content: 'partial' }),
-      new HumanMessage({ content: 'steer 1' }),
-      new HumanMessage({ content: 'steer 2' }),
-    ]);
-    expect(result.map((m) => m.getType())).toEqual(['human', 'ai', 'human']);
-    expect(result[2].content).toBe('steer 1\n\nsteer 2');
-  });
-
-  it('merges context plus injected messages into one turn', () => {
-    const result = coalesceAdjacentUserTurns([
-      new AIMessage({ content: 'partial' }),
-      new HumanMessage({
-        content: 'hook context',
-        additional_kwargs: { role: 'system', source: 'hook' },
-      }),
-      new HumanMessage({
-        content: 'steer',
-        additional_kwargs: { role: 'user', source: 'steer' },
-      }),
-    ]);
-    expect(result).toHaveLength(2);
-    expect(result[1].content).toBe('hook context\n\nsteer');
-  });
-
-  it('concatenates block content rather than stringifying it', () => {
-    const result = coalesceAdjacentUserTurns([
-      new HumanMessage({ content: [{ type: 'text', text: 'look' }] }),
-      new HumanMessage({
-        content: [{ type: 'image_url', image_url: { url: 'data:,' } }],
-      }),
-    ]);
-    expect(result).toHaveLength(1);
-    expect(result[0].content).toEqual([
-      { type: 'text', text: 'look' },
-      { type: 'image_url', image_url: { url: 'data:,' } },
-    ]);
-  });
-
-  it('normalizes a mixed string and block pair', () => {
-    const result = coalesceAdjacentUserTurns([
-      new HumanMessage({ content: 'plain' }),
-      new HumanMessage({ content: [{ type: 'text', text: 'blocks' }] }),
-    ]);
-    expect(result).toHaveLength(1);
-    expect(result[0].content).toEqual([
-      { type: 'text', text: 'plain' },
-      { type: 'text', text: 'blocks' },
-    ]);
-  });
-
-  /**
-   * Both vendored converters merge adjacent tool-result runs themselves, and
-   * folding one into a text turn would orphan the pairing.
-   */
-  it('never merges tool-result turns', () => {
-    const result = coalesceAdjacentUserTurns([
-      new HumanMessage({
-        content: [{ type: 'tool_result', tool_use_id: 't1', content: 'ok' }],
-      }),
-      new HumanMessage({
-        content: [{ type: 'tool_result', tool_use_id: 't2', content: 'ok' }],
-      }),
-    ]);
-    expect(result).toHaveLength(2);
-  });
-
-  it('never merges a tool-result turn into a text turn', () => {
-    const result = coalesceAdjacentUserTurns([
-      new HumanMessage({
-        content: [{ type: 'tool_result', tool_use_id: 't1', content: 'ok' }],
-      }),
-      new HumanMessage({ content: 'steer' }),
-    ]);
-    expect(result).toHaveLength(2);
-  });
-
-  /**
-   * The prompt-cache tail anchor reasons positionally — it inserts the
-   * breakpoint after the merged message's LAST text block — so the last
-   * part's provenance flags must survive the merge. A skill body absorbed
-   * into a real user turn stays anchorable; a real turn absorbed into a
-   * trailing skill body must not let the anchor pin the volatile body.
-   */
-  it('keeps the last turn\'s additional_kwargs and the first turn\'s id', () => {
-    const result = coalesceAdjacentUserTurns([
-      new HumanMessage({
-        content: 'skill body',
-        id: 'first-id',
-        additional_kwargs: { isMeta: true, source: 'skill' },
-      }),
-      new HumanMessage({
-        content: 'real user turn',
-        id: 'second-id',
-        additional_kwargs: { role: 'user' },
-      }),
-    ]);
-    expect(result).toHaveLength(1);
-    expect(result[0].additional_kwargs).toEqual({ role: 'user' });
-    expect(result[0].id).toBe('first-id');
-  });
-
-  it('marks the merge meta when the trailing part is the volatile one', () => {
-    const result = coalesceAdjacentUserTurns([
-      new HumanMessage({
-        content: 'real steer',
-        additional_kwargs: { source: 'steer' },
-      }),
-      new HumanMessage({
-        content: 'skill body',
-        additional_kwargs: { isMeta: true, source: 'skill', skillName: 'x' },
-      }),
-    ]);
-    expect(result).toHaveLength(1);
-    expect(result[0].additional_kwargs.source).toBe('skill');
-    expect(result[0].additional_kwargs.isMeta).toBe(true);
-  });
-
-  /**
-   * Only ALL-tool-result turns are excluded. A mixed turn is an ordinary
-   * user turn that happens to carry a result block — merging preserves block
-   * order, so the pairing survives, and excluding it would leave adjacent
-   * user turns on the wire for exactly the shape Bedrock rejects.
-   */
-  it('merges a mixed text plus tool-result turn', () => {
-    const result = coalesceAdjacentUserTurns([
-      new HumanMessage({
-        content: [
-          { type: 'tool_result', tool_use_id: 't1', content: 'ok' },
-          { type: 'text', text: 'and my comment' },
-        ],
-      }),
-      new HumanMessage({ content: 'next turn' }),
-    ]);
-    expect(result).toHaveLength(1);
-    expect(result[0].content).toEqual([
-      { type: 'tool_result', tool_use_id: 't1', content: 'ok' },
-      { type: 'text', text: 'and my comment' },
-      { type: 'text', text: 'next turn' },
-    ]);
-  });
-
-  it('excludes the camelCase toolResult variant too', () => {
-    const result = coalesceAdjacentUserTurns([
-      new HumanMessage({
-        content: [{ type: 'toolResult', toolResult: { content: 'ok' } }],
-      }),
-      new HumanMessage({ content: 'steer' }),
-    ]);
-    expect(result).toHaveLength(2);
-  });
-
-  it('does not mutate the input array or its messages', () => {
-    const first = new HumanMessage({ content: 'a' });
-    const second = new HumanMessage({ content: 'b' });
-    const messages = [first, second];
-    coalesceAdjacentUserTurns(messages);
-    expect(messages).toHaveLength(2);
-    expect(first.content).toBe('a');
-    expect(second.content).toBe('b');
-  });
-});