@librechat/agents 3.4.7 → 3.5.1

package/src/llm/vertexai/fixThoughtSignatures.test.ts

@@ -1,154 +0,0 @@
-import { expect, test, describe } from '@jest/globals';
-import { AIMessage, HumanMessage, ToolMessage } from '@langchain/core/messages';
-import type { GeminiContent } from '@langchain/google-common';
-import { fixThoughtSignatures } from './index';
-
-const SIG_A = 'AY89a1/sigA==';
-const SIG_B = 'AY89a1/sigB==';
-
-const buildContents = (
-  blocks: Array<['user' | 'model' | 'function', GeminiContent['parts']]>
-): GeminiContent[] =>
-  blocks.map(([role, parts]) => ({ role, parts }) as GeminiContent);
-
-describe('fixThoughtSignatures', () => {
-  test('attaches signature to functionCall part when prior turn is a plain-text AI message (issue LibreChat#13006-followup)', () => {
-    // Reproduces the live failure from the issue: a Gemini 3 conversation
-    // where turn 1 was plain text ("Hello!") and turn 2 emitted a tool call
-    // with a thought signature. The plain-text AI message has no signatures,
-    // so the old position-by-filter code matched the toolcall AIMessage with
-    // the WRONG model content.
-    const helloAi = new AIMessage('Hello! How can I help you today?');
-    const toolcallAi = new AIMessage({
-      content: '',
-      tool_calls: [
-        { name: 'bash_tool', args: { command: 'echo hi' }, id: 'tc1' },
-      ],
-      additional_kwargs: { signatures: [SIG_A, ''] },
-    });
-    const input = [
-      new HumanMessage('hi there'),
-      helloAi,
-      new HumanMessage('run something'),
-      toolcallAi,
-      new ToolMessage({ content: 'ok', tool_call_id: 'tc1' }),
-    ];
-
-    const contents = buildContents([
-      ['user', [{ text: 'hi there' }]],
-      ['model', [{ text: 'Hello! How can I help you today?' }]],
-      ['user', [{ text: 'run something' }]],
-      [
-        'model',
-        [{ functionCall: { name: 'bash_tool', args: { command: 'echo hi' } } }],
-      ],
-      [
-        'user',
-        [
-          {
-            functionResponse: {
-              name: 'bash_tool',
-              response: { content: 'ok' },
-            },
-          },
-        ],
-      ],
-    ]);
-
-    fixThoughtSignatures(contents, input);
-
-    expect(contents[1].parts[0].thoughtSignature).toBeUndefined();
-    expect(contents[3].parts[0]).toMatchObject({
-      functionCall: { name: 'bash_tool' },
-      thoughtSignature: SIG_A,
-    });
-  });
-
-  test('attaches signatures across multiple tool-call turns by position', () => {
-    const turn1 = new AIMessage({
-      content: '',
-      tool_calls: [{ name: 'a', args: {}, id: 't1' }],
-      additional_kwargs: { signatures: [SIG_A, ''] },
-    });
-    const turn2 = new AIMessage({
-      content: '',
-      tool_calls: [{ name: 'b', args: {}, id: 't2' }],
-      additional_kwargs: { signatures: [SIG_B, ''] },
-    });
-
-    const input = [
-      new HumanMessage('q1'),
-      turn1,
-      new ToolMessage({ content: '1', tool_call_id: 't1' }),
-      new HumanMessage('q2'),
-      turn2,
-      new ToolMessage({ content: '2', tool_call_id: 't2' }),
-    ];
-    const contents = buildContents([
-      ['user', [{ text: 'q1' }]],
-      ['model', [{ functionCall: { name: 'a', args: {} } }]],
-      ['user', [{ functionResponse: { name: 'a', response: {} } }]],
-      ['user', [{ text: 'q2' }]],
-      ['model', [{ functionCall: { name: 'b', args: {} } }]],
-      ['user', [{ functionResponse: { name: 'b', response: {} } }]],
-    ]);
-
-    fixThoughtSignatures(contents, input);
-
-    expect(contents[1].parts[0].thoughtSignature).toBe(SIG_A);
-    expect(contents[4].parts[0].thoughtSignature).toBe(SIG_B);
-  });
-
-  test('does not overwrite signatures already attached by the library', () => {
-    const ai = new AIMessage({
-      content: '',
-      tool_calls: [{ name: 'a', args: {}, id: 't1' }],
-      additional_kwargs: { signatures: [SIG_A] },
-    });
-    const input = [new HumanMessage('q'), ai];
-    const contents = buildContents([
-      ['user', [{ text: 'q' }]],
-      [
-        'model',
-        [{ functionCall: { name: 'a', args: {} }, thoughtSignature: SIG_B }],
-      ],
-    ]);
-
-    fixThoughtSignatures(contents, input);
-
-    expect(contents[1].parts[0].thoughtSignature).toBe(SIG_B);
-  });
-
-  test('no-op when AI message has no signatures', () => {
-    const ai = new AIMessage({
-      content: '',
-      tool_calls: [{ name: 'a', args: {}, id: 't1' }],
-    });
-    const input = [new HumanMessage('q'), ai];
-    const contents = buildContents([
-      ['user', [{ text: 'q' }]],
-      ['model', [{ functionCall: { name: 'a', args: {} } }]],
-    ]);
-
-    fixThoughtSignatures(contents, input);
-
-    expect(contents[1].parts[0].thoughtSignature).toBeUndefined();
-  });
-
-  test('skips empty-string signatures', () => {
-    const ai = new AIMessage({
-      content: '',
-      tool_calls: [{ name: 'a', args: {}, id: 't1' }],
-      additional_kwargs: { signatures: ['', '', ''] },
-    });
-    const input = [new HumanMessage('q'), ai];
-    const contents = buildContents([
-      ['user', [{ text: 'q' }]],
-      ['model', [{ functionCall: { name: 'a', args: {} } }]],
-    ]);
-
-    fixThoughtSignatures(contents, input);
-
-    expect(contents[1].parts[0].thoughtSignature).toBeUndefined();
-  });
-});

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

@@ -1,271 +0,0 @@
-// 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/llm/vertexai/llm.spec.ts

@@ -1,159 +0,0 @@
-import { config } from 'dotenv';
-config();
-import { expect, test, describe, jest } from '@jest/globals';
-
-jest.setTimeout(90000);
-import {
-  AIMessageChunk,
-  HumanMessage,
-  ToolMessage,
-} from '@langchain/core/messages';
-import { tool } from '@langchain/core/tools';
-import { z } from 'zod/v3';
-import { ChatVertexAI } from './index';
-
-const gemini3Models = [
-  'gemini-3-pro-preview',
-  'gemini-3-flash-preview',
-  'gemini-3.1-flash-lite-preview',
-];
-
-const weatherTool = tool(async () => 'The weather is 80 degrees and sunny', {
-  name: 'weather',
-  description: 'Gets the current weather in a given location',
-  schema: z.object({
-    location: z.string().describe('The city to get the weather for'),
-  }),
-});
-
-describe('ChatVertexAI upstream compatibility', () => {
-  test('serialization uses the LibreChat constructor name on the Vertex namespace', () => {
-    const model = new ChatVertexAI();
-    expect(JSON.stringify(model)).toEqual(
-      '{"lc":1,"type":"constructor","id":["langchain","chat_models","vertexai","LibreChatVertexAI"],"kwargs":{"platform_type":"gcp"}}'
-    );
-  });
-
-  test('labels parameter support', () => {
-    expect(() => {
-      const model = new ChatVertexAI({
-        labels: {
-          team: 'test',
-          environment: 'development',
-        },
-      });
-      expect(model.platform).toEqual('gcp');
-    }).not.toThrow();
-  });
-
-  test('constructor overload supports model string', () => {
-    const model = new ChatVertexAI('gemini-1.5-pro');
-    expect(model.model).toEqual('gemini-1.5-pro');
-    expect(model.platform).toEqual('gcp');
-  });
-});
-
-describe.each(gemini3Models)(
-  'Vertex AI reasoning with thinkingLevel (%s)',
-  (modelName) => {
-    const model = new ChatVertexAI({
-      model: modelName,
-      location: 'global',
-      maxRetries: 2,
-      thinkingConfig: {
-        thinkingLevel: 'HIGH',
-        includeThoughts: true,
-      },
-    });
-
-    test('invoke with thinkingLevel produces a response with reasoning tokens', async () => {
-      const result = await model.invoke('What is 2+2? Think step by step.');
-      expect(result.content).toBeDefined();
-      const reasoningTokens = (result.usage_metadata as Record<string, unknown>)
-        ?.output_token_details;
-      expect(reasoningTokens).toBeDefined();
-      expect(
-        (reasoningTokens as Record<string, number>)?.reasoning
-      ).toBeGreaterThan(0);
-    });
-
-    test('stream: usage_metadata includes reasoning in output_tokens (issue LibreChat#13006)', async () => {
-      let finalChunk: AIMessageChunk | undefined;
-      for await (const chunk of await model.stream(
-        'What is 2+2? Think step by step.'
-      )) {
-        finalChunk = finalChunk ? finalChunk.concat(chunk) : chunk;
-      }
-      const usage = finalChunk?.usage_metadata;
-      expect(usage).toBeDefined();
-      const reasoning = (
-        usage as { output_token_details?: { reasoning?: number } }
-      )?.output_token_details?.reasoning;
-      expect(reasoning).toBeGreaterThan(0);
-      expect(usage!.total_tokens).toBe(
-        usage!.input_tokens + usage!.output_tokens
-      );
-    });
-  }
-);
-
-describe.each(gemini3Models)(
-  'Vertex AI tool calling with thought signatures (%s)',
-  (modelName) => {
-    const model = new ChatVertexAI({
-      model: modelName,
-      location: 'global',
-      maxRetries: 2,
-    });
-    const modelWithTools = model.bindTools([weatherTool]);
-
-    test('invoke: tool call completes round-trip with thought signature', async () => {
-      const result = await modelWithTools.invoke(
-        'What is the current weather in San Francisco?'
-      );
-      expect(result.tool_calls).toBeDefined();
-      expect(result.tool_calls!.length).toBeGreaterThanOrEqual(1);
-      expect(result.tool_calls![0].id).toBeDefined();
-
-      const toolMessage = new ToolMessage({
-        content: 'The weather is 80 degrees and sunny',
-        tool_call_id: result.tool_calls![0].id ?? '',
-      });
-
-      // Critical round-trip: sending the function call + tool result back to the API.
-      // Without proper thought_signature handling, this fails with
-      // "function call X is missing a thought_signature"
-      const finalResult = await model.invoke([
-        new HumanMessage('What is the current weather in San Francisco?'),
-        result,
-        toolMessage,
-      ]);
-      expect(finalResult.content).toBeDefined();
-    });
-
-    test('stream: tool call completes round-trip with thought signature', async () => {
-      let finalChunk: AIMessageChunk | undefined;
-      for await (const chunk of await modelWithTools.stream(
-        'What is the current weather in San Francisco?'
-      )) {
-        finalChunk = finalChunk ? finalChunk.concat(chunk) : chunk;
-      }
-      expect(finalChunk).toBeDefined();
-      expect(finalChunk?.tool_calls).toBeDefined();
-      expect(finalChunk?.tool_calls!.length).toBeGreaterThanOrEqual(1);
-
-      const toolMessage = new ToolMessage({
-        content: 'The weather is 80 degrees and sunny',
-        tool_call_id: finalChunk?.tool_calls![0].id ?? '',
-      });
-
-      // Round-trip: send tool result back — verifies thought_signature handling
-      const finalResult = await model.invoke([
-        new HumanMessage('What is the current weather in San Francisco?'),
-        finalChunk!,
-        toolMessage,
-      ]);
-      expect(finalResult.content).toBeDefined();
-    });
-  }
-);

package/src/llm/vertexai/repairUsageMetadata.test.ts

@@ -1,54 +0,0 @@
-import { expect, test, describe } from '@jest/globals';
-import type { UsageMetadata } from '@langchain/core/messages';
-import { repairStreamUsageMetadata } from './index';
-
-const goodUsage: UsageMetadata = {
-  input_tokens: 80657,
-  output_tokens: 2608,
-  total_tokens: 83265,
-  output_token_details: { reasoning: 1842 },
-};
-
-const buggyFallbackUsage: UsageMetadata = {
-  input_tokens: 80657,
-  output_tokens: 766,
-  total_tokens: 83265,
-};
-
-describe('repairStreamUsageMetadata', () => {
-  test('replaces buggy fallback usage with tracked good usage from generationInfo', () => {
-    const result = repairStreamUsageMetadata(buggyFallbackUsage, goodUsage);
-    expect(result).toBe(goodUsage);
-  });
-
-  test('returns current unchanged when no generationInfo usage was tracked', () => {
-    const result = repairStreamUsageMetadata(buggyFallbackUsage, undefined);
-    expect(result).toBe(buggyFallbackUsage);
-  });
-
-  test('returns undefined unchanged', () => {
-    const result = repairStreamUsageMetadata(undefined, goodUsage);
-    expect(result).toBeUndefined();
-  });
-
-  test('does not replace when total_tokens differ (different request)', () => {
-    const stale: UsageMetadata = { ...goodUsage, total_tokens: 100 };
-    const result = repairStreamUsageMetadata(buggyFallbackUsage, stale);
-    expect(result).toBe(buggyFallbackUsage);
-  });
-
-  test('does not replace when generationInfo output_tokens is not larger (already correct)', () => {
-    const equivalent: UsageMetadata = {
-      ...buggyFallbackUsage,
-      output_tokens: buggyFallbackUsage.output_tokens,
-    };
-    const result = repairStreamUsageMetadata(buggyFallbackUsage, equivalent);
-    expect(result).toBe(buggyFallbackUsage);
-  });
-
-  test('does not replace when generationInfo output_tokens is smaller', () => {
-    const smaller: UsageMetadata = { ...goodUsage, output_tokens: 100 };
-    const result = repairStreamUsageMetadata(buggyFallbackUsage, smaller);
-    expect(result).toBe(buggyFallbackUsage);
-  });
-});