@librechat/agents 3.4.7 → 3.5.1

package/src/llm/streamLimits.test.ts

@@ -1,450 +0,0 @@
-import { describe, it, expect } from '@jest/globals';
-import type { ToolCallChunk } from '@langchain/core/messages/tool';
-import type { StreamLimitState } from '@/llm/streamLimits';
-import {
-  STREAMED_TOOL_CALL_ADAPTER_METADATA_KEY,
-  STREAMED_TOOL_CALL_SEAL_METADATA_KEY,
-  OPENAI_RESPONSES_STREAMED_TOOL_CALL_ADAPTER,
-  BEDROCK_CONVERSE_STREAMED_TOOL_CALL_ADAPTER,
-} from '@/tools/streamedToolCallSeals';
-import {
-  DEFAULT_MAX_TOOL_CALL_ARG_BYTES,
-  STREAM_LIMIT_REDISPATCH_KEY,
-  STREAM_LIMIT_ATTEMPT_KEY,
-  enforceStreamedToolCallArgLimit,
-  enforceStreamDeltaEventLimit,
-  StreamLimitExceededError,
-  resolveGenerationKey,
-  resolveStreamLimits,
-} from '@/llm/streamLimits';
-
-const chunk = (fields: Partial<ToolCallChunk>): ToolCallChunk =>
-  ({ type: 'tool_call_chunk', ...fields }) as ToolCallChunk;
-
-const generation = (step: number): Record<string, unknown> => ({
-  langgraph_checkpoint_ns: '',
-  langgraph_node: 'agent',
-  langgraph_step: step,
-});
-
-describe('resolveStreamLimits', () => {
-  it('defaults the byte cap ON and the event cap OFF', () => {
-    expect(resolveStreamLimits()).toEqual({
-      maxToolCallArgBytes: DEFAULT_MAX_TOOL_CALL_ARG_BYTES,
-      maxDeltaEventsPerTurn: 0,
-      hasEnforceableToolCallArgLimit: true,
-    });
-    expect(resolveStreamLimits({})).toEqual({
-      maxToolCallArgBytes: DEFAULT_MAX_TOOL_CALL_ARG_BYTES,
-      maxDeltaEventsPerTurn: 0,
-      hasEnforceableToolCallArgLimit: true,
-    });
-  });
-
-  it('honors explicit values and floors fractions', () => {
-    expect(
-      resolveStreamLimits({ maxToolCallArgBytes: 100.9, maxDeltaEventsPerTurn: 5 })
-    ).toEqual({
-      maxToolCallArgBytes: 100,
-      maxDeltaEventsPerTurn: 5,
-      hasEnforceableToolCallArgLimit: true,
-    });
-  });
-
-  it('treats 0, negatives, and Infinity as disabled', () => {
-    expect(resolveStreamLimits({ maxToolCallArgBytes: 0 }).maxToolCallArgBytes).toBe(0);
-    expect(resolveStreamLimits({ maxToolCallArgBytes: -5 }).maxToolCallArgBytes).toBe(0);
-    expect(
-      resolveStreamLimits({ maxToolCallArgBytes: Infinity }).maxToolCallArgBytes
-    ).toBe(0);
-    expect(
-      resolveStreamLimits({ maxDeltaEventsPerTurn: -1 }).maxDeltaEventsPerTurn
-    ).toBe(0);
-  });
-
-  it('falls back to the default on NaN', () => {
-    expect(resolveStreamLimits({ maxToolCallArgBytes: NaN }).maxToolCallArgBytes).toBe(
-      DEFAULT_MAX_TOOL_CALL_ARG_BYTES
-    );
-  });
-});
-
-describe('resolveGenerationKey', () => {
-  it('derives a stable key from langgraph node-execution metadata', () => {
-    expect(resolveGenerationKey(generation(3))).toBe('|agent|3|');
-    expect(resolveGenerationKey(generation(3))).toBe(resolveGenerationKey(generation(3)));
-  });
-
-  it('separates supersteps, nodes, and namespaces', () => {
-    expect(resolveGenerationKey(generation(3))).not.toBe(resolveGenerationKey(generation(4)));
-    expect(
-      resolveGenerationKey({ ...generation(3), langgraph_node: 'other_agent' })
-    ).not.toBe(resolveGenerationKey(generation(3)));
-    expect(
-      resolveGenerationKey({ ...generation(3), langgraph_checkpoint_ns: 'child' })
-    ).not.toBe(resolveGenerationKey(generation(3)));
-  });
-
-  it('degrades to a shared bucket when metadata is absent', () => {
-    expect(resolveGenerationKey(undefined)).toBe('');
-    expect(resolveGenerationKey({})).toBe('|||');
-  });
-
-  it('scopes model attempts via the attempt stamp, even for identical models', () => {
-    const attemptOne = { ...generation(1), [STREAM_LIMIT_ATTEMPT_KEY]: 7 };
-    const attemptTwo = { ...generation(1), [STREAM_LIMIT_ATTEMPT_KEY]: 8 };
-    expect(resolveGenerationKey(attemptOne)).not.toBe(resolveGenerationKey(attemptTwo));
-
-    const graph: StreamLimitState = {
-      streamLimits: resolveStreamLimits({ maxToolCallArgBytes: 10 }),
-    };
-    enforceStreamedToolCallArgLimit({
-      graph,
-      metadata: attemptOne,
-      toolCallChunks: [chunk({ args: '12345678', index: 0 })],
-    });
-    enforceStreamedToolCallArgLimit({
-      graph,
-      metadata: attemptTwo,
-      toolCallChunks: [chunk({ args: '12345678', index: 0 })],
-    });
-    expect(graph.streamedToolCallArgTallies?.get('|agent|1|7:i:0')?.bytes).toBe(8);
-    expect(graph.streamedToolCallArgTallies?.get('|agent|1|8:i:0')?.bytes).toBe(8);
-  });
-});
-
-describe('enforceStreamedToolCallArgLimit', () => {
-  it('accumulates across chunk events and throws past the limit', () => {
-    const graph: StreamLimitState = {
-      streamLimits: resolveStreamLimits({ maxToolCallArgBytes: 10 }),
-    };
-    const metadata = generation(1);
-    enforceStreamedToolCallArgLimit({
-      graph,
-      metadata,
-      toolCallChunks: [chunk({ name: 'db_query', id: 'call_1', args: '', index: 0 })],
-    });
-    enforceStreamedToolCallArgLimit({
-      graph,
-      metadata,
-      toolCallChunks: [chunk({ args: '12345', index: 0 })],
-    });
-    enforceStreamedToolCallArgLimit({
-      graph,
-      metadata,
-      toolCallChunks: [chunk({ args: '67890', index: 0 })],
-    });
-    let caught: unknown;
-    try {
-      enforceStreamedToolCallArgLimit({
-        graph,
-        metadata,
-        toolCallChunks: [chunk({ args: '!', index: 0 })],
-      });
-    } catch (error) {
-      caught = error;
-    }
-    expect(caught).toBeInstanceOf(StreamLimitExceededError);
-    const limitError = caught as StreamLimitExceededError;
-    expect(limitError.kind).toBe('tool_call_args');
-    expect(limitError.limit).toBe(10);
-    expect(limitError.observed).toBe(11);
-    expect(limitError.toolName).toBe('db_query');
-    expect(limitError.message).toContain('10-byte');
-    expect(limitError.message).toContain('(tool call: db_query)');
-    expect(limitError.message).toContain('maxToolCallArgBytes');
-  });
-
-  it('counts UTF-8 bytes, not string length', () => {
-    const graph: StreamLimitState = {
-      streamLimits: resolveStreamLimits({ maxToolCallArgBytes: 5 }),
-    };
-    expect(() =>
-      enforceStreamedToolCallArgLimit({
-        graph,
-        metadata: generation(1),
-        toolCallChunks: [chunk({ args: '€€', index: 0 })],
-      })
-    ).toThrow(StreamLimitExceededError);
-    expect(graph.streamedToolCallArgTallies?.get('|agent|1|:i:0')?.bytes).toBe(6);
-  });
-
-  it('reconciles surrogate pairs split across chunk boundaries', () => {
-    const graph: StreamLimitState = {
-      streamLimits: resolveStreamLimits({ maxToolCallArgBytes: 4 }),
-    };
-    const metadata = generation(1);
-    const [high, low] = ['\uD83D', '\uDE00'];
-    enforceStreamedToolCallArgLimit({
-      graph,
-      metadata,
-      toolCallChunks: [chunk({ args: high, index: 0 })],
-    });
-    enforceStreamedToolCallArgLimit({
-      graph,
-      metadata,
-      toolCallChunks: [chunk({ args: low, index: 0 })],
-    });
-    expect(graph.streamedToolCallArgTallies?.get('|agent|1|:i:0')?.bytes).toBe(4);
-    expect(() =>
-      enforceStreamedToolCallArgLimit({
-        graph,
-        metadata,
-        toolCallChunks: [chunk({ args: 'x', index: 0 })],
-      })
-    ).toThrow(StreamLimitExceededError);
-  });
-
-  it('keeps counting unpaired surrogates conservatively', () => {
-    const graph: StreamLimitState = {
-      streamLimits: resolveStreamLimits({ maxToolCallArgBytes: 100 }),
-    };
-    const metadata = generation(1);
-    enforceStreamedToolCallArgLimit({
-      graph,
-      metadata,
-      toolCallChunks: [chunk({ args: '\uD83D', index: 0 })],
-    });
-    enforceStreamedToolCallArgLimit({
-      graph,
-      metadata,
-      toolCallChunks: [chunk({ args: 'abc', index: 0 })],
-    });
-    expect(graph.streamedToolCallArgTallies?.get('|agent|1|:i:0')?.bytes).toBe(6);
-  });
-
-  it('tallies parallel tool calls and generations independently', () => {
-    const graph: StreamLimitState = {
-      streamLimits: resolveStreamLimits({ maxToolCallArgBytes: 8 }),
-    };
-    enforceStreamedToolCallArgLimit({
-      graph,
-      metadata: generation(1),
-      toolCallChunks: [
-        chunk({ name: 'first', args: '123456', index: 0 }),
-        chunk({ name: 'second', args: '123456', index: 1 }),
-      ],
-    });
-    enforceStreamedToolCallArgLimit({
-      graph,
-      metadata: generation(2),
-      toolCallChunks: [chunk({ args: '123456', index: 0 })],
-    });
-    expect(() =>
-      enforceStreamedToolCallArgLimit({
-        graph,
-        metadata: generation(1),
-        toolCallChunks: [chunk({ args: '789', index: 1 })],
-      })
-    ).toThrow('(tool call: second)');
-  });
-
-  it('falls back to the chunk id when index is absent', () => {
-    const graph: StreamLimitState = {
-      streamLimits: resolveStreamLimits({ maxToolCallArgBytes: 8 }),
-    };
-    const metadata = generation(1);
-    enforceStreamedToolCallArgLimit({
-      graph,
-      metadata,
-      toolCallChunks: [chunk({ id: 'call_a', name: 'a_tool', args: '123456' })],
-    });
-    enforceStreamedToolCallArgLimit({
-      graph,
-      metadata,
-      toolCallChunks: [chunk({ id: 'call_b', name: 'b_tool', args: '123456' })],
-    });
-    expect(graph.streamedToolCallArgTallies?.get('|agent|1|:c:call_a')?.bytes).toBe(6);
-    expect(() =>
-      enforceStreamedToolCallArgLimit({
-        graph,
-        metadata,
-        toolCallChunks: [chunk({ id: 'call_b', args: '789' })],
-      })
-    ).toThrow('(tool call: b_tool)');
-  });
-
-  it('keys anonymous chunks by batch position so parallel calls stay separate', () => {
-    const graph: StreamLimitState = {
-      streamLimits: resolveStreamLimits({ maxToolCallArgBytes: 8 }),
-    };
-    const metadata = generation(1);
-    enforceStreamedToolCallArgLimit({
-      graph,
-      metadata,
-      toolCallChunks: [
-        chunk({ name: 'anon_a', args: '123456' }),
-        chunk({ name: 'anon_b', args: '123456' }),
-      ],
-    });
-    expect(graph.streamedToolCallArgTallies?.get('|agent|1|:#0')?.bytes).toBe(6);
-    expect(graph.streamedToolCallArgTallies?.get('|agent|1|:#1')?.bytes).toBe(6);
-    expect(() =>
-      enforceStreamedToolCallArgLimit({
-        graph,
-        metadata,
-        toolCallChunks: [chunk({ args: '789' })],
-      })
-    ).toThrow(StreamLimitExceededError);
-  });
-
-  it('checks arrival-sealed complete calls standalone, keeping no tally', () => {
-    const graph: StreamLimitState = {
-      streamLimits: resolveStreamLimits({ maxToolCallArgBytes: 64 }),
-    };
-    const sealAll = { [STREAMED_TOOL_CALL_SEAL_METADATA_KEY]: { kind: 'all' } };
-    enforceStreamedToolCallArgLimit({
-      graph,
-      metadata: generation(1),
-      toolCallChunks: [
-        chunk({ args: 'x'.repeat(40) }),
-        chunk({ args: 'y'.repeat(40) }),
-      ],
-      responseMetadata: sealAll,
-    });
-    expect(graph.streamedToolCallArgTallies?.size).toBe(0);
-    expect(() =>
-      enforceStreamedToolCallArgLimit({
-        graph,
-        metadata: generation(1),
-        toolCallChunks: [chunk({ name: 'big_call', args: 'z'.repeat(70) })],
-        responseMetadata: sealAll,
-      })
-    ).toThrow('(tool call: big_call)');
-  });
-
-  it('replaces the tally when a single-seal chunk restates complete args (OpenAI Responses)', () => {
-    const graph: StreamLimitState = {
-      streamLimits: resolveStreamLimits({ maxToolCallArgBytes: 50 }),
-    };
-    const metadata = generation(1);
-    const fullArgs = 'x'.repeat(40);
-    enforceStreamedToolCallArgLimit({
-      graph,
-      metadata,
-      toolCallChunks: [chunk({ args: fullArgs.slice(0, 20), index: 0 })],
-    });
-    enforceStreamedToolCallArgLimit({
-      graph,
-      metadata,
-      toolCallChunks: [chunk({ args: fullArgs.slice(20), index: 0 })],
-    });
-    enforceStreamedToolCallArgLimit({
-      graph,
-      metadata,
-      toolCallChunks: [chunk({ name: 'writer', args: fullArgs, index: 0 })],
-      responseMetadata: {
-        [STREAMED_TOOL_CALL_ADAPTER_METADATA_KEY]:
-          OPENAI_RESPONSES_STREAMED_TOOL_CALL_ADAPTER,
-        [STREAMED_TOOL_CALL_SEAL_METADATA_KEY]: { kind: 'single', index: 0 },
-      },
-    });
-    expect(graph.streamedToolCallArgTallies?.has('|agent|1|:i:0')).toBe(false);
-  });
-
-  it('releases the tally on a Bedrock Converse stop chunk without counting it', () => {
-    const graph: StreamLimitState = {
-      streamLimits: resolveStreamLimits({ maxToolCallArgBytes: 50 }),
-    };
-    const metadata = generation(1);
-    enforceStreamedToolCallArgLimit({
-      graph,
-      metadata,
-      toolCallChunks: [chunk({ args: '1234567890', index: 0 })],
-    });
-    enforceStreamedToolCallArgLimit({
-      graph,
-      metadata,
-      toolCallChunks: [chunk({ args: '', index: 0 })],
-      responseMetadata: {
-        [STREAMED_TOOL_CALL_ADAPTER_METADATA_KEY]:
-          BEDROCK_CONVERSE_STREAMED_TOOL_CALL_ADAPTER,
-        [STREAMED_TOOL_CALL_SEAL_METADATA_KEY]: { kind: 'single', index: 0 },
-      },
-    });
-    expect(graph.streamedToolCallArgTallies?.has('|agent|1|:i:0')).toBe(false);
-  });
-
-  it('does nothing when disabled', () => {
-    const graph: StreamLimitState = {
-      streamLimits: resolveStreamLimits({ maxToolCallArgBytes: 0 }),
-    };
-    enforceStreamedToolCallArgLimit({
-      graph,
-      metadata: generation(1),
-      toolCallChunks: [chunk({ args: 'x'.repeat(1_000_000), index: 0 })],
-    });
-    expect(graph.streamedToolCallArgTallies).toBeUndefined();
-  });
-
-  it('applies the default limit when graph state was never resolved', () => {
-    const graph: StreamLimitState = {};
-    const metadata = generation(1);
-    enforceStreamedToolCallArgLimit({
-      graph,
-      metadata,
-      toolCallChunks: [
-        chunk({ args: 'x'.repeat(DEFAULT_MAX_TOOL_CALL_ARG_BYTES), index: 0 }),
-      ],
-    });
-    expect(() =>
-      enforceStreamedToolCallArgLimit({
-        graph,
-        metadata,
-        toolCallChunks: [chunk({ args: 'x', index: 0 })],
-      })
-    ).toThrow(StreamLimitExceededError);
-  });
-});
-
-describe('enforceStreamDeltaEventLimit', () => {
-  it('throws once a single generation exceeds the event limit', () => {
-    const graph: StreamLimitState = {
-      streamLimits: resolveStreamLimits({ maxDeltaEventsPerTurn: 3 }),
-    };
-    const metadata = generation(1);
-    enforceStreamDeltaEventLimit({ graph, metadata });
-    enforceStreamDeltaEventLimit({ graph, metadata });
-    enforceStreamDeltaEventLimit({ graph, metadata });
-    let caught: unknown;
-    try {
-      enforceStreamDeltaEventLimit({ graph, metadata });
-    } catch (error) {
-      caught = error;
-    }
-    expect(caught).toBeInstanceOf(StreamLimitExceededError);
-    const limitError = caught as StreamLimitExceededError;
-    expect(limitError.kind).toBe('delta_events');
-    expect(limitError.limit).toBe(3);
-    expect(limitError.observed).toBe(4);
-    expect(limitError.message).toContain('maxDeltaEventsPerTurn');
-    enforceStreamDeltaEventLimit({ graph, metadata: generation(2) });
-    expect(graph.streamDeltaEventCounts?.get('|agent|2|')?.count).toBe(1);
-  });
-
-  it('is disabled by default and allocates nothing', () => {
-    const graph: StreamLimitState = {};
-    for (let i = 0; i < 10; i++) {
-      enforceStreamDeltaEventLimit({ graph, metadata: generation(1) });
-    }
-    expect(graph.streamDeltaEventCounts).toBeUndefined();
-  });
-
-  it('does not double-count inline re-dispatched transformed chunks', () => {
-    const graph: StreamLimitState = {
-      streamLimits: resolveStreamLimits({ maxDeltaEventsPerTurn: 2 }),
-    };
-    const redispatch = {
-      ...generation(1),
-      [STREAM_LIMIT_REDISPATCH_KEY]: true,
-    };
-    for (let i = 0; i < 10; i++) {
-      enforceStreamDeltaEventLimit({ graph, metadata: redispatch });
-    }
-    enforceStreamDeltaEventLimit({ graph, metadata: generation(1) });
-    enforceStreamDeltaEventLimit({ graph, metadata: generation(1) });
-    expect(() =>
-      enforceStreamDeltaEventLimit({ graph, metadata: generation(1) })
-    ).toThrow(StreamLimitExceededError);
-  });
-});

package/src/llm/truncation.test.ts

@@ -1,242 +0,0 @@
-import { describe, expect, it } from '@jest/globals';
-import { AIMessage, AIMessageChunk } from '@langchain/core/messages';
-import {
-  OutputTruncationError,
-  assertNotTruncatedToolCall,
-  getTruncationStopReason,
-} from '@/llm/truncation';
-import { Providers } from '@/common';
-
-describe('getTruncationStopReason', () => {
-  it('returns null when there is no response metadata', () => {
-    expect(getTruncationStopReason(new AIMessage('hi'))).toBeNull();
-    expect(getTruncationStopReason(undefined)).toBeNull();
-  });
-
-  it('detects Bedrock Converse streaming shape (messageStop.stopReason)', () => {
-    const message = new AIMessageChunk({
-      content: '',
-      response_metadata: { messageStop: { stopReason: 'max_tokens' } },
-    });
-    expect(getTruncationStopReason(message)).toBe('max_tokens');
-  });
-
-  it('detects Bedrock Converse non-streaming shape (stopReason)', () => {
-    const message = new AIMessage({
-      content: '',
-      response_metadata: { stopReason: 'max_tokens' },
-    });
-    expect(getTruncationStopReason(message)).toBe('max_tokens');
-  });
-
-  it('detects Anthropic shape (stop_reason)', () => {
-    const message = new AIMessage({
-      content: '',
-      response_metadata: { stop_reason: 'max_tokens' },
-    });
-    expect(getTruncationStopReason(message)).toBe('max_tokens');
-  });
-
-  it('detects OpenAI shape (finish_reason: length)', () => {
-    const message = new AIMessage({
-      content: '',
-      response_metadata: { finish_reason: 'length' },
-    });
-    expect(getTruncationStopReason(message)).toBe('length');
-  });
-
-  it('detects Google shape (finishReason: MAX_TOKENS, case-insensitive)', () => {
-    const message = new AIMessage({
-      content: '',
-      response_metadata: { finishReason: 'MAX_TOKENS' },
-    });
-    expect(getTruncationStopReason(message)).toBe('max_tokens');
-  });
-
-  it('detects Anthropic streaming shape (additional_kwargs.stop_reason)', () => {
-    const message = new AIMessageChunk({
-      content: '',
-      additional_kwargs: { stop_reason: 'max_tokens' },
-      response_metadata: { model_provider: 'anthropic' },
-    });
-    expect(getTruncationStopReason(message)).toBe('max_tokens');
-  });
-
-  it('detects OpenAI Responses shape (incomplete_details.reason)', () => {
-    const message = new AIMessage({
-      content: '',
-      response_metadata: {
-        status: 'incomplete',
-        incomplete_details: { reason: 'max_output_tokens' },
-      },
-    });
-    expect(getTruncationStopReason(message)).toBe('max_tokens');
-  });
-
-  it('returns null for a non-token incomplete reason (content_filter)', () => {
-    const message = new AIMessage({
-      content: '',
-      response_metadata: {
-        status: 'incomplete',
-        incomplete_details: { reason: 'content_filter' },
-      },
-    });
-    expect(getTruncationStopReason(message)).toBeNull();
-  });
-
-  it('returns null for normal stop reasons', () => {
-    expect(
-      getTruncationStopReason(
-        new AIMessage({
-          content: 'x',
-          response_metadata: { stopReason: 'end_turn' },
-        })
-      )
-    ).toBeNull();
-    expect(
-      getTruncationStopReason(
-        new AIMessage({
-          content: 'x',
-          response_metadata: { finish_reason: 'stop' },
-        })
-      )
-    ).toBeNull();
-    expect(
-      getTruncationStopReason(
-        new AIMessage({
-          content: 'x',
-          response_metadata: { stopReason: 'tool_use' },
-        })
-      )
-    ).toBeNull();
-  });
-});
-
-describe('assertNotTruncatedToolCall', () => {
-  it('no-ops for a normal completion', () => {
-    expect(() =>
-      assertNotTruncatedToolCall(
-        new AIMessage({
-          content: 'done',
-          response_metadata: { stopReason: 'end_turn' },
-        })
-      )
-    ).not.toThrow();
-  });
-
-  it('no-ops for a truncated plain-text turn (no tool calls)', () => {
-    expect(() =>
-      assertNotTruncatedToolCall(
-        new AIMessage({
-          content: 'partial...',
-          response_metadata: { stopReason: 'max_tokens' },
-        })
-      )
-    ).not.toThrow();
-  });
-
-  it('no-ops for a complete tool call (normal stop reason)', () => {
-    const message = new AIMessage({
-      content: '',
-      tool_calls: [
-        { id: '1', name: 'create_file', args: { path: 'a', content: 'b' } },
-      ],
-      response_metadata: { stopReason: 'tool_use' },
-    });
-    expect(() => assertNotTruncatedToolCall(message)).not.toThrow();
-  });
-
-  it('throws when a tool call is present and the turn was truncated', () => {
-    const message = new AIMessage({
-      content: '',
-      tool_calls: [{ id: '1', name: 'create_file', args: { path: 'a' } }],
-      response_metadata: { messageStop: { stopReason: 'max_tokens' } },
-    });
-    expect(() => assertNotTruncatedToolCall(message)).toThrow(
-      OutputTruncationError
-    );
-    try {
-      assertNotTruncatedToolCall(message);
-    } catch (err) {
-      expect(err).toBeInstanceOf(OutputTruncationError);
-      expect((err as OutputTruncationError).stopReason).toBe('max_tokens');
-      expect((err as OutputTruncationError).toolCallNames).toContain(
-        'create_file'
-      );
-      expect((err as OutputTruncationError).message).toMatch(
-        /max output tokens/i
-      );
-    }
-  });
-
-  it('throws when only incomplete tool_call_chunks survived truncation', () => {
-    const message = new AIMessageChunk({
-      content: '',
-      tool_call_chunks: [
-        {
-          name: 'create_file',
-          args: '{"path":"a"',
-          index: 0,
-          type: 'tool_call_chunk',
-        },
-      ],
-      response_metadata: { messageStop: { stopReason: 'max_tokens' } },
-    });
-    expect(() => assertNotTruncatedToolCall(message)).toThrow(
-      OutputTruncationError
-    );
-  });
-
-  it('still throws for a streaming-arg provider (Anthropic)', () => {
-    const message = new AIMessage({
-      content: '',
-      tool_calls: [{ id: '1', name: 'create_file', args: { path: 'a' } }],
-      response_metadata: { stop_reason: 'max_tokens' },
-    });
-    expect(() =>
-      assertNotTruncatedToolCall(message, Providers.ANTHROPIC)
-    ).toThrow(OutputTruncationError);
-  });
-
-  it('throws for an Anthropic streaming tool call truncated via additional_kwargs', () => {
-    const message = new AIMessageChunk({
-      content: '',
-      tool_calls: [{ id: '1', name: 'create_file', args: { path: 'a' } }],
-      additional_kwargs: { stop_reason: 'max_tokens' },
-      response_metadata: { model_provider: 'anthropic' },
-    });
-    expect(() =>
-      assertNotTruncatedToolCall(message, Providers.ANTHROPIC)
-    ).toThrow(OutputTruncationError);
-  });
-
-  it('throws for an OpenAI Responses tool call truncated via incomplete_details', () => {
-    const message = new AIMessage({
-      content: '',
-      tool_calls: [{ id: '1', name: 'create_file', args: { path: 'a' } }],
-      response_metadata: {
-        status: 'incomplete',
-        incomplete_details: { reason: 'max_output_tokens' },
-      },
-    });
-    expect(() => assertNotTruncatedToolCall(message, Providers.OPENAI)).toThrow(
-      OutputTruncationError
-    );
-  });
-
-  it('does not throw for providers that deliver complete tool calls (Google/Vertex)', () => {
-    const message = new AIMessage({
-      content: '',
-      tool_calls: [
-        { id: '1', name: 'create_file', args: { path: 'a', content: 'b' } },
-      ],
-      response_metadata: { finishReason: 'MAX_TOKENS' },
-    });
-    expect(() =>
-      assertNotTruncatedToolCall(message, Providers.GOOGLE)
-    ).not.toThrow();
-    expect(() =>
-      assertNotTruncatedToolCall(message, Providers.VERTEXAI)
-    ).not.toThrow();
-  });
-});