@machina.ai/cell-cli-core 1.49.0-rc5 → 1.50.0-rc1

package/dist/src/core/openAiCompatibleContentGenerator.test.js

@@ -0,0 +1,850 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { OpenAiCompatibleContentGenerator } from './openAiCompatibleContentGenerator.js';
+import { LlmRole } from '../telemetry/types.js';
+import { Type, ThinkingLevel } from '@google/genai';
+function getFetchBody() {
+    const call = vi.mocked(fetch).mock.calls[0];
+    const init = call?.[1];
+    return JSON.parse(String(init?.body || '{}'));
+}
+function createSseBody(events) {
+    const encoder = new TextEncoder();
+    const chunks = events.map((event) => {
+        if (typeof event === 'string') {
+            return encoder.encode(event);
+        }
+        return encoder.encode(`data: ${JSON.stringify(event)}
+
+`);
+    });
+    let index = 0;
+    return {
+        getReader() {
+            return {
+                async read() {
+                    if (index >= chunks.length) {
+                        return { done: true, value: undefined };
+                    }
+                    const value = chunks[index];
+                    index += 1;
+                    return { done: false, value };
+                },
+            };
+        },
+    };
+}
+describe('OpenAiCompatibleContentGenerator', () => {
+    let mockConfig;
+    beforeEach(() => {
+        vi.stubGlobal('fetch', vi.fn());
+        mockConfig = {
+            getAgentApiUrl: vi.fn().mockReturnValue('https://cell-api.local/api/'),
+        };
+    });
+    afterEach(() => {
+        vi.unstubAllGlobals();
+        vi.restoreAllMocks();
+    });
+    it('defaults openai and xai providers to the Responses transport', () => {
+        const openai = new OpenAiCompatibleContentGenerator(mockConfig, 'openai/gpt-5.6-luna', 'mock-keycloak-token');
+        expect(openai.provider).toBe('openai');
+        expect(openai.modelName).toBe('gpt-5.6-luna');
+        expect(openai.transportMode).toBe('responses');
+        expect(openai.endpointUrl).toBe('https://cell-api.local/api/cell/v1.1/openai/v1/responses');
+        const xai = new OpenAiCompatibleContentGenerator(mockConfig, 'xai/grok-4.5', 'mock-keycloak-token');
+        expect(xai.transportMode).toBe('responses');
+        expect(xai.endpointUrl).toBe('https://cell-api.local/api/cell/v1.1/xai/v1/responses');
+    });
+    it('keeps chat_completions transport when explicitly configured', () => {
+        mockConfig.getOpenAiTransportMode = vi
+            .fn()
+            .mockReturnValue('chat_completions');
+        const generator = new OpenAiCompatibleContentGenerator(mockConfig, 'openai/gpt-4o', 'mock-keycloak-token');
+        expect(generator.transportMode).toBe('chat_completions');
+        expect(generator.endpointUrl).toBe('https://cell-api.local/api/cell/v1.1/openai/v1/chat/completions');
+    });
+    it('should inject Keycloak Authorization token correctly into request headers', async () => {
+        const generator = new OpenAiCompatibleContentGenerator(mockConfig, 'xai/grok-2', 'mock-keycloak-token');
+        const mockResponse = {
+            ok: true,
+            json: async () => ({
+                output: [
+                    {
+                        type: 'message',
+                        content: [{ type: 'output_text', text: 'Hello World' }],
+                    },
+                ],
+                usage: {
+                    input_tokens: 9,
+                    output_tokens: 12,
+                },
+            }),
+        };
+        vi.mocked(fetch).mockResolvedValue(mockResponse);
+        const response = await generator.generateContent({
+            model: 'xai/grok-2',
+            contents: [{ role: 'user', parts: [{ text: 'hi' }] }],
+        }, 'user-prompt-1', LlmRole.MAIN);
+        expect(response).toBeDefined();
+        expect(fetch).toHaveBeenCalledWith('https://cell-api.local/api/cell/v1.1/xai/v1/responses', expect.objectContaining({
+            method: 'POST',
+            headers: expect.objectContaining({
+                Authorization: 'Bearer mock-keycloak-token',
+                'Content-Type': 'application/json',
+            }),
+        }));
+    });
+    it('should inject sessionId header correctly into request headers when passed in constructor', async () => {
+        const generator = new OpenAiCompatibleContentGenerator(mockConfig, 'xai/grok-2', 'mock-keycloak-token', 'test-session-id-param');
+        const mockResponse = {
+            ok: true,
+            json: async () => ({
+                output: [
+                    {
+                        type: 'message',
+                        content: [{ type: 'output_text', text: 'response' }],
+                    },
+                ],
+            }),
+        };
+        vi.mocked(fetch).mockResolvedValue(mockResponse);
+        await generator.generateContent({
+            model: 'xai/grok-2',
+            contents: [{ role: 'user', parts: [{ text: 'hi' }] }],
+        }, 'user-prompt-1', LlmRole.MAIN);
+        expect(fetch).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({
+            headers: expect.objectContaining({
+                sessionId: 'test-session-id-param',
+            }),
+        }));
+    });
+    it('should fallback to config.getSessionId() for sessionId header when not passed in constructor', async () => {
+        mockConfig.getSessionId = vi.fn().mockReturnValue('fallback-session-id');
+        const generator = new OpenAiCompatibleContentGenerator(mockConfig, 'xai/grok-2', 'mock-keycloak-token');
+        const mockResponse = {
+            ok: true,
+            json: async () => ({
+                output: [
+                    {
+                        type: 'message',
+                        content: [{ type: 'output_text', text: 'response' }],
+                    },
+                ],
+            }),
+        };
+        vi.mocked(fetch).mockResolvedValue(mockResponse);
+        await generator.generateContent({
+            model: 'xai/grok-2',
+            contents: [{ role: 'user', parts: [{ text: 'hi' }] }],
+        }, 'user-prompt-1', LlmRole.MAIN);
+        expect(fetch).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({
+            headers: expect.objectContaining({
+                sessionId: 'fallback-session-id',
+            }),
+        }));
+    });
+    it('maps conversation history to Responses input and always sets store:false', async () => {
+        const generator = new OpenAiCompatibleContentGenerator(mockConfig, 'openai/gpt-4o', 'mock-keycloak-token');
+        const mockResponse = {
+            ok: true,
+            json: async () => ({
+                output: [
+                    {
+                        type: 'message',
+                        content: [{ type: 'output_text', text: 'hello back' }],
+                    },
+                ],
+            }),
+        };
+        vi.mocked(fetch).mockResolvedValue(mockResponse);
+        await generator.generateContent({
+            model: 'openai/gpt-4o',
+            contents: [
+                { role: 'user', parts: [{ text: 'Hello' }] },
+                { role: 'model', parts: [{ text: 'Hi, how can I help?' }] },
+                { role: 'user', parts: [{ text: 'Tell me a joke.' }] },
+            ],
+            config: {
+                systemInstruction: 'You are a funny assistant.',
+            },
+        }, 'prompt-1', LlmRole.MAIN);
+        const body = getFetchBody();
+        expect(body).toEqual({
+            model: 'gpt-4o',
+            store: false,
+            input: [
+                { role: 'system', content: 'You are a funny assistant.' },
+                { role: 'user', content: 'Hello' },
+                { role: 'assistant', content: 'Hi, how can I help?' },
+                { role: 'user', content: 'Tell me a joke.' },
+            ],
+        });
+        expect(body).not.toHaveProperty('previous_response_id');
+        expect(body).not.toHaveProperty('messages');
+    });
+    it('maps multi-turn tool history into function_call and function_call_output items', async () => {
+        const generator = new OpenAiCompatibleContentGenerator(mockConfig, 'openai/gpt-4o', 'mock-keycloak-token');
+        const mockResponse = {
+            ok: true,
+            json: async () => ({
+                output: [
+                    {
+                        type: 'message',
+                        content: [{ type: 'output_text', text: 'tool response processed' }],
+                    },
+                ],
+            }),
+        };
+        vi.mocked(fetch).mockResolvedValue(mockResponse);
+        await generator.generateContent({
+            model: 'openai/gpt-4o',
+            contents: [
+                { role: 'user', parts: [{ text: 'What is the weather in London?' }] },
+                {
+                    role: 'model',
+                    parts: [
+                        {
+                            functionCall: {
+                                name: 'get_weather',
+                                args: { location: 'London' },
+                            },
+                        },
+                    ],
+                },
+                {
+                    role: 'user',
+                    parts: [
+                        {
+                            functionResponse: {
+                                name: 'get_weather',
+                                response: { temperature: '15C' },
+                            },
+                        },
+                    ],
+                },
+            ],
+        }, 'prompt-1', LlmRole.MAIN);
+        const body = getFetchBody();
+        expect(body['input']).toEqual([
+            { role: 'user', content: 'What is the weather in London?' },
+            {
+                type: 'function_call',
+                call_id: 'call_0',
+                name: 'get_weather',
+                arguments: JSON.stringify({ location: 'London' }),
+            },
+            {
+                type: 'function_call_output',
+                call_id: 'call_0',
+                output: JSON.stringify({ temperature: '15C' }),
+            },
+        ]);
+    });
+    it('maps tools to internally-tagged Responses format with strict:false', async () => {
+        const generator = new OpenAiCompatibleContentGenerator(mockConfig, 'openai/gpt-4o', 'mock-keycloak-token');
+        const mockResponse = {
+            ok: true,
+            json: async () => ({
+                output: [
+                    {
+                        type: 'message',
+                        content: [
+                            { type: 'output_text', text: 'I will call get_weather now' },
+                        ],
+                    },
+                    {
+                        type: 'function_call',
+                        call_id: 'call_999',
+                        name: 'get_weather',
+                        arguments: '{"location":"New York"}',
+                    },
+                ],
+                usage: {
+                    input_tokens: 15,
+                    output_tokens: 25,
+                    output_tokens_details: { reasoning_tokens: 3 },
+                },
+            }),
+        };
+        vi.mocked(fetch).mockResolvedValue(mockResponse);
+        const response = await generator.generateContent({
+            model: 'openai/gpt-4o',
+            contents: [
+                { role: 'user', parts: [{ text: 'Check weather in New York' }] },
+            ],
+            config: {
+                tools: [
+                    {
+                        functionDeclarations: [
+                            {
+                                name: 'get_weather',
+                                description: 'Get weather description',
+                                parameters: {
+                                    type: Type.OBJECT,
+                                    properties: {
+                                        location: { type: Type.STRING },
+                                    },
+                                    required: ['location'],
+                                },
+                            },
+                        ],
+                    },
+                ],
+            },
+        }, 'prompt-1', LlmRole.MAIN);
+        const body = getFetchBody();
+        expect(body['tools']).toEqual([
+            {
+                type: 'function',
+                name: 'get_weather',
+                description: 'Get weather description',
+                parameters: {
+                    type: 'object',
+                    properties: {
+                        location: { type: 'string' },
+                    },
+                    required: ['location'],
+                },
+                strict: false,
+            },
+        ]);
+        expect(response.candidates?.[0]?.content?.parts).toEqual([
+            { text: 'I will call get_weather now' },
+            {
+                functionCall: {
+                    id: 'call_999',
+                    name: 'get_weather',
+                    args: { location: 'New York' },
+                },
+            },
+        ]);
+        expect(response.usageMetadata).toEqual({
+            promptTokenCount: 15,
+            candidatesTokenCount: 25,
+            totalTokenCount: 43,
+            thoughtsTokenCount: 3,
+        });
+    });
+    it('omits reasoning for grok-4-1-fast models', async () => {
+        const generator = new OpenAiCompatibleContentGenerator(mockConfig, 'xai/grok-4-1-fast-reasoning', 'mock-keycloak-token');
+        vi.mocked(fetch).mockResolvedValue({
+            ok: true,
+            json: async () => ({
+                output: [
+                    {
+                        type: 'message',
+                        content: [{ type: 'output_text', text: 'ok' }],
+                    },
+                ],
+            }),
+        });
+        await generator.generateContent({
+            model: 'xai/grok-4-1-fast-reasoning',
+            contents: [{ role: 'user', parts: [{ text: 'hi' }] }],
+            config: {
+                thinkingConfig: {
+                    thinkingLevel: ThinkingLevel.HIGH,
+                },
+            },
+        }, 'prompt-1', LlmRole.MAIN);
+        const body = getFetchBody();
+        expect(body).not.toHaveProperty('reasoning');
+    });
+    it('clamps xhigh reasoning effort to high for xAI models', async () => {
+        const generator = new OpenAiCompatibleContentGenerator(mockConfig, 'xai/grok-4.5', 'mock-keycloak-token');
+        vi.mocked(fetch).mockResolvedValue({
+            ok: true,
+            json: async () => ({
+                output: [
+                    {
+                        type: 'message',
+                        content: [{ type: 'output_text', text: 'ok' }],
+                    },
+                ],
+            }),
+        });
+        await generator.generateContent({
+            model: 'xai/grok-4.5',
+            contents: [{ role: 'user', parts: [{ text: 'hi' }] }],
+            config: {
+                thinkingConfig: {
+                    // Exercise clamp path via unsupported high-end effort string.
+                    thinkingLevel: 'xhigh',
+                },
+            },
+        }, 'prompt-1', LlmRole.MAIN);
+        const body = getFetchBody();
+        expect(body['reasoning']).toEqual({ effort: 'high' });
+    });
+    it('sends reasoning.effort for gpt-5.6 models with tools', async () => {
+        const generator = new OpenAiCompatibleContentGenerator(mockConfig, 'openai/gpt-5.6-luna', 'mock-keycloak-token');
+        vi.mocked(fetch).mockResolvedValue({
+            ok: true,
+            json: async () => ({
+                output: [
+                    {
+                        type: 'function_call',
+                        call_id: 'call_1',
+                        name: 'read_file',
+                        arguments: '{"path":"a.ts"}',
+                    },
+                ],
+            }),
+        });
+        await generator.generateContent({
+            model: 'openai/gpt-5.6-luna',
+            contents: [{ role: 'user', parts: [{ text: 'read a.ts' }] }],
+            config: {
+                thinkingConfig: {
+                    thinkingLevel: ThinkingLevel.HIGH,
+                },
+                tools: [
+                    {
+                        functionDeclarations: [
+                            {
+                                name: 'read_file',
+                                description: 'Read a file',
+                                parameters: {
+                                    type: Type.OBJECT,
+                                    properties: {
+                                        path: { type: Type.STRING },
+                                    },
+                                },
+                            },
+                        ],
+                    },
+                ],
+            },
+        }, 'prompt-1', LlmRole.MAIN);
+        const body = getFetchBody();
+        expect(body['reasoning']).toEqual({ effort: 'high' });
+        expect(body['store']).toBe(false);
+        expect(Array.isArray(body['tools'])).toBe(true);
+    });
+    it('omits top_p for OpenAI Responses even when request config provides topP', async () => {
+        const generator = new OpenAiCompatibleContentGenerator(mockConfig, 'openai/gpt-5.6-luna', 'mock-keycloak-token');
+        vi.mocked(fetch).mockResolvedValue({
+            ok: true,
+            json: async () => ({
+                output: [
+                    {
+                        type: 'message',
+                        content: [{ type: 'output_text', text: 'ok' }],
+                    },
+                ],
+            }),
+        });
+        const stream = await generator.generateContentStream({
+            model: 'openai/gpt-5.6-luna',
+            contents: [{ role: 'user', parts: [{ text: 'hola' }] }],
+            config: {
+                topP: 0.95,
+                temperature: 1,
+            },
+        }, 'prompt-top-p', LlmRole.MAIN);
+        for await (const _chunk of stream) {
+            // Drain so makeStream executes the fetch.
+        }
+        const body = getFetchBody();
+        expect(body).not.toHaveProperty('top_p');
+        expect(body['temperature']).toBe(1);
+    });
+    it('uses non-stream Responses for OpenAI GPT simple prompt to avoid stream_options proxy bug', async () => {
+        const generator = new OpenAiCompatibleContentGenerator(mockConfig, 'openai/gpt-5.6-luna', 'mock-keycloak-token');
+        const mockResponse = {
+            ok: true,
+            json: async () => ({
+                output: [
+                    {
+                        type: 'message',
+                        content: [{ type: 'output_text', text: '¡Hola!' }],
+                    },
+                ],
+                usage: { input_tokens: 2, output_tokens: 1 },
+            }),
+        };
+        vi.mocked(fetch).mockResolvedValue(mockResponse);
+        const stream = await generator.generateContentStream({
+            model: 'openai/gpt-5.6-luna',
+            contents: [{ role: 'user', parts: [{ text: 'hola' }] }],
+        }, 'prompt-hola', LlmRole.MAIN);
+        const texts = [];
+        for await (const chunk of stream) {
+            const text = chunk.candidates?.[0]?.content?.parts?.[0]?.text;
+            if (text)
+                texts.push(text);
+        }
+        expect(texts).toEqual(['¡Hola!']);
+        // Critical: non-stream OpenAI must set finishReason or GeminiChat retries 4x
+        // and the UI concatenates the same greeting.
+        // (asserted via a second drain below on a dedicated response)
+        const body = getFetchBody();
+        expect(body).toEqual({
+            model: 'gpt-5.6-luna',
+            store: false,
+            input: [{ role: 'user', content: 'hola' }],
+        });
+        expect(body).not.toHaveProperty('stream');
+        expect(body).not.toHaveProperty('stream_options');
+        expect(body).not.toHaveProperty('previous_response_id');
+        expect(body).not.toHaveProperty('messages');
+        expect(body).not.toHaveProperty('reasoning_effort');
+        expect(fetch).toHaveBeenCalledWith('https://cell-api.local/api/cell/v1.1/openai/v1/responses', expect.objectContaining({ method: 'POST' }));
+    });
+    it('sets finishReason STOP on non-stream OpenAI Responses payloads', async () => {
+        const generator = new OpenAiCompatibleContentGenerator(mockConfig, 'openai/gpt-5.6-luna', 'mock-keycloak-token');
+        vi.mocked(fetch).mockResolvedValue({
+            ok: true,
+            json: async () => ({
+                output: [
+                    {
+                        type: 'message',
+                        content: [{ type: 'output_text', text: '¡Hola!' }],
+                    },
+                ],
+                usage: { input_tokens: 2, output_tokens: 1 },
+            }),
+        });
+        const stream = await generator.generateContentStream({
+            model: 'openai/gpt-5.6-luna',
+            contents: [{ role: 'user', parts: [{ text: 'hola' }] }],
+        }, 'prompt-finish', LlmRole.MAIN);
+        let finish;
+        let text = '';
+        for await (const chunk of stream) {
+            text += chunk.candidates?.[0]?.content?.parts?.[0]?.text || '';
+            finish = chunk.candidates?.[0]?.finishReason || finish;
+        }
+        expect(text).toBe('¡Hola!');
+        expect(finish).toBe('STOP');
+    });
+    it('keeps true SSE streaming for xAI Responses', async () => {
+        const generator = new OpenAiCompatibleContentGenerator(mockConfig, 'xai/grok-4.5', 'mock-keycloak-token');
+        const mockResponse = {
+            ok: true,
+            headers: {
+                get: (name) => name.toLowerCase() === 'content-type' ? 'text/event-stream' : null,
+            },
+            body: createSseBody([
+                { type: 'response.output_text.delta', delta: 'Hola Grok' },
+                {
+                    type: 'response.completed',
+                    response: { usage: { input_tokens: 2, output_tokens: 1 } },
+                },
+            ]),
+        };
+        vi.mocked(fetch).mockResolvedValue(mockResponse);
+        const stream = await generator.generateContentStream({
+            model: 'xai/grok-4.5',
+            contents: [{ role: 'user', parts: [{ text: 'hola' }] }],
+        }, 'prompt-grok', LlmRole.MAIN);
+        const texts = [];
+        for await (const chunk of stream) {
+            const text = chunk.candidates?.[0]?.content?.parts?.[0]?.text;
+            if (text)
+                texts.push(text);
+        }
+        expect(texts).toEqual(['Hola Grok']);
+        expect(getFetchBody()['stream']).toBe(true);
+        expect(getFetchBody()['store']).toBe(false);
+    });
+    it('falls back to non-stream JSON when Responses returns application/json', async () => {
+        const generator = new OpenAiCompatibleContentGenerator(mockConfig, 'openai/gpt-5.6-luna', 'mock-keycloak-token');
+        const mockResponse = {
+            ok: true,
+            headers: {
+                get: () => 'application/json',
+            },
+            json: async () => ({
+                output: [
+                    {
+                        type: 'message',
+                        content: [{ type: 'output_text', text: 'hola de vuelta' }],
+                    },
+                ],
+                usage: { input_tokens: 1, output_tokens: 2 },
+            }),
+            body: {
+                getReader() {
+                    throw new Error('should not stream JSON body');
+                },
+            },
+        };
+        vi.mocked(fetch).mockResolvedValue(mockResponse);
+        const stream = await generator.generateContentStream({
+            model: 'openai/gpt-5.6-luna',
+            contents: [{ role: 'user', parts: [{ text: 'hola' }] }],
+        }, 'prompt-hola-json', LlmRole.MAIN);
+        const chunks = [];
+        for await (const chunk of stream) {
+            chunks.push(chunk);
+        }
+        expect(chunks).toHaveLength(1);
+        expect(chunks[0].candidates?.[0]?.content?.parts?.[0]?.text).toBe('hola de vuelta');
+    });
+    it('parses Responses SSE text deltas', async () => {
+        const generator = new OpenAiCompatibleContentGenerator(mockConfig, 'xai/grok-4.5', 'mock-keycloak-token');
+        const mockResponse = {
+            ok: true,
+            headers: {
+                get: (name) => name.toLowerCase() === 'content-type' ? 'text/event-stream' : null,
+            },
+            body: createSseBody([
+                { type: 'response.output_text.delta', delta: 'Hello' },
+                { type: 'response.output_text.delta', delta: ' World' },
+                {
+                    type: 'response.completed',
+                    response: {
+                        usage: { input_tokens: 4, output_tokens: 2 },
+                    },
+                },
+            ]),
+        };
+        vi.mocked(fetch).mockResolvedValue(mockResponse);
+        const stream = await generator.generateContentStream({
+            model: 'xai/grok-4.5',
+            contents: [{ role: 'user', parts: [{ text: 'stream test' }] }],
+        }, 'prompt-1', LlmRole.MAIN);
+        const chunks = [];
+        let usage;
+        for await (const chunk of stream) {
+            const text = chunk.candidates?.[0]?.content?.parts?.[0]?.text || '';
+            if (text) {
+                chunks.push(text);
+            }
+            if (chunk.usageMetadata) {
+                usage = chunk.usageMetadata;
+            }
+        }
+        expect(chunks).toEqual(['Hello', ' World']);
+        expect(usage).toEqual({
+            promptTokenCount: 4,
+            candidatesTokenCount: 2,
+            totalTokenCount: 6,
+            thoughtsTokenCount: undefined,
+        });
+        expect(getFetchBody()['stream']).toBe(true);
+        expect(getFetchBody()['store']).toBe(false);
+        expect(getFetchBody()).not.toHaveProperty('stream_options');
+    });
+    it('parses Responses SSE single tool call events', async () => {
+        const generator = new OpenAiCompatibleContentGenerator(mockConfig, 'xai/grok-4.5', 'mock-keycloak-token');
+        const mockResponse = {
+            ok: true,
+            body: createSseBody([
+                {
+                    type: 'response.output_item.added',
+                    item: {
+                        type: 'function_call',
+                        id: 'fc_1',
+                        call_id: 'call_abc',
+                        name: 'get_weather',
+                    },
+                },
+                {
+                    type: 'response.function_call_arguments.delta',
+                    item_id: 'fc_1',
+                    call_id: 'call_abc',
+                    delta: '{"location":',
+                },
+                {
+                    type: 'response.function_call_arguments.delta',
+                    item_id: 'fc_1',
+                    call_id: 'call_abc',
+                    delta: '"Paris"}',
+                },
+                {
+                    type: 'response.output_item.done',
+                    item: {
+                        type: 'function_call',
+                        id: 'fc_1',
+                        call_id: 'call_abc',
+                        name: 'get_weather',
+                        arguments: '{"location":"Paris"}',
+                    },
+                },
+                {
+                    type: 'response.completed',
+                    response: {
+                        usage: { input_tokens: 10, output_tokens: 5 },
+                    },
+                },
+            ]),
+        };
+        vi.mocked(fetch).mockResolvedValue(mockResponse);
+        const stream = await generator.generateContentStream({
+            model: 'xai/grok-4.5',
+            contents: [{ role: 'user', parts: [{ text: 'weather?' }] }],
+        }, 'prompt-1', LlmRole.MAIN);
+        const functionCalls = [];
+        for await (const chunk of stream) {
+            if (chunk.functionCalls) {
+                functionCalls.push(...chunk.functionCalls);
+            }
+        }
+        expect(functionCalls).toEqual([
+            {
+                id: 'call_abc',
+                name: 'get_weather',
+                args: { location: 'Paris' },
+            },
+        ]);
+    });
+    it('parses Responses SSE parallel tool calls', async () => {
+        const generator = new OpenAiCompatibleContentGenerator(mockConfig, 'xai/grok-4.5', 'mock-keycloak-token');
+        const mockResponse = {
+            ok: true,
+            body: createSseBody([
+                {
+                    type: 'response.output_item.added',
+                    item: {
+                        type: 'function_call',
+                        id: 'fc_1',
+                        call_id: 'call_1',
+                        name: 'tool_a',
+                        arguments: '{"a":1}',
+                    },
+                },
+                {
+                    type: 'response.output_item.added',
+                    item: {
+                        type: 'function_call',
+                        id: 'fc_2',
+                        call_id: 'call_2',
+                        name: 'tool_b',
+                        arguments: '{"b":2}',
+                    },
+                },
+                {
+                    type: 'response.completed',
+                    response: {
+                        usage: { input_tokens: 1, output_tokens: 1 },
+                    },
+                },
+            ]),
+        };
+        vi.mocked(fetch).mockResolvedValue(mockResponse);
+        const stream = await generator.generateContentStream({
+            model: 'xai/grok-4.5',
+            contents: [{ role: 'user', parts: [{ text: 'parallel' }] }],
+        }, 'prompt-1', LlmRole.MAIN);
+        const names = [];
+        for await (const chunk of stream) {
+            for (const call of chunk.functionCalls || []) {
+                if (call.name) {
+                    names.push(call.name);
+                }
+            }
+        }
+        expect(names.sort()).toEqual(['tool_a', 'tool_b']);
+    });
+    it('does not re-emit full text from output_text.done and finishes on message done', async () => {
+        const generator = new OpenAiCompatibleContentGenerator(mockConfig, 'xai/grok-4.5', 'mock-keycloak-token');
+        const mockResponse = {
+            ok: true,
+            headers: {
+                get: (name) => name.toLowerCase() === 'content-type' ? 'text/event-stream' : null,
+            },
+            body: createSseBody([
+                { type: 'response.output_text.delta', delta: 'Hola' },
+                {
+                    type: 'response.output_text.done',
+                    text: 'Hola',
+                },
+                {
+                    type: 'response.output_item.done',
+                    item: {
+                        type: 'message',
+                        content: [{ type: 'output_text', text: 'Hola' }],
+                    },
+                },
+                {
+                    type: 'response.completed',
+                    response: { usage: { input_tokens: 1, output_tokens: 1 } },
+                },
+            ]),
+        };
+        vi.mocked(fetch).mockResolvedValue(mockResponse);
+        const stream = await generator.generateContentStream({
+            model: 'xai/grok-4.5',
+            contents: [{ role: 'user', parts: [{ text: 'hola' }] }],
+        }, 'prompt-dedupe', LlmRole.MAIN);
+        const texts = [];
+        let finishCount = 0;
+        for await (const chunk of stream) {
+            const t = chunk.candidates?.[0]?.content?.parts?.[0]?.text;
+            if (t)
+                texts.push(t);
+            if (chunk.candidates?.[0]?.finishReason)
+                finishCount += 1;
+        }
+        expect(texts).toEqual(['Hola']);
+        expect(finishCount).toBeGreaterThanOrEqual(1);
+    });
+    it('surfaces Responses SSE mid-stream errors', async () => {
+        const generator = new OpenAiCompatibleContentGenerator(mockConfig, 'xai/grok-4.5', 'mock-keycloak-token');
+        const mockResponse = {
+            ok: true,
+            body: createSseBody([
+                { type: 'response.output_text.delta', delta: 'partial' },
+                {
+                    type: 'response.failed',
+                    error: { message: 'boom mid-stream' },
+                },
+            ]),
+        };
+        vi.mocked(fetch).mockResolvedValue(mockResponse);
+        const stream = await generator.generateContentStream({
+            model: 'xai/grok-4.5',
+            contents: [{ role: 'user', parts: [{ text: 'fail' }] }],
+        }, 'prompt-1', LlmRole.MAIN);
+        await expect(async () => {
+            for await (const _chunk of stream) {
+                // drain
+            }
+        }).rejects.toThrow('boom mid-stream');
+    });
+    it('ignores reasoning output items in non-stream responses', () => {
+        const generator = new OpenAiCompatibleContentGenerator(mockConfig, 'openai/gpt-5.6-terra', 'mock-keycloak-token');
+        const parsed = generator.parseResponsesPayload({
+            output: [
+                { type: 'reasoning', id: 'r1' },
+                {
+                    type: 'message',
+                    content: [{ type: 'output_text', text: 'final answer' }],
+                },
+            ],
+            usage: { input_tokens: 2, output_tokens: 3 },
+        });
+        expect(parsed.candidates?.[0]?.content?.parts).toEqual([
+            { text: 'final answer' },
+        ]);
+    });
+    it('supports chat_completions transport for non-default providers', async () => {
+        const generator = new OpenAiCompatibleContentGenerator(mockConfig, 'local/llama-3', 'mock-token', undefined, 'chat_completions');
+        expect(generator.endpointUrl).toBe('https://cell-api.local/api/cell/v1.1/local/v1/chat/completions');
+        vi.mocked(fetch).mockResolvedValue({
+            ok: true,
+            json: async () => ({
+                choices: [{ message: { content: 'local ok' } }],
+                usage: { prompt_tokens: 1, completion_tokens: 1, total_tokens: 2 },
+            }),
+        });
+        const response = await generator.generateContent({
+            model: 'local/llama-3',
+            contents: [{ role: 'user', parts: [{ text: 'hi' }] }],
+        }, 'prompt-1', LlmRole.MAIN);
+        const body = getFetchBody();
+        expect(body).toEqual({
+            model: 'llama-3',
+            messages: [{ role: 'user', content: 'hi' }],
+        });
+        expect(response.candidates?.[0]?.content?.parts?.[0]?.text).toBe('local ok');
+    });
+});
+//# sourceMappingURL=openAiCompatibleContentGenerator.test.js.map