@iaforged/context-code 1.0.77 → 1.0.79

package/dist/src/services/api/openai.js

@@ -1,5 +1,6 @@
 import { APIUserAbortError } from '@anthropic-ai/sdk/error.js';
-import { checkAndRefreshOpenAIOAuthTokenIfNeeded, getOpenAICompatibleAccessToken, getOpenAIAccessToken, handleOpenAIOAuth401Error, } from '../../utils/auth.js';
+import { randomUUID } from 'node:crypto';
+import { checkAndRefreshOpenAIOAuthTokenIfNeeded, getGeminiGoogleAuthHeaders, getOpenAICompatibleAccessToken, getOpenAIAccessToken, handleOpenAIOAuth401Error, } from '../../utils/auth.js';
 import { getAPIProvider, } from '../../utils/model/providers.js';
 import { getConfiguredProviderBaseUrl } from '../../utils/model/providerBaseUrls.js';
 import { errorMessage } from '../../utils/errors.js';
@@ -48,6 +49,8 @@ function getOpenAICompatibleProvider() {
     return provider === 'openrouter' ||
         provider === 'ollama' ||
         provider === 'ollama-cloud' ||
+        provider === 'gemini-api' ||
+        provider === 'gemini-google' ||
         provider === 'zai'
         ? provider
         : 'openai';
@@ -57,9 +60,13 @@ function getOpenAICompatibleProviderLabel(provider = getOpenAICompatibleProvider
         case 'openrouter':
             return 'OpenRouter';
         case 'ollama':
-            return 'Ollama Local';
+            return 'Ollama';
         case 'ollama-cloud':
             return 'Ollama Cloud';
+        case 'gemini-api':
+            return 'Gemini API';
+        case 'gemini-google':
+            return 'Gemini Google';
         case 'zai':
             return 'Z.AI';
         default:
@@ -88,7 +95,8 @@ function getOpenAIBaseUrl(provider = getOpenAICompatibleProvider()) {
                 : `${raw}/v1`;
     }
     if (provider === 'ollama-cloud') {
-        const raw = process.env.OLLAMA_BASE_URL ||
+        const raw = process.env.OLLAMA_CLOUD_BASE_URL ||
+            process.env.OLLAMA_BASE_URL ||
             getConfiguredProviderBaseUrl('ollama-cloud') ||
             'http://localhost:11434/v1';
         return raw.endsWith('/v1')
@@ -105,6 +113,17 @@ function getOpenAIBaseUrl(provider = getOpenAICompatibleProvider()) {
             ? raw.slice(0, -1)
             : raw;
     }
+    if (provider === 'gemini-api' || provider === 'gemini-google') {
+        const envBaseUrl = provider === 'gemini-api'
+            ? process.env.GEMINI_BASE_URL || process.env.GEMINI_API_BASE_URL
+            : process.env.GEMINI_GOOGLE_BASE_URL || process.env.GEMINI_BASE_URL;
+        const raw = envBaseUrl ||
+            getConfiguredProviderBaseUrl(provider) ||
+            'https://generativelanguage.googleapis.com/v1beta/openai';
+        return raw.endsWith('/')
+            ? raw.slice(0, -1)
+            : raw;
+    }
     const raw = process.env.OPENAI_API_BASE_URL ||
         process.env.OPENAI_BASE_URL ||
         'https://api.openai.com/v1';
@@ -131,6 +150,12 @@ function getOpenAIHeaders(provider = getOpenAICompatibleProvider()) {
         'Content-Type': 'application/json',
     };
 }
+async function getOpenAIRequestHeaders(provider = getOpenAICompatibleProvider()) {
+    if (provider === 'gemini-google') {
+        return getGeminiGoogleAuthHeaders();
+    }
+    return getOpenAIHeaders(provider);
+}
 function isLocalOllamaProviderHost(provider, baseUrl = getOpenAIBaseUrl(provider)) {
     return ((provider === 'ollama' || provider === 'ollama-cloud') &&
         (baseUrl.includes('localhost') || baseUrl.includes('127.0.0.1')));
@@ -139,6 +164,10 @@ function getOpenAIAccessTokenOrThrow(provider = getOpenAICompatibleProvider()) {
     if (isLocalOllamaProviderHost(provider)) {
         return 'ollama';
     }
+    if (provider === 'gemini-google') {
+        return (getOpenAICompatibleAccessToken(provider) ||
+            'google-application-default-credentials');
+    }
     const token = getOpenAICompatibleAccessToken(provider);
     if (!token) {
         throw new Error(`${getOpenAICompatibleProviderLabel(provider)} is selected but no credentials were found.`);
@@ -484,6 +513,13 @@ async function readOpenAIResponseBody(response) {
     }
     try {
         const parsed = JSON.parse(rawBody);
+        if (isRecord(parsed) && typeof parsed.error === 'string') {
+            return {
+                ...parsed,
+                error: { message: parsed.error },
+                raw_error_text: rawBody,
+            };
+        }
         return isRecord(parsed)
             ? { ...parsed, raw_error_text: rawBody }
             : { error: { message: rawBody }, raw_error_text: rawBody };
@@ -589,11 +625,14 @@ function parseOpenAISSEBody(rawBody) {
     };
 }
 function buildOpenAIErrorMessage(params) {
-    const primary = params.data.error?.message?.trim() ||
+    const primaryRaw = params.data.error?.message?.trim() ||
         params.data.raw_error_text?.trim() ||
         `OpenAI request failed (${params.status} ${params.statusText})`;
+    const primary = /requires a subscription|upgrade for access/i.test(primaryRaw)
+        ? `El modelo ${params.model ?? 'seleccionado'} requiere una suscripcion de Ollama Cloud. Cambia a otro modelo en /model o actualiza tu plan de Ollama.`
+        : primaryRaw;
     const rawSnippet = params.data.raw_error_text?.trim();
-    const compactRaw = rawSnippet && rawSnippet !== primary
+    const compactRaw = rawSnippet && rawSnippet !== primaryRaw && rawSnippet !== primary
         ? rawSnippet.replace(/\s+/g, ' ').slice(0, 400)
         : null;
     return compactRaw
@@ -660,7 +699,7 @@ function messageToChatMessages(message) {
                 textParts.push(block.text);
             }
         }
-        const msg = { role: 'assistant', content: textParts.join('\n') || null };
+        const msg = { role: 'assistant', content: textParts.join('\n') };
         if (toolCalls.length > 0)
             msg.tool_calls = toolCalls;
         return [msg];
@@ -748,6 +787,416 @@ function buildChatToolChoice(options) {
         default: return 'auto';
     }
 }
+function chatContentToGeminiParts(content) {
+    if (typeof content === 'string') {
+        return content ? [{ text: content }] : [];
+    }
+    if (!Array.isArray(content)) {
+        return [];
+    }
+    return content
+        .map(part => {
+        if (part.type === 'text') {
+            return part.text ? { text: part.text } : null;
+        }
+        if (part.type === 'image_url') {
+            return {
+                text: `[Image input: ${part.image_url.url}]`,
+            };
+        }
+        return null;
+    })
+        .filter((part) => part !== null);
+}
+function buildGeminiContents(chatMessages) {
+    const toolNameById = new Map();
+    const contents = [];
+    for (const message of chatMessages) {
+        if (message.role === 'system') {
+            continue;
+        }
+        if (message.role === 'assistant') {
+            const parts = chatContentToGeminiParts(message.content);
+            for (const toolCall of message.tool_calls ?? []) {
+                toolNameById.set(toolCall.id, toolCall.function.name);
+                const parsedArgs = parseFunctionCallArguments(toolCall.function.arguments);
+                parts.push({
+                    functionCall: {
+                        name: toolCall.function.name,
+                        args: isPlainObject(parsedArgs) ? parsedArgs : { raw: parsedArgs },
+                    },
+                });
+            }
+            if (parts.length > 0) {
+                contents.push({ role: 'model', parts });
+            }
+            continue;
+        }
+        if (message.role === 'tool') {
+            const name = message.tool_call_id
+                ? toolNameById.get(message.tool_call_id) ?? 'tool'
+                : 'tool';
+            contents.push({
+                role: 'function',
+                parts: [
+                    {
+                        functionResponse: {
+                            name,
+                            response: { result: message.content ?? '' },
+                        },
+                    },
+                ],
+            });
+            continue;
+        }
+        const parts = chatContentToGeminiParts(message.content);
+        if (parts.length > 0) {
+            contents.push({ role: 'user', parts });
+        }
+    }
+    return contents.length > 0
+        ? contents
+        : [{ role: 'user', parts: [{ text: '' }] }];
+}
+function buildGeminiTools(chatTools) {
+    if (chatTools.length === 0) {
+        return undefined;
+    }
+    return [
+        {
+            functionDeclarations: chatTools.map(tool => ({
+                name: tool.function.name,
+                description: tool.function.description,
+                parameters: sanitizeGeminiSchema(tool.function.parameters ?? { type: 'object', properties: {} }),
+            })),
+        },
+    ];
+}
+function getGeminiEnumType(value) {
+    switch (typeof value) {
+        case 'string':
+            return 'string';
+        case 'number':
+            return Number.isInteger(value) ? 'integer' : 'number';
+        case 'boolean':
+            return 'boolean';
+        default:
+            return undefined;
+    }
+}
+function collapseSimpleGeminiAnyOf(schemas) {
+    const enumValues = [];
+    let nullable = false;
+    let enumType;
+    for (const item of schemas) {
+        if (!isRecord(item)) {
+            return null;
+        }
+        if (item.type === 'null') {
+            nullable = true;
+            continue;
+        }
+        const values = item.const !== undefined
+            ? [item.const]
+            : Array.isArray(item.enum)
+                ? item.enum
+                : null;
+        if (!values) {
+            return null;
+        }
+        for (const value of values) {
+            const valueType = getGeminiEnumType(value);
+            if (!valueType) {
+                return null;
+            }
+            if (enumType && enumType !== valueType) {
+                return null;
+            }
+            enumType = valueType;
+            enumValues.push(value);
+        }
+    }
+    if (!enumType || enumValues.length === 0) {
+        return null;
+    }
+    return {
+        type: enumType,
+        enum: Array.from(new Set(enumValues)),
+        ...(nullable ? { nullable: true } : {}),
+    };
+}
+function sanitizeGeminiSchema(schema) {
+    if (!isRecord(schema)) {
+        return { type: 'object', properties: {} };
+    }
+    const anyOf = Array.isArray(schema.anyOf)
+        ? schema.anyOf
+        : Array.isArray(schema.any_of)
+            ? schema.any_of
+            : null;
+    const oneOf = Array.isArray(schema.oneOf)
+        ? schema.oneOf
+        : Array.isArray(schema.one_of)
+            ? schema.one_of
+            : null;
+    if (anyOf || oneOf) {
+        const collapsed = collapseSimpleGeminiAnyOf(anyOf ?? oneOf ?? []);
+        if (collapsed) {
+            return collapsed;
+        }
+        return {
+            anyOf: (anyOf ?? oneOf ?? []).map(sanitizeGeminiSchema),
+        };
+    }
+    const out = {};
+    const typeValue = schema.type;
+    if (Array.isArray(typeValue)) {
+        const nonNullType = typeValue.find(value => value !== 'null');
+        if (typeof nonNullType === 'string') {
+            out.type = nonNullType;
+        }
+        if (typeValue.includes('null')) {
+            out.nullable = true;
+        }
+    }
+    else if (typeof typeValue === 'string') {
+        out.type = typeValue;
+    }
+    for (const key of [
+        'title',
+        'description',
+        'format',
+        'nullable',
+        'minimum',
+        'maximum',
+        'minItems',
+        'maxItems',
+        'minLength',
+        'maxLength',
+        'pattern',
+    ]) {
+        if (schema[key] !== undefined) {
+            out[key] = schema[key];
+        }
+    }
+    if (Array.isArray(schema.enum)) {
+        out.enum = schema.enum;
+    }
+    else if (schema.const !== undefined) {
+        out.enum = [schema.const];
+    }
+    if (!out.type && Array.isArray(out.enum) && out.enum.length > 0) {
+        out.type = getGeminiEnumType(out.enum[0]);
+    }
+    if (schema.exclusiveMinimum !== undefined && out.minimum === undefined) {
+        out.minimum =
+            typeof schema.exclusiveMinimum === 'number'
+                ? schema.exclusiveMinimum
+                : schema.minimum;
+    }
+    if (schema.exclusiveMaximum !== undefined && out.maximum === undefined) {
+        out.maximum =
+            typeof schema.exclusiveMaximum === 'number'
+                ? schema.exclusiveMaximum
+                : schema.maximum;
+    }
+    if (isRecord(schema.items)) {
+        out.items = sanitizeGeminiSchema(schema.items);
+    }
+    else if (Array.isArray(schema.items) && schema.items.length > 0) {
+        out.items = sanitizeGeminiSchema(schema.items[0]);
+    }
+    if (isRecord(schema.properties)) {
+        const properties = {};
+        for (const [name, value] of Object.entries(schema.properties)) {
+            properties[name] = sanitizeGeminiSchema(value);
+        }
+        out.properties = properties;
+    }
+    if (Array.isArray(schema.required)) {
+        out.required = schema.required.filter((name) => typeof name === 'string');
+    }
+    if (!out.type) {
+        out.type = out.properties ? 'object' : out.items ? 'array' : 'object';
+    }
+    if (out.type === 'object' && !out.properties) {
+        out.properties = {};
+    }
+    return out;
+}
+function buildGeminiToolConfig(toolChoice) {
+    if (toolChoice === 'auto') {
+        return undefined;
+    }
+    if (toolChoice === 'none') {
+        return { functionCallingConfig: { mode: 'NONE' } };
+    }
+    if (toolChoice === 'required') {
+        return { functionCallingConfig: { mode: 'ANY' } };
+    }
+    return {
+        functionCallingConfig: {
+            mode: 'ANY',
+            allowedFunctionNames: [toolChoice.function.name],
+        },
+    };
+}
+function parseGeminiCodeAssistResponse(response) {
+    const candidates = response.response?.candidates ?? [];
+    return {
+        id: response.traceId,
+        choices: candidates.map(candidate => {
+            const contentParts = [];
+            const toolCalls = [];
+            for (const part of candidate.content?.parts ?? []) {
+                if ('text' in part && typeof part.text === 'string') {
+                    contentParts.push(part.text);
+                }
+                if ('functionCall' in part && part.functionCall?.name) {
+                    toolCalls.push({
+                        id: `call_${randomUUID().replace(/-/g, '')}`,
+                        type: 'function',
+                        function: {
+                            name: part.functionCall.name,
+                            arguments: jsonStringify(part.functionCall.args ?? {}),
+                        },
+                    });
+                }
+            }
+            return {
+                message: {
+                    content: contentParts.join('') || null,
+                    tool_calls: toolCalls.length > 0 ? toolCalls : undefined,
+                },
+                finish_reason: candidate.finishReason,
+            };
+        }),
+        usage: {
+            prompt_tokens: response.response?.usageMetadata?.promptTokenCount,
+            completion_tokens: response.response?.usageMetadata?.candidatesTokenCount,
+        },
+    };
+}
+function getExplicitGeminiGoogleProjectId() {
+    return process.env.GEMINI_GOOGLE_PROJECT_ID?.trim() || undefined;
+}
+async function postGeminiCodeAssist(method, headers, body, signal) {
+    const response = await fetch(`https://cloudcode-pa.googleapis.com/v1internal:${method}`, {
+        method: 'POST',
+        headers,
+        body: jsonStringify(body),
+        signal,
+    });
+    const data = (await readOpenAIResponseBody(response));
+    return { response, data };
+}
+function getGeminiCodeAssistMetadata(projectId) {
+    return {
+        ideType: 'IDE_UNSPECIFIED',
+        platform: 'PLATFORM_UNSPECIFIED',
+        pluginType: 'GEMINI',
+        ...(projectId ? { duetProject: projectId } : {}),
+    };
+}
+async function resolveGeminiCodeAssistProject(headers, signal) {
+    const explicitProjectId = getExplicitGeminiGoogleProjectId();
+    const loadBody = {
+        ...(explicitProjectId ? { cloudaicompanionProject: explicitProjectId } : {}),
+        metadata: getGeminiCodeAssistMetadata(explicitProjectId),
+    };
+    const { response, data } = await postGeminiCodeAssist('loadCodeAssist', headers, loadBody, signal);
+    if (!response.ok) {
+        return explicitProjectId;
+    }
+    if (typeof data.cloudaicompanionProject === 'string') {
+        return data.cloudaicompanionProject;
+    }
+    if (explicitProjectId) {
+        return explicitProjectId;
+    }
+    const allowedTiers = Array.isArray(data.allowedTiers)
+        ? data.allowedTiers.filter(isRecord)
+        : [];
+    const tier = allowedTiers.find(tierInfo => tierInfo.isDefault === true) ??
+        allowedTiers[0];
+    const tierId = typeof tier?.id === 'string' ? tier.id : undefined;
+    if (!tierId) {
+        return undefined;
+    }
+    const { response: onboardResponse, data: onboardData } = await postGeminiCodeAssist('onboardUser', headers, {
+        tierId,
+        metadata: getGeminiCodeAssistMetadata(),
+    }, signal);
+    if (!onboardResponse.ok) {
+        return undefined;
+    }
+    const responseData = isRecord(onboardData.response)
+        ? onboardData.response
+        : onboardData;
+    const companionProject = isRecord(responseData.cloudaicompanionProject)
+        ? responseData.cloudaicompanionProject
+        : null;
+    return typeof companionProject?.id === 'string'
+        ? companionProject.id
+        : undefined;
+}
+async function createGeminiGoogleChatCompletionResponse(params) {
+    const { model, chatMessages, chatTools, toolChoice, signal, maxOutputTokens, temperature, } = params;
+    const headers = await getGeminiGoogleAuthHeaders();
+    const project = await resolveGeminiCodeAssistProject(headers, signal);
+    const generationConfig = {};
+    if (maxOutputTokens) {
+        generationConfig.maxOutputTokens = maxOutputTokens;
+    }
+    if (temperature !== undefined) {
+        generationConfig.temperature = temperature;
+    }
+    const request = {
+        contents: buildGeminiContents(chatMessages),
+        session_id: randomUUID(),
+    };
+    const systemText = chatMessages
+        .filter(message => message.role === 'system' && typeof message.content === 'string')
+        .map(message => message.content)
+        .join('\n\n');
+    if (systemText) {
+        request.systemInstruction = {
+            role: 'user',
+            parts: [{ text: systemText }],
+        };
+    }
+    const geminiTools = buildGeminiTools(chatTools);
+    if (geminiTools) {
+        request.tools = geminiTools;
+    }
+    const geminiToolConfig = buildGeminiToolConfig(toolChoice);
+    if (geminiToolConfig) {
+        request.toolConfig = geminiToolConfig;
+    }
+    if (Object.keys(generationConfig).length > 0) {
+        request.generationConfig = generationConfig;
+    }
+    const body = {
+        model,
+        ...(project ? { project } : {}),
+        user_prompt_id: randomUUID(),
+        request,
+    };
+    const url = 'https://cloudcode-pa.googleapis.com/v1internal:generateContent';
+    logForDebugging(`[Gemini Google] codeassist generateContent request model=${model} messages=${chatMessages.length} tools=${chatTools.length} endpoint=${url}`);
+    const { response, data } = (await postGeminiCodeAssist('generateContent', headers, body, signal));
+    if (!response.ok) {
+        logForDebugging(`[Gemini Google] codeassist generateContent error status=${response.status} model=${model} endpoint=${url} body=${(data.error?.message ?? '').replace(/\s+/g, ' ').slice(0, 500)}`, { level: 'error' });
+        throw new Error(buildOpenAIErrorMessage({
+            status: response.status,
+            statusText: response.statusText,
+            url,
+            model,
+            data: data,
+        }));
+    }
+    return parseGeminiCodeAssistResponse(data);
+}
 async function createChatCompletionResponse({ messages, systemPrompt, tools, signal, options, }) {
     const provider = getOpenAICompatibleProvider();
     await maybeRefreshOpenAICompatibleAuth(provider);
@@ -779,15 +1228,23 @@ async function createChatCompletionResponse({ messages, systemPrompt, tools, sig
     if (options.effortValue) {
         body.reasoning_effort = options.effortValue;
     }
-    const sendRequest = async (bearerToken) => {
+    if (provider === 'gemini-google') {
+        return createGeminiGoogleChatCompletionResponse({
+            model: String(options.model),
+            chatMessages,
+            chatTools,
+            toolChoice: buildChatToolChoice(options),
+            signal,
+            maxOutputTokens: options.maxOutputTokensOverride,
+            temperature: options.temperatureOverride,
+        });
+    }
+    const sendRequest = async (bearerToken = getOpenAICompatibleAccessToken(provider) ?? '') => {
         const url = `${getOpenAIBaseUrl(provider)}/chat/completions`;
         logForDebugging(`[${getOpenAICompatibleProviderLabel(provider)}] chat.completions request model=${options.model} messages=${chatMessages.length} tools=${chatTools.length} endpoint=${url}`);
         const response = await fetch(url, {
             method: 'POST',
-            headers: {
-                Authorization: `Bearer ${bearerToken}`,
-                'Content-Type': 'application/json',
-            },
+            headers: await getOpenAIRequestHeaders(provider),
             body: jsonStringify(body),
             signal,
         });
@@ -810,7 +1267,8 @@ async function createChatCompletionResponse({ messages, systemPrompt, tools, sig
         }
         return data;
     };
-    return sendRequest(getOpenAIAccessTokenOrThrow(provider));
+    getOpenAIAccessTokenOrThrow(provider);
+    return sendRequest();
 }
 async function buildOpenAITools(tools, options) {
     const schemas = await Promise.all(tools.map(tool => toolToAPISchema(tool, {
@@ -981,9 +1439,121 @@ function buildSideQueryToolChoice(toolChoice) {
     }
     return 'auto';
 }
+function sideQueryMessageToChatMessage(message) {
+    const content = Array.isArray(message.content)
+        ? message.content
+            .filter((block) => block?.type === 'text' && typeof block.text === 'string')
+            .map(block => block.text)
+            .join('\n')
+        : String(message.content ?? '');
+    return {
+        role: message.role,
+        content,
+    };
+}
+function sideQueryToolToChatTool(tool) {
+    return {
+        type: 'function',
+        function: {
+            name: tool.name,
+            description: tool.description,
+            parameters: tool.input_schema ?? { type: 'object', properties: {} },
+        },
+    };
+}
+function buildSideQueryChatToolChoice(toolChoice) {
+    const responsesChoice = buildSideQueryToolChoice(toolChoice);
+    if (responsesChoice === 'auto' || responsesChoice === 'none') {
+        return responsesChoice;
+    }
+    if (responsesChoice === 'required') {
+        return 'required';
+    }
+    return {
+        type: 'function',
+        function: { name: responsesChoice.name },
+    };
+}
 export async function queryOpenAISideQuery({ model, systemPrompt, messages, tools, toolChoice, outputFormat, signal, maxOutputTokens, temperature, }) {
     const provider = getOpenAICompatibleProvider();
     await maybeRefreshOpenAICompatibleAuth(provider);
+    const baseUrl = getOpenAIBaseUrl(provider);
+    const bearerToken = getOpenAICompatibleAccessToken(provider);
+    const isCodexOAuth = provider === 'openai' && bearerToken && isJwtToken(bearerToken);
+    if (!isCodexOAuth) {
+        const chatMessages = [
+            ...(systemPrompt
+                ? [{ role: 'system', content: systemPrompt }]
+                : []),
+            ...messages.map(sideQueryMessageToChatMessage),
+        ];
+        const body = {
+            model,
+            messages: chatMessages,
+            stream: false,
+        };
+        const chatTools = tools?.map(sideQueryToolToChatTool) ?? [];
+        const chatToolChoice = buildSideQueryChatToolChoice(toolChoice);
+        if (chatTools.length > 0) {
+            body.tools = chatTools;
+            body.tool_choice = chatToolChoice;
+        }
+        if (outputFormat?.type === 'json_schema') {
+            body.response_format = {
+                type: 'json_schema',
+                json_schema: {
+                    name: 'side_query_output',
+                    strict: true,
+                    schema: outputFormat.schema,
+                },
+            };
+        }
+        if (maxOutputTokens) {
+            body.max_tokens = maxOutputTokens;
+        }
+        if (temperature !== undefined) {
+            body.temperature = temperature;
+        }
+        if (provider === 'gemini-google') {
+            const data = await createGeminiGoogleChatCompletionResponse({
+                model,
+                chatMessages,
+                chatTools,
+                toolChoice: chatToolChoice,
+                signal,
+                maxOutputTokens,
+                temperature,
+            });
+            return {
+                id: data.id,
+                content: parseChatCompletionResponse(data).content,
+                usage: getChatUsage(data),
+            };
+        }
+        const url = `${baseUrl}/chat/completions`;
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: await getOpenAIRequestHeaders(provider),
+            body: jsonStringify(body),
+            signal,
+        });
+        const data = await readOpenAIResponseBody(response);
+        if (!response.ok) {
+            logForDebugging(`[${getOpenAICompatibleProviderLabel(provider)}] sideQuery chat.completions error status=${response.status} model=${model} endpoint=${url} body=${(data.error?.message ?? '').replace(/\s+/g, ' ').slice(0, 500)}`, { level: 'error' });
+            throw new Error(buildOpenAIErrorMessage({
+                status: response.status,
+                statusText: response.statusText,
+                url,
+                model,
+                data,
+            }));
+        }
+        return {
+            id: data.id,
+            content: parseChatCompletionResponse(data).content,
+            usage: getChatUsage(data),
+        };
+    }
     const input = messages.flatMap(sideQueryMessageToOpenAIInput);
     const body = {
         model,
@@ -1012,17 +1582,10 @@ export async function queryOpenAISideQuery({ model, systemPrompt, messages, tool
     if (temperature !== undefined) {
         body.temperature = temperature;
     }
-    const baseUrl = getOpenAIBaseUrl(provider);
-    const bearerToken = getOpenAICompatibleAccessToken(provider);
-    const isCodexOAuth = provider === 'openai' && bearerToken && isJwtToken(bearerToken);
-    const endpoint = isCodexOAuth ? 'responses' : 'chat/completions';
-    const url = `${baseUrl}/${endpoint}`;
-    // Si no es un proveedor que soporte la Responses API, deberíamos ideally transformar el body.
-    // Pero para SideQuery a menudo el body ya es compatible o se ignora si falla.
-    // Por ahora arreglamos el 404 cambiando el endpoint.
+    const url = `${baseUrl}/responses`;
     const response = await fetch(url, {
         method: 'POST',
-        headers: getOpenAIHeaders(provider),
+        headers: await getOpenAIRequestHeaders(provider),
         body: jsonStringify(body),
         signal,
     });