@machina.ai/cell-cli-core 1.49.0-rc6 → 1.51.0-rc1

package/dist/src/core/openAiCompatibleContentGenerator.js

@@ -0,0 +1,1161 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { debugLogger } from '../utils/debugLogger.js';
+const OPENAI_REASONING_EFFORTS = new Set([
+    'none',
+    'low',
+    'medium',
+    'high',
+    'xhigh',
+    'max',
+]);
+const XAI_REASONING_EFFORTS = new Set([
+    'none',
+    'low',
+    'medium',
+    'high',
+]);
+const RESPONSES_DEFAULT_PROVIDERS = new Set(['openai', 'xai']);
+const RESPONSES_BODY_ALLOWLIST = new Set([
+    'model',
+    'input',
+    'tools',
+    'stream',
+    'tool_choice',
+    'parallel_tool_calls',
+    'reasoning',
+    'max_output_tokens',
+    'store',
+    'temperature',
+    'top_p',
+]);
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+function isContentLike(value) {
+    return isRecord(value) && ('role' in value || 'parts' in value);
+}
+function isPartLike(value) {
+    return isRecord(value);
+}
+function getPartText(part) {
+    return typeof part.text === 'string' ? part.text : undefined;
+}
+function getFunctionCall(part) {
+    if (!isRecord(part.functionCall)) {
+        return undefined;
+    }
+    return part.functionCall;
+}
+function getFunctionResponse(part) {
+    if (!isRecord(part.functionResponse)) {
+        return undefined;
+    }
+    return part.functionResponse;
+}
+function isToolWithFunctionDeclarations(tool) {
+    return (isRecord(tool) &&
+        'functionDeclarations' in tool &&
+        Array.isArray(tool['functionDeclarations']));
+}
+function asJsonSchema(value) {
+    if (!isRecord(value)) {
+        return undefined;
+    }
+    return value;
+}
+function toGenerateContentResponse(response) {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+    return response;
+}
+function parseJsonRecord(value) {
+    if (!isRecord(value)) {
+        return {};
+    }
+    return value;
+}
+function mapUsageMetadata(usage) {
+    if (!usage) {
+        return undefined;
+    }
+    const promptTokenCount = usage.input_tokens ?? usage.prompt_tokens;
+    const candidatesTokenCount = usage.output_tokens ?? usage.completion_tokens;
+    const reasoningTokens = usage.output_tokens_details?.reasoning_tokens;
+    const totalTokenCount = usage.total_tokens ??
+        (promptTokenCount !== undefined || candidatesTokenCount !== undefined
+            ? (promptTokenCount ?? 0) +
+                (candidatesTokenCount ?? 0) +
+                (reasoningTokens ?? 0)
+            : undefined);
+    return {
+        promptTokenCount,
+        candidatesTokenCount,
+        totalTokenCount,
+        thoughtsTokenCount: reasoningTokens,
+    };
+}
+function mapFinishReason(finishReasonRaw) {
+    if (!finishReasonRaw) {
+        return undefined;
+    }
+    if (finishReasonRaw === 'stop') {
+        return 'STOP';
+    }
+    if (finishReasonRaw === 'length') {
+        return 'MAX_TOKENS';
+    }
+    if (finishReasonRaw === 'tool_calls' || finishReasonRaw === 'function_call') {
+        return 'STOP';
+    }
+    return finishReasonRaw.toUpperCase();
+}
+function shouldOmitReasoning(modelName) {
+    return /^(grok-4-1-fast|grok-4-fast)/i.test(modelName);
+}
+function clampReasoningEffort(provider, effort) {
+    if (provider === 'xai') {
+        if (effort === 'xhigh' || effort === 'max') {
+            return 'high';
+        }
+        if (!XAI_REASONING_EFFORTS.has(effort)) {
+            return 'medium';
+        }
+        return effort;
+    }
+    if (!OPENAI_REASONING_EFFORTS.has(effort)) {
+        return 'medium';
+    }
+    return effort;
+}
+function resolveReasoningEffortFromRequest(request) {
+    const thinkingConfig = request.config?.thinkingConfig;
+    if (!thinkingConfig || !isRecord(thinkingConfig)) {
+        return undefined;
+    }
+    const level = thinkingConfig['thinkingLevel'];
+    if (typeof level === 'string') {
+        const normalized = level.toLowerCase();
+        if (normalized === 'minimal' || normalized === 'none') {
+            return 'none';
+        }
+        if (normalized === 'low') {
+            return 'low';
+        }
+        if (normalized === 'medium') {
+            return 'medium';
+        }
+        if (normalized === 'high') {
+            return 'high';
+        }
+        if (normalized === 'xhigh' || normalized === 'max') {
+            return normalized;
+        }
+    }
+    const budget = thinkingConfig['thinkingBudget'];
+    if (typeof budget === 'number') {
+        if (budget <= 0) {
+            return 'none';
+        }
+        if (budget < 1024) {
+            return 'low';
+        }
+        if (budget < 8192) {
+            return 'medium';
+        }
+        return 'high';
+    }
+    return undefined;
+}
+function parseArgumentsObject(raw) {
+    try {
+        const parsed = JSON.parse(raw || '{}');
+        if (isRecord(parsed)) {
+            return parsed;
+        }
+    }
+    catch {
+        // ignore invalid JSON arguments
+    }
+    return {};
+}
+/**
+ * Stateless compatibility adapter for OpenAI-compatible APIs hosted via the
+ * unified Keycloak proxy. Uses Responses API for openai/xai by default and
+ * chat/completions for other OpenAI-compatible backends.
+ */
+export class OpenAiCompatibleContentGenerator {
+    config;
+    token;
+    sessionId;
+    provider;
+    modelName;
+    endpointUrl;
+    transportMode;
+    localModelApiKey;
+    constructor(config, model, token, sessionId, transportMode) {
+        this.config = config;
+        this.token = token;
+        this.sessionId = sessionId;
+        const parts = model.split('/');
+        if (parts.length === 2 && parts[0].length > 0 && parts[1].length > 0) {
+            this.provider = parts[0];
+            this.modelName = parts[1];
+        }
+        else {
+            throw new Error(`Invalid model format for OpenAI-compatible adapter: ${model}`);
+        }
+        this.transportMode =
+            transportMode ?? this.resolveTransportMode(this.provider, this.config);
+        const localModelUrl = this.config.getLocalModelUrl?.();
+        if (localModelUrl) {
+            const cleanBaseUrl = localModelUrl.replace(/\/+$/, '');
+            this.endpointUrl = `${cleanBaseUrl}/chat/completions`;
+            this.transportMode = 'chat_completions';
+            this.localModelApiKey = this.config.getLocalModelApiKey?.();
+        }
+        else {
+            const agentApiUrl = this.config.getAgentApiUrl();
+            if (!agentApiUrl) {
+                throw new Error('Agent API URL is not configured.');
+            }
+            const cleanBaseUrl = agentApiUrl.replace(/\/+$/, '');
+            this.endpointUrl = this.buildEndpointUrl(cleanBaseUrl, this.provider, this.transportMode);
+        }
+    }
+    /**
+     * Resolve transport mode from provider defaults and optional config override.
+     * Config may expose getOpenAiTransportMode(): 'responses' | 'chat_completions'.
+     */
+    resolveTransportMode(provider, config) {
+        const maybeGetter = config.getOpenAiTransportMode;
+        const configured = typeof maybeGetter === 'function' ? maybeGetter.call(config) : undefined;
+        if (configured === 'responses' || configured === 'chat_completions') {
+            return configured;
+        }
+        return RESPONSES_DEFAULT_PROVIDERS.has(provider)
+            ? 'responses'
+            : 'chat_completions';
+    }
+    buildEndpointUrl(cleanBaseUrl, provider, transportMode) {
+        const path = transportMode === 'responses' ? 'responses' : 'chat/completions';
+        return `${cleanBaseUrl}/cell/v1.1/${provider}/v1/${path}`;
+    }
+    mapMessages(request) {
+        const messages = [];
+        const sysInstruction = request.config?.systemInstruction;
+        if (sysInstruction) {
+            let sysText = '';
+            if (typeof sysInstruction === 'string') {
+                sysText = sysInstruction;
+            }
+            else if (isRecord(sysInstruction) && 'parts' in sysInstruction) {
+                const parts = Array.isArray(sysInstruction['parts'])
+                    ? sysInstruction['parts']
+                    : [];
+                sysText = parts
+                    .filter(isPartLike)
+                    .map((p) => getPartText(p) || '')
+                    .filter(Boolean)
+                    .join('\n');
+            }
+            if (sysText) {
+                messages.push({ role: 'system', content: sysText });
+            }
+        }
+        let toolCallCounter = 0;
+        const activeMappings = {};
+        const rawContents = request.contents || [];
+        const contents = Array.isArray(rawContents) ? rawContents : [rawContents];
+        const intermediateMessages = [];
+        for (const rawContent of contents) {
+            if (!isContentLike(rawContent)) {
+                continue;
+            }
+            const content = rawContent;
+            const parts = Array.isArray(content.parts)
+                ? content.parts.filter(isPartLike)
+                : [];
+            if (content.role === 'model') {
+                const textParts = parts
+                    .map((p) => getPartText(p))
+                    .filter((text) => Boolean(text));
+                const textContent = textParts.join('\n');
+                const functionCallParts = parts
+                    .map((p) => getFunctionCall(p))
+                    .filter((fc) => Boolean(fc));
+                const toolCalls = functionCallParts.map((fc) => {
+                    let toolCallId = fc.id || `call_${toolCallCounter++}`;
+                    const functionName = fc.name || 'unknown';
+                    const prefix = `${functionName}__`;
+                    if (toolCallId.startsWith(prefix)) {
+                        toolCallId = toolCallId.slice(prefix.length);
+                    }
+                    activeMappings[functionName] = toolCallId;
+                    return {
+                        id: toolCallId,
+                        type: 'function',
+                        function: {
+                            name: functionName,
+                            arguments: JSON.stringify(fc.args || {}),
+                        },
+                    };
+                });
+                const assistantMsg = {
+                    role: 'assistant',
+                    content: textContent || '',
+                };
+                if (toolCalls.length > 0) {
+                    assistantMsg.tool_calls = toolCalls;
+                }
+                intermediateMessages.push(assistantMsg);
+            }
+            else {
+                const textParts = parts
+                    .map((p) => getPartText(p))
+                    .filter((text) => Boolean(text));
+                const textContent = textParts.join('\n');
+                const functionResponseParts = parts
+                    .map((p) => getFunctionResponse(p))
+                    .filter((fr) => Boolean(fr));
+                if (textContent || functionResponseParts.length === 0) {
+                    intermediateMessages.push({
+                        role: 'user',
+                        content: textContent || '',
+                    });
+                }
+                for (const fr of functionResponseParts) {
+                    const functionName = fr.name || 'unknown';
+                    let resolvedId = fr.id || activeMappings[functionName] || 'call_unknown';
+                    const prefix = `${functionName}__`;
+                    if (resolvedId.startsWith(prefix)) {
+                        resolvedId = resolvedId.slice(prefix.length);
+                    }
+                    intermediateMessages.push({
+                        role: 'tool',
+                        content: JSON.stringify(fr.response || {}),
+                        tool_call_id: resolvedId,
+                    });
+                }
+            }
+        }
+        // Consolidate/merge consecutive messages of the same role
+        for (const msg of intermediateMessages) {
+            if (messages.length === 0) {
+                messages.push(msg);
+                continue;
+            }
+            const lastMsg = messages[messages.length - 1];
+            if (msg.role === lastMsg.role &&
+                (msg.role === 'user' ||
+                    (msg.role === 'assistant' && !msg.tool_calls && !lastMsg.tool_calls))) {
+                lastMsg.content =
+                    (lastMsg.content ? lastMsg.content + '\n\n' : '') +
+                        (msg.content || '');
+            }
+            else {
+                messages.push(msg);
+            }
+        }
+        return messages;
+    }
+    /**
+     * Map chat-style messages to Responses API input items.
+     * Assistant tool_calls become function_call items; tool results become
+     * function_call_output items. Roles are preserved as input messages.
+     */
+    mapMessagesToResponsesInput(messages) {
+        const input = [];
+        for (const msg of messages) {
+            if (msg.role === 'tool') {
+                input.push({
+                    type: 'function_call_output',
+                    call_id: msg.tool_call_id || 'call_unknown',
+                    output: msg.content || '',
+                });
+                continue;
+            }
+            if (msg.role === 'assistant' &&
+                msg.tool_calls &&
+                msg.tool_calls.length > 0) {
+                if (msg.content) {
+                    input.push({
+                        role: 'assistant',
+                        content: msg.content,
+                    });
+                }
+                for (const tc of msg.tool_calls) {
+                    input.push({
+                        type: 'function_call',
+                        call_id: tc.id,
+                        name: tc.function.name,
+                        arguments: tc.function.arguments,
+                    });
+                }
+                continue;
+            }
+            input.push({
+                role: msg.role,
+                content: msg.content || '',
+            });
+        }
+        return input;
+    }
+    mapSchema(schema) {
+        if (!schema || !isRecord(schema)) {
+            return undefined;
+        }
+        const mapped = { ...schema };
+        if (typeof mapped.type === 'string') {
+            mapped.type = mapped.type.toLowerCase();
+        }
+        if (mapped.properties && isRecord(mapped.properties)) {
+            const newProps = {};
+            for (const [key, val] of Object.entries(mapped.properties)) {
+                const nested = this.mapSchema(val);
+                if (nested) {
+                    newProps[key] = nested;
+                }
+            }
+            mapped.properties = newProps;
+        }
+        if (mapped.items) {
+            mapped.items = this.mapSchema(mapped.items);
+        }
+        return mapped;
+    }
+    mapChatTools(request) {
+        const geminiTools = request.config?.tools || [];
+        const tools = [];
+        for (const t of geminiTools) {
+            if (!t || typeof t !== 'object' || !isToolWithFunctionDeclarations(t)) {
+                continue;
+            }
+            for (const fd of t.functionDeclarations) {
+                const rawParameters = fd.parameters ||
+                    (isRecord(fd) ? asJsonSchema(fd['parametersJsonSchema']) : undefined);
+                const parameters = this.mapSchema(rawParameters) || {
+                    type: 'object',
+                    properties: {},
+                };
+                tools.push({
+                    type: 'function',
+                    function: {
+                        name: fd.name || 'unknown',
+                        description: fd.description,
+                        parameters,
+                    },
+                });
+            }
+        }
+        return tools.length > 0 ? tools : undefined;
+    }
+    /**
+     * Transform Gemini tools into Responses API internally-tagged function tools.
+     * strict is always false to preserve non-strict tool calling behavior.
+     */
+    mapResponsesTools(request) {
+        const chatTools = this.mapChatTools(request);
+        if (!chatTools) {
+            return undefined;
+        }
+        return chatTools.map((tool) => ({
+            type: 'function',
+            name: tool.function.name,
+            description: tool.function.description,
+            parameters: tool.function.parameters,
+            strict: false,
+        }));
+    }
+    buildHeaders() {
+        const headers = {
+            'Content-Type': 'application/json',
+        };
+        const isLocal = !!this.config.getLocalModelUrl?.();
+        const resolvedToken = isLocal ? this.localModelApiKey : this.token;
+        if (resolvedToken) {
+            headers['Authorization'] = `Bearer ${resolvedToken}`;
+        }
+        const finalSessionId = this.sessionId ||
+            (typeof this.config.getSessionId === 'function'
+                ? this.config.getSessionId()
+                : undefined);
+        if (finalSessionId && !isLocal) {
+            headers['sessionId'] = finalSessionId;
+        }
+        return headers;
+    }
+    resolveEndpoint(request) {
+        let modelName = this.modelName;
+        let provider = this.provider;
+        let transportMode = this.transportMode;
+        let endpointUrl = this.endpointUrl;
+        if (request.model && request.model.includes('/')) {
+            const parts = request.model.split('/');
+            if (parts.length === 2 && parts[0].length > 0 && parts[1].length > 0) {
+                provider = parts[0];
+                modelName = parts[1];
+                transportMode = this.resolveTransportMode(provider, this.config);
+                const localModelUrl = this.config.getLocalModelUrl?.();
+                if (localModelUrl) {
+                    const cleanBaseUrl = localModelUrl.replace(/\/+$/, '');
+                    endpointUrl = `${cleanBaseUrl}/chat/completions`;
+                    transportMode = 'chat_completions';
+                }
+                else {
+                    const agentApiUrl = this.config.getAgentApiUrl();
+                    if (agentApiUrl) {
+                        const cleanBaseUrl = agentApiUrl.replace(/\/+$/, '');
+                        endpointUrl = this.buildEndpointUrl(cleanBaseUrl, provider, transportMode);
+                    }
+                }
+            }
+        }
+        return { modelName, endpointUrl, provider, transportMode };
+    }
+    /**
+     * Build a Responses API request body from an allowlist of fields.
+     * Always sets store:false and never includes previous_response_id.
+     */
+    buildResponsesRequestBody(params) {
+        const { modelName, provider, messages, request } = params;
+        const input = this.mapMessagesToResponsesInput(messages);
+        const tools = this.mapResponsesTools(request);
+        const { stream } = params;
+        const candidate = {
+            model: modelName,
+            input,
+            store: false,
+        };
+        // stream:true is required for SSE. Never send stream_options —
+        // Responses rejects stream_options.include_usage.
+        if (stream) {
+            candidate['stream'] = true;
+        }
+        if (tools) {
+            candidate['tools'] = tools;
+        }
+        if (!shouldOmitReasoning(modelName)) {
+            const effort = resolveReasoningEffortFromRequest(request);
+            if (effort) {
+                candidate['reasoning'] = {
+                    effort: clampReasoningEffort(provider, effort),
+                };
+            }
+        }
+        const maxOutputTokens = request.config?.maxOutputTokens;
+        if (typeof maxOutputTokens === 'number') {
+            candidate['max_output_tokens'] = maxOutputTokens;
+        }
+        const temperature = request.config?.temperature;
+        if (typeof temperature === 'number') {
+            candidate['temperature'] = temperature;
+        }
+        // gpt-5.6* (and possibly other OpenAI reasoning models) reject top_p on
+        // /v1/responses. Keep it only for non-openai providers that still accept it.
+        const topP = request.config?.topP;
+        if (typeof topP === 'number' && provider !== 'openai') {
+            candidate['top_p'] = topP;
+        }
+        // Allowlist filter — drop unsupported params and log them.
+        // Also drop stream_options/include_usage even if injected by a proxy.
+        const body = {};
+        for (const [key, value] of Object.entries(candidate)) {
+            if (RESPONSES_BODY_ALLOWLIST.has(key) &&
+                !key.includes('stream_options') &&
+                !key.includes('include_usage')) {
+                body[key] = value;
+            }
+            else {
+                debugLogger.debug(`OpenAI Responses transport dropped unsupported param: ${key}`);
+            }
+        }
+        // Hard guarantees for ZDR posture and Responses compatibility.
+        body['store'] = false;
+        delete body['previous_response_id'];
+        delete body['stream_options'];
+        return body;
+    }
+    buildChatCompletionsRequestBody(params) {
+        const { modelName, messages, request, stream } = params;
+        const tools = this.mapChatTools(request);
+        const body = {
+            model: modelName,
+            messages,
+        };
+        if (stream) {
+            body['stream'] = true;
+        }
+        if (tools) {
+            body['tools'] = tools;
+        }
+        return body;
+    }
+    parseResponsesPayload(data) {
+        const parts = [];
+        const fnCalls = [];
+        for (const item of data.output || []) {
+            if (item.type === 'reasoning') {
+                // Ignore reasoning items — do not render or persist.
+                continue;
+            }
+            if (item.type === 'message') {
+                const contentParts = Array.isArray(item.content) ? item.content : [];
+                for (const contentPart of contentParts) {
+                    if (contentPart.type === 'output_text' &&
+                        typeof contentPart.text === 'string' &&
+                        contentPart.text.length > 0) {
+                        parts.push({ text: contentPart.text });
+                    }
+                }
+                continue;
+            }
+            if (item.type === 'function_call') {
+                const args = parseArgumentsObject(item.arguments);
+                const fnCall = {
+                    id: item.call_id || item.id,
+                    name: item.name,
+                    args,
+                };
+                fnCalls.push(fnCall);
+                parts.push({ functionCall: fnCall });
+            }
+        }
+        // Non-stream Responses are complete in one payload. Always set
+        // finishReason so GeminiChat does not throw NO_FINISH_REASON and retry
+        // (which previously caused OpenAI answers to appear 3-4 times in the UI).
+        return toGenerateContentResponse({
+            candidates: [
+                {
+                    content: {
+                        parts,
+                        role: 'model',
+                    },
+                    finishReason: 'STOP',
+                },
+            ],
+            functionCalls: fnCalls.length > 0 ? fnCalls : undefined,
+            usageMetadata: mapUsageMetadata(data.usage),
+        });
+    }
+    parseChatCompletionsPayload(data) {
+        const parts = [];
+        const choice = data.choices?.[0];
+        if (choice?.message?.content) {
+            parts.push({ text: choice.message.content });
+        }
+        const fnCalls = [];
+        if (choice?.message?.tool_calls) {
+            for (const tc of choice.message.tool_calls) {
+                if (tc.type === 'function' || tc.function) {
+                    const args = parseArgumentsObject(tc.function?.arguments);
+                    const fnCall = {
+                        id: tc.id,
+                        name: tc.function?.name,
+                        args,
+                    };
+                    fnCalls.push(fnCall);
+                    parts.push({
+                        functionCall: fnCall,
+                    });
+                }
+            }
+        }
+        return toGenerateContentResponse({
+            candidates: [
+                {
+                    content: {
+                        parts,
+                        role: 'model',
+                    },
+                    finishReason: mapFinishReason(choice?.finish_reason) || 'STOP',
+                },
+            ],
+            functionCalls: fnCalls.length > 0 ? fnCalls : undefined,
+            usageMetadata: mapUsageMetadata(data.usage),
+        });
+    }
+    /**
+     * Generates content.
+     */
+    async generateContent(request, _userPromptId, _role) {
+        const headers = this.buildHeaders();
+        const messages = this.mapMessages(request);
+        const { modelName, endpointUrl, provider, transportMode } = this.resolveEndpoint(request);
+        const body = transportMode === 'responses'
+            ? this.buildResponsesRequestBody({
+                modelName,
+                provider,
+                messages,
+                request,
+            })
+            : this.buildChatCompletionsRequestBody({
+                modelName,
+                messages,
+                request,
+            });
+        const response = await fetch(endpointUrl, {
+            method: 'POST',
+            headers,
+            body: JSON.stringify(body),
+        });
+        if (!response.ok) {
+            const errText = await response.text().catch(() => '');
+            throw new Error(`OpenAI-compatible request failed: ${response.statusText} - ${errText}`);
+        }
+        const raw = parseJsonRecord(await response.json());
+        if (transportMode === 'responses') {
+            return this.parseResponsesPayload(raw);
+        }
+        return this.parseChatCompletionsPayload(raw);
+    }
+    /**
+     * Generates content stream.
+     */
+    async generateContentStream(request, _userPromptId, _role) {
+        return this.makeStream(request);
+    }
+    async *makeStream(request) {
+        const headers = this.buildHeaders();
+        const messages = this.mapMessages(request);
+        const { modelName, endpointUrl, provider, transportMode } = this.resolveEndpoint(request);
+        // OpenAI Responses via Cell gateway rejects stream:true because the
+        // gateway injects stream_options.include_usage (unsupported there).
+        // Use non-stream Responses for openai and emit a single chunk.
+        // xAI Responses streaming works and keeps true SSE.
+        const useOpenAiNonStreamResponses = transportMode === 'responses' && provider === 'openai';
+        const body = transportMode === 'responses'
+            ? this.buildResponsesRequestBody({
+                modelName,
+                provider,
+                messages,
+                request,
+                stream: !useOpenAiNonStreamResponses,
+            })
+            : this.buildChatCompletionsRequestBody({
+                modelName,
+                messages,
+                request,
+                stream: true,
+            });
+        const response = await fetch(endpointUrl, {
+            method: 'POST',
+            headers,
+            body: JSON.stringify(body),
+        });
+        if (!response.ok) {
+            const errText = await response.text().catch(() => '');
+            throw new Error(`OpenAI-compatible stream request failed: ${response.statusText} - ${errText}`);
+        }
+        if (useOpenAiNonStreamResponses) {
+            const raw = parseJsonRecord(await response.json());
+            yield this.parseResponsesPayload(raw);
+            return;
+        }
+        if (!response.body) {
+            throw new Error('Response body is empty');
+        }
+        // Some proxies return a full JSON body even when stream was requested.
+        const contentType = response.headers?.get?.('content-type') || '';
+        if (transportMode === 'responses' &&
+            contentType.includes('application/json') &&
+            !contentType.includes('text/event-stream')) {
+            const raw = parseJsonRecord(await response.json());
+            yield this.parseResponsesPayload(raw);
+            return;
+        }
+        if (transportMode === 'responses') {
+            yield* this.parseResponsesStream(response.body);
+            return;
+        }
+        yield* this.parseChatCompletionsStream(response.body);
+    }
+    /**
+     * Parse Responses API SSE semantic events into Gemini-compatible chunks.
+     */
+    async *parseResponsesStream(bodyStream) {
+        const decoder = new TextDecoder('utf-8');
+        let buffer = '';
+        const accumulatedToolCalls = {};
+        let yieldedToolCalls = false;
+        let streamError;
+        const reader = bodyStream.getReader();
+        while (true) {
+            const { done, value: chunk } = await reader.read();
+            if (done) {
+                break;
+            }
+            const bytes = chunk instanceof Uint8Array
+                ? chunk
+                : new TextEncoder().encode(String(chunk));
+            buffer += decoder.decode(bytes, { stream: true });
+            const lines = buffer.split('\n');
+            buffer = lines.pop() || '';
+            /* eslint-disable no-restricted-syntax */
+            for (const line of lines) {
+                const trimmed = line.trim();
+                if (!trimmed || trimmed.startsWith('event:')) {
+                    // Event name is redundant when payload carries `type`.
+                    continue;
+                }
+                if (!trimmed.startsWith('data:')) {
+                    continue;
+                }
+                const dataContent = trimmed.slice(trimmed.indexOf(':') + 1).trim();
+                if (!dataContent || dataContent === '[DONE]') {
+                    continue;
+                }
+                let parsed;
+                try {
+                    parsed = parseJsonRecord(JSON.parse(dataContent));
+                }
+                catch {
+                    continue;
+                }
+                const eventType = typeof parsed['type'] === 'string' ? parsed['type'] : '';
+                if (eventType === 'response.failed' ||
+                    eventType === 'error' ||
+                    parsed['error']) {
+                    const errObj = isRecord(parsed['error']) ? parsed['error'] : parsed;
+                    streamError =
+                        (typeof errObj['message'] === 'string' && errObj['message']) ||
+                            'OpenAI Responses stream failed';
+                    throw new Error(streamError);
+                }
+                if (eventType === 'response.output_text.delta') {
+                    const delta = typeof parsed['delta'] === 'string' ? parsed['delta'] : '';
+                    if (delta) {
+                        yield toGenerateContentResponse({
+                            candidates: [
+                                {
+                                    content: {
+                                        parts: [{ text: delta }],
+                                        role: 'model',
+                                    },
+                                },
+                            ],
+                        });
+                    }
+                    continue;
+                }
+                // Full text is already streamed via deltas — never re-emit it from
+                // .done events (that would duplicate the answer in the UI).
+                if (eventType === 'response.output_text.done' ||
+                    eventType === 'response.content_part.done') {
+                    continue;
+                }
+                if (eventType === 'response.output_item.added') {
+                    const item = isRecord(parsed['item']) ? parsed['item'] : undefined;
+                    if (item && item['type'] === 'function_call') {
+                        const key = (typeof item['id'] === 'string' && item['id']) ||
+                            (typeof item['call_id'] === 'string' && item['call_id']) ||
+                            `item_${Object.keys(accumulatedToolCalls).length}`;
+                        accumulatedToolCalls[key] = {
+                            id: (typeof item['call_id'] === 'string' && item['call_id']) || key,
+                            name: typeof item['name'] === 'string' ? item['name'] : '',
+                            arguments: typeof item['arguments'] === 'string' ? item['arguments'] : '',
+                        };
+                    }
+                    continue;
+                }
+                if (eventType === 'response.function_call_arguments.delta' ||
+                    eventType === 'response.function_call_arguments.done') {
+                    const itemId = (typeof parsed['item_id'] === 'string' && parsed['item_id']) ||
+                        (typeof parsed['output_index'] === 'number'
+                            ? String(parsed['output_index'])
+                            : undefined);
+                    const callId = typeof parsed['call_id'] === 'string'
+                        ? parsed['call_id']
+                        : undefined;
+                    const key = itemId ||
+                        callId ||
+                        Object.keys(accumulatedToolCalls).slice(-1)[0] ||
+                        '0';
+                    if (!accumulatedToolCalls[key]) {
+                        accumulatedToolCalls[key] = {
+                            id: callId || key,
+                            name: '',
+                            arguments: '',
+                        };
+                    }
+                    if (callId) {
+                        accumulatedToolCalls[key].id = callId;
+                    }
+                    if (eventType === 'response.function_call_arguments.delta') {
+                        const delta = typeof parsed['delta'] === 'string' ? parsed['delta'] : '';
+                        accumulatedToolCalls[key].arguments += delta;
+                    }
+                    else if (typeof parsed['arguments'] === 'string') {
+                        accumulatedToolCalls[key].arguments = parsed['arguments'];
+                    }
+                    continue;
+                }
+                if (eventType === 'response.output_item.done') {
+                    const item = isRecord(parsed['item']) ? parsed['item'] : undefined;
+                    if (item && item['type'] === 'function_call') {
+                        const key = (typeof item['id'] === 'string' && item['id']) ||
+                            (typeof item['call_id'] === 'string' && item['call_id']) ||
+                            Object.keys(accumulatedToolCalls).slice(-1)[0] ||
+                            '0';
+                        if (!accumulatedToolCalls[key]) {
+                            accumulatedToolCalls[key] = {
+                                id: (typeof item['call_id'] === 'string' && item['call_id']) ||
+                                    key,
+                                name: typeof item['name'] === 'string' ? item['name'] : '',
+                                arguments: '',
+                            };
+                        }
+                        if (typeof item['call_id'] === 'string') {
+                            accumulatedToolCalls[key].id = item['call_id'];
+                        }
+                        if (typeof item['name'] === 'string') {
+                            accumulatedToolCalls[key].name = item['name'];
+                        }
+                        if (typeof item['arguments'] === 'string') {
+                            accumulatedToolCalls[key].arguments = item['arguments'];
+                        }
+                        continue;
+                    }
+                    // Message completed: signal finish without re-emitting text.
+                    // This reduces NO_FINISH_REASON retries if response.completed is lost.
+                    if (item &&
+                        item['type'] === 'message' &&
+                        Object.keys(accumulatedToolCalls).length === 0) {
+                        yield toGenerateContentResponse({
+                            candidates: [
+                                {
+                                    finishReason: 'STOP',
+                                },
+                            ],
+                        });
+                    }
+                    continue;
+                }
+                if (eventType === 'response.completed') {
+                    const responseObj = isRecord(parsed['response'])
+                        ? parsed['response']
+                        : parsed;
+                    const usage = isRecord(responseObj['usage'])
+                        ? responseObj['usage']
+                        : undefined;
+                    const chunkFunctionCalls = [];
+                    const parts = [];
+                    if (Object.keys(accumulatedToolCalls).length > 0) {
+                        yieldedToolCalls = true;
+                        for (const acc of Object.values(accumulatedToolCalls)) {
+                            if (!acc?.name)
+                                continue;
+                            const args = parseArgumentsObject(acc.arguments);
+                            const fnCall = {
+                                id: acc.id,
+                                name: acc.name,
+                                args,
+                            };
+                            chunkFunctionCalls.push(fnCall);
+                            parts.push({ functionCall: fnCall });
+                        }
+                    }
+                    yield toGenerateContentResponse({
+                        candidates: [
+                            {
+                                content: parts.length > 0
+                                    ? {
+                                        parts,
+                                        role: 'model',
+                                    }
+                                    : undefined,
+                                finishReason: 'STOP',
+                            },
+                        ],
+                        functionCalls: chunkFunctionCalls.length > 0 ? chunkFunctionCalls : undefined,
+                        usageMetadata: mapUsageMetadata(usage),
+                    });
+                }
+                // Unknown event types are ignored for forward compatibility.
+            }
+            /* eslint-enable no-restricted-syntax */
+        }
+        if (Object.keys(accumulatedToolCalls).length > 0 && !yieldedToolCalls) {
+            const finalFunctionCalls = [];
+            const finalParts = [];
+            for (const acc of Object.values(accumulatedToolCalls)) {
+                if (!acc?.name)
+                    continue;
+                const args = parseArgumentsObject(acc.arguments);
+                const fnCall = {
+                    id: acc.id,
+                    name: acc.name,
+                    args,
+                };
+                finalFunctionCalls.push(fnCall);
+                finalParts.push({ functionCall: fnCall });
+            }
+            if (finalFunctionCalls.length > 0) {
+                yield toGenerateContentResponse({
+                    candidates: [
+                        {
+                            content: {
+                                parts: finalParts,
+                                role: 'model',
+                            },
+                            finishReason: 'STOP',
+                        },
+                    ],
+                    functionCalls: finalFunctionCalls,
+                });
+            }
+        }
+    }
+    async *parseChatCompletionsStream(bodyStream) {
+        const decoder = new TextDecoder('utf-8');
+        let buffer = '';
+        const accumulatedToolCalls = {};
+        let yieldedToolCalls = false;
+        const reader = bodyStream.getReader();
+        while (true) {
+            const { done, value: chunk } = await reader.read();
+            if (done) {
+                break;
+            }
+            const bytes = chunk instanceof Uint8Array
+                ? chunk
+                : new TextEncoder().encode(String(chunk));
+            buffer += decoder.decode(bytes, { stream: true });
+            const lines = buffer.split('\n');
+            buffer = lines.pop() || '';
+            for (const line of lines) {
+                const trimmed = line.trim();
+                if (!trimmed)
+                    continue;
+                if (trimmed.startsWith('data: ')) {
+                    const dataContent = trimmed.slice(6).trim();
+                    if (dataContent === '[DONE]') {
+                        break;
+                    }
+                    try {
+                        const parsed = parseJsonRecord(JSON.parse(dataContent));
+                        const choice = parsed.choices?.[0];
+                        const text = choice?.delta?.content || '';
+                        const toolCalls = choice?.delta?.tool_calls;
+                        const finishReason = mapFinishReason(choice?.finish_reason);
+                        const parts = [];
+                        if (text) {
+                            parts.push({ text });
+                        }
+                        if (toolCalls) {
+                            for (const tc of toolCalls) {
+                                const idx = tc.index ?? 0;
+                                if (!accumulatedToolCalls[idx]) {
+                                    accumulatedToolCalls[idx] = {
+                                        id: tc.id || '',
+                                        name: tc.function?.name || '',
+                                        arguments: '',
+                                    };
+                                }
+                                if (tc.id) {
+                                    accumulatedToolCalls[idx].id = tc.id;
+                                }
+                                if (tc.function?.name) {
+                                    accumulatedToolCalls[idx].name = tc.function.name;
+                                }
+                                if (tc.function?.arguments) {
+                                    accumulatedToolCalls[idx].arguments += tc.function.arguments;
+                                }
+                            }
+                        }
+                        const chunkFunctionCalls = [];
+                        const isFinalChunk = !!finishReason;
+                        if (isFinalChunk && Object.keys(accumulatedToolCalls).length > 0) {
+                            yieldedToolCalls = true;
+                            for (const acc of Object.values(accumulatedToolCalls)) {
+                                if (acc && acc.name) {
+                                    const args = parseArgumentsObject(acc.arguments);
+                                    const fnCall = {
+                                        id: acc.id,
+                                        name: acc.name,
+                                        args,
+                                    };
+                                    chunkFunctionCalls.push(fnCall);
+                                    parts.push({
+                                        functionCall: fnCall,
+                                    });
+                                }
+                            }
+                        }
+                        if (parts.length > 0 ||
+                            finishReason ||
+                            chunkFunctionCalls.length > 0) {
+                            yield toGenerateContentResponse({
+                                candidates: [
+                                    {
+                                        content: parts.length > 0
+                                            ? {
+                                                parts,
+                                                role: 'model',
+                                            }
+                                            : undefined,
+                                        finishReason,
+                                    },
+                                ],
+                                functionCalls: chunkFunctionCalls.length > 0
+                                    ? chunkFunctionCalls
+                                    : undefined,
+                                usageMetadata: mapUsageMetadata(parsed.usage),
+                            });
+                        }
+                    }
+                    catch {
+                        // ignore malformed SSE chunks
+                    }
+                }
+            }
+        }
+        if (Object.keys(accumulatedToolCalls).length > 0 && !yieldedToolCalls) {
+            const finalFunctionCalls = [];
+            const finalParts = [];
+            for (const acc of Object.values(accumulatedToolCalls)) {
+                if (acc && acc.name) {
+                    const args = parseArgumentsObject(acc.arguments);
+                    const fnCall = {
+                        id: acc.id,
+                        name: acc.name,
+                        args,
+                    };
+                    finalFunctionCalls.push(fnCall);
+                    finalParts.push({
+                        functionCall: fnCall,
+                    });
+                }
+            }
+            if (finalFunctionCalls.length > 0) {
+                yield toGenerateContentResponse({
+                    candidates: [
+                        {
+                            content: {
+                                parts: finalParts,
+                                role: 'model',
+                            },
+                            finishReason: 'STOP',
+                        },
+                    ],
+                    functionCalls: finalFunctionCalls,
+                });
+            }
+        }
+    }
+    /**
+     * Counts tokens.
+     */
+    async countTokens(_request) {
+        return { totalTokens: 0 };
+    }
+    /**
+     * Embeds content.
+     */
+    async embedContent(_request) {
+        return { embeddings: [] };
+    }
+}
+//# sourceMappingURL=openAiCompatibleContentGenerator.js.map