@librechat/agents 3.4.7 → 3.5.0

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

@@ -1,182 +0,0 @@
-import OpenAI from 'openai';
-
-import {
-  addChatCacheBreakpoints,
-  addResponseCacheBreakpoints,
-  shouldIncludeEncryptedReasoning,
-} from './index';
-
-describe('managed GPT-5.6 request fields', () => {
-  it('places cache breakpoints after instructions and the prior history prefix', () => {
-    const messages = addChatCacheBreakpoints([
-      { role: 'system', content: 'Stable instructions.' },
-      { role: 'user', content: 'First question.' },
-      { role: 'assistant', content: 'First answer.' },
-      { role: 'user', content: 'Current question.' },
-    ]);
-
-    expect(messages[0]).toMatchObject({
-      content: [
-        {
-          type: 'text',
-          text: 'Stable instructions.',
-          prompt_cache_breakpoint: { mode: 'explicit' },
-        },
-      ],
-    });
-    expect(messages[2]).toMatchObject({
-      content: [
-        {
-          type: 'text',
-          text: 'First answer.',
-          prompt_cache_breakpoint: { mode: 'explicit' },
-        },
-      ],
-    });
-    expect(JSON.stringify(messages[1])).not.toContain(
-      'prompt_cache_breakpoint'
-    );
-    expect(JSON.stringify(messages[3])).not.toContain(
-      'prompt_cache_breakpoint'
-    );
-  });
-
-  it('uses supported Responses content blocks for the same stable prefixes', () => {
-    const input = [
-      {
-        type: 'message',
-        role: 'developer',
-        content: [{ type: 'input_text', text: 'Stable instructions.' }],
-      },
-      {
-        type: 'message',
-        role: 'user',
-        content: [{ type: 'input_text', text: 'Prior question.' }],
-      },
-      {
-        type: 'message',
-        role: 'user',
-        content: [{ type: 'input_text', text: 'Current question.' }],
-      },
-    ] as unknown as OpenAI.Responses.ResponseInput;
-    const result = addResponseCacheBreakpoints(input);
-
-    expect(result).toMatchObject([
-      {
-        content: [
-          {
-            prompt_cache_breakpoint: { mode: 'explicit' },
-          },
-        ],
-      },
-      {
-        content: [
-          {
-            prompt_cache_breakpoint: { mode: 'explicit' },
-          },
-        ],
-      },
-      {
-        content: [{ type: 'input_text', text: 'Current question.' }],
-      },
-    ]);
-  });
-
-  it('does not mark replayed assistant output blocks as breakpoints', () => {
-    const input = [
-      {
-        type: 'message',
-        role: 'developer',
-        content: [{ type: 'input_text', text: 'Stable instructions.' }],
-      },
-      {
-        type: 'message',
-        role: 'user',
-        content: [{ type: 'input_text', text: 'First question.' }],
-      },
-      {
-        type: 'message',
-        role: 'assistant',
-        content: [{ type: 'output_text', text: 'Prior answer.' }],
-      },
-      {
-        type: 'message',
-        role: 'user',
-        content: [{ type: 'input_text', text: 'Current question.' }],
-      },
-    ] as unknown as OpenAI.Responses.ResponseInput;
-    const result = addResponseCacheBreakpoints(input) as unknown as Array<{
-      content: Array<Record<string, unknown>>;
-    }>;
-
-    // output_text is rejected with a 400 by OpenAI, so it must stay unmarked;
-    // the stable prefix falls back to the prior user input message.
-    expect(result[2].content[0]).not.toHaveProperty('prompt_cache_breakpoint');
-    expect(result[1].content[0]).toHaveProperty('prompt_cache_breakpoint');
-    expect(result[0].content[0]).toHaveProperty('prompt_cache_breakpoint');
-  });
-
-  it('marks string-content Responses messages by wrapping them in input_text', () => {
-    const input = [
-      { type: 'message', role: 'system', content: 'Stable system prompt.' },
-      { type: 'message', role: 'user', content: 'Prior turn.' },
-      { type: 'message', role: 'user', content: 'Current question.' },
-    ] as unknown as OpenAI.Responses.ResponseInput;
-    const result = addResponseCacheBreakpoints(input) as unknown as Array<{
-      content: unknown;
-    }>;
-
-    expect(result[0].content).toEqual([
-      {
-        type: 'input_text',
-        text: 'Stable system prompt.',
-        prompt_cache_breakpoint: { mode: 'explicit' },
-      },
-    ]);
-  });
-
-  it('does not rewrite assistant string content as input_text', () => {
-    const input = [
-      { type: 'message', role: 'system', content: 'Stable system prompt.' },
-      { type: 'message', role: 'user', content: 'First question.' },
-      { type: 'message', role: 'assistant', content: 'Prior answer.' },
-      { type: 'message', role: 'user', content: 'Current question.' },
-    ] as unknown as OpenAI.Responses.ResponseInput;
-    const result = addResponseCacheBreakpoints(input) as unknown as Array<{
-      content: unknown;
-    }>;
-
-    // input_text under role:assistant is rejected with a 400, so assistant
-    // string content must stay a string and the breakpoint falls back to the
-    // prior user turn.
-    expect(result[2].content).toBe('Prior answer.');
-    expect(result[1].content).toEqual([
-      {
-        type: 'input_text',
-        text: 'First question.',
-        prompt_cache_breakpoint: { mode: 'explicit' },
-      },
-    ]);
-  });
-
-  it('requests encrypted reasoning whenever persisted or stateless replay may be needed', () => {
-    expect(shouldIncludeEncryptedReasoning('gpt-5.6', {})).toBe(true);
-    expect(
-      shouldIncludeEncryptedReasoning('gpt-5.6', {
-        reasoning: { context: 'all_turns' },
-      })
-    ).toBe(true);
-    expect(
-      shouldIncludeEncryptedReasoning('gpt-5.6', {
-        reasoning: { context: 'current_turn' },
-      })
-    ).toBe(false);
-    expect(
-      shouldIncludeEncryptedReasoning('gpt-5.6', {
-        store: false,
-        reasoning: { context: 'current_turn' },
-      })
-    ).toBe(true);
-    expect(shouldIncludeEncryptedReasoning('gpt-5.5', {})).toBe(false);
-  });
-});

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

@@ -1,199 +0,0 @@
-import { AIMessageChunk } from '@langchain/core/messages';
-import { expect, test, describe, beforeEach, afterAll } from '@jest/globals';
-import type { BaseMessageChunk } from '@langchain/core/messages';
-import {
-  STREAMED_TOOL_CALL_ADAPTER_METADATA_KEY,
-  OPENAI_CHAT_SEQUENTIAL_STREAMED_TOOL_CALL_ADAPTER,
-} from '@/tools/streamedToolCallSeals';
-import { ChatOpenAI, AzureChatOpenAI } from './index';
-
-type DeltaConverter = {
-  _convertCompletionsDeltaToBaseMessageChunk(
-    delta: Record<string, unknown>,
-    rawResponse: Record<string, unknown>
-  ): BaseMessageChunk;
-};
-
-const rawResponse = {
-  id: 'chatcmpl-1',
-  object: 'chat.completion.chunk',
-  created: 1,
-  model: 'gpt-5.5',
-  choices: [],
-};
-
-const toolCallDelta = {
-  role: 'assistant',
-  tool_calls: [
-    {
-      index: 0,
-      id: 'call_1',
-      type: 'function',
-      function: { name: 'weather', arguments: '{"ci' },
-    },
-  ],
-};
-
-function convertDelta(
-  model: unknown,
-  delta: Record<string, unknown>
-): AIMessageChunk {
-  const converter = (model as { completions: DeltaConverter }).completions;
-  const message = converter._convertCompletionsDeltaToBaseMessageChunk(
-    delta,
-    rawResponse
-  );
-  expect(message).toBeInstanceOf(AIMessageChunk);
-  return message as AIMessageChunk;
-}
-
-function adapterOf(message: AIMessageChunk): unknown {
-  return (message.response_metadata as Record<string, unknown>)[
-    STREAMED_TOOL_CALL_ADAPTER_METADATA_KEY
-  ];
-}
-
-describe('Chat Completions sequential tool-call seal stamping', () => {
-  // Both the implementation (OPENAI_BASE_URL fallback) and the Azure
-  // constructor (AZURE_OPENAI_BASE_PATH fallback) read the environment, so
-  // isolate these vars to keep the suite deterministic across shells.
-  const ISOLATED_ENV_VARS = ['OPENAI_BASE_URL', 'AZURE_OPENAI_BASE_PATH'];
-  const originalEnv = new Map(
-    ISOLATED_ENV_VARS.map((name) => [name, process.env[name]])
-  );
-
-  beforeEach(() => {
-    for (const name of ISOLATED_ENV_VARS) {
-      delete process.env[name];
-    }
-  });
-
-  afterAll(() => {
-    for (const [name, value] of originalEnv) {
-      if (value == null) {
-        delete process.env[name];
-      } else {
-        process.env[name] = value;
-      }
-    }
-  });
-
-  test('stamps tool-call deltas when no baseURL is configured (official)', () => {
-    const model = new ChatOpenAI({ model: 'gpt-5.5', apiKey: 'test' });
-    const message = convertDelta(model, toolCallDelta);
-    expect(adapterOf(message)).toBe(
-      OPENAI_CHAT_SEQUENTIAL_STREAMED_TOOL_CALL_ADAPTER
-    );
-  });
-
-  test('stamps tool-call deltas for an explicit api.openai.com baseURL', () => {
-    const model = new ChatOpenAI({
-      model: 'gpt-5.5',
-      apiKey: 'test',
-      configuration: { baseURL: 'https://api.openai.com/v1' },
-    });
-    const message = convertDelta(model, toolCallDelta);
-    expect(adapterOf(message)).toBe(
-      OPENAI_CHAT_SEQUENTIAL_STREAMED_TOOL_CALL_ADAPTER
-    );
-  });
-
-  test('does not stamp tool-call deltas for OpenAI-compatible endpoints', () => {
-    const model = new ChatOpenAI({
-      model: 'kimi-k2',
-      apiKey: 'test',
-      configuration: { baseURL: 'https://api.moonshot.ai/v1' },
-    });
-    const message = convertDelta(model, toolCallDelta);
-    expect(adapterOf(message)).toBeUndefined();
-  });
-
-  test('does not stamp text-only deltas', () => {
-    const model = new ChatOpenAI({ model: 'gpt-5.5', apiKey: 'test' });
-    const message = convertDelta(model, {
-      role: 'assistant',
-      content: 'hello',
-    });
-    expect(adapterOf(message)).toBeUndefined();
-  });
-
-  test('does not stamp when OPENAI_BASE_URL routes to a compatible endpoint', () => {
-    process.env.OPENAI_BASE_URL = 'https://api.moonshot.ai/v1';
-    const model = new ChatOpenAI({ model: 'gpt-5.5', apiKey: 'test' });
-    const message = convertDelta(model, toolCallDelta);
-    expect(adapterOf(message)).toBeUndefined();
-  });
-
-  test('stamps when OPENAI_BASE_URL points at api.openai.com', () => {
-    process.env.OPENAI_BASE_URL = 'https://api.openai.com/v1';
-    const model = new ChatOpenAI({ model: 'gpt-5.5', apiKey: 'test' });
-    const message = convertDelta(model, toolCallDelta);
-    expect(adapterOf(message)).toBe(
-      OPENAI_CHAT_SEQUENTIAL_STREAMED_TOOL_CALL_ADAPTER
-    );
-  });
-
-  test('stamps Azure OpenAI tool-call deltas (first-party endpoint)', () => {
-    const model = new AzureChatOpenAI({
-      azureOpenAIApiKey: 'test',
-      azureOpenAIApiInstanceName: 'test-instance',
-      azureOpenAIApiDeploymentName: 'test-deployment',
-      azureOpenAIApiVersion: '2024-08-01-preview',
-    });
-    const message = convertDelta(model, toolCallDelta);
-    expect(adapterOf(message)).toBe(
-      OPENAI_CHAT_SEQUENTIAL_STREAMED_TOOL_CALL_ADAPTER
-    );
-  });
-
-  test('stamps Azure deltas for an *.openai.azure.com base path', () => {
-    const model = new AzureChatOpenAI({
-      azureOpenAIApiKey: 'test',
-      azureOpenAIApiDeploymentName: 'test-deployment',
-      azureOpenAIApiVersion: '2024-08-01-preview',
-      azureOpenAIBasePath:
-        'https://test-resource.openai.azure.com/openai/deployments',
-    });
-    const message = convertDelta(model, toolCallDelta);
-    expect(adapterOf(message)).toBe(
-      OPENAI_CHAT_SEQUENTIAL_STREAMED_TOOL_CALL_ADAPTER
-    );
-  });
-
-  test('stamps Azure deltas for a regional cognitive services base path', () => {
-    const model = new AzureChatOpenAI({
-      azureOpenAIApiKey: 'test',
-      azureOpenAIApiDeploymentName: 'test-deployment',
-      azureOpenAIApiVersion: '2024-08-01-preview',
-      azureOpenAIBasePath:
-        'https://westeurope.api.cognitive.microsoft.com/openai/deployments',
-    });
-    const message = convertDelta(model, toolCallDelta);
-    expect(adapterOf(message)).toBe(
-      OPENAI_CHAT_SEQUENTIAL_STREAMED_TOOL_CALL_ADAPTER
-    );
-  });
-
-  test('does not stamp Azure deltas routed through a proxy base path', () => {
-    const model = new AzureChatOpenAI({
-      azureOpenAIApiKey: 'test',
-      azureOpenAIApiDeploymentName: 'test-deployment',
-      azureOpenAIApiVersion: '2024-08-01-preview',
-      azureOpenAIBasePath: 'https://proxy.example.com/openai/deployments',
-    });
-    const message = convertDelta(model, toolCallDelta);
-    expect(adapterOf(message)).toBeUndefined();
-  });
-
-  test('does not stamp Azure deltas with a custom client baseURL', () => {
-    const model = new AzureChatOpenAI({
-      azureOpenAIApiKey: 'test',
-      azureOpenAIApiInstanceName: 'test-instance',
-      azureOpenAIApiDeploymentName: 'test-deployment',
-      azureOpenAIApiVersion: '2024-08-01-preview',
-      configuration: { baseURL: 'https://gateway.example.com/azure' },
-    } as unknown as ConstructorParameters<typeof AzureChatOpenAI>[0]);
-    const message = convertDelta(model, toolCallDelta);
-    expect(adapterOf(message)).toBeUndefined();
-  });
-});

package/src/llm/openai/streamMetadata.spec.ts

@@ -1,86 +0,0 @@
-import { expect, test, describe } from '@jest/globals';
-import { AIMessageChunk } from '@langchain/core/messages';
-import { ChatGenerationChunk } from '@langchain/core/outputs';
-import type { SeenScalarMetadata } from './streamMetadata';
-import { dropRepeatedScalarMetadata } from './streamMetadata';
-
-function chunkWithGenerationInfo(
-  generationInfo: Record<string, unknown>
-): ChatGenerationChunk {
-  return new ChatGenerationChunk({
-    text: '',
-    message: new AIMessageChunk({ content: '' }),
-    generationInfo,
-  });
-}
-
-describe('dropRepeatedScalarMetadata', () => {
-  test('drops a scalar repeated within the same completion (keep-first)', () => {
-    const seen: SeenScalarMetadata = new Map();
-    const first = chunkWithGenerationInfo({
-      completion: 0,
-      finish_reason: 'stop',
-      model_name: 'm',
-    });
-    const second = chunkWithGenerationInfo({
-      completion: 0,
-      finish_reason: 'stop',
-      model_name: 'm',
-    });
-
-    dropRepeatedScalarMetadata(first, seen);
-    dropRepeatedScalarMetadata(second, seen);
-
-    expect(first.generationInfo?.finish_reason).toBe('stop');
-    expect(second.generationInfo?.finish_reason).toBeUndefined();
-    expect(second.generationInfo?.model_name).toBeUndefined();
-  });
-
-  test('keeps a scalar that repeats across different completion indices', () => {
-    const seen: SeenScalarMetadata = new Map();
-    const choice0 = chunkWithGenerationInfo({
-      completion: 0,
-      finish_reason: 'stop',
-      model_name: 'm',
-    });
-    const choice1 = chunkWithGenerationInfo({
-      completion: 1,
-      finish_reason: 'stop',
-      model_name: 'm',
-    });
-
-    dropRepeatedScalarMetadata(choice0, seen);
-    dropRepeatedScalarMetadata(choice1, seen);
-
-    // each completion keeps its own finish metadata (n > 1 aggregates per choice)
-    expect(choice0.generationInfo?.finish_reason).toBe('stop');
-    expect(choice1.generationInfo?.finish_reason).toBe('stop');
-  });
-
-  test('clones before deleting so a shared metadata object is not mutated', () => {
-    const seen: SeenScalarMetadata = new Map();
-    // Simulate ChatDeepSeek splitting one raw chunk into pieces that share the
-    // same generationInfo object.
-    const shared = { completion: 0, finish_reason: 'stop', model_name: 'm' };
-    const first = new ChatGenerationChunk({
-      text: '',
-      message: new AIMessageChunk({ content: 'a' }),
-      generationInfo: shared,
-    });
-    const second = new ChatGenerationChunk({
-      text: '',
-      message: new AIMessageChunk({ content: 'b' }),
-      generationInfo: shared,
-    });
-
-    dropRepeatedScalarMetadata(first, seen);
-    dropRepeatedScalarMetadata(second, seen);
-
-    // the already-emitted first piece (and the shared object) keep finish_reason
-    expect(first.generationInfo?.finish_reason).toBe('stop');
-    expect(shared.finish_reason).toBe('stop');
-    // the repeat piece got its own cleaned copy
-    expect(second.generationInfo?.finish_reason).toBeUndefined();
-    expect(second.generationInfo).not.toBe(first.generationInfo);
-  });
-});

package/src/llm/openai/streamMetadataDedup.spec.ts

@@ -1,166 +0,0 @@
-import { concat } from '@langchain/core/utils/stream';
-import { expect, test, describe } from '@jest/globals';
-import { HumanMessage, AIMessageChunk } from '@langchain/core/messages';
-import type {
-  NewTokenIndices,
-  HandleLLMNewTokenCallbackFields,
-} from '@langchain/core/callbacks/base';
-import type { LLMResult } from '@langchain/core/outputs';
-import type { OpenAIClient } from '@langchain/openai';
-import { ChatOpenAI } from './index';
-
-/**
- * Regression for duplicated stream `response_metadata` (issue #14086).
- *
- * Providers that emit `finish_reason` on more than one streamed chunk (e.g.
- * OpenRouter / `openai/gpt-chat-latest`) made LangChain core's `_mergeDicts`
- * concatenate the scalar fields it stamps alongside finish_reason — producing
- * `finish_reason: "stopstop"` and duplicated `model_name`. That corruption
- * appeared in BOTH aggregations: core's `_streamIterator` (feeds `handleLLMEnd`
- * / the Langfuse GENERATION observation) and any host-side `concat` of the
- * yielded chunks (the graph message / trace output). Both are exercised here.
- */
-
-type RawChunk = OpenAIClient.Chat.Completions.ChatCompletionChunk;
-
-const MODEL = 'openai/gpt-chat-latest-20260505';
-
-function stubStream(model: ChatOpenAI, chunks: RawChunk[]): void {
-  (
-    model as unknown as {
-      completions: {
-        completionWithRetry: (
-          request: unknown
-        ) => Promise<AsyncIterable<RawChunk>>;
-      };
-    }
-  ).completions.completionWithRetry = async (): Promise<
-    AsyncIterable<RawChunk>
-  > => ({
-    async *[Symbol.asyncIterator](): AsyncGenerator<RawChunk> {
-      for (const chunk of chunks) {
-        yield chunk;
-      }
-    },
-  });
-}
-
-function rawChunk(
-  delta: Record<string, unknown>,
-  finishReason: 'stop' | null,
-  extra: Partial<RawChunk> = {}
-): RawChunk {
-  return {
-    id: 'chatcmpl-1',
-    object: 'chat.completion.chunk',
-    created: 1,
-    model: MODEL,
-    choices: [
-      {
-        index: 0,
-        delta,
-        finish_reason: finishReason,
-        logprobs: null,
-      },
-    ],
-    ...extra,
-  } as unknown as RawChunk;
-}
-
-async function collect(model: ChatOpenAI): Promise<{
-  coreEnd?: AIMessageChunk;
-  hostConcat?: AIMessageChunk;
-  tokenFinishReasons: unknown[];
-}> {
-  let coreEnd: AIMessageChunk | undefined;
-  const tokenFinishReasons: unknown[] = [];
-  const stream = await model.stream([new HumanMessage('hi')], {
-    callbacks: [
-      {
-        handleLLMEnd(output: LLMResult): void {
-          const generation = output.generations?.[0]?.[0] as
-            | { message?: AIMessageChunk }
-            | undefined;
-          coreEnd = generation?.message;
-        },
-        handleLLMNewToken(
-          _token: string,
-          _idx: NewTokenIndices,
-          _runId: string,
-          _parentRunId?: string,
-          _tags?: string[],
-          fields?: HandleLLMNewTokenCallbackFields
-        ): void {
-          // At emit time the scalars still live in `generationInfo` (core
-          // folds them into `response_metadata` only after it receives the
-          // chunk), so read the surface a token-callback consumer sees here.
-          const chunk = fields?.chunk as
-            | {
-                generationInfo?: Record<string, unknown>;
-                message?: AIMessageChunk;
-              }
-            | undefined;
-          const finishReason =
-            chunk?.generationInfo?.finish_reason ??
-            chunk?.message?.response_metadata?.finish_reason;
-          if (finishReason != null) {
-            tokenFinishReasons.push(finishReason);
-          }
-        },
-      },
-    ],
-  });
-  let hostConcat: AIMessageChunk | undefined;
-  for await (const chunk of stream) {
-    hostConcat = hostConcat == null ? chunk : concat(hostConcat, chunk);
-  }
-  return { coreEnd, hostConcat, tokenFinishReasons };
-}
-
-describe('streamed response_metadata scalar de-duplication', () => {
-  test('collapses repeated finish_reason / model_name across two finish chunks', async () => {
-    const model = new ChatOpenAI({ model: MODEL, apiKey: 'test-key' });
-    stubStream(model, [
-      rawChunk({ role: 'assistant', content: 'Hi' }, 'stop'),
-      rawChunk({ content: '' }, 'stop', {
-        service_tier: 'default',
-      } as Partial<RawChunk>),
-    ]);
-
-    const { coreEnd, hostConcat, tokenFinishReasons } = await collect(model);
-
-    for (const meta of [
-      coreEnd?.response_metadata,
-      hostConcat?.response_metadata,
-    ]) {
-      expect(meta?.finish_reason).toBe('stop');
-      expect(meta?.model_name).toBe(MODEL);
-      // keep-first still preserves a field that only appears on the 2nd chunk
-      expect(meta?.service_tier).toBe('default');
-    }
-    // token callbacks observe the same de-duplicated chunks (finish_reason
-    // stays on the first finish chunk only, never re-emitted on the repeat)
-    expect(tokenFinishReasons).toEqual(['stop']);
-  });
-
-  test('leaves a conformant single-finish stream untouched', async () => {
-    const model = new ChatOpenAI({ model: MODEL, apiKey: 'test-key' });
-    stubStream(model, [
-      rawChunk({ role: 'assistant', content: 'Hi' }, null),
-      rawChunk({ content: '' }, 'stop', {
-        system_fingerprint: 'fp_1',
-      } as Partial<RawChunk>),
-    ]);
-
-    const { coreEnd, hostConcat } = await collect(model);
-
-    for (const meta of [
-      coreEnd?.response_metadata,
-      hostConcat?.response_metadata,
-    ]) {
-      expect(meta?.finish_reason).toBe('stop');
-      expect(meta?.model_name).toBe(MODEL);
-      expect(meta?.system_fingerprint).toBe('fp_1');
-    }
-  });
-});