@librechat/agents 3.4.6 → 3.5.0

package/src/llm/preempt.test.ts

@@ -1,323 +0,0 @@
-import { AIMessageChunk } from '@langchain/core/messages';
-import { canSealPreempt, resolveMaxSeals } from './preempt';
-
-/**
- * The budget is read by two consumers that interpret it differently — a
- * numeric comparison in the seal gate, and an addition into the graph's
- * recursion limit. Normalizing once keeps them in agreement.
- */
-describe('resolveMaxSeals', () => {
-  it('defaults when unset', () => {
-    expect(resolveMaxSeals(undefined)).toBe(8);
-  });
-
-  it('passes a sane whole number through', () => {
-    expect(resolveMaxSeals(3)).toBe(3);
-  });
-
-  it('floors a fractional budget so both readers agree', () => {
-    expect(resolveMaxSeals(1.5)).toBe(1);
-  });
-
-  it('honors zero as a deliberate never-seal', () => {
-    expect(resolveMaxSeals(0)).toBe(0);
-  });
-
-  it('clamps a negative budget to never-seal', () => {
-    expect(resolveMaxSeals(-4)).toBe(0);
-  });
-
-  it('falls back rather than poisoning the recursion limit', () => {
-    expect(resolveMaxSeals(NaN)).toBe(8);
-    expect(resolveMaxSeals(Infinity)).toBe(8);
-    expect(resolveMaxSeals(-Infinity)).toBe(8);
-  });
-});
-
-function chunk(fields: Partial<AIMessageChunk>): AIMessageChunk {
-  return new AIMessageChunk({
-    content: '',
-    ...fields,
-  } as ConstructorParameters<typeof AIMessageChunk>[0]);
-}
-
-describe('canSealPreempt', () => {
-  describe('refuses to seal', () => {
-    it('on a missing chunk', () => {
-      expect(canSealPreempt(undefined)).toBe(false);
-    });
-
-    it('on empty string content', () => {
-      expect(canSealPreempt(chunk({ content: '' }))).toBe(false);
-    });
-
-    it('on whitespace-only string content', () => {
-      expect(canSealPreempt(chunk({ content: '  \n\t ' }))).toBe(false);
-    });
-
-    it('on an empty content array', () => {
-      expect(canSealPreempt(chunk({ content: [] }))).toBe(false);
-    });
-
-    it('on whitespace-only text blocks', () => {
-      expect(
-        canSealPreempt(chunk({ content: [{ type: 'text', text: '   ' }] }))
-      ).toBe(false);
-    });
-
-    it('when the only content is thinking', () => {
-      expect(
-        canSealPreempt(
-          chunk({
-            content: [
-              { type: 'thinking', thinking: 'Let me work through this.' },
-            ],
-          })
-        )
-      ).toBe(false);
-    });
-
-    it('when the only content is reasoning', () => {
-      expect(
-        canSealPreempt(
-          chunk({
-            content: [{ type: 'reasoning', reasoning: 'Considering.' }],
-          })
-        )
-      ).toBe(false);
-    });
-
-    it('when the only content is redacted_thinking', () => {
-      expect(
-        canSealPreempt(
-          chunk({ content: [{ type: 'redacted_thinking', data: 'xxx' }] })
-        )
-      ).toBe(false);
-    });
-
-    it('with a resolved tool call present', () => {
-      expect(
-        canSealPreempt(
-          chunk({
-            content: 'Looking that up.',
-            tool_calls: [{ id: 'c1', name: 'search', args: {} }],
-          })
-        )
-      ).toBe(false);
-    });
-
-    it('with a partial tool call still streaming', () => {
-      expect(
-        canSealPreempt(
-          chunk({
-            content: 'Looking that up.',
-            tool_call_chunks: [
-              { id: 'c1', name: 'search', args: '{"q"', index: 0 },
-            ],
-          })
-        )
-      ).toBe(false);
-    });
-
-    /**
-     * Assigned after construction on purpose: `AIMessageChunk` derives
-     * `invalid_tool_calls` from `tool_call_chunks` and drops a directly
-     * supplied array, so this is the only way to exercise the guard on its
-     * own rather than through the `tool_call_chunks` check above it.
-     */
-    it('with an invalid tool call present', () => {
-      const c = chunk({ content: 'Looking that up.' });
-      c.invalid_tool_calls = [
-        { id: 'c1', name: 'search', args: '{oops', error: 'bad json' },
-      ];
-      expect(canSealPreempt(c)).toBe(false);
-    });
-
-    /**
-     * Anthropic emits a `tool_call_chunk` alongside every `server_tool_use`
-     * content block, and `concat` keeps it on the accumulated message for the
-     * rest of the turn. So a web-search turn is refused by the tool-call gate,
-     * both while the search is in flight and after its result has landed —
-     * this pins that invariant rather than a content-block check.
-     */
-    it('while an Anthropic server tool is in flight', () => {
-      expect(
-        canSealPreempt(
-          chunk({
-            content: [
-              { type: 'text', text: 'Searching the web for that.' },
-              {
-                type: 'server_tool_use',
-                id: 'srvtoolu_1',
-                name: 'web_search',
-                input: { query: 'x' },
-              },
-            ],
-            tool_call_chunks: [
-              { id: 'srvtoolu_1', name: 'web_search', args: '', index: 0 },
-            ],
-          })
-        )
-      ).toBe(false);
-    });
-
-    /**
-     * Gemini server-side tools land as `toolCall` / `toolResponse` content
-     * blocks and never populate `tool_calls` or `tool_call_chunks`, so the
-     * tool-call gates above cannot see them.
-     */
-    it('while a Google server tool call is unanswered', () => {
-      expect(
-        canSealPreempt(
-          chunk({
-            content: [
-              { type: 'text', text: 'Let me look that up.' },
-              { type: 'toolCall', id: 'gcall_1', name: 'google_search' },
-            ],
-          })
-        )
-      ).toBe(false);
-    });
-
-    it('with more Google server tool calls than responses', () => {
-      expect(
-        canSealPreempt(
-          chunk({
-            content: [
-              { type: 'text', text: 'Checking two things.' },
-              { type: 'toolCall', id: 'gcall_1', name: 'google_search' },
-              { type: 'toolResponse', id: 'gcall_1', response: {} },
-              { type: 'toolCall', id: 'gcall_2', name: 'google_search' },
-            ],
-          })
-        )
-      ).toBe(false);
-    });
-
-    it('while one of several server tool calls is still unanswered', () => {
-      expect(
-        canSealPreempt(
-          chunk({
-            content: [
-              { type: 'text', text: 'Checking two sources.' },
-              {
-                type: 'web_search_tool_result',
-                tool_use_id: 'srvtoolu_1',
-                content: [],
-              },
-            ],
-            tool_call_chunks: [
-              { id: 'srvtoolu_1', name: 'web_search', args: '', index: 0 },
-              { id: 'srvtoolu_2', name: 'web_search', args: '', index: 1 },
-            ],
-          })
-        )
-      ).toBe(false);
-    });
-  });
-
-  describe('seals', () => {
-    it('on non-empty string content', () => {
-      expect(canSealPreempt(chunk({ content: 'The migration has' }))).toBe(
-        true
-      );
-    });
-
-    it('on a non-empty text block', () => {
-      expect(
-        canSealPreempt(
-          chunk({ content: [{ type: 'text', text: 'The migration has' }] })
-        )
-      ).toBe(true);
-    });
-
-    it('on text that follows signed thinking', () => {
-      expect(
-        canSealPreempt(
-          chunk({
-            content: [
-              {
-                type: 'thinking',
-                thinking: 'Working it out.',
-                signature: 'sig',
-              },
-              { type: 'text', text: 'The migration has' },
-            ],
-          })
-        )
-      ).toBe(true);
-    });
-
-    it('with empty tool-call arrays present', () => {
-      expect(
-        canSealPreempt(
-          chunk({
-            content: 'The migration has',
-            tool_calls: [],
-            tool_call_chunks: [],
-            invalid_tool_calls: [],
-          })
-        )
-      ).toBe(true);
-    });
-
-    it('once every Google server tool call has been answered', () => {
-      expect(
-        canSealPreempt(
-          chunk({
-            content: [
-              { type: 'text', text: 'Here is what I found.' },
-              { type: 'toolCall', id: 'gcall_1', name: 'google_search' },
-              { type: 'toolResponse', id: 'gcall_1', response: {} },
-            ],
-          })
-        )
-      ).toBe(true);
-    });
-
-    /**
-     * Provider-side tools never reach `ToolNode`, so no `PostToolBatch`
-     * boundary exists to drain into. Refusing forever after a search would
-     * defer a queued message to the end of the turn rather than to the next
-     * tool step, so a call whose result has landed counts as settled.
-     */
-    it('once an Anthropic server tool result has landed', () => {
-      expect(
-        canSealPreempt(
-          chunk({
-            content: [
-              { type: 'text', text: 'Here is what I found.' },
-              {
-                type: 'server_tool_use',
-                id: 'srvtoolu_1',
-                name: 'web_search',
-                input: { query: 'x' },
-              },
-              {
-                type: 'web_search_tool_result',
-                tool_use_id: 'srvtoolu_1',
-                content: [],
-              },
-            ],
-            tool_call_chunks: [
-              { id: 'srvtoolu_1', name: 'web_search', args: '', index: 0 },
-            ],
-          })
-        )
-      ).toBe(true);
-    });
-
-    it('on a non-text block that carries no tool call', () => {
-      expect(
-        canSealPreempt(
-          chunk({
-            content: [
-              { type: 'text', text: 'Here is the diagram.' },
-              { type: 'image_url', image_url: { url: 'https://x/y.png' } },
-            ],
-          })
-        )
-      ).toBe(true);
-    });
-  });
-});

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

@@ -1,202 +0,0 @@
-import { AIMessageChunk } from '@langchain/core/messages';
-import { ChatGenerationChunk } from '@langchain/core/outputs';
-import {
-  toGenerationSmoothItem,
-  getReasoningKwargsText,
-  cloneGenerationChunkPiece,
-} from './chunkAdapters';
-
-type MessageChunkFields = {
-  usage_metadata?: AIMessageChunk['usage_metadata'];
-  additional_kwargs?: AIMessageChunk['additional_kwargs'];
-  response_metadata?: AIMessageChunk['response_metadata'];
-};
-
-function textChunk(
-  text: string,
-  extra: MessageChunkFields = {}
-): ChatGenerationChunk {
-  return new ChatGenerationChunk({
-    text,
-    message: new AIMessageChunk({ content: text, ...extra }),
-  });
-}
-
-describe('toGenerationSmoothItem classification', () => {
-  it('splits plain string-content text chunks', () => {
-    const item = toGenerationSmoothItem(textChunk('alpha beta gamma'));
-    expect(item.smooth).toBe(true);
-    expect(item.atomic).toBeUndefined();
-    expect(item.text).toBe('alpha beta gamma');
-  });
-
-  it('keeps chunks carrying reasoning_content kwargs atomic', () => {
-    const chunk = textChunk('visible text here', {
-      additional_kwargs: { reasoning_content: 'hidden thought' },
-    });
-    const item = toGenerationSmoothItem(chunk);
-    expect(item.smooth).toBe(true);
-    expect(item.atomic).toBe(true);
-    expect(item.emit({ text: item.text, isFirst: true, isLast: true })).toBe(
-      chunk
-    );
-  });
-
-  it('keeps chunks carrying a reasoning summary object atomic', () => {
-    const chunk = textChunk('visible text here', {
-      additional_kwargs: { reasoning: { summary: [{ text: 'thought' }] } },
-    });
-    expect(toGenerationSmoothItem(chunk).atomic).toBe(true);
-  });
-
-  it('keeps chunks carrying OpenRouter reasoning_details atomic', () => {
-    const chunk = textChunk('visible text here', {
-      additional_kwargs: {
-        reasoning_details: [{ type: 'reasoning.text', text: 'thought' }],
-      },
-    });
-    expect(toGenerationSmoothItem(chunk).atomic).toBe(true);
-  });
-
-  it('keeps chunks carrying camelCase finishReason atomic', () => {
-    const chunk = new ChatGenerationChunk({
-      text: 'final text with several words here',
-      generationInfo: { finishReason: 'STOP' },
-      message: new AIMessageChunk({
-        content: 'final text with several words here',
-      }),
-    });
-    const item = toGenerationSmoothItem(chunk);
-    expect(item.atomic).toBe(true);
-    expect(item.emit({ text: item.text, isFirst: true, isLast: true })).toBe(
-      chunk
-    );
-  });
-
-  it('keeps mixed text/tool-call chunks atomic', () => {
-    const chunk = new ChatGenerationChunk({
-      text: 'calling the weather tool for you now',
-      message: new AIMessageChunk({
-        content: 'calling the weather tool for you now',
-        tool_call_chunks: [
-          { name: 'weather', args: '{"city":', id: 'call_1', index: 0 },
-        ],
-      }),
-    });
-    const item = toGenerationSmoothItem(chunk);
-    expect(item.atomic).toBe(true);
-    expect(item.emit({ text: item.text, isFirst: true, isLast: true })).toBe(
-      chunk
-    );
-  });
-
-  it('paces reasoning-only chunks atomically via the kwargs extractor', () => {
-    const thoughtOnly = new ChatGenerationChunk({
-      text: '',
-      message: new AIMessageChunk({
-        content: '',
-        additional_kwargs: { reasoning: 'a hidden gemini thought' },
-      }),
-    });
-    const item = toGenerationSmoothItem(thoughtOnly, getReasoningKwargsText);
-    expect(item.smooth).toBe(true);
-    expect(item.atomic).toBe(true);
-    expect(item.text).toBe('a hidden gemini thought');
-  });
-
-  it('paces reasoning_details-only chunks atomically via the kwargs extractor', () => {
-    const detailsOnly = new ChatGenerationChunk({
-      text: '',
-      message: new AIMessageChunk({
-        content: '',
-        additional_kwargs: {
-          reasoning_details: [
-            { type: 'reasoning.text', text: 'first thought ' },
-            { type: 'reasoning.text', text: 'second thought' },
-          ],
-        },
-      }),
-    });
-    const item = toGenerationSmoothItem(detailsOnly, getReasoningKwargsText);
-    expect(item.smooth).toBe(true);
-    expect(item.atomic).toBe(true);
-    expect(item.text).toBe('first thought second thought');
-  });
-
-  it('classifies usage-only chunks as passthrough', () => {
-    const chunk = new ChatGenerationChunk({
-      text: '',
-      message: new AIMessageChunk({
-        content: '',
-        usage_metadata: { input_tokens: 1, output_tokens: 2, total_tokens: 3 },
-      }),
-    });
-    const item = toGenerationSmoothItem(chunk);
-    expect(item.smooth).toBe(false);
-    expect(item.text).toBe('');
-  });
-});
-
-describe('cloneGenerationChunkPiece metadata scoping', () => {
-  const chunk = textChunk('alpha beta gamma', {
-    usage_metadata: { input_tokens: 1, output_tokens: 2, total_tokens: 3 },
-    additional_kwargs: { annotation: 'once' },
-    response_metadata: { model_name: 'test-model' },
-  });
-
-  it('keeps kwargs, response metadata and usage on the first piece only', () => {
-    const first = cloneGenerationChunkPiece(chunk, {
-      text: 'alpha ',
-      isFirst: true,
-      isLast: false,
-    });
-    const later = cloneGenerationChunkPiece(chunk, {
-      text: 'beta ',
-      isFirst: false,
-      isLast: false,
-    });
-
-    const firstMessage = first.message as AIMessageChunk;
-    const laterMessage = later.message as AIMessageChunk;
-    expect(firstMessage.additional_kwargs).toEqual({ annotation: 'once' });
-    expect(firstMessage.response_metadata).toEqual({
-      model_name: 'test-model',
-    });
-    expect(firstMessage.usage_metadata).toBeDefined();
-    expect(laterMessage.additional_kwargs).toEqual({});
-    expect(laterMessage.response_metadata).toEqual({});
-    expect(laterMessage.usage_metadata).toBeUndefined();
-  });
-
-  it('keeps generationInfo on the first piece only', () => {
-    const infoChunk = new ChatGenerationChunk({
-      text: 'alpha beta gamma',
-      generationInfo: {
-        usage_metadata: { input_tokens: 1, output_tokens: 2, total_tokens: 3 },
-      },
-      message: new AIMessageChunk({ content: 'alpha beta gamma' }),
-    });
-    const first = cloneGenerationChunkPiece(infoChunk, {
-      text: 'alpha ',
-      isFirst: true,
-      isLast: false,
-    });
-    const later = cloneGenerationChunkPiece(infoChunk, {
-      text: 'beta ',
-      isFirst: false,
-      isLast: false,
-    });
-    expect(first.generationInfo).toBeDefined();
-    expect(later.generationInfo).toBeUndefined();
-  });
-
-  it('returns the original chunk for unsplit pieces', () => {
-    expect(
-      cloneGenerationChunkPiece(chunk, {
-        text: 'alpha beta gamma',
-        isFirst: true,
-        isLast: true,
-      })
-    ).toBe(chunk);
-  });
-});