@librechat/agents 3.1.85 → 3.1.87

package/src/llm/custom-chat-models.smoke.test.ts

@@ -3,13 +3,15 @@ import {
   AIMessageChunk,
   HumanMessage,
 } from '@langchain/core/messages';
+import type { CallbackManagerForLLMRun } from '@langchain/core/callbacks/manager';
 import type { OpenAIChatInput, OpenAIClient } from '@langchain/openai';
-import type { ChatOpenRouterCallOptions } from '@/llm/openrouter';
-import type { CustomAnthropicInput } from '@/llm/anthropic';
+import type { ChatGenerationChunk } from '@langchain/core/outputs';
 import type {
   ChatAnthropicToolType,
   AnthropicMCPServerURLDefinition,
 } from '@/llm/anthropic/types';
+import type { ChatOpenRouterCallOptions } from '@/llm/openrouter';
+import type { CustomAnthropicInput } from '@/llm/anthropic';
 import {
   ChatXAI,
   ChatOpenAI,
@@ -80,6 +82,19 @@ type OpenAIStreamEvent = {
 type OpenAIStreamItem =
   | OpenAIClient.Chat.Completions.ChatCompletionChunk
   | OpenAIStreamEvent;
+type FetchOutcome = 'resolved' | 'rejected' | 'pending';
+type AbortableFetchCapture = {
+  fetch: typeof fetch;
+  getSignal: () => AbortSignal | undefined;
+};
+type FetchTimeoutClient = {
+  fetchWithTimeout: (
+    url: RequestInfo,
+    init: RequestInit | undefined,
+    ms: number,
+    controller: AbortController
+  ) => Promise<Response>;
+};
 type MockableCompletionCreate = (
   request: unknown,
   options?: unknown
@@ -133,6 +148,18 @@ type CompletionUsageWithCacheWrite = Omit<
 };
 type OpenAIStreamModel = ChatOpenAI | AzureChatOpenAI;
 
+class CallbackTestChatOpenRouter extends ChatOpenRouter {
+  streamChunksWithCallbacks(
+    runManager?: CallbackManagerForLLMRun
+  ): AsyncGenerator<ChatGenerationChunk> {
+    return this._streamResponseChunks(
+      [new HumanMessage('hi')],
+      {} as this['ParsedCallOptions'],
+      runManager
+    );
+  }
+}
+
 const baseAzureFields = {
   azureOpenAIApiKey: 'test-azure-key',
   azureOpenAIApiVersion: '2024-10-21',
@@ -140,6 +167,55 @@ const baseAzureFields = {
   azureOpenAIApiDeploymentName: 'test-deployment',
 };
 
+const waitForFetchOutcome = (
+  promise: Promise<Response>,
+  timeoutMs = 100
+): Promise<FetchOutcome> =>
+  Promise.race([
+    promise.then(
+      () => 'resolved' as const,
+      () => 'rejected' as const
+    ),
+    new Promise<'pending'>((resolve) => {
+      setTimeout(() => resolve('pending'), timeoutMs);
+    }),
+  ]);
+
+const createAbortableFetch = (): AbortableFetchCapture => {
+  let requestSignal: AbortSignal | undefined;
+  return {
+    fetch: async (_url, init): Promise<Response> =>
+      new Promise<Response>((_resolve, reject) => {
+        requestSignal = init?.signal ?? undefined;
+        requestSignal?.addEventListener(
+          'abort',
+          () => reject(new Error('Aborted')),
+          { once: true }
+        );
+      }),
+    getSignal: () => requestSignal,
+  };
+};
+
+const expectFetchTimeoutAbort = async (
+  client: FetchTimeoutClient,
+  capturedFetch: AbortableFetchCapture,
+  url: string
+): Promise<void> => {
+  const controller = new AbortController();
+
+  const response = client.fetchWithTimeout(
+    url,
+    { method: 'post' },
+    10,
+    controller
+  );
+
+  await expect(waitForFetchOutcome(response)).resolves.toBe('rejected');
+  expect(controller.signal.aborted).toBe(true);
+  expect(capturedFetch.getSignal()?.aborted).toBe(true);
+};
+
 const baseBedrockFields = {
   region: 'us-east-1',
   credentials: {
@@ -711,8 +787,7 @@ describe('custom chat model class smoke tests', () => {
     }
 
     const usageChunk = chunks.find(
-      (chunk) =>
-        chunk.usage_metadata?.input_token_details?.cache_creation === 5
+      (chunk) => chunk.usage_metadata?.input_token_details?.cache_creation === 5
     );
     expect(usageChunk?.usage_metadata).toEqual({
       input_tokens: 11,
@@ -730,6 +805,44 @@ describe('custom chat model class smoke tests', () => {
     });
   });
 
+  it('emits OpenRouter callbacks before an early stream break', async () => {
+    const model = new CallbackTestChatOpenRouter({
+      model: 'openai/gpt-4o-mini',
+      apiKey: 'test-key',
+      _lc_stream_delay: 1,
+    } as OpenRouterFields & { _lc_stream_delay: number });
+    const completions = (model as unknown as StreamingCompletionBackedModel)
+      .completions;
+    const textChunks: string[] = [];
+    const callbackTokens: string[] = [];
+
+    async function* streamChunks(): AsyncGenerator<OpenAIClient.Chat.Completions.ChatCompletionChunk> {
+      yield createOpenAIStreamChunk('alpha beta gamma');
+    }
+
+    completions.completionWithRetry = async (): Promise<
+      AsyncIterable<OpenAIClient.Chat.Completions.ChatCompletionChunk>
+    > => streamChunks();
+
+    const runManager = {
+      handleLLMNewToken(token: string): void {
+        if (token !== '') {
+          callbackTokens.push(token);
+        }
+      },
+    } as unknown as CallbackManagerForLLMRun;
+
+    for await (const chunk of model.streamChunksWithCallbacks(runManager)) {
+      if (chunk.text !== '') {
+        textChunks.push(chunk.text);
+      }
+      break;
+    }
+
+    expect(textChunks).toEqual(['alpha beta gamma']);
+    expect(callbackTokens).toEqual(textChunks);
+  });
+
   it('keeps Anthropic output, residency, compaction, and stream-delay options', () => {
     const contextManagement = {
       edits: [
@@ -748,6 +861,10 @@ describe('custom chat model class smoke tests', () => {
       contextManagement,
       _lc_stream_delay: 8,
     });
+    const defaultModel = new CustomAnthropic({
+      model: 'claude-sonnet-4-5-20250929',
+      apiKey: 'test-key',
+    });
 
     const params = model.invocationParams({
       outputConfig: { effort: 'low' },
@@ -756,6 +873,7 @@ describe('custom chat model class smoke tests', () => {
 
     expect(CustomAnthropic.lc_name()).toBe('LibreChatAnthropic');
     expect(model._lc_stream_delay).toBe(8);
+    expect(defaultModel._lc_stream_delay).toBe(25);
     expect(params.output_config).toEqual({ effort: 'low' });
     expect(params.inference_geo).toBe('eu');
     expect(params.context_management).toEqual(contextManagement);
@@ -909,4 +1027,57 @@ describe('custom chat model class smoke tests', () => {
     expect(method).toBe('PATCH');
     expect(client.abortHandler).toBeDefined();
   });
+
+  it('aborts custom OpenAI fetches when the request timeout elapses', async () => {
+    const capturedFetch = createAbortableFetch();
+    const client = new CustomOpenAIClient({
+      apiKey: 'test-key',
+      fetch: capturedFetch.fetch,
+    });
+
+    await expectFetchTimeoutAbort(
+      client,
+      capturedFetch,
+      'https://example.test/v1/chat/completions'
+    );
+  });
+
+  it('aborts custom Azure OpenAI fetches when the request timeout elapses', async () => {
+    const capturedFetch = createAbortableFetch();
+    const client = new CustomAzureOpenAIClient({
+      apiKey: 'test-azure-key',
+      apiVersion: '2024-10-21',
+      baseURL: 'https://example.test/openai/deployments/test-deployment',
+      fetch: capturedFetch.fetch,
+    });
+
+    await expectFetchTimeoutAbort(
+      client,
+      capturedFetch,
+      'https://example.test/openai/deployments/test-deployment/chat/completions'
+    );
+  });
+
+  it('propagates caller abort signals to custom OpenAI fetches', async () => {
+    const capturedFetch = createAbortableFetch();
+    const client = new CustomOpenAIClient({
+      apiKey: 'test-key',
+      fetch: capturedFetch.fetch,
+    });
+    const callerController = new AbortController();
+    const requestController = new AbortController();
+
+    const response = client.fetchWithTimeout(
+      'https://example.test/v1/chat/completions',
+      { method: 'post', signal: callerController.signal },
+      1000,
+      requestController
+    );
+
+    callerController.abort();
+
+    await expect(waitForFetchOutcome(response)).resolves.toBe('rejected');
+    expect(requestController.signal.aborted).toBe(true);
+    expect(capturedFetch.getSignal()?.aborted).toBe(true);
+  });
 });

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

@@ -4,6 +4,12 @@ import {
   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', () => {
@@ -107,6 +113,35 @@ describe('OpenAI content block translator compatibility', () => {
   });
 
   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 = {

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

@@ -1,4 +1,5 @@
 import { AIMessage, HumanMessage, ToolMessage } from '@langchain/core/messages';
+import type { CallbackManagerForLLMRun } from '@langchain/core/callbacks/manager';
 import type { ChatGenerationChunk } from '@langchain/core/outputs';
 import type { BaseMessage } from '@langchain/core/messages';
 import type { OpenAIClient } from '@langchain/openai';
@@ -66,6 +67,16 @@ class CapturingChatDeepSeek extends ChatDeepSeek {
       signal,
     } as this['ParsedCallOptions']);
   }
+
+  streamChunksWithCallbacks(
+    runManager?: CallbackManagerForLLMRun
+  ): AsyncGenerator<ChatGenerationChunk> {
+    return this._streamResponseChunks(
+      [new HumanMessage('hi')],
+      {} as this['ParsedCallOptions'],
+      runManager
+    );
+  }
 }
 
 function createToolContextMessages(): BaseMessage[] {
@@ -111,7 +122,10 @@ function createCompletionStreamChunks(): OpenAIChatCompletionChunk[] {
   ];
 }
 
-function createContentChunk(content: string): OpenAIChatCompletionChunk {
+function createContentChunk(
+  content: string,
+  logprobs: OpenAIChatCompletionChunk['choices'][number]['logprobs'] = null
+): OpenAIChatCompletionChunk {
   return {
     id: 'chatcmpl-deepseek-test',
     object: 'chat.completion.chunk',
@@ -125,7 +139,7 @@ function createContentChunk(content: string): OpenAIChatCompletionChunk {
           content,
         },
         finish_reason: null,
-        logprobs: null,
+        logprobs,
       },
     ],
   };
@@ -489,4 +503,189 @@ describe('ChatDeepSeek', () => {
 
     await expect(iterator.next()).rejects.toThrow('AbortError');
   });
+
+  it('does not yield a delayed DeepSeek chunk after abort', async () => {
+    const controller = new AbortController();
+    const model = new CapturingChatDeepSeek(
+      {
+        apiKey: 'test-key',
+        model: 'deepseek-v4-pro',
+        streaming: true,
+        _lc_stream_delay: 1000,
+      },
+      [createContentChunk('first '), createContentChunk('second')]
+    );
+    const stream = model.streamChunksWithSignal(controller.signal);
+    const iterator = stream[Symbol.asyncIterator]();
+
+    await expect(iterator.next()).resolves.toEqual(
+      expect.objectContaining({
+        done: false,
+        value: expect.objectContaining({
+          text: 'first ',
+        }),
+      })
+    );
+
+    const delayedChunk = iterator.next();
+    await Promise.resolve();
+    controller.abort(new Error('AbortError: User aborted request.'));
+
+    await expect(delayedChunk).rejects.toThrow('AbortError');
+  });
+
+  it('splits large delayed DeepSeek text chunks', async () => {
+    const model = new CapturingChatDeepSeek(
+      {
+        apiKey: 'test-key',
+        model: 'deepseek-v4-pro',
+        streaming: true,
+        _lc_stream_delay: 1,
+      },
+      [createContentChunk('alpha beta gamma')]
+    );
+    const textChunks: string[] = [];
+
+    for await (const chunk of model.streamChunksWithSignal(
+      new AbortController().signal
+    )) {
+      if (chunk.text) {
+        textChunks.push(chunk.text);
+      }
+    }
+
+    expect(textChunks).toEqual(['alpha ', 'beta ', 'gamma']);
+  });
+
+  it('keeps delayed DeepSeek logprob chunks intact', async () => {
+    const logprobs = { content: [], refusal: null } as NonNullable<
+      OpenAIChatCompletionChunk['choices'][number]['logprobs']
+    >;
+    const model = new CapturingChatDeepSeek(
+      {
+        apiKey: 'test-key',
+        model: 'deepseek-v4-pro',
+        streaming: true,
+        logprobs: true,
+        _lc_stream_delay: 1,
+      },
+      [createContentChunk('alpha beta gamma', logprobs)]
+    );
+    const chunks: ChatGenerationChunk[] = [];
+
+    for await (const chunk of model.streamChunksWithSignal(
+      new AbortController().signal
+    )) {
+      if (chunk.text !== '') {
+        chunks.push(chunk);
+      }
+    }
+
+    expect(chunks.map((chunk) => chunk.text)).toEqual(['alpha beta gamma']);
+    expect(chunks[0].generationInfo?.logprobs).toBe(logprobs);
+  });
+
+  it('emits callbacks for split delayed DeepSeek text chunks', async () => {
+    const model = new CapturingChatDeepSeek(
+      {
+        apiKey: 'test-key',
+        model: 'deepseek-v4-pro',
+        streaming: true,
+        _lc_stream_delay: 1,
+      },
+      [createContentChunk('alpha beta gamma')]
+    );
+    const textChunks: string[] = [];
+    const callbackTokens: string[] = [];
+
+    const stream = await model.stream([new HumanMessage('hi')], {
+      callbacks: [
+        {
+          handleLLMNewToken(token: string): void {
+            if (token !== '') {
+              callbackTokens.push(token);
+            }
+          },
+        },
+      ],
+    });
+
+    for await (const chunk of stream) {
+      if (typeof chunk.content === 'string' && chunk.content !== '') {
+        textChunks.push(chunk.content);
+      }
+    }
+
+    expect(textChunks).toEqual(['alpha ', 'beta ', 'gamma']);
+    expect(callbackTokens).toEqual(textChunks);
+  });
+
+  it('emits a delayed DeepSeek callback before an early stream break', async () => {
+    const model = new CapturingChatDeepSeek(
+      {
+        apiKey: 'test-key',
+        model: 'deepseek-v4-pro',
+        streaming: true,
+        _lc_stream_delay: 1,
+      },
+      [createContentChunk('alpha beta gamma')]
+    );
+    const textChunks: string[] = [];
+    const callbackTokens: string[] = [];
+    const runManager = {
+      handleLLMNewToken(token: string): void {
+        if (token !== '') {
+          callbackTokens.push(token);
+        }
+      },
+    } as unknown as CallbackManagerForLLMRun;
+
+    for await (const chunk of model.streamChunksWithCallbacks(runManager)) {
+      if (chunk.text !== '') {
+        textChunks.push(chunk.text);
+      }
+      break;
+    }
+
+    expect(textChunks).toEqual(['alpha ']);
+    expect(callbackTokens).toEqual(textChunks);
+  });
+
+  it('counts consumer work toward delayed DeepSeek cadence', async () => {
+    const model = new CapturingChatDeepSeek(
+      {
+        apiKey: 'test-key',
+        model: 'deepseek-v4-pro',
+        streaming: true,
+        _lc_stream_delay: 100,
+      },
+      [createContentChunk('first '), createContentChunk('second')]
+    );
+    const stream = model.streamChunksWithSignal(new AbortController().signal);
+    const iterator = stream[Symbol.asyncIterator]();
+
+    await expect(iterator.next()).resolves.toEqual(
+      expect.objectContaining({
+        done: false,
+        value: expect.objectContaining({
+          text: 'first ',
+        }),
+      })
+    );
+
+    await new Promise<void>((resolve) => {
+      setTimeout(resolve, 125);
+    });
+    const started = Date.now();
+
+    await expect(iterator.next()).resolves.toEqual(
+      expect.objectContaining({
+        done: false,
+        value: expect.objectContaining({
+          text: 'second',
+        }),
+      })
+    );
+    expect(Date.now() - started).toBeLessThan(50);
+  });
 });