discoclaw 0.1.0

package/dist/runtime/openai-compat.js

@@ -0,0 +1,178 @@
+/**
+ * Returns true for models that require `max_completion_tokens` instead of `max_tokens`.
+ * Strips any provider namespace (e.g. "openai/") before matching.
+ */
+export function useMaxCompletionTokens(model) {
+    const name = model.includes('/') ? model.slice(model.lastIndexOf('/') + 1) : model;
+    const lower = name.toLowerCase();
+    return lower.startsWith('o1') || lower.startsWith('o3') || lower.startsWith('gpt-5');
+}
+/** Extract the data payload from an SSE line, or undefined if not a data line. */
+function parseSSEData(line) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith(':'))
+        return undefined;
+    // SSE spec: space after colon is optional (data:payload and data: payload are both valid)
+    if (trimmed.startsWith('data: '))
+        return trimmed.slice('data: '.length);
+    if (trimmed.startsWith('data:'))
+        return trimmed.slice('data:'.length);
+    return undefined;
+}
+export function createOpenAICompatRuntime(opts) {
+    const capabilities = new Set(['streaming_text']);
+    return {
+        id: opts.id ?? 'openai',
+        capabilities,
+        defaultModel: opts.defaultModel,
+        invoke(params) {
+            return (async function* () {
+                const model = params.model || opts.defaultModel;
+                const url = `${opts.baseUrl}/chat/completions`;
+                const tokenField = params.maxTokens !== undefined
+                    ? (useMaxCompletionTokens(model)
+                        ? { max_completion_tokens: params.maxTokens }
+                        : { max_tokens: params.maxTokens })
+                    : {};
+                const body = JSON.stringify({
+                    model,
+                    messages: [{ role: 'user', content: params.prompt }],
+                    stream: true,
+                    ...tokenField,
+                });
+                const controller = new AbortController();
+                let timer;
+                if (params.timeoutMs) {
+                    timer = setTimeout(() => controller.abort(), params.timeoutMs);
+                }
+                // Forward caller's AbortSignal into the controller.
+                const onCallerAbort = () => controller.abort();
+                params.signal?.addEventListener('abort', onCallerAbort, { once: true });
+                if (params.signal?.aborted)
+                    controller.abort();
+                let accumulated = '';
+                try {
+                    opts.log?.debug({ url, model }, 'openai-compat: request');
+                    // Resolve bearer token: static key or dynamic OAuth
+                    let bearerToken = opts.auth === 'chatgpt_oauth'
+                        ? await opts.tokenProvider.getAccessToken()
+                        : opts.apiKey;
+                    let response = await fetch(url, {
+                        method: 'POST',
+                        headers: {
+                            'Authorization': `Bearer ${bearerToken}`,
+                            'Content-Type': 'application/json',
+                        },
+                        body,
+                        signal: controller.signal,
+                    });
+                    // On 401 with OAuth, force-refresh the token and retry once
+                    if (!response.ok && response.status === 401 && opts.auth === 'chatgpt_oauth') {
+                        opts.log?.debug('openai-compat: 401 received, force-refreshing OAuth token');
+                        bearerToken = await opts.tokenProvider.getAccessToken(true);
+                        response = await fetch(url, {
+                            method: 'POST',
+                            headers: {
+                                'Authorization': `Bearer ${bearerToken}`,
+                                'Content-Type': 'application/json',
+                            },
+                            body,
+                            signal: controller.signal,
+                        });
+                    }
+                    if (!response.ok) {
+                        yield { type: 'error', message: `OpenAI API error: ${response.status} ${response.statusText}` };
+                        yield { type: 'done' };
+                        return;
+                    }
+                    if (!response.body) {
+                        yield { type: 'error', message: 'OpenAI API returned no response body' };
+                        yield { type: 'done' };
+                        return;
+                    }
+                    const reader = response.body.getReader();
+                    const decoder = new TextDecoder();
+                    let buffer = '';
+                    // Process a single SSE line, returning 'done' if [DONE] sentinel was hit
+                    const processLine = function* (line) {
+                        const data = parseSSEData(line);
+                        if (data === undefined)
+                            return false;
+                        if (data === '[DONE]') {
+                            yield { type: 'text_final', text: accumulated };
+                            yield { type: 'done' };
+                            return true;
+                        }
+                        try {
+                            const parsed = JSON.parse(data);
+                            const content = parsed?.choices?.[0]?.delta?.content;
+                            if (content) {
+                                accumulated += content;
+                                yield { type: 'text_delta', text: content };
+                            }
+                        }
+                        catch {
+                            // Skip unparseable lines
+                        }
+                        return false;
+                    };
+                    while (true) {
+                        const { done, value } = await reader.read();
+                        if (done)
+                            break;
+                        buffer += decoder.decode(value, { stream: true });
+                        // Process complete lines
+                        const lines = buffer.split('\n');
+                        // Keep the last (possibly incomplete) line in the buffer
+                        buffer = lines.pop() ?? '';
+                        for (const line of lines) {
+                            const result = processLine(line);
+                            let step = result.next();
+                            while (!step.done) {
+                                yield step.value;
+                                step = result.next();
+                            }
+                            if (step.value)
+                                return; // [DONE] hit
+                        }
+                    }
+                    // Process any remaining buffered content (stream ended without trailing newline)
+                    if (buffer.trim()) {
+                        const result = processLine(buffer);
+                        let step = result.next();
+                        while (!step.done) {
+                            yield step.value;
+                            step = result.next();
+                        }
+                        if (step.value)
+                            return; // [DONE] hit
+                    }
+                    // Stream ended without [DONE] — emit what we have
+                    yield { type: 'text_final', text: accumulated };
+                    yield { type: 'done' };
+                }
+                catch (err) {
+                    if (timer)
+                        clearTimeout(timer);
+                    if (controller.signal.aborted) {
+                        if (params.signal?.aborted) {
+                            yield { type: 'error', message: 'aborted' };
+                        }
+                        else {
+                            yield { type: 'error', message: `openai-compat timed out after ${params.timeoutMs}ms` };
+                        }
+                        yield { type: 'done' };
+                        return;
+                    }
+                    yield { type: 'error', message: String(err) };
+                    yield { type: 'done' };
+                }
+                finally {
+                    if (timer)
+                        clearTimeout(timer);
+                    params.signal?.removeEventListener('abort', onCallerAbort);
+                }
+            })();
+        },
+    };
+}

package/dist/runtime/openai-compat.test.js

@@ -0,0 +1,449 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { createOpenAICompatRuntime } from './openai-compat.js';
+async function collectEvents(iter) {
+    const events = [];
+    for await (const evt of iter) {
+        events.push(evt);
+    }
+    return events;
+}
+function makeSSEResponse(chunks, status = 200, statusText = 'OK') {
+    const text = chunks.join('\n') + '\n';
+    const encoder = new TextEncoder();
+    const stream = new ReadableStream({
+        start(controller) {
+            controller.enqueue(encoder.encode(text));
+            controller.close();
+        },
+    });
+    return new Response(stream, { status, statusText });
+}
+/** Like makeSSEResponse but does NOT append a trailing newline — simulates EOF without \n. */
+function makeSSEResponseRaw(rawText, status = 200, statusText = 'OK') {
+    const encoder = new TextEncoder();
+    const stream = new ReadableStream({
+        start(controller) {
+            controller.enqueue(encoder.encode(rawText));
+            controller.close();
+        },
+    });
+    return new Response(stream, { status, statusText });
+}
+function makeSSEData(content) {
+    return `data: ${JSON.stringify({ choices: [{ delta: { content } }] })}`;
+}
+describe('OpenAI-compat runtime adapter', () => {
+    const originalFetch = globalThis.fetch;
+    afterEach(() => {
+        globalThis.fetch = originalFetch;
+    });
+    it('happy path: SSE stream with 3 chunks + [DONE]', async () => {
+        globalThis.fetch = vi.fn().mockResolvedValue(makeSSEResponse([
+            makeSSEData('Hello'),
+            makeSSEData(' world'),
+            makeSSEData('!'),
+            'data: [DONE]',
+        ]));
+        const rt = createOpenAICompatRuntime({
+            baseUrl: 'https://api.example.com/v1',
+            apiKey: 'test-key',
+            defaultModel: 'gpt-4o',
+        });
+        const events = await collectEvents(rt.invoke({
+            prompt: 'Hi',
+            model: '',
+            cwd: '/tmp',
+        }));
+        const deltas = events.filter((e) => e.type === 'text_delta');
+        expect(deltas).toHaveLength(3);
+        expect(deltas.map((d) => d.text)).toEqual(['Hello', ' world', '!']);
+        const final = events.find((e) => e.type === 'text_final');
+        expect(final).toBeDefined();
+        expect(final.text).toBe('Hello world!');
+        const done = events.find((e) => e.type === 'done');
+        expect(done).toBeDefined();
+    });
+    it('HTTP error (401) yields error + done', async () => {
+        globalThis.fetch = vi.fn().mockResolvedValue(new Response('Unauthorized', { status: 401, statusText: 'Unauthorized' }));
+        const rt = createOpenAICompatRuntime({
+            baseUrl: 'https://api.example.com/v1',
+            apiKey: 'bad-key',
+            defaultModel: 'gpt-4o',
+        });
+        const events = await collectEvents(rt.invoke({
+            prompt: 'Hi',
+            model: '',
+            cwd: '/tmp',
+        }));
+        const errorEvt = events.find((e) => e.type === 'error');
+        expect(errorEvt).toBeDefined();
+        expect(errorEvt.message).toContain('401');
+        expect(events[events.length - 1].type).toBe('done');
+    });
+    it('HTTP error (500) yields error + done', async () => {
+        globalThis.fetch = vi.fn().mockResolvedValue(new Response('Server Error', { status: 500, statusText: 'Internal Server Error' }));
+        const rt = createOpenAICompatRuntime({
+            baseUrl: 'https://api.example.com/v1',
+            apiKey: 'test-key',
+            defaultModel: 'gpt-4o',
+        });
+        const events = await collectEvents(rt.invoke({
+            prompt: 'Hi',
+            model: '',
+            cwd: '/tmp',
+        }));
+        const errorEvt = events.find((e) => e.type === 'error');
+        expect(errorEvt).toBeDefined();
+        expect(errorEvt.message).toContain('500');
+        expect(events[events.length - 1].type).toBe('done');
+    });
+    it('network error yields error + done', async () => {
+        globalThis.fetch = vi.fn().mockRejectedValue(new Error('ECONNREFUSED'));
+        const rt = createOpenAICompatRuntime({
+            baseUrl: 'https://api.example.com/v1',
+            apiKey: 'test-key',
+            defaultModel: 'gpt-4o',
+        });
+        const events = await collectEvents(rt.invoke({
+            prompt: 'Hi',
+            model: '',
+            cwd: '/tmp',
+        }));
+        const errorEvt = events.find((e) => e.type === 'error');
+        expect(errorEvt).toBeDefined();
+        expect(errorEvt.message).toContain('ECONNREFUSED');
+        expect(events[events.length - 1].type).toBe('done');
+    });
+    it('timeout yields error + done', async () => {
+        // Mock fetch that delays longer than the timeout
+        globalThis.fetch = vi.fn().mockImplementation((_url, init) => {
+            return new Promise((_resolve, reject) => {
+                const signal = init?.signal;
+                if (signal) {
+                    signal.addEventListener('abort', () => {
+                        reject(new DOMException('The operation was aborted', 'AbortError'));
+                    });
+                }
+            });
+        });
+        const rt = createOpenAICompatRuntime({
+            baseUrl: 'https://api.example.com/v1',
+            apiKey: 'test-key',
+            defaultModel: 'gpt-4o',
+        });
+        const events = await collectEvents(rt.invoke({
+            prompt: 'Hi',
+            model: '',
+            cwd: '/tmp',
+            timeoutMs: 50,
+        }));
+        const errorEvt = events.find((e) => e.type === 'error');
+        expect(errorEvt).toBeDefined();
+        expect(errorEvt.message).toContain('timed out');
+        expect(events[events.length - 1].type).toBe('done');
+    });
+    it('empty stream (immediate [DONE]) yields empty text_final + done', async () => {
+        globalThis.fetch = vi.fn().mockResolvedValue(makeSSEResponse(['data: [DONE]']));
+        const rt = createOpenAICompatRuntime({
+            baseUrl: 'https://api.example.com/v1',
+            apiKey: 'test-key',
+            defaultModel: 'gpt-4o',
+        });
+        const events = await collectEvents(rt.invoke({
+            prompt: 'Hi',
+            model: '',
+            cwd: '/tmp',
+        }));
+        const final = events.find((e) => e.type === 'text_final');
+        expect(final).toBeDefined();
+        expect(final.text).toBe('');
+        expect(events[events.length - 1].type).toBe('done');
+    });
+    it('stream without [DONE] still emits text_final + done', async () => {
+        globalThis.fetch = vi.fn().mockResolvedValue(makeSSEResponse([
+            makeSSEData('Hello'),
+            makeSSEData(' there'),
+            // No [DONE] — stream just ends
+        ]));
+        const rt = createOpenAICompatRuntime({
+            baseUrl: 'https://api.example.com/v1',
+            apiKey: 'test-key',
+            defaultModel: 'gpt-4o',
+        });
+        const events = await collectEvents(rt.invoke({
+            prompt: 'Hi',
+            model: '',
+            cwd: '/tmp',
+        }));
+        const final = events.find((e) => e.type === 'text_final');
+        expect(final).toBeDefined();
+        expect(final.text).toBe('Hello there');
+        expect(events[events.length - 1].type).toBe('done');
+    });
+    it('model override: params.model takes precedence over defaultModel', async () => {
+        let capturedBody;
+        globalThis.fetch = vi.fn().mockImplementation((_url, init) => {
+            capturedBody = init?.body;
+            return Promise.resolve(makeSSEResponse(['data: [DONE]']));
+        });
+        const rt = createOpenAICompatRuntime({
+            baseUrl: 'https://api.example.com/v1',
+            apiKey: 'test-key',
+            defaultModel: 'gpt-4o',
+        });
+        await collectEvents(rt.invoke({
+            prompt: 'Hi',
+            model: 'gpt-4o-mini',
+            cwd: '/tmp',
+        }));
+        const parsed = JSON.parse(capturedBody);
+        expect(parsed.model).toBe('gpt-4o-mini');
+    });
+    it('ignores tools/sessions — no error, tools not in request body', async () => {
+        let capturedBody;
+        globalThis.fetch = vi.fn().mockImplementation((_url, init) => {
+            capturedBody = init?.body;
+            return Promise.resolve(makeSSEResponse(['data: [DONE]']));
+        });
+        const rt = createOpenAICompatRuntime({
+            baseUrl: 'https://api.example.com/v1',
+            apiKey: 'test-key',
+            defaultModel: 'gpt-4o',
+        });
+        const events = await collectEvents(rt.invoke({
+            prompt: 'Hi',
+            model: '',
+            cwd: '/tmp',
+            tools: ['Read', 'Glob', 'Grep'],
+            sessionKey: 'test-session',
+        }));
+        // Should complete without error
+        expect(events.find((e) => e.type === 'error')).toBeUndefined();
+        expect(events.find((e) => e.type === 'done')).toBeDefined();
+        // Request body should not contain tools
+        const parsed = JSON.parse(capturedBody);
+        expect(parsed.tools).toBeUndefined();
+    });
+    it('data: without space after colon is parsed correctly', async () => {
+        // SSE spec allows "data:payload" (no space) — some endpoints emit this form
+        const noSpaceData = `data:${JSON.stringify({ choices: [{ delta: { content: 'no-space' } }] })}`;
+        globalThis.fetch = vi.fn().mockResolvedValue(makeSSEResponse([noSpaceData, 'data:[DONE]']));
+        const rt = createOpenAICompatRuntime({
+            baseUrl: 'https://api.example.com/v1',
+            apiKey: 'test-key',
+            defaultModel: 'gpt-4o',
+        });
+        const events = await collectEvents(rt.invoke({
+            prompt: 'Hi',
+            model: '',
+            cwd: '/tmp',
+        }));
+        const deltas = events.filter((e) => e.type === 'text_delta');
+        expect(deltas).toHaveLength(1);
+        expect(deltas[0].text).toBe('no-space');
+        const final = events.find((e) => e.type === 'text_final');
+        expect(final).toBeDefined();
+        expect(final.text).toBe('no-space');
+        expect(events[events.length - 1].type).toBe('done');
+    });
+    // ---------------------------------------------------------------------------
+    // OAuth 401 retry tests
+    // ---------------------------------------------------------------------------
+    it('401 with OAuth: force-refresh token and retry succeeds', async () => {
+        const capturedHeaders = [];
+        let callCount = 0;
+        globalThis.fetch = vi.fn().mockImplementation((_url, init) => {
+            callCount++;
+            capturedHeaders.push(init?.headers && init.headers['Authorization'] || '');
+            if (callCount === 1) {
+                // First call returns 401
+                return Promise.resolve(new Response('Unauthorized', { status: 401, statusText: 'Unauthorized' }));
+            }
+            // Retry succeeds
+            return Promise.resolve(makeSSEResponse([
+                makeSSEData('retried'),
+                'data: [DONE]',
+            ]));
+        });
+        let forceRefreshCalled = false;
+        const tokenProvider = {
+            getAccessToken: vi.fn().mockImplementation((forceRefresh) => {
+                if (forceRefresh)
+                    forceRefreshCalled = true;
+                return Promise.resolve(forceRefresh ? 'refreshed-token' : 'stale-token');
+            }),
+        };
+        const rt = createOpenAICompatRuntime({
+            baseUrl: 'https://api.example.com/v1',
+            auth: 'chatgpt_oauth',
+            tokenProvider,
+            defaultModel: 'gpt-4o',
+        });
+        const events = await collectEvents(rt.invoke({
+            prompt: 'Hi',
+            model: '',
+            cwd: '/tmp',
+        }));
+        expect(forceRefreshCalled).toBe(true);
+        expect(callCount).toBe(2);
+        // First request used the stale token, retry used the refreshed token
+        expect(capturedHeaders[0]).toBe('Bearer stale-token');
+        expect(capturedHeaders[1]).toBe('Bearer refreshed-token');
+        const final = events.find((e) => e.type === 'text_final');
+        expect(final).toBeDefined();
+        expect(final.text).toBe('retried');
+        expect(events[events.length - 1].type).toBe('done');
+        expect(events.find((e) => e.type === 'error')).toBeUndefined();
+    });
+    it('401 with OAuth: retry also fails yields error + done', async () => {
+        // Both calls return 401
+        globalThis.fetch = vi.fn().mockResolvedValue(new Response('Unauthorized', { status: 401, statusText: 'Unauthorized' }));
+        const tokenProvider = {
+            getAccessToken: vi.fn().mockImplementation((forceRefresh) => Promise.resolve(forceRefresh ? 'refreshed-token' : 'stale-token')),
+        };
+        const rt = createOpenAICompatRuntime({
+            baseUrl: 'https://api.example.com/v1',
+            auth: 'chatgpt_oauth',
+            tokenProvider,
+            defaultModel: 'gpt-4o',
+        });
+        const events = await collectEvents(rt.invoke({
+            prompt: 'Hi',
+            model: '',
+            cwd: '/tmp',
+        }));
+        // Should have called getAccessToken twice (initial + force refresh)
+        expect(tokenProvider.getAccessToken).toHaveBeenCalledTimes(2);
+        expect(tokenProvider.getAccessToken).toHaveBeenLastCalledWith(true);
+        // Should have made two HTTP attempts (initial + retry)
+        expect(globalThis.fetch).toHaveBeenCalledTimes(2);
+        const errorEvt = events.find((e) => e.type === 'error');
+        expect(errorEvt).toBeDefined();
+        expect(errorEvt.message).toContain('401');
+        expect(events[events.length - 1].type).toBe('done');
+    });
+    it('401 with static API key: no retry, yields error + done', async () => {
+        globalThis.fetch = vi.fn().mockResolvedValue(new Response('Unauthorized', { status: 401, statusText: 'Unauthorized' }));
+        const rt = createOpenAICompatRuntime({
+            baseUrl: 'https://api.example.com/v1',
+            apiKey: 'bad-key',
+            defaultModel: 'gpt-4o',
+        });
+        const events = await collectEvents(rt.invoke({
+            prompt: 'Hi',
+            model: '',
+            cwd: '/tmp',
+        }));
+        // fetch should only be called once — no retry for static API keys
+        expect(globalThis.fetch).toHaveBeenCalledTimes(1);
+        const errorEvt = events.find((e) => e.type === 'error');
+        expect(errorEvt).toBeDefined();
+        expect(errorEvt.message).toContain('401');
+        expect(events[events.length - 1].type).toBe('done');
+    });
+    it('adapter id defaults to "openai" when id is not provided', () => {
+        const rt = createOpenAICompatRuntime({
+            baseUrl: 'https://api.example.com/v1',
+            apiKey: 'test-key',
+            defaultModel: 'gpt-4o',
+        });
+        expect(rt.id).toBe('openai');
+    });
+    it('adapter id uses override when id is provided in opts', () => {
+        const rt = createOpenAICompatRuntime({
+            id: 'openrouter',
+            baseUrl: 'https://openrouter.ai/api/v1',
+            apiKey: 'test-key',
+            defaultModel: 'openai/gpt-4o',
+        });
+        expect(rt.id).toBe('openrouter');
+    });
+    // ---------------------------------------------------------------------------
+    // maxTokens field routing tests
+    // ---------------------------------------------------------------------------
+    it('maxTokens with standard model (gpt-4o) sends max_tokens', async () => {
+        let capturedBody;
+        globalThis.fetch = vi.fn().mockImplementation((_url, init) => {
+            capturedBody = init?.body;
+            return Promise.resolve(makeSSEResponse(['data: [DONE]']));
+        });
+        const rt = createOpenAICompatRuntime({
+            baseUrl: 'https://api.example.com/v1',
+            apiKey: 'test-key',
+            defaultModel: 'gpt-4o',
+        });
+        await collectEvents(rt.invoke({
+            prompt: 'Hi',
+            model: 'gpt-4o',
+            cwd: '/tmp',
+            maxTokens: 512,
+        }));
+        const parsed = JSON.parse(capturedBody);
+        expect(parsed.max_tokens).toBe(512);
+        expect(parsed.max_completion_tokens).toBeUndefined();
+    });
+    it('maxTokens with newer model (o3-mini) sends max_completion_tokens', async () => {
+        let capturedBody;
+        globalThis.fetch = vi.fn().mockImplementation((_url, init) => {
+            capturedBody = init?.body;
+            return Promise.resolve(makeSSEResponse(['data: [DONE]']));
+        });
+        const rt = createOpenAICompatRuntime({
+            baseUrl: 'https://api.example.com/v1',
+            apiKey: 'test-key',
+            defaultModel: 'gpt-4o',
+        });
+        await collectEvents(rt.invoke({
+            prompt: 'Hi',
+            model: 'o3-mini',
+            cwd: '/tmp',
+            maxTokens: 1024,
+        }));
+        const parsed = JSON.parse(capturedBody);
+        expect(parsed.max_completion_tokens).toBe(1024);
+        expect(parsed.max_tokens).toBeUndefined();
+    });
+    it('no maxTokens set: neither max_tokens nor max_completion_tokens in request body', async () => {
+        let capturedBody;
+        globalThis.fetch = vi.fn().mockImplementation((_url, init) => {
+            capturedBody = init?.body;
+            return Promise.resolve(makeSSEResponse(['data: [DONE]']));
+        });
+        const rt = createOpenAICompatRuntime({
+            baseUrl: 'https://api.example.com/v1',
+            apiKey: 'test-key',
+            defaultModel: 'gpt-4o',
+        });
+        await collectEvents(rt.invoke({
+            prompt: 'Hi',
+            model: 'gpt-4o',
+            cwd: '/tmp',
+        }));
+        const parsed = JSON.parse(capturedBody);
+        expect(parsed.max_tokens).toBeUndefined();
+        expect(parsed.max_completion_tokens).toBeUndefined();
+    });
+    it('stream ending without trailing newline still processes buffered data', async () => {
+        // Simulate a stream that ends with a data line but no trailing \n
+        const chunk = makeSSEData('buffered');
+        const rawText = `${chunk}`; // no trailing newline
+        globalThis.fetch = vi.fn().mockResolvedValue(makeSSEResponseRaw(rawText));
+        const rt = createOpenAICompatRuntime({
+            baseUrl: 'https://api.example.com/v1',
+            apiKey: 'test-key',
+            defaultModel: 'gpt-4o',
+        });
+        const events = await collectEvents(rt.invoke({
+            prompt: 'Hi',
+            model: '',
+            cwd: '/tmp',
+        }));
+        const deltas = events.filter((e) => e.type === 'text_delta');
+        expect(deltas).toHaveLength(1);
+        expect(deltas[0].text).toBe('buffered');
+        const final = events.find((e) => e.type === 'text_final');
+        expect(final).toBeDefined();
+        expect(final.text).toBe('buffered');
+        expect(events[events.length - 1].type).toBe('done');
+    });
+});