@librechat/agents 3.2.45 → 3.2.51

package/src/llm/openrouter/index.ts

@@ -161,9 +161,7 @@ export class ChatOpenRouter extends ChatOpenAI {
     return 'LibreChatOpenRouter';
   }
 
-  // @ts-expect-error - OpenRouter reasoning extends OpenAI Reasoning with additional
-  // effort levels ('xhigh' | 'none' | 'minimal') not in ReasoningEffort.
-  // The parent's generic conditional return type cannot be widened in an override.
+  // OpenRouter widens OpenAI reasoning with extra effort levels ('xhigh' | 'none' | 'minimal').
   override invocationParams(
     options?: this['ParsedCallOptions'],
     extra?: InvocationParamsExtra

package/src/llm/vertexai/inherited-stream-events.spec.ts

@@ -0,0 +1,271 @@
+// Inherited stream-events specs for the LibreChat Vertex fork, ported from two
+// upstream @langchain/google-common@2.2.0 suites:
+//
+//   1. utils/tests/stream_events.test.ts  (the original prompt references it as
+//      google-common_stream_events.test.ts) — unit tests for the pure converter
+//      `convertGoogleGeminiStream`, which turns Gemini-style stream responses
+//      into LangChain `ChatModelStreamEvent`s. Our fork's `ChatVertexAI` does
+//      not re-implement this converter; it is re-exported from
+//      `@langchain/google-common` and exercised verbatim here as a pure unit.
+//
+//   2. chat_models/tests/chat_models_stream_events.test.ts (the prompt references
+//      it as google-common_chat_models_stream_events.test.ts) — tests
+//      `ChatGoogle.streamEvents()`. Upstream drove a `TestChatGoogle` helper whose
+//      `authOptions.resultFile` replayed recorded mock JSON and asserted via
+//      vitest custom matchers (`toHaveStreamText` / `toHaveStreamReasoning` /
+//      `toHaveStreamToolCalls`). Those fixture files and matchers are not
+//      available in this repo, so each case is routed through OUR fork:
+//      `new ChatVertexAI({...})` (which extends ChatGoogle and inherits the
+//      native `_streamChatModelEvents` path) with the google transport mocked at
+//      the `streamedConnection.request` boundary — it returns `{ data: <json
+//      stream> }`, the exact shape `_streamChatModelEvents` consumes. The matchers
+//      are re-expressed against the public `ChatModelStream` sub-streams
+//      (`.text` / `.reasoning` / `.toolCalls`) that those matchers wrap.
+//
+// All cases are deterministic and run against a mocked transport — no live
+// Vertex access. vitest -> jest, `zod/v3` -> n/a (no zod here).
+
+import { describe, it, test, expect } from '@jest/globals';
+import { convertGoogleGeminiStream } from '@langchain/google-common';
+import { ChatModelStream } from '@langchain/core/language_models/stream';
+import type { BaseChatModelCallOptions } from '@langchain/core/language_models/chat_models';
+import type { ChatModelStreamEvent } from '@langchain/core/language_models/event';
+import { ChatVertexAI } from '@/llm/vertexai';
+
+type GeminiChunk = Record<string, unknown>;
+
+// --- Converter unit-test harness (upstream source 1) -----------------------
+
+async function* asAsyncIterable(
+  chunks: GeminiChunk[]
+): AsyncGenerator<GeminiChunk> {
+  for (const chunk of chunks) {
+    yield chunk;
+  }
+}
+
+async function collectEvents(
+  chunks: GeminiChunk[]
+): Promise<ChatModelStreamEvent[]> {
+  const out: ChatModelStreamEvent[] = [];
+  for await (const event of convertGoogleGeminiStream(
+    asAsyncIterable(chunks)
+  )) {
+    out.push(event);
+  }
+  return out;
+}
+
+// --- Class streamEvents harness (upstream source 2, routed through fork) ----
+
+interface MockJsonStream {
+  readonly streamDone: boolean;
+  nextChunk(): Promise<GeminiChunk | null>;
+}
+
+function makeJsonStream(chunks: GeminiChunk[]): MockJsonStream {
+  let i = 0;
+  return {
+    get streamDone(): boolean {
+      return i >= chunks.length;
+    },
+    async nextChunk(): Promise<GeminiChunk | null> {
+      if (i >= chunks.length) return null;
+      const chunk = chunks[i];
+      i += 1;
+      return chunk;
+    },
+  };
+}
+
+interface StreamedConnectionModel {
+  streamedConnection: {
+    request: () => Promise<{ data: MockJsonStream }>;
+  };
+  _streamChatModelEvents: (
+    messages: unknown[],
+    options: BaseChatModelCallOptions
+  ) => AsyncGenerator<ChatModelStreamEvent>;
+}
+
+function createStreamModel(chunks: GeminiChunk[]): ChatVertexAI {
+  const model = new ChatVertexAI({
+    model: 'gemini-2.0-flash',
+    authOptions: {
+      credentials: { client_email: 'test@example.com', private_key: 'test' },
+      projectId: 'test-project',
+    },
+  } as ConstructorParameters<typeof ChatVertexAI>[0]);
+  (model as unknown as StreamedConnectionModel).streamedConnection.request =
+    async () => ({ data: makeJsonStream(chunks) });
+  return model;
+}
+
+function streamEvents(
+  model: ChatVertexAI,
+  options: BaseChatModelCallOptions = {} as BaseChatModelCallOptions
+): AsyncGenerator<ChatModelStreamEvent> {
+  return (model as unknown as StreamedConnectionModel)._streamChatModelEvents(
+    [],
+    options
+  );
+}
+
+// ---------------------------------------------------------------------------
+// Source 1: convertGoogleGeminiStream (pure converter, re-exported from
+// @langchain/google-common and inherited unchanged by the fork)
+// ---------------------------------------------------------------------------
+
+describe('convertGoogleGeminiStream (inherited from @langchain/google-common)', () => {
+  test('text-only streaming', async () => {
+    const events = await collectEvents([
+      { candidates: [{ content: { parts: [{ text: 'Hello' }] } }] },
+      { candidates: [{ content: { parts: [{ text: ' world' }] } }] },
+    ]);
+
+    const textDeltas = events.filter(
+      (e) =>
+        e.event === 'content-block-delta' &&
+        (e as { delta: { type: string } }).delta.type === 'text-delta'
+    );
+    expect(textDeltas).toHaveLength(2);
+
+    expect(
+      events.find((e) => e.event === 'content-block-finish')
+    ).toMatchObject({
+      content: { text: 'Hello world' },
+    });
+  });
+
+  test('maps Gemini finish reasons', async () => {
+    const lengthEvents = await collectEvents([
+      {
+        candidates: [
+          {
+            content: { parts: [{ text: 'Hello' }] },
+            finishReason: 'MAX_TOKENS',
+          },
+        ],
+      },
+    ]);
+    const lengthFinish = lengthEvents.find((e) => e.event === 'message-finish');
+    expect(lengthFinish).toMatchObject({ reason: 'length' });
+
+    const filterEvents = await collectEvents([
+      {
+        candidates: [
+          {
+            content: { parts: [{ text: 'Hello' }] },
+            finishReason: 'SAFETY',
+          },
+        ],
+      },
+    ]);
+    const filterFinish = filterEvents.find((e) => e.event === 'message-finish');
+    expect(filterFinish).toMatchObject({ reason: 'content_filter' });
+  });
+
+  test('thinking parts map to reasoning', async () => {
+    const events = await collectEvents([
+      {
+        candidates: [
+          {
+            content: { parts: [{ text: 'Let me think', thought: true }] },
+          },
+        ],
+      },
+    ]);
+
+    expect(
+      events.find(
+        (e) =>
+          e.event === 'content-block-finish' &&
+          (e as { content: { type: string } }).content.type === 'reasoning'
+      )
+    ).toMatchObject({
+      content: { reasoning: 'Let me think' },
+    });
+  });
+
+  test('usage snapshots', async () => {
+    const events = await collectEvents([
+      {
+        usageMetadata: {
+          promptTokenCount: 10,
+          candidatesTokenCount: 4,
+          totalTokenCount: 14,
+        },
+        candidates: [{ content: { parts: [{ text: 'Hi' }] } }],
+      },
+    ]);
+
+    expect(events.filter((e) => e.event === 'usage').length).toBe(1);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Source 2: ChatGoogle.streamEvents — inherited native streamEvents path on
+// the fork (ChatVertexAI does not override _streamChatModelEvents). Re-expressed
+// against the public ChatModelStream sub-streams that the upstream vitest
+// matchers wrapped.
+// ---------------------------------------------------------------------------
+
+describe('ChatVertexAI.streamEvents (inherited native path)', () => {
+  test('streams text', async () => {
+    const model = createStreamModel([
+      { candidates: [{ content: { parts: [{ text: 'Hello' }] } }] },
+      {
+        candidates: [
+          { content: { parts: [{ text: ' world' }] }, finishReason: 'STOP' },
+        ],
+      },
+    ]);
+    const stream = new ChatModelStream(streamEvents(model));
+    expect(await stream.text).toBe('Hello world');
+  });
+
+  test('streams reasoning', async () => {
+    const model = createStreamModel([
+      {
+        candidates: [
+          {
+            content: { parts: [{ text: 'Let me reason...', thought: true }] },
+            finishReason: 'STOP',
+          },
+        ],
+      },
+    ]);
+    const stream = new ChatModelStream(streamEvents(model));
+    expect(await stream.reasoning).toBe('Let me reason...');
+  });
+
+  test('streams tool calls', async () => {
+    const model = createStreamModel([
+      {
+        candidates: [
+          {
+            content: {
+              parts: [
+                {
+                  functionCall: {
+                    name: 'web_search',
+                    args: { query: 'weather' },
+                  },
+                },
+              ],
+            },
+            finishReason: 'STOP',
+          },
+        ],
+      },
+    ]);
+    const stream = new ChatModelStream(streamEvents(model));
+    const calls = await stream.toolCalls;
+    expect(calls).toEqual([
+      expect.objectContaining({
+        name: 'web_search',
+        args: { query: 'weather' },
+      }),
+    ]);
+  });
+});

package/src/messages/format.ts

@@ -334,6 +334,10 @@ interface FormatAssistantMessageOptions {
 
 interface FormatAgentMessagesOptions {
   provider?: Providers;
+  /** Reconstruct hidden `reasoning_content` from `THINK` parts onto prior
+   *  tool-call messages. Explicit opt-in for OpenAI-compatible endpoints that
+   *  replay reasoning across turns; defaults to on for DeepSeek thinking-mode. */
+  preserveReasoningContent?: boolean;
   /** Skill names already primed fresh this turn (manual/always-apply). Their
    *  historical `skill` tool_calls are not reconstructed into a HumanMessage,
    *  so the same SKILL.md body is not injected twice in one request. */
@@ -1435,7 +1439,8 @@ export const formatAgentMessages = (
 
     const formattedMessages = formatAssistantMessage(processedMessage, {
       preserveUnpairedServerToolUses: i === payload.length - 1,
-      preserveReasoningContent: options?.provider === Providers.DEEPSEEK,
+      preserveReasoningContent:
+        options?.preserveReasoningContent ?? options?.provider === Providers.DEEPSEEK,
       provider: options?.provider,
     });
     if (sourceMessageId != null && sourceMessageId !== '') {

package/src/messages/formatAgentMessages.test.ts

@@ -2189,6 +2189,82 @@ describe('formatAgentMessages', () => {
     );
   });
 
+  it('should preserve hidden reasoning_content via explicit preserveReasoningContent without a provider', () => {
+    const payload: TPayload = [
+      {
+        role: 'assistant',
+        content: [
+          {
+            type: ContentTypes.THINK,
+            [ContentTypes.THINK]: 'Need calculator.',
+          },
+          {
+            type: ContentTypes.TEXT,
+            [ContentTypes.TEXT]: 'Using calculator.',
+            tool_call_ids: ['call_1'],
+          },
+          {
+            type: ContentTypes.TOOL_CALL,
+            tool_call: {
+              id: 'call_1',
+              name: 'calculator',
+              args: '{"input":"127 * 453"}',
+              output: '57531',
+            },
+          },
+        ],
+      },
+    ];
+
+    const result = formatAgentMessages(payload, undefined, undefined, undefined, {
+      preserveReasoningContent: true,
+    });
+
+    const toolCallMessage = result.messages[0] as AIMessage;
+    expect(toolCallMessage.tool_calls).toHaveLength(1);
+    expect(toolCallMessage.additional_kwargs.reasoning_content).toBe(
+      'Need calculator.'
+    );
+  });
+
+  it('should not reconstruct reasoning_content when preserveReasoningContent is explicitly false for DeepSeek', () => {
+    const payload: TPayload = [
+      {
+        role: 'assistant',
+        content: [
+          {
+            type: ContentTypes.THINK,
+            [ContentTypes.THINK]: 'Need calculator.',
+          },
+          {
+            type: ContentTypes.TEXT,
+            [ContentTypes.TEXT]: 'Using calculator.',
+            tool_call_ids: ['call_1'],
+          },
+          {
+            type: ContentTypes.TOOL_CALL,
+            tool_call: {
+              id: 'call_1',
+              name: 'calculator',
+              args: '{"input":"127 * 453"}',
+              output: '57531',
+            },
+          },
+        ],
+      },
+    ];
+
+    const result = formatAgentMessages(payload, undefined, undefined, undefined, {
+      provider: Providers.DEEPSEEK,
+      preserveReasoningContent: false,
+    });
+
+    const toolCallMessage = result.messages[0] as AIMessage;
+    expect(
+      toolCallMessage.additional_kwargs.reasoning_content
+    ).toBeUndefined();
+  });
+
   it('should preserve DeepSeek reasoning from supported hidden content blocks', () => {
     const payload: TPayload = [
       {