@librechat/agents 3.4.7 → 3.5.1

package/src/llm/stream/reassembly.test.ts

@@ -1,241 +0,0 @@
-import { concat } from '@langchain/core/utils/stream';
-import { AIMessageChunk } from '@langchain/core/messages';
-import { ChatGenerationChunk } from '@langchain/core/outputs';
-import type { SmoothItem } from './smoother';
-import { toSmoothItem } from '@/llm/openai';
-import {
-  toGenerationSmoothItem,
-  getReasoningKwargsText,
-} from './chunkAdapters';
-import { findStreamChunkBoundary } from './smoother';
-
-/**
- * Lossless-reassembly property: for ANY chunk shape an adapter classifies,
- * aggregating the emitted pieces must reproduce the original chunk's
- * observable payload — text, content, kwargs, response metadata, usage,
- * tool calls. This is the invariant behind every split-corruption bug class
- * (duplicated reasoning/kwargs, summed usage, cloned tool args): if a field
- * cannot survive slicing, the adapter must classify the chunk atomic or
- * scope the field to a single piece, and this property proves it did.
- */
-
-type AdapterName = 'openai-family' | 'generic';
-
-const ADAPTERS: Record<
-  AdapterName,
-  (chunk: ChatGenerationChunk) => SmoothItem<ChatGenerationChunk>
-> = {
-  'openai-family': (chunk) => toSmoothItem(chunk),
-  generic: (chunk) => toGenerationSmoothItem(chunk, getReasoningKwargsText),
-};
-
-/** Emits the item the way the engine would: split smooth+splittable items
- * into ≥2 boundary-aligned pieces; atomic and passthrough emit whole. */
-function emitPieces(item: SmoothItem<ChatGenerationChunk>): ChatGenerationChunk[] {
-  if (!item.smooth || item.atomic === true || item.text.length < 8) {
-    return [item.emit({ text: item.text, isFirst: true, isLast: true })];
-  }
-  const pieces: ChatGenerationChunk[] = [];
-  let offset = 0;
-  while (offset < item.text.length) {
-    const end = offset + findStreamChunkBoundary(item.text.slice(offset), 4);
-    pieces.push(
-      item.emit({
-        text: item.text.slice(offset, end),
-        isFirst: offset === 0,
-        isLast: end === item.text.length,
-      })
-    );
-    offset = end;
-  }
-  return pieces;
-}
-
-function aggregate(pieces: ChatGenerationChunk[]): AIMessageChunk {
-  let merged = pieces[0].message as AIMessageChunk;
-  for (const piece of pieces.slice(1)) {
-    merged = concat(merged, piece.message as AIMessageChunk);
-  }
-  return merged;
-}
-
-function assertLossless(
-  adapter: AdapterName,
-  chunk: ChatGenerationChunk
-): void {
-  const item = ADAPTERS[adapter](chunk);
-  const pieces = emitPieces(item);
-  const original = chunk.message as AIMessageChunk;
-
-  const joinedText = pieces.map((p) => p.text).join('');
-  if (item.smooth) {
-    expect(joinedText === chunk.text || joinedText === item.text).toBe(true);
-  }
-
-  const merged = aggregate(pieces);
-  expect(merged.content).toEqual(original.content);
-  expect(merged.additional_kwargs).toEqual(original.additional_kwargs);
-  expect(merged.response_metadata).toEqual(original.response_metadata);
-  /** concat() adds empty *_token_details objects during merge; token COUNTS
-   * are the corruption signal (replicated usage would sum). */
-  expect(merged.usage_metadata?.input_tokens).toBe(
-    original.usage_metadata?.input_tokens
-  );
-  expect(merged.usage_metadata?.output_tokens).toBe(
-    original.usage_metadata?.output_tokens
-  );
-  expect(merged.usage_metadata?.total_tokens).toBe(
-    original.usage_metadata?.total_tokens
-  );
-  expect(merged.tool_call_chunks ?? []).toEqual(
-    original.tool_call_chunks ?? []
-  );
-}
-
-type MatrixCase = {
-  name: string;
-  chunk: () => ChatGenerationChunk;
-  adapters: AdapterName[];
-};
-
-const TEXT = 'the quick brown fox jumps over the lazy dog again and again ';
-
-const MATRIX: MatrixCase[] = [
-  {
-    name: 'plain string text',
-    adapters: ['openai-family', 'generic'],
-    chunk: () =>
-      new ChatGenerationChunk({
-        text: TEXT,
-        message: new AIMessageChunk({ content: TEXT }),
-      }),
-  },
-  {
-    name: 'text with usage metadata',
-    adapters: ['openai-family', 'generic'],
-    chunk: () =>
-      new ChatGenerationChunk({
-        text: TEXT,
-        message: new AIMessageChunk({
-          content: TEXT,
-          usage_metadata: { input_tokens: 7, output_tokens: 11, total_tokens: 18 },
-        }),
-      }),
-  },
-  {
-    name: 'text with an unknown string kwargs field',
-    adapters: ['openai-family', 'generic'],
-    chunk: () =>
-      new ChatGenerationChunk({
-        text: TEXT,
-        message: new AIMessageChunk({
-          content: TEXT,
-          additional_kwargs: { annotation: 'gateway-added-value' },
-        }),
-      }),
-  },
-  {
-    name: 'text with scalar response metadata',
-    adapters: ['openai-family', 'generic'],
-    chunk: () =>
-      new ChatGenerationChunk({
-        text: TEXT,
-        message: new AIMessageChunk({
-          content: TEXT,
-          response_metadata: { model_name: 'test-model', system_fingerprint: 'fp_1' },
-        }),
-      }),
-  },
-  {
-    name: 'text with reasoning_content kwargs',
-    adapters: ['openai-family', 'generic'],
-    chunk: () =>
-      new ChatGenerationChunk({
-        text: TEXT,
-        message: new AIMessageChunk({
-          content: TEXT,
-          additional_kwargs: { reasoning_content: 'a hidden thought' },
-        }),
-      }),
-  },
-  {
-    name: 'text with reasoning_details kwargs',
-    adapters: ['openai-family', 'generic'],
-    chunk: () =>
-      new ChatGenerationChunk({
-        text: TEXT,
-        message: new AIMessageChunk({
-          content: TEXT,
-          additional_kwargs: {
-            reasoning_details: [{ type: 'reasoning.text', text: 'thought' }],
-          },
-        }),
-      }),
-  },
-  {
-    name: 'text alongside tool_call_chunks',
-    adapters: ['openai-family', 'generic'],
-    chunk: () =>
-      new ChatGenerationChunk({
-        text: TEXT,
-        message: new AIMessageChunk({
-          content: TEXT,
-          tool_call_chunks: [
-            { name: 'lookup', args: '{"q":1}', id: 'call_1', index: 0, type: 'tool_call_chunk' },
-          ],
-        }),
-      }),
-  },
-  {
-    name: 'indexed text-part array content (google shape)',
-    adapters: ['generic'],
-    chunk: () =>
-      new ChatGenerationChunk({
-        text: TEXT,
-        message: new AIMessageChunk({
-          content: [{ type: 'text', text: TEXT, index: 0 }],
-        }),
-      }),
-  },
-  {
-    name: 'index-less text-part array content (no merge key)',
-    adapters: ['generic'],
-    chunk: () =>
-      new ChatGenerationChunk({
-        text: TEXT,
-        message: new AIMessageChunk({
-          content: [{ type: 'text', text: TEXT }],
-        }),
-      }),
-  },
-  {
-    name: 'reasoning-only delta',
-    adapters: ['openai-family', 'generic'],
-    chunk: () =>
-      new ChatGenerationChunk({
-        text: '',
-        message: new AIMessageChunk({
-          content: '',
-          additional_kwargs: { reasoning_content: 'thought only delta here' },
-        }),
-      }),
-  },
-  {
-    name: 'usage-only delta',
-    adapters: ['openai-family', 'generic'],
-    chunk: () =>
-      new ChatGenerationChunk({
-        text: '',
-        message: new AIMessageChunk({
-          content: '',
-          usage_metadata: { input_tokens: 1, output_tokens: 2, total_tokens: 3 },
-        }),
-      }),
-  },
-];
-
-describe.each(MATRIX)('lossless reassembly: $name', ({ chunk, adapters }) => {
-  it.each(adapters)('%s adapter', (adapter) => {
-    assertLossless(adapter, chunk());
-  });
-});

package/src/llm/stream/smoother.bench.test.ts

@@ -1,155 +0,0 @@
-import http from 'node:http';
-import { HumanMessage } from '@langchain/core/messages';
-import type { AddressInfo } from 'node:net';
-import { ChatOpenAI } from '@/llm/openai';
-import { SMOOTH_TARGET_LATENCY_MS } from './smoother';
-
-/**
- * End-to-end cadence/lag benchmark: drives the real ChatOpenAI client against
- * a local SSE server that emits large chunks fast (the big-chunk gateway
- * profile smoothing exists for), asserting the properties that define the
- * feature: even cadence at the configured tick, and render lag pinned near
- * the target latency instead of growing with reply length.
- */
-describe('adaptive smoothing benchmark (big-chunk provider)', () => {
-  const WORDS =
-    'ClickHouse stores data in columns so queries read only what they touch and compress well '.split(
-      ' '
-    );
-  const CHUNK_CHARS = 110;
-  const PROVIDER_INTERVAL_MS = 20;
-
-  function buildChunks(totalWords: number): string[] {
-    const out: string[] = [];
-    let current = '';
-    for (let i = 0; i < totalWords; i++) {
-      current += WORDS[i % WORDS.length] + ' ';
-      if (current.length >= CHUNK_CHARS) {
-        out.push(current);
-        current = '';
-      }
-    }
-    if (current) {
-      out.push(current);
-    }
-    return out;
-  }
-
-  function startServer(chunks: string[], stamp: { doneAt: number }): Promise<{
-    server: http.Server;
-    port: number;
-  }> {
-    return new Promise((resolve) => {
-      const server = http.createServer((req, res) => {
-        res.writeHead(200, { 'Content-Type': 'text/event-stream' });
-        const frame = (
-          delta: Record<string, unknown>,
-          finish: string | null
-        ): string =>
-          `data: ${JSON.stringify({
-            id: 'bench',
-            object: 'chat.completion.chunk',
-            created: 1,
-            model: 'bench-model',
-            choices: [{ index: 0, delta, finish_reason: finish }],
-          })}\n\n`;
-        res.write(frame({ role: 'assistant', content: '' }, null));
-        let i = 0;
-        const send = (): void => {
-          if (i < chunks.length) {
-            res.write(frame({ content: chunks[i] }, null));
-            i += 1;
-            setTimeout(send, PROVIDER_INTERVAL_MS);
-          } else {
-            stamp.doneAt = Date.now();
-            res.write(frame({}, 'stop'));
-            res.write('data: [DONE]\n\n');
-            res.end();
-          }
-        };
-        send();
-      });
-      server.listen(0, '127.0.0.1', () => {
-        resolve({ server, port: (server.address() as AddressInfo).port });
-      });
-    });
-  }
-
-  async function measure(
-    totalWords: number,
-    tick: number
-  ): Promise<{
-    meanGap: number;
-    jitter: number;
-    lag: number;
-    totalText: string;
-    expected: string;
-  }> {
-    const chunks = buildChunks(totalWords);
-    const stamp = { doneAt: 0 };
-    const { server, port } = await startServer(chunks, stamp);
-    try {
-      const model = new ChatOpenAI({
-        model: 'bench-model',
-        apiKey: 'bench',
-        streaming: true,
-        configuration: { baseURL: `http://127.0.0.1:${port}/v1` },
-        _lc_stream_delay: tick,
-      });
-
-      const gaps: number[] = [];
-      let totalText = '';
-      let last = Date.now();
-      for await (const piece of await model.stream([new HumanMessage('go')])) {
-        if (typeof piece.content !== 'string' || piece.content === '') {
-          continue;
-        }
-        const now = Date.now();
-        gaps.push(now - last);
-        last = now;
-        totalText += piece.content;
-      }
-      const renderDoneAt = Date.now();
-
-      const paint = gaps.slice(1);
-      const mean = paint.reduce((a, b) => a + b, 0) / paint.length;
-      const jitter = Math.sqrt(
-        paint.reduce((a, b) => a + (b - mean) ** 2, 0) / paint.length
-      );
-      return {
-        meanGap: mean,
-        jitter,
-        lag: renderDoneAt - stamp.doneAt,
-        totalText,
-        expected: chunks.join(''),
-      };
-    } finally {
-      server.close();
-    }
-  }
-
-  /** Bounds are deliberately loose on absolutes (CI machines and parallel
-   * jest workers add scheduling noise); the discriminating assertion is the
-   * last one — lag must stay FLAT as reply length grows, which is the
-   * property fixed-rate smoothing lacks (it lagged +31s at 4x length). */
-  test('holds cadence at the tick with bounded lag on a medium reply', async () => {
-    const tick = 15;
-    const result = await measure(500, tick);
-
-    expect(result.totalText).toBe(result.expected);
-    expect(result.meanGap).toBeGreaterThan(tick * 0.5);
-    expect(result.meanGap).toBeLessThan(tick * 2.5);
-    expect(result.jitter).toBeLessThan(25);
-    expect(result.lag).toBeLessThan(SMOOTH_TARGET_LATENCY_MS * 4);
-  }, 60000);
-
-  test('lag does not grow with reply length', async () => {
-    const tick = 15;
-    const short = await measure(250, tick);
-    const long = await measure(1000, tick);
-
-    expect(long.totalText).toBe(long.expected);
-    expect(long.lag).toBeLessThan(SMOOTH_TARGET_LATENCY_MS * 4);
-    expect(long.lag).toBeLessThan(short.lag + SMOOTH_TARGET_LATENCY_MS * 2);
-  }, 60000);
-});