@qduc/term2 0.7.2 → 0.8.0

package/dist/services/stream-event-processor.test.js

@@ -1,5 +1,5 @@
-import test from 'ava';
-import { LoggingService } from './logging-service.js';
+import { it, expect } from 'vitest';
+import { LoggingService } from './logging/logging-service.js';
 import { createStreamAccumulator, processStreamEvents, } from './stream-event-processor.js';
 const logger = new LoggingService({ disableLogging: true });
 const makeStream = (events, extras = {}) => {
@@ -18,7 +18,7 @@ const baseOpts = () => ({
     preserveExistingToolArgs: false,
 });
 const baseDeps = () => ({ logger, sessionId: 'test-session' });
-test('emits text_delta events with accumulated fullText', async (t) => {
+it('emits text_delta events with accumulated fullText', async () => {
     const stream = makeStream([
         { type: 'raw_model_stream_event', data: { type: 'output_text_delta', delta: 'Hello' } },
         { type: 'raw_model_stream_event', data: { type: 'output_text_delta', delta: ' world' } },
@@ -29,14 +29,14 @@ test('emits text_delta events with accumulated fullText', async (t) => {
         events.push(ev);
     }
     const textEvents = events.filter((e) => e.type === 'text_delta');
-    t.is(textEvents.length, 2);
-    t.is(textEvents[0].delta, 'Hello');
-    t.is(textEvents[0].fullText, 'Hello');
-    t.is(textEvents[1].fullText, 'Hello world');
-    t.is(acc.finalOutput, 'Hello world');
-    t.is(acc.textDeltaCount, 2);
+    expect(textEvents.length).toBe(2);
+    expect(textEvents[0].delta).toBe('Hello');
+    expect(textEvents[0].fullText).toBe('Hello');
+    expect(textEvents[1].fullText).toBe('Hello world');
+    expect(acc.finalOutput).toBe('Hello world');
+    expect(acc.textDeltaCount).toBe(2);
 });
-test('preserves newline between code fence language and first code line across text deltas', async (t) => {
+it('preserves newline between code fence language and first code line across text deltas', async () => {
     const stream = makeStream([
         { type: 'raw_model_stream_event', data: { type: 'output_text_delta', delta: '```typescript' } },
         { type: 'raw_model_stream_event', data: { type: 'output_text_delta', delta: '\n' } },
@@ -48,10 +48,10 @@ test('preserves newline between code fence language and first code line across t
     for await (const ev of processStreamEvents(stream, acc, baseOpts(), baseDeps())) {
         events.push(ev);
     }
-    t.is(acc.finalOutput, '```typescript\nif (enabled) {\n  run();\n}\n```');
-    t.true(events.some((e) => e.type === 'text_delta' && e.fullText === '```typescript\nif (enabled) {\n'));
+    expect(acc.finalOutput).toBe('```typescript\nif (enabled) {\n  run();\n}\n```');
+    expect(events.some((e) => e.type === 'text_delta' && e.fullText === '```typescript\nif (enabled) {\n')).toBe(true);
 });
-test('emits reasoning_delta events with accumulated fullText', async (t) => {
+it('emits reasoning_delta events with accumulated fullText', async () => {
     const stream = makeStream([
         { data: { type: 'model', event: { choices: [{ delta: { reasoning_content: 'think' } }] } } },
         { data: { type: 'model', event: { choices: [{ delta: { reasoning_content: 'ing' } }] } } },
@@ -62,11 +62,11 @@ test('emits reasoning_delta events with accumulated fullText', async (t) => {
         events.push(ev);
     }
     const reasoningEvents = events.filter((e) => e.type === 'reasoning_delta');
-    t.is(reasoningEvents.length, 2);
-    t.is(reasoningEvents[0].delta, 'think');
-    t.is(reasoningEvents[1].fullText, 'thinking');
+    expect(reasoningEvents.length).toBe(2);
+    expect(reasoningEvents[0].delta).toBe('think');
+    expect(reasoningEvents[1].fullText).toBe('thinking');
 });
-test('emits tool_started for function_call run_item_stream_event', async (t) => {
+it('emits tool_started for function_call run_item_stream_event', async () => {
     const stream = makeStream([
         {
             type: 'run_item_stream_event',
@@ -87,12 +87,12 @@ test('emits tool_started for function_call run_item_stream_event', async (t) =>
         events.push(ev);
     }
     const toolStarted = events.find((e) => e.type === 'tool_started');
-    t.truthy(toolStarted);
-    t.is(toolStarted.toolCallId, 'call-1');
-    t.is(toolStarted.toolName, 'shell');
-    t.deepEqual(toolStarted.arguments, { command: 'ls' });
+    expect(toolStarted).toBeTruthy();
+    expect(toolStarted.toolCallId).toBe('call-1');
+    expect(toolStarted.toolName).toBe('shell');
+    expect(toolStarted.arguments).toEqual({ command: 'ls' });
 });
-test('emits one tool_started for duplicate function_call events with the same callId', async (t) => {
+it('emits one tool_started for duplicate function_call events with the same callId', async () => {
     const functionCall = {
         type: 'run_item_stream_event',
         item: {
@@ -112,11 +112,11 @@ test('emits one tool_started for duplicate function_call events with the same ca
         events.push(ev);
     }
     const starts = events.filter((e) => e.type === 'tool_started');
-    t.is(starts.length, 2);
-    t.deepEqual(starts[0].arguments, { command: 'npm test' });
-    t.deepEqual(starts[1].arguments, { command: 'npm test' });
+    expect(starts.length).toBe(2);
+    expect(starts[0].arguments).toEqual({ command: 'npm test' });
+    expect(starts[1].arguments).toEqual({ command: 'npm test' });
 });
-test('emits tool_started even when the callId was already emitted by approval handling', async (t) => {
+it('emits tool_started even when the callId was already emitted by approval handling', async () => {
     const stream = makeStream([
         {
             type: 'run_item_stream_event',
@@ -136,9 +136,9 @@ test('emits tool_started even when the callId was already emitted by approval ha
     for await (const ev of processStreamEvents(stream, acc, opts, baseDeps())) {
         events.push(ev);
     }
-    t.true(events.some((e) => e.type === 'tool_started'));
+    expect(events.some((e) => e.type === 'tool_started')).toBe(true);
 });
-test('invalid JSON arguments are deduped via emittedInvalidToolCallPackets', async (t) => {
+it('invalid JSON arguments are deduped via emittedInvalidToolCallPackets', async () => {
     const events1 = [
         {
             type: 'run_item_stream_event',
@@ -173,10 +173,10 @@ test('invalid JSON arguments are deduped via emittedInvalidToolCallPackets', asy
     for await (const _ of processStreamEvents(makeStream(events1), acc2, opts, deps)) {
         void _;
     }
-    t.is(errorLogCount, 1);
-    t.true(opts.emittedInvalidToolCallPackets.has('call-bad'));
+    expect(errorLogCount).toBe(1);
+    expect(opts.emittedInvalidToolCallPackets.has('call-bad')).toBe(true);
 });
-test('preserveExistingToolArgs=false clears the args map at start', async (t) => {
+it('preserveExistingToolArgs=false clears the args map at start', async () => {
     const opts = baseOpts();
     opts.toolCallArgumentsById.set('old-call', { stale: true });
     opts.preserveExistingToolArgs = false;
@@ -185,9 +185,9 @@ test('preserveExistingToolArgs=false clears the args map at start', async (t) =>
     for await (const _ of processStreamEvents(stream, acc, opts, baseDeps())) {
         void _;
     }
-    t.false(opts.toolCallArgumentsById.has('old-call'));
+    expect(opts.toolCallArgumentsById.has('old-call')).toBe(false);
 });
-test('preserveExistingToolArgs=true keeps the args map intact', async (t) => {
+it('preserveExistingToolArgs=true keeps the args map intact', async () => {
     const opts = baseOpts();
     opts.toolCallArgumentsById.set('old-call', { kept: true });
     opts.preserveExistingToolArgs = true;
@@ -196,9 +196,9 @@ test('preserveExistingToolArgs=true keeps the args map intact', async (t) => {
     for await (const _ of processStreamEvents(stream, acc, opts, baseDeps())) {
         void _;
     }
-    t.deepEqual(opts.toolCallArgumentsById.get('old-call'), { kept: true });
+    expect(opts.toolCallArgumentsById.get('old-call')).toEqual({ kept: true });
 });
-test('emits usage_update when stream event includes usage', async (t) => {
+it('emits usage_update when stream event includes usage', async () => {
     const stream = makeStream([
         {
             data: {
@@ -215,10 +215,10 @@ test('emits usage_update when stream event includes usage', async (t) => {
         events.push(ev);
     }
     const usageEvents = events.filter((e) => e.type === 'usage_update');
-    t.is(usageEvents.length, 1);
-    t.truthy(acc.latestUsage);
+    expect(usageEvents.length).toBe(1);
+    expect(acc.latestUsage).toBeTruthy();
 });
-test('end-of-stream usage harvest from completed promise', async (t) => {
+it('end-of-stream usage harvest from completed promise', async () => {
     const stream = makeStream([], {
         completed: Promise.resolve({ usage: { input_tokens: 5, output_tokens: 7 } }),
     });
@@ -226,9 +226,9 @@ test('end-of-stream usage harvest from completed promise', async (t) => {
     for await (const _ of processStreamEvents(stream, acc, baseOpts(), baseDeps())) {
         void _;
     }
-    t.truthy(acc.latestUsage);
+    expect(acc.latestUsage).toBeTruthy();
 });
-test('end-of-stream usage preserves cache counters from streaming events when completion omits them', async (t) => {
+it('end-of-stream usage preserves cache counters from streaming events when completion omits them', async () => {
     const stream = makeStream([
         {
             type: 'raw_model_stream_event',
@@ -253,26 +253,26 @@ test('end-of-stream usage preserves cache counters from streaming events when co
     for await (const _ of processStreamEvents(stream, acc, baseOpts(), baseDeps())) {
         void _;
     }
-    t.deepEqual(acc.latestUsage, {
+    expect(acc.latestUsage).toEqual({
         prompt_tokens: 100,
         completion_tokens: 20,
         total_tokens: 120,
         cache_read_tokens: 60,
     });
 });
-test('throws AbortError if stream is cancelled', async (t) => {
+it('throws AbortError if stream is cancelled', async () => {
     const stream = makeStream([], {
         completed: Promise.resolve(null),
         cancelled: true,
     });
     const acc = createStreamAccumulator();
-    await t.throwsAsync(async () => {
+    await expect(async () => {
         for await (const _ of processStreamEvents(stream, acc, baseOpts(), baseDeps())) {
             void _;
         }
-    }, { name: 'AbortError', message: 'The user aborted a request.' });
+    }).rejects.toMatchObject({ name: 'AbortError', message: 'The user aborted a request.' });
 });
-test('extracts codex rate limits from nested or flat structures in raw events', async (t) => {
+it('extracts codex rate limits from nested or flat structures in raw events', async () => {
     const nestedEvent = {
         type: 'codex.rate_limits',
         plan_type: 'plus',
@@ -290,11 +290,622 @@ test('extracts codex rate limits from nested or flat structures in raw events',
         events.push(ev);
     }
     const rateLimitEvents = events.filter((e) => e.type === 'codex_rate_limits');
-    t.is(rateLimitEvents.length, 1);
+    expect(rateLimitEvents.length).toBe(1);
     const info = rateLimitEvents[0].rateLimits;
-    t.is(info.allowed, true);
-    t.is(info.limit_reached, false);
-    t.is(info.primary.used_percent, 11);
-    t.is(info.secondary.used_percent, 14);
+    expect(info.allowed).toBe(true);
+    expect(info.limit_reached).toBe(false);
+    expect(info.primary.used_percent).toBe(11);
+    expect(info.secondary.used_percent).toBe(14);
+});
+it('emits tool_call_streaming_delta for Responses API argument deltas', async () => {
+    const stream = makeStream([
+        // Model starts a function_call
+        {
+            type: 'raw_model_stream_event',
+            data: {
+                type: 'model',
+                event: {
+                    type: 'response.output_item.added',
+                    output_index: 0,
+                    output_item: { type: 'function_call', name: 'shell', id: 'call-1' },
+                },
+            },
+        },
+        // Arguments stream in chunks
+        {
+            type: 'raw_model_stream_event',
+            data: {
+                type: 'model',
+                event: {
+                    type: 'response.function_call_arguments.delta',
+                    output_index: 0,
+                    delta: '{"command',
+                },
+            },
+        },
+        {
+            type: 'raw_model_stream_event',
+            data: {
+                type: 'model',
+                event: {
+                    type: 'response.function_call_arguments.delta',
+                    output_index: 0,
+                    delta: '":"ls"}',
+                },
+            },
+        },
+    ]);
+    const acc = createStreamAccumulator();
+    const events = [];
+    for await (const ev of processStreamEvents(stream, acc, baseOpts(), baseDeps())) {
+        events.push(ev);
+    }
+    const deltas = events.filter((e) => e.type === 'tool_call_streaming_delta');
+    expect(deltas.length).toBe(2);
+    // First delta: tool name from added event
+    expect(deltas[0].toolName).toBe('shell');
+    expect(deltas[0].argumentCharCount).toBe(9); // '{"command'.length
+    // Second delta: name still available, count accumulated
+    expect(deltas[1].toolName).toBe('shell');
+    expect(deltas[1].argumentCharCount).toBe(16); // full args length
+});
+it('emits tool_call_streaming_delta for custom tool input deltas', async () => {
+    const stream = makeStream([
+        {
+            type: 'raw_model_stream_event',
+            data: {
+                type: 'model',
+                event: {
+                    type: 'response.output_item.added',
+                    output_index: 0,
+                    output_item: { type: 'function_call', name: 'custom_tool', id: 'call-1' },
+                },
+            },
+        },
+        {
+            type: 'raw_model_stream_event',
+            data: {
+                type: 'model',
+                event: {
+                    type: 'response.custom_tool_call_input.delta',
+                    output_index: 0,
+                    delta: '{"arg',
+                },
+            },
+        },
+        {
+            type: 'raw_model_stream_event',
+            data: {
+                type: 'model',
+                event: {
+                    type: 'response.custom_tool_call_input.delta',
+                    output_index: 0,
+                    delta: '":1}',
+                },
+            },
+        },
+    ]);
+    const acc = createStreamAccumulator();
+    const events = [];
+    for await (const ev of processStreamEvents(stream, acc, baseOpts(), baseDeps())) {
+        events.push(ev);
+    }
+    const deltas = events.filter((e) => e.type === 'tool_call_streaming_delta');
+    expect(deltas.length).toBe(2);
+    expect(deltas[0].toolName).toBe('custom_tool');
+    expect(deltas[0].argumentCharCount).toBe(5); // '{"arg'.length
+    expect(deltas[1].argumentCharCount).toBe(9);
+});
+it('emits tool_call_streaming_delta for MCP tool call argument deltas', async () => {
+    const stream = makeStream([
+        {
+            type: 'raw_model_stream_event',
+            data: {
+                type: 'model',
+                event: {
+                    type: 'response.output_item.added',
+                    output_index: 0,
+                    output_item: { type: 'function_call', name: 'mcp_tool', id: 'call-1' },
+                },
+            },
+        },
+        {
+            type: 'raw_model_stream_event',
+            data: {
+                type: 'model',
+                event: {
+                    type: 'response.mcp_call_arguments.delta',
+                    output_index: 0,
+                    delta: '{"param',
+                },
+            },
+        },
+    ]);
+    const acc = createStreamAccumulator();
+    const events = [];
+    for await (const ev of processStreamEvents(stream, acc, baseOpts(), baseDeps())) {
+        events.push(ev);
+    }
+    const deltas = events.filter((e) => e.type === 'tool_call_streaming_delta');
+    expect(deltas.length).toBe(1);
+    expect(deltas[0].toolName).toBe('mcp_tool');
+    expect(deltas[0].argumentCharCount).toBe(7);
+});
+it('emits tool_call_streaming_delta for legacy response.output_item.delta fallback', async () => {
+    const stream = makeStream([
+        {
+            type: 'raw_model_stream_event',
+            data: {
+                type: 'response.output_item.added',
+                output_index: 0,
+                output_item: { type: 'function_call', name: 'shell', id: 'call-1' },
+            },
+        },
+        {
+            type: 'raw_model_stream_event',
+            data: {
+                type: 'response.output_item.delta',
+                output_index: 0,
+                delta: { arguments: '{"command' },
+            },
+        },
+    ]);
+    const acc = createStreamAccumulator();
+    const events = [];
+    for await (const ev of processStreamEvents(stream, acc, baseOpts(), baseDeps())) {
+        events.push(ev);
+    }
+    const deltas = events.filter((e) => e.type === 'tool_call_streaming_delta');
+    expect(deltas.length).toBe(1);
+    expect(deltas[0].toolName).toBe('shell');
+    expect(deltas[0].argumentCharCount).toBe(9);
+});
+it('emits tool_call_streaming_delta for Chat Completions API tool_calls deltas', async () => {
+    const stream = makeStream([
+        // First chunk: tool call starts with name
+        {
+            data: {
+                type: 'chunk',
+                event: {
+                    choices: [
+                        {
+                            delta: {
+                                tool_calls: [{ index: 0, id: 'call-1', function: { name: 'shell', arguments: '' } }],
+                            },
+                        },
+                    ],
+                },
+            },
+        },
+        // Argument chunks
+        {
+            data: {
+                type: 'chunk',
+                event: {
+                    choices: [
+                        {
+                            delta: {
+                                tool_calls: [{ index: 0, function: { arguments: '{"cmd' } }],
+                            },
+                        },
+                    ],
+                },
+            },
+        },
+        {
+            data: {
+                type: 'chunk',
+                event: {
+                    choices: [
+                        {
+                            delta: {
+                                tool_calls: [{ index: 0, function: { arguments: '":"pwd"}' } }],
+                            },
+                        },
+                    ],
+                },
+            },
+        },
+    ]);
+    const acc = createStreamAccumulator();
+    const events = [];
+    for await (const ev of processStreamEvents(stream, acc, baseOpts(), baseDeps())) {
+        events.push(ev);
+    }
+    const deltas = events.filter((e) => e.type === 'tool_call_streaming_delta');
+    // First chunk has empty arguments, so only 2 deltas emitted (chunks 2 and 3)
+    expect(deltas.length).toBe(2);
+    expect(deltas[0].toolName).toBe('shell');
+    expect(deltas[0].argumentCharCount).toBe(5); // '{"cmd'.length
+    expect(deltas[1].toolName).toBe('shell');
+    expect(deltas[1].argumentCharCount).toBe(13); // full args length: '{"cmd' + '":"pwd"}'
+});
+it('tool_call_streaming_delta accumulates argument char count across deltas', async () => {
+    const stream = makeStream([
+        {
+            data: {
+                type: 'model',
+                event: {
+                    type: 'response.function_call_arguments.delta',
+                    output_index: 0,
+                    delta: 'aaa',
+                },
+            },
+        },
+        {
+            data: {
+                type: 'model',
+                event: {
+                    type: 'response.function_call_arguments.delta',
+                    output_index: 0,
+                    delta: 'bbb',
+                },
+            },
+        },
+        {
+            data: {
+                type: 'model',
+                event: {
+                    type: 'response.function_call_arguments.delta',
+                    output_index: 0,
+                    delta: 'ccc',
+                },
+            },
+        },
+    ]);
+    const acc = createStreamAccumulator();
+    const events = [];
+    for await (const ev of processStreamEvents(stream, acc, baseOpts(), baseDeps())) {
+        events.push(ev);
+    }
+    const deltas = events.filter((e) => e.type === 'tool_call_streaming_delta');
+    expect(deltas.length).toBe(3);
+    expect(deltas[0].argumentCharCount).toBe(3);
+    expect(deltas[1].argumentCharCount).toBe(6);
+    expect(deltas[2].argumentCharCount).toBe(9);
+});
+it('tool_call_streaming_delta includes tool name from output_item.added when available', async () => {
+    const stream = makeStream([
+        {
+            data: {
+                type: 'model',
+                event: {
+                    type: 'response.output_item.added',
+                    output_index: 0,
+                    output_item: { type: 'function_call', name: 'find_files', id: 'call-1' },
+                },
+            },
+        },
+        {
+            data: {
+                type: 'model',
+                event: {
+                    type: 'response.function_call_arguments.delta',
+                    output_index: 0,
+                    delta: '{"pattern',
+                },
+            },
+        },
+    ]);
+    const acc = createStreamAccumulator();
+    const events = [];
+    for await (const ev of processStreamEvents(stream, acc, baseOpts(), baseDeps())) {
+        events.push(ev);
+    }
+    const deltas = events.filter((e) => e.type === 'tool_call_streaming_delta');
+    expect(deltas.length).toBe(1);
+    expect(deltas[0].toolName).toBe('find_files');
+    expect(deltas[0].argumentCharCount).toBe(9); // '{"pattern'.length
+});
+it('tool_call_streaming_delta omits tool name when no output_item.added was seen', async () => {
+    const stream = makeStream([
+        {
+            data: {
+                type: 'model',
+                event: {
+                    type: 'response.function_call_arguments.delta',
+                    output_index: 0,
+                    delta: '{"x":1}',
+                },
+            },
+        },
+    ]);
+    const acc = createStreamAccumulator();
+    const events = [];
+    for await (const ev of processStreamEvents(stream, acc, baseOpts(), baseDeps())) {
+        events.push(ev);
+    }
+    const deltas = events.filter((e) => e.type === 'tool_call_streaming_delta');
+    expect(deltas.length).toBe(1);
+    expect(deltas[0].toolName).toBe(undefined);
+    expect(deltas[0].argumentCharCount).toBe(7);
+});
+it('tool_call_streaming_delta tracks argument char count independently per tool call index', async () => {
+    const stream = makeStream([
+        // Tool call 0 starts
+        {
+            data: {
+                type: 'model',
+                event: {
+                    type: 'response.output_item.added',
+                    output_index: 0,
+                    output_item: { type: 'function_call', name: 'shell', id: 'call-1' },
+                },
+            },
+        },
+        // Tool call 1 starts
+        {
+            data: {
+                type: 'model',
+                event: {
+                    type: 'response.output_item.added',
+                    output_index: 1,
+                    output_item: { type: 'function_call', name: 'find_files', id: 'call-2' },
+                },
+            },
+        },
+        // Arguments for tool call 0
+        {
+            data: {
+                type: 'model',
+                event: {
+                    type: 'response.function_call_arguments.delta',
+                    output_index: 0,
+                    delta: '{"cmd":"ls"}',
+                },
+            },
+        },
+        // Arguments for tool call 1
+        {
+            data: {
+                type: 'model',
+                event: {
+                    type: 'response.function_call_arguments.delta',
+                    output_index: 1,
+                    delta: '{"pattern":"*.ts"}',
+                },
+            },
+        },
+        // More arguments for tool call 0
+        {
+            data: {
+                type: 'model',
+                event: {
+                    type: 'response.function_call_arguments.delta',
+                    output_index: 0,
+                    delta: ',"detailed":true',
+                },
+            },
+        },
+    ]);
+    const acc = createStreamAccumulator();
+    const events = [];
+    for await (const ev of processStreamEvents(stream, acc, baseOpts(), baseDeps())) {
+        events.push(ev);
+    }
+    const deltas = events.filter((e) => e.type === 'tool_call_streaming_delta');
+    expect(deltas.length).toBe(3);
+    expect(deltas[0].toolName).toBe('shell');
+    expect(deltas[0].argumentCharCount).toBe(12); // '{"cmd":"ls"}'.length
+    expect(deltas[1].toolName).toBe('find_files');
+    expect(deltas[1].argumentCharCount).toBe(18); // '{"pattern":"*.ts"}'.length
+    expect(deltas[2].toolName).toBe('shell');
+    expect(deltas[2].argumentCharCount).toBe(28); // 12 + ',"detailed":true'.length
+});
+it('emits tool_call_streaming_delta for AI SDK tool-input start and delta events', async () => {
+    const stream = makeStream([
+        {
+            type: 'raw_model_stream_event',
+            data: {
+                type: 'model',
+                event: {
+                    type: 'tool-input-start',
+                    id: 'call-1',
+                    toolName: 'shell',
+                },
+            },
+        },
+        {
+            type: 'raw_model_stream_event',
+            data: {
+                type: 'model',
+                event: {
+                    type: 'tool-input-delta',
+                    id: 'call-1',
+                    delta: '{"command',
+                },
+            },
+        },
+        {
+            type: 'raw_model_stream_event',
+            data: {
+                type: 'model',
+                event: {
+                    type: 'tool-input-delta',
+                    id: 'call-1',
+                    delta: '":"ls"}',
+                },
+            },
+        },
+    ]);
+    const acc = createStreamAccumulator();
+    const events = [];
+    for await (const ev of processStreamEvents(stream, acc, baseOpts(), baseDeps())) {
+        events.push(ev);
+    }
+    const deltas = events.filter((e) => e.type === 'tool_call_streaming_delta');
+    expect(deltas.length).toBe(2);
+    expect(deltas[0].toolName).toBe('shell');
+    expect(deltas[0].argumentCharCount).toBe(9); // '{"command'.length
+    expect(deltas[1].toolName).toBe('shell');
+    expect(deltas[1].argumentCharCount).toBe(16); // full args length
+});
+it('tool_call_streaming_delta resets argument char count when a new tool call starts on the same index/id', async () => {
+    const stream = makeStream([
+        // Responses API - tool call 0 (shell)
+        {
+            data: {
+                type: 'model',
+                event: {
+                    type: 'response.output_item.added',
+                    output_index: 0,
+                    output_item: { type: 'function_call', name: 'shell', id: 'call-1' },
+                },
+            },
+        },
+        {
+            data: {
+                type: 'model',
+                event: {
+                    type: 'response.function_call_arguments.delta',
+                    output_index: 0,
+                    delta: '{"cmd":"ls"}',
+                },
+            },
+        },
+        // Responses API - tool call 0 again (grep)
+        {
+            data: {
+                type: 'model',
+                event: {
+                    type: 'response.output_item.added',
+                    output_index: 0,
+                    output_item: { type: 'function_call', name: 'grep', id: 'call-2' },
+                },
+            },
+        },
+        {
+            data: {
+                type: 'model',
+                event: {
+                    type: 'response.function_call_arguments.delta',
+                    output_index: 0,
+                    delta: '{"pattern":"foo"}',
+                },
+            },
+        },
+        // Chat Completions API - tool call 0 (shell)
+        {
+            data: {
+                type: 'chunk',
+                event: {
+                    choices: [
+                        {
+                            delta: {
+                                tool_calls: [{ index: 0, id: 'call-3', function: { name: 'shell', arguments: '' } }],
+                            },
+                        },
+                    ],
+                },
+            },
+        },
+        {
+            data: {
+                type: 'chunk',
+                event: {
+                    choices: [
+                        {
+                            delta: {
+                                tool_calls: [{ index: 0, function: { arguments: '{"cmd"' } }],
+                            },
+                        },
+                    ],
+                },
+            },
+        },
+        // Chat Completions API - tool call 0 again (grep)
+        {
+            data: {
+                type: 'chunk',
+                event: {
+                    choices: [
+                        {
+                            delta: {
+                                tool_calls: [{ index: 0, id: 'call-4', function: { name: 'grep', arguments: '' } }],
+                            },
+                        },
+                    ],
+                },
+            },
+        },
+        {
+            data: {
+                type: 'chunk',
+                event: {
+                    choices: [
+                        {
+                            delta: {
+                                tool_calls: [{ index: 0, function: { arguments: '{"pat"' } }],
+                            },
+                        },
+                    ],
+                },
+            },
+        },
+        // AI SDK - tool call 1 (shell)
+        {
+            data: {
+                type: 'model',
+                event: {
+                    type: 'tool-input-start',
+                    id: 'call-5',
+                    toolName: 'shell',
+                },
+            },
+        },
+        {
+            data: {
+                type: 'model',
+                event: {
+                    type: 'tool-input-delta',
+                    id: 'call-5',
+                    delta: '{"command',
+                },
+            },
+        },
+        // AI SDK - tool call 1 again (grep)
+        {
+            data: {
+                type: 'model',
+                event: {
+                    type: 'tool-input-start',
+                    id: 'call-5',
+                    toolName: 'grep',
+                },
+            },
+        },
+        {
+            data: {
+                type: 'model',
+                event: {
+                    type: 'tool-input-delta',
+                    id: 'call-5',
+                    delta: '{"pattern',
+                },
+            },
+        },
+    ]);
+    const acc = createStreamAccumulator();
+    const events = [];
+    for await (const ev of processStreamEvents(stream, acc, baseOpts(), baseDeps())) {
+        events.push(ev);
+    }
+    const deltas = events.filter((e) => e.type === 'tool_call_streaming_delta');
+    expect(deltas.length).toBe(6);
+    // Responses API verification
+    expect(deltas[0].toolName).toBe('shell');
+    expect(deltas[0].argumentCharCount).toBe(12); // '{"cmd":"ls"}'.length
+    expect(deltas[1].toolName).toBe('grep');
+    expect(deltas[1].argumentCharCount).toBe(17); // '{"pattern":"foo"}'.length (should be reset, not 29)
+    // Chat Completions API verification
+    expect(deltas[2].toolName).toBe('shell');
+    expect(deltas[2].argumentCharCount).toBe(6); // '{"cmd"'.length
+    expect(deltas[3].toolName).toBe('grep');
+    expect(deltas[3].argumentCharCount).toBe(6); // '{"pat"'.length (should be reset, not 12)
+    // AI SDK verification
+    expect(deltas[4].toolName).toBe('shell');
+    expect(deltas[4].argumentCharCount).toBe(9); // '{"command'.length
+    expect(deltas[5].toolName).toBe('grep');
+    expect(deltas[5].argumentCharCount).toBe(9); // '{"pattern'.length (should be reset, not 18)
 });
 //# sourceMappingURL=stream-event-processor.test.js.map