@iaforged/context-code 1.0.72 → 1.0.74

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

@@ -0,0 +1,1187 @@
+import { APIUserAbortError } from '@anthropic-ai/sdk/error.js';
+import { checkAndRefreshOpenAIOAuthTokenIfNeeded, 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';
+import { logForDebugging } from '../../utils/debug.js';
+import { logError } from '../../utils/log.js';
+import { createAssistantAPIErrorMessage, createAssistantMessage, } from '../../utils/messages.js';
+import { toolToAPISchema } from '../../utils/api.js';
+import { jsonStringify } from '../../utils/slowOperations.js';
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function isPlainObject(value) {
+    if (!isRecord(value)) {
+        return false;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}
+// ── Detección de token JWT (OAuth de Codex) vs API key estándar ─────────────
+function isJwtToken(token) {
+    const parts = token.split('.');
+    return parts.length === 3;
+}
+function extractCodexAccountId(token) {
+    try {
+        const payload = JSON.parse(atob(token.split('.')[1]));
+        const accountId = payload?.['https://api.openai.com/auth']?.chatgpt_account_id;
+        if (!accountId)
+            throw new Error('No account ID in token');
+        return accountId;
+    }
+    catch {
+        throw new Error('Failed to extract chatgpt-account-id from OAuth token');
+    }
+}
+function getCodexBackendUrl() {
+    const base = (process.env.OPENAI_OAUTH_BASE_URL || 'https://chatgpt.com/backend-api').replace(/\/+$/, '');
+    if (base.endsWith('/codex/responses'))
+        return base;
+    if (base.endsWith('/codex'))
+        return `${base}/responses`;
+    return `${base}/codex/responses`;
+}
+function getOpenAICompatibleProvider() {
+    const provider = getAPIProvider();
+    return provider === 'openrouter' ||
+        provider === 'ollama' ||
+        provider === 'ollama-cloud' ||
+        provider === 'zai'
+        ? provider
+        : 'openai';
+}
+function getOpenAICompatibleProviderLabel(provider = getOpenAICompatibleProvider()) {
+    switch (provider) {
+        case 'openrouter':
+            return 'OpenRouter';
+        case 'ollama':
+            return 'Ollama Local';
+        case 'ollama-cloud':
+            return 'Ollama Cloud';
+        case 'zai':
+            return 'Z.AI';
+        default:
+            return 'OpenAI';
+    }
+}
+function getOpenAIBaseUrl(provider = getOpenAICompatibleProvider()) {
+    if (provider === 'openrouter') {
+        const raw = process.env.OPENROUTER_BASE_URL ||
+            getConfiguredProviderBaseUrl('openrouter') ||
+            'https://openrouter.ai/api/v1';
+        return raw.endsWith('/v1')
+            ? raw
+            : raw.endsWith('/')
+                ? `${raw}v1`
+                : `${raw}/v1`;
+    }
+    if (provider === 'ollama') {
+        const raw = process.env.OLLAMA_BASE_URL ||
+            getConfiguredProviderBaseUrl('ollama') ||
+            'http://localhost:11434/v1';
+        return raw.endsWith('/v1')
+            ? raw
+            : raw.endsWith('/')
+                ? `${raw}v1`
+                : `${raw}/v1`;
+    }
+    if (provider === 'ollama-cloud') {
+        const raw = process.env.OLLAMA_BASE_URL ||
+            getConfiguredProviderBaseUrl('ollama-cloud') ||
+            'http://localhost:11434/v1';
+        return raw.endsWith('/v1')
+            ? raw
+            : raw.endsWith('/')
+                ? `${raw}v1`
+                : `${raw}/v1`;
+    }
+    if (provider === 'zai') {
+        const raw = process.env.ZAI_BASE_URL ||
+            getConfiguredProviderBaseUrl('zai') ||
+            'https://api.z.ai/api/coding/paas/v4';
+        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';
+    return raw.endsWith('/v1')
+        ? raw
+        : raw.endsWith('/')
+            ? `${raw}v1`
+            : `${raw}/v1`;
+}
+function getOpenAIHeaders(provider = getOpenAICompatibleProvider()) {
+    const token = getOpenAICompatibleAccessToken(provider);
+    const baseUrl = getOpenAIBaseUrl(provider);
+    const isLocalOllamaHost = isLocalOllamaProviderHost(provider, baseUrl);
+    if (isLocalOllamaHost) {
+        return {
+            'Content-Type': 'application/json',
+        };
+    }
+    if (!token) {
+        throw new Error(`${getOpenAICompatibleProviderLabel(provider)} is selected but no credentials were found.`);
+    }
+    return {
+        Authorization: `Bearer ${token}`,
+        'Content-Type': 'application/json',
+    };
+}
+function isLocalOllamaProviderHost(provider, baseUrl = getOpenAIBaseUrl(provider)) {
+    return ((provider === 'ollama' || provider === 'ollama-cloud') &&
+        (baseUrl.includes('localhost') || baseUrl.includes('127.0.0.1')));
+}
+function getOpenAIAccessTokenOrThrow(provider = getOpenAICompatibleProvider()) {
+    if (isLocalOllamaProviderHost(provider)) {
+        return 'ollama';
+    }
+    const token = getOpenAICompatibleAccessToken(provider);
+    if (!token) {
+        throw new Error(`${getOpenAICompatibleProviderLabel(provider)} is selected but no credentials were found.`);
+    }
+    return token;
+}
+async function maybeRefreshOpenAICompatibleAuth(provider = getOpenAICompatibleProvider()) {
+    if (provider === 'openai') {
+        await checkAndRefreshOpenAIOAuthTokenIfNeeded();
+    }
+}
+async function maybeRecoverOpenAICompatible401(bearerToken, provider = getOpenAICompatibleProvider()) {
+    if (provider !== 'openai') {
+        return null;
+    }
+    const recovered = await handleOpenAIOAuth401Error(bearerToken);
+    if (!recovered) {
+        return null;
+    }
+    const refreshedToken = getOpenAIAccessToken();
+    if (refreshedToken && refreshedToken !== bearerToken) {
+        return refreshedToken;
+    }
+    return null;
+}
+function toInputText(text) {
+    return {
+        type: 'input_text',
+        text,
+    };
+}
+function toOutputText(text) {
+    return {
+        type: 'output_text',
+        text,
+    };
+}
+function normalizeBlocksForRole(blocks, role) {
+    if (role !== 'assistant') {
+        return blocks;
+    }
+    return blocks.map(block => {
+        if (block.type === 'input_text') {
+            return toOutputText(block.text);
+        }
+        return block;
+    });
+}
+function toOpenAIInputImage(source) {
+    if (source.type === 'base64') {
+        const mediaType = source.media_type;
+        const data = source.data;
+        if (typeof mediaType !== 'string' || typeof data !== 'string') {
+            return null;
+        }
+        return {
+            type: 'input_image',
+            image_url: `data:${mediaType};base64,${data}`,
+        };
+    }
+    if (source.type === 'url' && typeof source.url === 'string') {
+        return {
+            type: 'input_image',
+            image_url: source.url,
+        };
+    }
+    if (source.type === 'file' && typeof source.file_id === 'string') {
+        return {
+            type: 'input_image',
+            file_id: source.file_id,
+        };
+    }
+    return null;
+}
+function toOpenAIInputFile(source, filename) {
+    if (source.type === 'file' && typeof source.file_id === 'string') {
+        return {
+            type: 'input_file',
+            file_id: source.file_id,
+        };
+    }
+    if (source.type === 'base64' && typeof source.data === 'string') {
+        if (typeof source.media_type !== 'string') {
+            return null;
+        }
+        return {
+            type: 'input_file',
+            file_data: source.data,
+            ...(typeof filename === 'string' && filename ? { filename } : {}),
+        };
+    }
+    if (source.type === 'url' && typeof source.url === 'string') {
+        return {
+            type: 'input_file',
+            file_url: source.url,
+            ...(typeof filename === 'string' && filename ? { filename } : {}),
+        };
+    }
+    if (source.type === 'text' && typeof source.data === 'string') {
+        return toInputText(source.data);
+    }
+    return null;
+}
+function stringifyBlockContent(content) {
+    if (typeof content === 'string') {
+        return content;
+    }
+    if (Array.isArray(content)) {
+        return content
+            .map(item => {
+            if (typeof item === 'string') {
+                return item;
+            }
+            if (item &&
+                typeof item === 'object' &&
+                'type' in item &&
+                item.type === 'text' &&
+                'text' in item &&
+                typeof item.text === 'string') {
+                return item.text;
+            }
+            return jsonStringify(item);
+        })
+            .join('\n');
+    }
+    if (content == null) {
+        return '';
+    }
+    return jsonStringify(content);
+}
+function normalizeResponseContent(content) {
+    if (Array.isArray(content)) {
+        return content;
+    }
+    if (content === null || content === undefined) {
+        return [];
+    }
+    return [content];
+}
+function blockToOpenAIContentBlocks(block) {
+    if (!isRecord(block)) {
+        return null;
+    }
+    if (block.type === 'text' && typeof block.text === 'string') {
+        return [toInputText(block.text)];
+    }
+    if (block.type === 'image') {
+        const source = isRecord(block.source) ? block.source : null;
+        const imageBlock = source ? toOpenAIInputImage(source) : null;
+        return imageBlock ? [imageBlock] : null;
+    }
+    if (block.type === 'document') {
+        const source = isRecord(block.source) ? block.source : null;
+        if (!source) {
+            return null;
+        }
+        const fileBlock = toOpenAIInputFile(source, typeof block.title === 'string' ? block.title : undefined);
+        if (fileBlock) {
+            return [fileBlock];
+        }
+        if (source.type === 'content' && typeof source.content === 'string') {
+            return [toInputText(source.content)];
+        }
+        if (source.type === 'content' && Array.isArray(source.content)) {
+            const nestedBlocks = [];
+            for (const nested of source.content) {
+                const converted = blockToOpenAIContentBlocks(nested);
+                if (converted) {
+                    nestedBlocks.push(...converted);
+                }
+            }
+            return nestedBlocks.length > 0 ? nestedBlocks : null;
+        }
+        return null;
+    }
+    if (block.type === 'search_result' && Array.isArray(block.content)) {
+        const lines = [];
+        if (typeof block.title === 'string' && block.title.trim()) {
+            lines.push(block.title.trim());
+        }
+        if (typeof block.source === 'string' && block.source.trim()) {
+            lines.push(block.source.trim());
+        }
+        for (const nested of block.content) {
+            if (nested && typeof nested === 'object' && 'text' in nested) {
+                const text = nested.text;
+                if (typeof text === 'string' && text.trim()) {
+                    lines.push(text.trim());
+                }
+            }
+        }
+        return [toInputText(lines.join('\n\n'))];
+    }
+    if (block.type === 'container_upload' && typeof block.file_id === 'string') {
+        return [
+            {
+                type: 'input_file',
+                file_id: block.file_id,
+            },
+        ];
+    }
+    if ((block.type === 'bash_code_execution_output' ||
+        block.type === 'mcp_tool_result' ||
+        block.type === 'code_execution_tool_result' ||
+        block.type === 'web_search_tool_result' ||
+        block.type === 'web_fetch_tool_result' ||
+        block.type === 'text_editor_code_execution_tool_result' ||
+        block.type === 'tool_search_tool_result') &&
+        'content' in block) {
+        const content = block.content;
+        if (typeof content === 'string') {
+            return [toInputText(content)];
+        }
+        if (Array.isArray(content)) {
+            const converted = [];
+            for (const nested of content) {
+                const nestedBlocks = blockToOpenAIContentBlocks(nested);
+                if (nestedBlocks) {
+                    converted.push(...nestedBlocks);
+                }
+            }
+            return converted.length > 0 ? converted : null;
+        }
+    }
+    if ('content' in block && (typeof block.content === 'string' || Array.isArray(block.content))) {
+        const content = block.content;
+        if (typeof content === 'string') {
+            return [toInputText(content)];
+        }
+        const converted = [];
+        for (const nested of content) {
+            const nestedBlocks = blockToOpenAIContentBlocks(nested);
+            if (nestedBlocks) {
+                converted.push(...nestedBlocks);
+            }
+        }
+        return converted.length > 0 ? converted : null;
+    }
+    if ('data' in block && typeof block.data === 'string') {
+        return [toInputText(block.data)];
+    }
+    return null;
+}
+function toolResultContentToOpenAIOutput(content) {
+    if (typeof content === 'string') {
+        return content;
+    }
+    if (!Array.isArray(content)) {
+        return stringifyBlockContent(content);
+    }
+    const blocks = [];
+    for (const block of content) {
+        const converted = blockToOpenAIContentBlocks(block);
+        if (converted && converted.length > 0) {
+            blocks.push(...converted);
+            continue;
+        }
+        const fallback = stringifyBlockContent(block).trim();
+        if (fallback) {
+            blocks.push(toInputText(fallback));
+        }
+    }
+    if (blocks.length === 0) {
+        return '';
+    }
+    if (blocks.every(block => block.type === 'input_text')) {
+        return blocks.map(block => block.text).join('\n\n');
+    }
+    return blocks;
+}
+function messageToOpenAIInput(message) {
+    // Ignorar mensajes internos que no son de usuario ni de asistente
+    // (p.ej. mensajes de tipo 'system' no tienen .message)
+    if (!message.message || (message.type !== 'user' && message.type !== 'assistant')) {
+        return [];
+    }
+    const content = Array.isArray(message.message.content)
+        ? message.message.content
+        : [{ type: 'text', text: String(message.message.content ?? '') }];
+    const role = message.type === 'assistant' ? 'assistant' : 'user';
+    const items = [];
+    const contentBlocks = [];
+    const flushMessage = () => {
+        if (contentBlocks.length === 0) {
+            return;
+        }
+        items.push({
+            type: 'message',
+            role,
+            content: [...contentBlocks],
+        });
+        contentBlocks.length = 0;
+    };
+    for (const block of content) {
+        if (message.type === 'assistant' &&
+            block.type === 'tool_use' &&
+            typeof block.id === 'string' &&
+            typeof block.name === 'string') {
+            flushMessage();
+            items.push({
+                type: 'function_call',
+                call_id: block.id,
+                name: block.name,
+                arguments: jsonStringify(block.input ?? {}),
+            });
+            continue;
+        }
+        if (message.type === 'user' &&
+            block.type === 'tool_result' &&
+            typeof block.tool_use_id === 'string') {
+            flushMessage();
+            items.push({
+                type: 'function_call_output',
+                call_id: block.tool_use_id,
+                output: toolResultContentToOpenAIOutput(block.content),
+            });
+            continue;
+        }
+        if (block.type === 'thinking' || block.type === 'redacted_thinking') {
+            continue;
+        }
+        const openAIBlocks = blockToOpenAIContentBlocks(block);
+        if (openAIBlocks && openAIBlocks.length > 0) {
+            contentBlocks.push(...normalizeBlocksForRole(openAIBlocks, role));
+            continue;
+        }
+        contentBlocks.push(...(role === 'assistant'
+            ? [toOutputText(stringifyBlockContent(block))]
+            : [toInputText(stringifyBlockContent(block))]));
+    }
+    flushMessage();
+    return items;
+}
+async function readOpenAIResponseBody(response) {
+    const rawBody = await response.text();
+    if (!rawBody.trim()) {
+        return {};
+    }
+    const trimmedBody = rawBody.trim();
+    if (trimmedBody.startsWith('data:') ||
+        trimmedBody.startsWith('event:')) {
+        return parseOpenAISSEBody(rawBody);
+    }
+    try {
+        const parsed = JSON.parse(rawBody);
+        return isRecord(parsed)
+            ? { ...parsed, raw_error_text: rawBody }
+            : { error: { message: rawBody }, raw_error_text: rawBody };
+    }
+    catch {
+        return {
+            error: {
+                message: rawBody,
+            },
+            raw_error_text: rawBody,
+        };
+    }
+}
+function parseOpenAISSEBody(rawBody) {
+    const events = [];
+    for (const chunk of rawBody.split(/\r?\n\r?\n/)) {
+        const lines = chunk
+            .split(/\r?\n/)
+            .map(line => line.trim())
+            .filter(Boolean);
+        if (lines.length === 0) {
+            continue;
+        }
+        const dataLines = lines
+            .filter(line => line.startsWith('data:'))
+            .map(line => line.slice(5).trim());
+        if (dataLines.length === 0) {
+            continue;
+        }
+        const payload = dataLines.join('\n').trim();
+        if (!payload || payload === '[DONE]') {
+            continue;
+        }
+        try {
+            const parsed = JSON.parse(payload);
+            if (isRecord(parsed)) {
+                events.push(parsed);
+            }
+        }
+        catch {
+            // Ignore malformed chunks and let the caller fall back to whatever valid events remain.
+        }
+    }
+    let completed = null;
+    let latestError = null;
+    const outputItems = [];
+    let outputText = '';
+    for (const event of events) {
+        const eventType = typeof event.type === 'string' ? event.type : '';
+        if (eventType === 'response.completed' && isRecord(event.response)) {
+            completed = {
+                ...event.response,
+                raw_error_text: rawBody,
+            };
+            continue;
+        }
+        if (eventType === 'error') {
+            if (typeof event.message === 'string' && event.message.trim()) {
+                latestError = event.message;
+            }
+            else if (isRecord(event.error) && typeof event.error.message === 'string') {
+                latestError = event.error.message;
+            }
+            continue;
+        }
+        if (eventType === 'response.output_item.done' && isRecord(event.item)) {
+            outputItems.push(event.item);
+            continue;
+        }
+        if (eventType === 'response.output_text.delta' && typeof event.delta === 'string') {
+            outputText += event.delta;
+            continue;
+        }
+        if (eventType === 'response.output_text.done' && typeof event.text === 'string') {
+            outputText = event.text;
+        }
+    }
+    if (completed) {
+        if ((!completed.output || completed.output.length === 0) && outputItems.length > 0) {
+            completed.output = outputItems;
+        }
+        if (!completed.output_text && outputText) {
+            completed.output_text = outputText;
+        }
+        if (!completed.error && latestError) {
+            completed.error = { message: latestError };
+        }
+        return completed;
+    }
+    if (outputItems.length > 0 || outputText || latestError) {
+        return {
+            output: outputItems.length > 0 ? outputItems : undefined,
+            output_text: outputText || undefined,
+            error: latestError ? { message: latestError } : undefined,
+            raw_error_text: rawBody,
+        };
+    }
+    return {
+        error: {
+            message: rawBody,
+        },
+        raw_error_text: rawBody,
+    };
+}
+function buildOpenAIErrorMessage(params) {
+    const primary = params.data.error?.message?.trim() ||
+        params.data.raw_error_text?.trim() ||
+        `OpenAI request failed (${params.status} ${params.statusText})`;
+    const rawSnippet = params.data.raw_error_text?.trim();
+    const compactRaw = rawSnippet && rawSnippet !== primary
+        ? rawSnippet.replace(/\s+/g, ' ').slice(0, 400)
+        : null;
+    return compactRaw
+        ? `${primary} [model=${params.model ?? 'unknown'} endpoint=${params.url}] ${compactRaw}`
+        : `${primary} [model=${params.model ?? 'unknown'} endpoint=${params.url}]`;
+}
+// ── Chat Completions: conversión de mensajes ───────────────────────────────
+function blockToChatContentPart(block) {
+    if (block.type === 'text' && typeof block.text === 'string') {
+        return { type: 'text', text: block.text };
+    }
+    if (block.type === 'image') {
+        const source = isRecord(block.source) ? block.source : null;
+        if (!source)
+            return null;
+        if (source.type === 'base64' && typeof source.data === 'string' && typeof source.media_type === 'string') {
+            return { type: 'image_url', image_url: { url: `data:${source.media_type};base64,${source.data}` } };
+        }
+        if (source.type === 'url' && typeof source.url === 'string') {
+            return { type: 'image_url', image_url: { url: source.url } };
+        }
+    }
+    const text = stringifyBlockContent(block);
+    return text ? { type: 'text', text } : null;
+}
+function toolResultToString(content) {
+    if (typeof content === 'string')
+        return content;
+    if (!Array.isArray(content))
+        return stringifyBlockContent(content);
+    return content
+        .map(b => {
+        if (typeof b === 'string')
+            return b;
+        if (isRecord(b) && typeof b.text === 'string')
+            return b.text;
+        return stringifyBlockContent(b);
+    })
+        .filter(Boolean)
+        .join('\n');
+}
+function messageToChatMessages(message) {
+    if (!message.message || (message.type !== 'user' && message.type !== 'assistant')) {
+        return [];
+    }
+    const rawContent = message.message.content;
+    const blocks = Array.isArray(rawContent)
+        ? rawContent
+        : [{ type: 'text', text: String(rawContent ?? '') }];
+    if (message.type === 'assistant') {
+        const toolCalls = [];
+        const textParts = [];
+        for (const block of blocks) {
+            if (block.type === 'thinking' || block.type === 'redacted_thinking')
+                continue;
+            if (block.type === 'tool_use' && typeof block.id === 'string' && typeof block.name === 'string') {
+                toolCalls.push({
+                    id: block.id,
+                    type: 'function',
+                    function: { name: block.name, arguments: jsonStringify(block.input ?? {}) },
+                });
+            }
+            else if (block.type === 'text' && typeof block.text === 'string' && block.text.trim()) {
+                textParts.push(block.text);
+            }
+        }
+        const msg = { role: 'assistant', content: textParts.join('\n') || null };
+        if (toolCalls.length > 0)
+            msg.tool_calls = toolCalls;
+        return [msg];
+    }
+    // Mensajes de usuario: separar tool_results de contenido regular
+    const toolMessages = [];
+    const userParts = [];
+    for (const block of blocks) {
+        if (block.type === 'tool_result' && typeof block.tool_use_id === 'string') {
+            toolMessages.push({
+                role: 'tool',
+                tool_call_id: block.tool_use_id,
+                content: toolResultToString(block.content),
+            });
+        }
+        else {
+            const part = blockToChatContentPart(block);
+            if (part)
+                userParts.push(part);
+        }
+    }
+    const result = [...toolMessages];
+    if (userParts.length > 0) {
+        const allText = userParts.every(p => p.type === 'text');
+        result.push({
+            role: 'user',
+            content: allText
+                ? userParts.map(p => p.text).join('\n')
+                : userParts,
+        });
+    }
+    return result;
+}
+function parseChatCompletionResponse(response) {
+    const content = [];
+    for (const choice of response.choices ?? []) {
+        const msg = choice.message;
+        if (!msg)
+            continue;
+        if (typeof msg.content === 'string' && msg.content.trim()) {
+            content.push({ type: 'text', text: msg.content });
+        }
+        for (const tc of msg.tool_calls ?? []) {
+            content.push({
+                type: 'tool_use',
+                id: tc.id,
+                name: tc.function?.name ?? 'tool',
+                input: parseFunctionCallArguments(tc.function?.arguments),
+            });
+        }
+    }
+    return { content };
+}
+function getChatUsage(response) {
+    if (typeof response.usage?.prompt_tokens !== 'number' && typeof response.usage?.completion_tokens !== 'number') {
+        return undefined;
+    }
+    return {
+        input_tokens: response.usage?.prompt_tokens ?? 0,
+        output_tokens: response.usage?.completion_tokens ?? 0,
+    };
+}
+function buildChatTools(rawTools) {
+    return rawTools.map(t => ({
+        type: 'function',
+        function: {
+            name: t.name,
+            description: t.description,
+            parameters: t.parameters,
+            ...(t.strict ? { strict: true } : {}),
+        },
+    }));
+}
+function buildChatToolChoice(options) {
+    if (!options.toolChoice)
+        return 'auto';
+    switch (options.toolChoice.type) {
+        case 'auto': return 'auto';
+        case 'any': return 'required';
+        case 'none': return 'none';
+        case 'tool':
+            return typeof options.toolChoice.name === 'string'
+                ? { type: 'function', function: { name: options.toolChoice.name } }
+                : 'auto';
+        default: return 'auto';
+    }
+}
+async function createChatCompletionResponse({ messages, systemPrompt, tools, signal, options, }) {
+    const provider = getOpenAICompatibleProvider();
+    await maybeRefreshOpenAICompatibleAuth(provider);
+    const sysContent = systemPrompt.join('\n\n');
+    const chatMessages = [
+        ...(sysContent ? [{ role: 'system', content: sysContent }] : []),
+        ...messages.flatMap(messageToChatMessages),
+    ];
+    const rawTools = await buildOpenAITools(tools, options);
+    const chatTools = buildChatTools(rawTools);
+    const body = {
+        model: options.model,
+        messages: chatMessages,
+        stream: false,
+    };
+    if (chatTools.length > 0) {
+        body.tools = chatTools;
+        body.tool_choice = buildChatToolChoice(options);
+    }
+    if (shouldDisableParallelToolCalls(options)) {
+        body.parallel_tool_calls = false;
+    }
+    if (options.maxOutputTokensOverride) {
+        body.max_tokens = options.maxOutputTokensOverride;
+    }
+    if (options.temperatureOverride !== undefined) {
+        body.temperature = options.temperatureOverride;
+    }
+    if (options.effortValue) {
+        body.reasoning_effort = options.effortValue;
+    }
+    const sendRequest = async (bearerToken) => {
+        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',
+            },
+            body: jsonStringify(body),
+            signal,
+        });
+        const data = await readOpenAIResponseBody(response);
+        if (response.status === 401) {
+            const refreshedToken = await maybeRecoverOpenAICompatible401(bearerToken, provider);
+            if (refreshedToken) {
+                return sendRequest(refreshedToken);
+            }
+        }
+        if (!response.ok) {
+            logForDebugging(`[${getOpenAICompatibleProviderLabel(provider)}] chat.completions error status=${response.status} model=${options.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: String(options.model),
+                data,
+            }));
+        }
+        return data;
+    };
+    return sendRequest(getOpenAIAccessTokenOrThrow(provider));
+}
+async function buildOpenAITools(tools, options) {
+    const schemas = await Promise.all(tools.map(tool => toolToAPISchema(tool, {
+        getToolPermissionContext: options.getToolPermissionContext,
+        tools,
+        agents: options.agents,
+        allowedAgentTypes: options.allowedAgentTypes,
+        model: options.model,
+    })));
+    return schemas.map(schema => ({
+        type: 'function',
+        name: schema.name,
+        description: schema.description,
+        parameters: schema.input_schema,
+        ...(schema.strict ? { strict: true } : {}),
+    }));
+}
+function buildToolChoice(options) {
+    if (!options.toolChoice) {
+        return 'auto';
+    }
+    switch (options.toolChoice.type) {
+        case 'auto':
+            return 'auto';
+        case 'any':
+            return 'required';
+        case 'none':
+            return 'none';
+        case 'tool':
+            return typeof options.toolChoice.name === 'string'
+                ? {
+                    type: 'function',
+                    name: options.toolChoice.name,
+                }
+                : 'auto';
+        default:
+            return 'auto';
+    }
+}
+function shouldDisableParallelToolCalls(options) {
+    const toolChoice = options.toolChoice;
+    return Boolean(toolChoice &&
+        'disable_parallel_tool_use' in toolChoice &&
+        toolChoice.disable_parallel_tool_use === true);
+}
+function parseFunctionCallArguments(value) {
+    if (isPlainObject(value)) {
+        return value;
+    }
+    if (typeof value !== 'string') {
+        return value == null ? {} : { raw: value };
+    }
+    try {
+        const parsed = JSON.parse(value);
+        if (isPlainObject(parsed)) {
+            return parsed;
+        }
+        return { raw: parsed };
+    }
+    catch {
+        return { raw: value };
+    }
+}
+function parseOutputItems(response) {
+    const content = [];
+    for (const item of response.output ?? []) {
+        if (!item || typeof item !== 'object') {
+            continue;
+        }
+        if (item.type === 'function_call') {
+            const input = parseFunctionCallArguments(item.arguments);
+            content.push({
+                type: 'tool_use',
+                id: String(item.call_id ?? item.id ?? ''),
+                name: String(item.name ?? 'tool'),
+                input,
+            });
+            continue;
+        }
+        if (item.type === 'message') {
+            for (const part of normalizeResponseContent(item.content)) {
+                if (typeof part === 'string') {
+                    content.push({
+                        type: 'text',
+                        text: part,
+                    });
+                    continue;
+                }
+                if (!part || typeof part !== 'object' || !('type' in part)) {
+                    continue;
+                }
+                const partType = String(part.type ?? '');
+                const text = typeof part.text === 'string'
+                    ? (part.text ?? '')
+                    : typeof part.refusal === 'string'
+                        ? (part.refusal ?? '')
+                        : '';
+                if ((partType === 'output_text' ||
+                    partType === 'text' ||
+                    partType === 'refusal') &&
+                    text) {
+                    content.push({
+                        type: 'text',
+                        text,
+                    });
+                }
+            }
+        }
+    }
+    if (content.length === 0 && typeof response.output_text === 'string') {
+        content.push({
+            type: 'text',
+            text: response.output_text,
+        });
+    }
+    return { content };
+}
+function getUsage(response) {
+    if (typeof response.usage?.input_tokens !== 'number' &&
+        typeof response.usage?.output_tokens !== 'number') {
+        return undefined;
+    }
+    return {
+        input_tokens: response.usage?.input_tokens ?? 0,
+        output_tokens: response.usage?.output_tokens ?? 0,
+    };
+}
+function sideQueryMessageToOpenAIInput(message) {
+    const blocks = Array.isArray(message.content)
+        ? message.content
+            .filter((block) => block?.type === 'text' && typeof block.text === 'string')
+            .map(block => toInputText(block.text))
+        : [toInputText(String(message.content ?? ''))];
+    return [
+        {
+            type: 'message',
+            role: message.role,
+            content: blocks.length > 0 ? blocks : [toInputText('')],
+        },
+    ];
+}
+function sideQueryToolToOpenAITool(tool) {
+    return {
+        type: 'function',
+        name: tool.name,
+        description: tool.description,
+        parameters: tool.input_schema ?? { type: 'object', properties: {} },
+    };
+}
+function buildSideQueryToolChoice(toolChoice) {
+    if (!toolChoice || toolChoice === 'auto') {
+        return 'auto';
+    }
+    if (toolChoice === 'none' || toolChoice.type === 'none') {
+        return 'none';
+    }
+    if (toolChoice.type === 'any') {
+        return 'required';
+    }
+    if (toolChoice.type === 'auto') {
+        return 'auto';
+    }
+    if (typeof toolChoice.name === 'string' && toolChoice.name) {
+        return {
+            type: 'function',
+            name: toolChoice.name,
+        };
+    }
+    return 'auto';
+}
+export async function queryOpenAISideQuery({ model, systemPrompt, messages, tools, toolChoice, outputFormat, signal, maxOutputTokens, temperature, }) {
+    const provider = getOpenAICompatibleProvider();
+    await maybeRefreshOpenAICompatibleAuth(provider);
+    const input = messages.flatMap(sideQueryMessageToOpenAIInput);
+    const body = {
+        model,
+        input,
+        instructions: systemPrompt,
+        stream: false,
+        store: false,
+    };
+    if (tools && tools.length > 0) {
+        body.tools = tools.map(sideQueryToolToOpenAITool);
+        body.tool_choice = buildSideQueryToolChoice(toolChoice);
+    }
+    if (outputFormat?.type === 'json_schema') {
+        body.text = {
+            format: {
+                type: 'json_schema',
+                name: 'side_query_output',
+                strict: true,
+                schema: outputFormat.schema,
+            },
+        };
+    }
+    if (maxOutputTokens) {
+        body.max_output_tokens = maxOutputTokens;
+    }
+    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 response = await fetch(url, {
+        method: 'POST',
+        headers: getOpenAIHeaders(provider),
+        body: jsonStringify(body),
+        signal,
+    });
+    const data = await readOpenAIResponseBody(response);
+    if (!response.ok) {
+        logForDebugging(`[${getOpenAICompatibleProviderLabel(provider)}] sideQuery error status=${response.status} model=${model} endpoint=${baseUrl}/responses body=${(data.raw_error_text ?? '').replace(/\s+/g, ' ').slice(0, 500)}`, { level: 'error' });
+        throw new Error(buildOpenAIErrorMessage({
+            status: response.status,
+            statusText: response.statusText,
+            url: `${baseUrl}/responses`,
+            model,
+            data,
+        }));
+    }
+    return {
+        id: data.id,
+        content: parseOutputItems(data).content,
+        usage: getUsage(data),
+    };
+}
+async function createOpenAIResponse(params) {
+    const { messages, systemPrompt, tools, signal, options } = params;
+    const provider = getOpenAICompatibleProvider();
+    await maybeRefreshOpenAICompatibleAuth(provider);
+    const bearerToken = getOpenAIAccessTokenOrThrow(provider);
+    const isCodexOAuth = provider === 'openai' && isJwtToken(bearerToken);
+    if (!isCodexOAuth) {
+        const chatResp = await createChatCompletionResponse(params);
+        return {
+            id: chatResp.id,
+            output: chatResp.choices?.flatMap(choice => {
+                const items = [];
+                if (choice.message?.content) {
+                    items.push({
+                        type: 'message',
+                        role: 'assistant',
+                        content: [choice.message.content],
+                    });
+                }
+                if (choice.message?.tool_calls) {
+                    for (const call of choice.message.tool_calls) {
+                        items.push({
+                            type: 'function_call',
+                            call_id: call.id,
+                            name: call.function.name,
+                            arguments: call.function.arguments,
+                        });
+                    }
+                }
+                return items;
+            }) ?? [],
+            usage: {
+                input_tokens: chatResp.usage?.prompt_tokens,
+                output_tokens: chatResp.usage?.completion_tokens,
+            },
+        };
+    }
+    const input = messages.flatMap(messageToOpenAIInput);
+    const openAITools = await buildOpenAITools(tools, options);
+    const body = {
+        model: options.model,
+        input,
+        instructions: systemPrompt.join('\n\n'),
+        tools: openAITools,
+        tool_choice: buildToolChoice(options),
+        stream: false,
+        store: false,
+    };
+    if (shouldDisableParallelToolCalls(options)) {
+        body.parallel_tool_calls = false;
+    }
+    if (options.maxOutputTokensOverride) {
+        body.max_output_tokens = options.maxOutputTokensOverride;
+    }
+    if (options.temperatureOverride !== undefined) {
+        body.temperature = options.temperatureOverride;
+    }
+    if (options.effortValue) {
+        body.reasoning = { effort: options.effortValue };
+    }
+    const sendRequest = async (token) => {
+        const requestBody = isCodexOAuth ? { ...body, stream: true } : body;
+        let url;
+        let headers;
+        if (isCodexOAuth) {
+            const accountId = extractCodexAccountId(token);
+            url = getCodexBackendUrl();
+            headers = {
+                Authorization: `Bearer ${token}`,
+                'chatgpt-account-id': accountId,
+                'OpenAI-Beta': 'responses=experimental',
+                originator: 'pi',
+                'content-type': 'application/json',
+                accept: 'application/json',
+            };
+        }
+        else {
+            url = `${getOpenAIBaseUrl(provider)}/responses`;
+            headers = {
+                Authorization: `Bearer ${token}`,
+                'Content-Type': 'application/json',
+            };
+        }
+        const response = await fetch(url, {
+            method: 'POST',
+            headers,
+            body: jsonStringify(requestBody),
+            signal,
+        });
+        const data = await readOpenAIResponseBody(response);
+        if (response.status === 401) {
+            const refreshedToken = await maybeRecoverOpenAICompatible401(token, provider);
+            if (refreshedToken) {
+                return sendRequest(refreshedToken);
+            }
+        }
+        if (!response.ok) {
+            logForDebugging(`[${getOpenAICompatibleProviderLabel(provider)}] responses error status=${response.status} model=${options.model} endpoint=${url} oauth=${isCodexOAuth} body=${(data.raw_error_text ?? '').replace(/\s+/g, ' ').slice(0, 500)}`, { level: 'error' });
+            throw new Error(buildOpenAIErrorMessage({
+                status: response.status,
+                statusText: response.statusText,
+                url,
+                model: String(options.model),
+                data,
+            }));
+        }
+        return data;
+    };
+    return sendRequest(bearerToken);
+}
+export async function* queryOpenAIModelWithStreaming({ messages, systemPrompt, thinkingConfig: _thinkingConfig, tools, signal, options, }) {
+    try {
+        const response = await createOpenAIResponse({
+            messages,
+            systemPrompt,
+            tools,
+            signal,
+            options,
+        });
+        const { content } = parseOutputItems(response);
+        if (content.length === 0) {
+            yield createAssistantAPIErrorMessage({
+                content: 'OpenAI returned no content.',
+            });
+            return;
+        }
+        yield createAssistantMessage({
+            content,
+            usage: getUsage(response),
+        });
+    }
+    catch (error) {
+        if (signal.aborted) {
+            throw new APIUserAbortError();
+        }
+        logError(error);
+        yield createAssistantAPIErrorMessage({
+            content: errorMessage(error),
+            errorDetails: errorMessage(error),
+        });
+    }
+}