@librechat/agents 3.4.7 → 3.5.0

package/src/llm/mistral/streamSmoothing.test.ts

@@ -1,97 +0,0 @@
-import { expect, test, describe, jest, afterEach } from '@jest/globals';
-import { AIMessageChunk, HumanMessage } from '@langchain/core/messages';
-import { ChatGenerationChunk } from '@langchain/core/outputs';
-import { ChatMistralAI } from '@langchain/mistralai';
-import type { CallbackManagerForLLMRun } from '@langchain/core/callbacks/manager';
-import { CustomChatMistralAI } from './index';
-
-describe('Mistral stream smoothing', () => {
-  afterEach(() => {
-    jest.restoreAllMocks();
-  });
-
-  function stubParentStream(texts: string[]): void {
-    jest
-      .spyOn(
-        ChatMistralAI.prototype as unknown as {
-          _streamResponseChunks: (
-            ...args: unknown[]
-          ) => AsyncGenerator<ChatGenerationChunk>;
-        },
-        '_streamResponseChunks'
-      )
-      .mockImplementation(async function* () {
-        for (const text of texts) {
-          yield new ChatGenerationChunk({
-            text,
-            message: new AIMessageChunk({ content: text }),
-          });
-        }
-      });
-  }
-
-  async function collect(
-    model: CustomChatMistralAI,
-    runManager?: CallbackManagerForLLMRun
-  ): Promise<string[]> {
-    const texts: string[] = [];
-    for await (const chunk of model._streamResponseChunks(
-      [new HumanMessage('hi')],
-      {} as Parameters<CustomChatMistralAI['_streamResponseChunks']>[1],
-      runManager
-    )) {
-      if (chunk.text) {
-        texts.push(chunk.text);
-      }
-    }
-    return texts;
-  }
-
-  test('splits large text chunks at stream boundaries with pacing', async () => {
-    stubParentStream(['alpha beta gamma']);
-    const model = new CustomChatMistralAI({
-      model: 'mistral-large-latest',
-      apiKey: 'test-key',
-      _lc_stream_delay: 1,
-    });
-
-    const dispatchedTokens: string[] = [];
-    const runManager = {
-      handleLLMNewToken: jest.fn(async (token: string) => {
-        dispatchedTokens.push(token);
-      }),
-    } as unknown as CallbackManagerForLLMRun;
-
-    expect(await collect(model, runManager)).toEqual([
-      'alpha ',
-      'beta ',
-      'gamma',
-    ]);
-    expect(dispatchedTokens.filter(Boolean)).toEqual([
-      'alpha ',
-      'beta ',
-      'gamma',
-    ]);
-  });
-
-  test('passes chunks through unsplit when smoothing is disabled', async () => {
-    stubParentStream(['alpha beta gamma']);
-    const model = new CustomChatMistralAI({
-      model: 'mistral-large-latest',
-      apiKey: 'test-key',
-      _lc_stream_delay: 0,
-    });
-
-    expect(await collect(model)).toEqual(['alpha beta gamma']);
-  });
-
-  test('defaults to 25ms adaptive smoothing with 0 disabling', () => {
-    const base = { model: 'mistral-large-latest', apiKey: 'test-key' };
-    expect(new CustomChatMistralAI(base)._lc_stream_delay).toBe(25);
-    expect(
-      new CustomChatMistralAI({ ...base, _lc_stream_delay: 0 })
-        ._lc_stream_delay
-    ).toBe(0);
-    expect(CustomChatMistralAI.lc_name()).toBe('LibreChatMistralAI');
-  });
-});

package/src/llm/openai/cacheWriteTokens.test.ts

@@ -1,112 +0,0 @@
-import { AIMessage } from '@langchain/core/messages';
-import type { OpenAIClient } from '@langchain/openai';
-
-import {
-  getCacheWriteTokens,
-  attachCacheWriteUsage,
-  attachCacheWriteMetadata,
-} from './index';
-
-/**
- * Regression coverage for a crash reported against OpenAI-compatible
- * third-party servers (e.g. mlx_vlm.server) whose `/v1/responses` usage
- * payload omits `input_tokens_details` entirely — a shape the OpenAI API
- * itself always populates, but which `ResponsesUsageWithCacheWrite`
- * declares optional. Reading `.cache_write_tokens` off that missing object
- * without a second `?.` threw "Cannot read properties of undefined
- * (reading 'cache_write_tokens')" on every completion from such a server.
- */
-describe('cache write token extraction (Responses API)', () => {
-  describe('getCacheWriteTokens', () => {
-    it('returns undefined without throwing when usage has no input_tokens_details', () => {
-      const message = new AIMessage({
-        content: 'hi',
-        response_metadata: {
-          usage: {
-            input_tokens: 10,
-            output_tokens: 2,
-            total_tokens: 12,
-            // input_tokens_details intentionally omitted, mirroring a
-            // minimal OpenAI-compatible server's usage payload.
-          },
-        },
-      });
-
-      expect(() => getCacheWriteTokens(message)).not.toThrow();
-      expect(getCacheWriteTokens(message)).toBeUndefined();
-    });
-
-    it('returns undefined without throwing when there is no usage at all', () => {
-      const message = new AIMessage({
-        content: 'hi',
-        response_metadata: {},
-      });
-
-      expect(() => getCacheWriteTokens(message)).not.toThrow();
-      expect(getCacheWriteTokens(message)).toBeUndefined();
-    });
-
-    it('still reports cache_write_tokens when the field is present', () => {
-      const message = new AIMessage({
-        content: 'hi',
-        response_metadata: {
-          usage: {
-            input_tokens: 10,
-            output_tokens: 2,
-            total_tokens: 12,
-            input_tokens_details: { cache_write_tokens: 5 },
-          },
-        },
-      });
-
-      expect(getCacheWriteTokens(message)).toBe(5);
-    });
-
-    it('falls back to the serialized metadata key when usage is absent', () => {
-      const message = new AIMessage({
-        content: 'hi',
-        response_metadata: {
-          metadata: { __librechat_cache_write_tokens: '7' },
-        },
-      });
-
-      expect(getCacheWriteTokens(message)).toBe(7);
-    });
-  });
-
-  describe('attachCacheWriteUsage', () => {
-    it('leaves usage_metadata untouched without throwing when input_tokens_details is missing', () => {
-      const message = new AIMessage({
-        content: 'hi',
-        response_metadata: {
-          usage: { input_tokens: 10, output_tokens: 2, total_tokens: 12 },
-        },
-        usage_metadata: {
-          input_tokens: 10,
-          output_tokens: 2,
-          total_tokens: 12,
-        },
-      });
-
-      expect(() => attachCacheWriteUsage(message)).not.toThrow();
-      expect(message.usage_metadata?.input_token_details).toBeUndefined();
-    });
-  });
-
-  describe('attachCacheWriteMetadata', () => {
-    it('returns the response unmodified without throwing when input_tokens_details is missing', () => {
-      const response = {
-        usage: { input_tokens: 10, output_tokens: 2, total_tokens: 12 },
-      } as OpenAIClient.Responses.Response;
-
-      expect(() => attachCacheWriteMetadata(response)).not.toThrow();
-      expect(attachCacheWriteMetadata(response)).toBe(response);
-    });
-
-    it('returns the response unmodified without throwing when usage is missing entirely', () => {
-      const response = {} as OpenAIClient.Responses.Response;
-
-      expect(() => attachCacheWriteMetadata(response)).not.toThrow();
-    });
-  });
-});

package/src/llm/openai/contentBlocks.test.ts

@@ -1,381 +0,0 @@
-import { describe, expect, test } from '@jest/globals';
-import {
-  AIMessage,
-  AIMessageChunk,
-  type ContentBlock,
-} from '@langchain/core/messages';
-import {
-  STREAMED_TOOL_CALL_SEAL_METADATA_KEY,
-  STREAMED_TOOL_CALL_ADAPTER_METADATA_KEY,
-  OPENAI_RESPONSES_STREAMED_TOOL_CALL_ADAPTER,
-} from '@/tools/streamedToolCallSeals';
-import { _convertOpenAIResponsesDeltaToBaseMessageChunk } from './utils';
-
-describe('OpenAI content block translator compatibility', () => {
-  describe('Chat Completions', () => {
-    test('translates string content and tool calls to v1 content blocks', () => {
-      const message = new AIMessage({
-        content: 'Hello from OpenAI',
-        tool_calls: [
-          {
-            id: 'call_123',
-            name: 'get_weather',
-            args: { location: 'San Francisco' },
-          },
-        ],
-        response_metadata: { model_provider: 'openai' },
-      });
-
-      const expected: Array<ContentBlock.Standard> = [
-        { type: 'text', text: 'Hello from OpenAI' },
-        {
-          type: 'tool_call',
-          id: 'call_123',
-          name: 'get_weather',
-          args: { location: 'San Francisco' },
-        },
-      ];
-
-      expect(message.contentBlocks).toEqual(expected);
-      expect(message.content).not.toEqual(expected);
-
-      const v1Message = new AIMessage({
-        content: message.contentBlocks,
-        response_metadata: { output_version: 'v1' },
-      });
-      expect(v1Message.contentBlocks).toEqual(expected);
-      expect(v1Message.content).toEqual(expected);
-    });
-
-    test('does not include empty text block when content is empty string with tool calls', () => {
-      const message = new AIMessage({
-        content: '',
-        tool_calls: [
-          {
-            id: 'call_123',
-            name: 'get_value',
-            args: { key: 'a' },
-          },
-          {
-            id: 'call_456',
-            name: 'get_value',
-            args: { key: 'b' },
-          },
-        ],
-        response_metadata: { model_provider: 'openai' },
-      });
-
-      expect(message.contentBlocks).toEqual([
-        {
-          type: 'tool_call',
-          id: 'call_123',
-          name: 'get_value',
-          args: { key: 'a' },
-        },
-        {
-          type: 'tool_call',
-          id: 'call_456',
-          name: 'get_value',
-          args: { key: 'b' },
-        },
-      ]);
-    });
-
-    test('translates chat completion chunks with parsed tool call chunks', () => {
-      const chunk1 = new AIMessageChunk({
-        content: [{ type: 'text', text: 'Looking ', index: 0 }],
-        response_metadata: { model_provider: 'openai' },
-      });
-      const chunk2 = new AIMessageChunk({
-        content: [{ type: 'text', text: 'up.', index: 0 }],
-        tool_call_chunks: [
-          {
-            type: 'tool_call_chunk',
-            id: 'call_abc',
-            name: 'search',
-            args: '{"query":"weather"}',
-            index: 0,
-          },
-        ],
-        response_metadata: { model_provider: 'openai' },
-      });
-
-      expect(chunk1.concat(chunk2).contentBlocks).toEqual([
-        { type: 'text', text: 'Looking up.', index: 0 },
-        {
-          type: 'tool_call',
-          id: 'call_abc',
-          name: 'search',
-          args: { query: 'weather' },
-        },
-      ]);
-    });
-  });
-
-  describe('Responses', () => {
-    test('marks Responses function call arguments done as an explicit tool-call seal', () => {
-      const chunk = _convertOpenAIResponsesDeltaToBaseMessageChunk({
-        type: 'response.function_call_arguments.done',
-        sequence_number: 3,
-        item_id: 'fc_123',
-        output_index: 1,
-        name: 'search',
-        arguments: '{"query":"weather"}',
-      } as Parameters<typeof _convertOpenAIResponsesDeltaToBaseMessageChunk>[0]);
-      const message = chunk?.message as AIMessageChunk | undefined;
-
-      expect(message?.tool_call_chunks).toEqual([
-        {
-          type: 'tool_call_chunk',
-          name: 'search',
-          args: '{"query":"weather"}',
-          index: 1,
-        },
-      ]);
-      expect(message?.response_metadata).toMatchObject({
-        [STREAMED_TOOL_CALL_ADAPTER_METADATA_KEY]:
-          OPENAI_RESPONSES_STREAMED_TOOL_CALL_ADAPTER,
-        [STREAMED_TOOL_CALL_SEAL_METADATA_KEY]: {
-          kind: 'single',
-          index: 1,
-        },
-      });
-    });
-
-    test('translates Responses messages to v1 content blocks', () => {
-      const code = ['print(', 'hello', ')'].join(String.fromCharCode(39));
-      const responseTextBlock = {
-        type: 'text',
-        text: 'Here is a result.',
-        annotations: [
-          {
-            type: 'url_citation',
-            url: 'https://example.com',
-            title: 'Example',
-            start_index: 0,
-            end_index: 4,
-          },
-          {
-            type: 'file_citation',
-            file_id: 'file_123',
-            filename: 'doc.pdf',
-            index: 10,
-          },
-        ],
-      } as ContentBlock.Text;
-      const message = new AIMessage({
-        content: [responseTextBlock],
-        tool_calls: [
-          { id: 'call_456', name: 'summarize', args: { length: 'short' } },
-        ],
-        additional_kwargs: {
-          reasoning: { summary: [{ text: 'Thinking...' }, { text: ' Done.' }] },
-          tool_outputs: [
-            {
-              id: 'call_456',
-              type: 'code_interpreter_call',
-              code,
-              status: 'completed',
-              outputs: [{ type: 'logs', logs: 'hello' }],
-            },
-          ],
-        },
-        response_metadata: { model_provider: 'openai' },
-      });
-
-      const expected: Array<ContentBlock.Standard> = [
-        { type: 'reasoning', reasoning: 'Thinking... Done.' },
-        {
-          type: 'text',
-          text: 'Here is a result.',
-          annotations: [
-            {
-              type: 'citation',
-              url: 'https://example.com',
-              title: 'Example',
-              startIndex: 0,
-              endIndex: 4,
-            },
-            {
-              type: 'citation',
-              title: 'doc.pdf',
-              startIndex: 10,
-              endIndex: 10,
-              fileId: 'file_123',
-            },
-          ],
-        },
-        {
-          type: 'tool_call',
-          id: 'call_456',
-          name: 'summarize',
-          args: { length: 'short' },
-        },
-        {
-          type: 'server_tool_call',
-          name: 'code_interpreter',
-          id: 'call_456',
-          args: { code },
-        },
-        {
-          type: 'server_tool_call_result',
-          toolCallId: 'call_456',
-          status: 'success',
-          output: {
-            type: 'code_interpreter_output',
-            returnCode: 0,
-            stderr: undefined,
-            stdout: 'hello',
-          },
-        },
-      ];
-
-      expect(message.contentBlocks).toEqual(expected);
-
-      const v1Message = new AIMessage({
-        content: message.contentBlocks,
-        response_metadata: { output_version: 'v1' },
-      });
-      expect(v1Message.contentBlocks).toEqual(expected);
-      expect(v1Message.content).toEqual(expected);
-    });
-
-    test('translates image_generation_call to image content block', () => {
-      const message = new AIMessage({
-        content: [{ type: 'text', text: 'Here is your image:' }],
-        additional_kwargs: {
-          tool_outputs: [
-            {
-              type: 'image_generation_call',
-              id: 'ig_abc123',
-              status: 'completed',
-              result: 'base64ImageData',
-              revised_prompt: 'A beautiful sunset over the ocean',
-            },
-          ],
-        },
-        response_metadata: { model_provider: 'openai' },
-      });
-
-      expect(message.contentBlocks).toEqual([
-        { type: 'text', text: 'Here is your image:' },
-        {
-          type: 'image',
-          mimeType: 'image/png',
-          data: 'base64ImageData',
-          id: 'ig_abc123',
-          metadata: {
-            status: 'completed',
-          },
-        },
-        {
-          type: 'non_standard',
-          value: {
-            type: 'image_generation_call',
-            id: 'ig_abc123',
-            status: 'completed',
-            result: 'base64ImageData',
-            revised_prompt: 'A beautiful sunset over the ocean',
-          },
-        },
-      ]);
-    });
-
-    test('translates web_search_call and file_search_call to server tool blocks', () => {
-      const message = new AIMessage({
-        content: [{ type: 'text', text: 'Search results:' }],
-        additional_kwargs: {
-          tool_outputs: [
-            {
-              type: 'web_search_call',
-              id: 'ws_abc456',
-              status: 'completed',
-              action: {
-                type: 'search',
-                query: 'melbourne australia news today',
-                sources: [{ type: 'url', url: 'https://example.com/news' }],
-              },
-            },
-            {
-              type: 'file_search_call',
-              id: 'fs_abc123',
-              status: 'completed',
-              queries: ['quarterly report', 'revenue 2025'],
-              results: [
-                {
-                  file_id: 'file_001',
-                  filename: 'report.pdf',
-                  score: 0.95,
-                  text: 'Revenue grew 15% in Q3...',
-                },
-              ],
-            },
-          ],
-        },
-        response_metadata: { model_provider: 'openai' },
-      });
-
-      expect(message.contentBlocks).toEqual([
-        { type: 'text', text: 'Search results:' },
-        {
-          type: 'server_tool_call',
-          name: 'web_search',
-          id: 'ws_abc456',
-          args: { query: 'melbourne australia news today' },
-        },
-        {
-          type: 'server_tool_call_result',
-          toolCallId: 'ws_abc456',
-          status: 'success',
-          output: {
-            action: {
-              type: 'search',
-              query: 'melbourne australia news today',
-              sources: [{ type: 'url', url: 'https://example.com/news' }],
-            },
-          },
-        },
-        {
-          type: 'server_tool_call',
-          name: 'file_search',
-          id: 'fs_abc123',
-          args: { queries: ['quarterly report', 'revenue 2025'] },
-        },
-        {
-          type: 'server_tool_call_result',
-          toolCallId: 'fs_abc123',
-          status: 'success',
-          output: {
-            results: [
-              {
-                file_id: 'file_001',
-                filename: 'report.pdf',
-                score: 0.95,
-                text: 'Revenue grew 15% in Q3...',
-              },
-            ],
-          },
-        },
-      ]);
-    });
-
-    test('moves phase into extras on text content blocks', () => {
-      const textBlock = {
-        type: 'text',
-        text: 'The weather is sunny.',
-        annotations: [],
-        phase: 'final_answer',
-      } as ContentBlock.Text & { phase: string };
-      const message = new AIMessage({
-        content: [textBlock],
-        response_metadata: { model_provider: 'openai' },
-      });
-
-      const contentTextBlock = message.contentBlocks.find(
-        (block): block is ContentBlock.Text => block.type === 'text'
-      );
-      expect(contentTextBlock).toBeDefined();
-      expect(contentTextBlock?.extras).toEqual({ phase: 'final_answer' });
-    });
-  });
-});