npm - axon-code - Versions diffs - 2.4.0 → 2.5.1 - Mend

axon-code 2.4.0 → 2.5.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (569) hide show

package/dist/web/server/runtime/codex-client.js ADDED Viewed

@@ -0,0 +1,1002 @@
+const DEFAULT_CODEX_BASE_URL = 'https://chatgpt.com/backend-api/codex';
+const DEFAULT_CODEX_INSTRUCTIONS = 'You are Axon, a coding assistant helping inside a web IDE.';
+function safeJsonParse(value, fallback) {
+    if (!value)
+        return fallback;
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return fallback;
+    }
+}
+function coerceTextContent(content) {
+    if (typeof content === 'string')
+        return content;
+    if (!Array.isArray(content))
+        return '';
+    return content
+        .map(part => {
+        if (!part || typeof part !== 'object')
+            return '';
+        const text = part.text;
+        if (typeof text === 'string')
+            return text;
+        return '';
+    })
+        .filter(Boolean)
+        .join('\n');
+}
+function extractTextFromOutput(output) {
+    if (!Array.isArray(output))
+        return '';
+    return output
+        .flatMap(item => Array.isArray(item.content) ? item.content : [])
+        .map(part => part.text || '')
+        .join('');
+}
+function getResponseToolCallId(item) {
+    return item.call_id || item.id || `call_${Date.now()}`;
+}
+function isCodexCompatibleModel(model) {
+    if (!model)
+        return false;
+    const normalized = model.trim();
+    if (!normalized)
+        return false;
+    return /^(gpt-|o\d(?:$|[-_])|codex)/i.test(normalized) || normalized.toLowerCase().includes('codex');
+}
+function getMessageTextContentType(role) {
+    return role === 'assistant' ? 'output_text' : 'input_text';
+}
+function isImageBlock(block) {
+    return !!block
+        && typeof block === 'object'
+        && block.type === 'image'
+        && !!block.source?.data;
+}
+function isThinkingBlock(block) {
+    return !!block
+        && typeof block === 'object'
+        && block.type === 'thinking'
+        && typeof block.thinking === 'string';
+}
+function parseResponsesApiResult(value) {
+    const trimmed = value?.trim();
+    if (!trimmed) {
+        return null;
+    }
+    try {
+        return JSON.parse(trimmed);
+    }
+    catch {
+        return null;
+    }
+}
+function collapseWhitespace(value) {
+    return value.replace(/\s+/g, ' ').trim();
+}
+function truncateForError(value, maxLength = 240) {
+    if (value.length <= maxLength) {
+        return value;
+    }
+    return `${value.slice(0, maxLength - 3)}...`;
+}
+function looksLikeHtmlPayload(value) {
+    const trimmed = value?.trim().toLowerCase() || '';
+    return trimmed.startsWith('<!doctype html') || trimmed.startsWith('<html');
+}
+function extractErrorDetail(value) {
+    const trimmed = value?.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    const parsed = safeJsonParse(trimmed, null);
+    if (parsed && typeof parsed === 'object') {
+        if (typeof parsed.message === 'string' && parsed.message.trim()) {
+            return collapseWhitespace(parsed.message);
+        }
+        const nestedError = parsed.error;
+        if (typeof nestedError === 'string' && nestedError.trim()) {
+            return collapseWhitespace(nestedError);
+        }
+        if (nestedError && typeof nestedError === 'object') {
+            if (typeof nestedError.message === 'string' && nestedError.message.trim()) {
+                return collapseWhitespace(nestedError.message);
+            }
+            if (typeof nestedError.type === 'string' && nestedError.type.trim()) {
+                return collapseWhitespace(nestedError.type);
+            }
+        }
+    }
+    if (looksLikeHtmlPayload(trimmed)) {
+        const titleMatch = trimmed.match(/<title>\s*([^<]+?)\s*<\/title>/i);
+        if (titleMatch?.[1]) {
+            return collapseWhitespace(titleMatch[1]);
+        }
+        return 'upstream proxy returned an HTML error page';
+    }
+    return collapseWhitespace(trimmed);
+}
+function formatHttpErrorMessage(transportName, response, payload) {
+    const detail = extractErrorDetail(payload);
+    const statusParts = [];
+    if (response.status) {
+        statusParts.push(`HTTP ${response.status}`);
+    }
+    if (response.statusText) {
+        statusParts.push(response.statusText);
+    }
+    const statusSuffix = statusParts.length > 0 ? ` (${statusParts.join(' ')})` : '';
+    if (!detail) {
+        return `${transportName} request failed${statusSuffix}`;
+    }
+    return `${transportName} request failed${statusSuffix}: ${truncateForError(detail)}`;
+}
+function buildResponsesEndpoint(baseUrl) {
+    const normalized = baseUrl.replace(/\/+$/, '');
+    try {
+        const parsed = new URL(normalized);
+        const pathname = parsed.pathname.replace(/\/+$/, '');
+        if (pathname.endsWith('/backend-api/codex') || pathname.endsWith('/v1')) {
+            return `${normalized}/responses`;
+        }
+        return `${normalized}/v1/responses`;
+    }
+    catch {
+        if (normalized.endsWith('/backend-api/codex') || normalized.endsWith('/v1')) {
+            return `${normalized}/responses`;
+        }
+        return `${normalized}/v1/responses`;
+    }
+}
+function buildChatCompletionsEndpoint(baseUrl) {
+    const normalized = baseUrl.replace(/\/+$/, '');
+    try {
+        const parsed = new URL(normalized);
+        const pathname = parsed.pathname.replace(/\/+$/, '');
+        if (pathname.endsWith('/backend-api/codex')) {
+            return `${normalized}/chat/completions`;
+        }
+        if (pathname.endsWith('/v1')) {
+            return `${normalized}/chat/completions`;
+        }
+        return `${normalized}/v1/chat/completions`;
+    }
+    catch {
+        if (normalized.endsWith('/backend-api/codex') || normalized.endsWith('/v1')) {
+            return `${normalized}/chat/completions`;
+        }
+        return `${normalized}/v1/chat/completions`;
+    }
+}
+function isCustomResponsesEndpoint(baseUrl) {
+    const normalized = baseUrl.replace(/\/+$/, '');
+    return !/chatgpt\.com\/backend-api\/codex$/i.test(normalized);
+}
+function shouldFallbackToChatCompletions(response, errorText) {
+    const normalized = errorText?.toLowerCase() || '';
+    if (normalized.includes('convert_request_failed') || normalized.includes('not implemented')) {
+        return true;
+    }
+    const contentType = response.headers.get('content-type') || '';
+    const isHtmlError = /text\/html/i.test(contentType) || looksLikeHtmlPayload(errorText);
+    return response.status >= 500 && isHtmlError;
+}
+function shouldIncludeThinkingHistory(options) {
+    return options?.enableThinking !== false && options?.reasoningEffort !== 'none';
+}
+export class CodexConversationClient {
+    model;
+    authToken;
+    apiKey;
+    baseUrl;
+    accountId;
+    timeout;
+    customModelName;
+    constructor(config) {
+        this.model = config.model;
+        this.authToken = config.authToken;
+        this.apiKey = config.apiKey;
+        this.baseUrl = (config.baseUrl || DEFAULT_CODEX_BASE_URL).replace(/\/+$/, '');
+        this.accountId = config.accountId;
+        this.timeout = config.timeout || 300000;
+        this.customModelName = config.customModelName;
+    }
+    async createMessage(messages, tools, systemPrompt, options) {
+        if (this.shouldUseChatCompletionsTransport()) {
+            const response = await this.callChatCompletionsApi(messages, tools, systemPrompt, options, false);
+            return this.mapChatCompletionResponse(response);
+        }
+        const response = await this.callResponsesApi(messages, tools, systemPrompt, options, false);
+        const content = this.mapOutputToContentBlocks(response.output);
+        const hasToolUse = content.some(block => block.type === 'tool_use');
+        return {
+            content,
+            stopReason: hasToolUse ? 'tool_use' : 'end_turn',
+            usage: {
+                inputTokens: response.usage?.input_tokens || 0,
+                outputTokens: response.usage?.output_tokens || 0,
+                thinkingTokens: response.usage?.reasoning_tokens || 0,
+            },
+            model: response.model || this.resolveModelName(),
+        };
+    }
+    async *createMessageStream(messages, tools, systemPrompt, options) {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(new Error('Codex request timed out')), this.timeout);
+        if (options?.signal) {
+            options.signal.addEventListener('abort', () => controller.abort(options.signal?.reason), { once: true });
+        }
+        if (this.shouldUseChatCompletionsTransport()) {
+            yield* this.createChatCompletionsStream(messages, tools, systemPrompt, options);
+            return;
+        }
+        const endpoint = buildResponsesEndpoint(this.baseUrl);
+        const response = await fetch(endpoint, {
+            method: 'POST',
+            headers: this.buildHeaders(),
+            body: JSON.stringify(this.buildRequestBody(messages, tools, systemPrompt, options, true)),
+            signal: controller.signal,
+        });
+        if (!response.ok) {
+            const text = await response.text();
+            if (isCustomResponsesEndpoint(this.baseUrl) && shouldFallbackToChatCompletions(response, text)) {
+                yield* this.createChatCompletionsStream(messages, tools, systemPrompt, options);
+                return;
+            }
+            clearTimeout(timeoutId);
+            yield { type: 'response_headers', headers: response.headers };
+            yield { type: 'error', error: formatHttpErrorMessage('Codex', response, text) };
+            return;
+        }
+        clearTimeout(timeoutId);
+        yield { type: 'response_headers', headers: response.headers };
+        const contentType = response.headers.get('content-type') || '';
+        if (!/text\/event-stream/i.test(contentType)) {
+            const text = await response.text();
+            const apiResponse = parseResponsesApiResult(text);
+            if (!apiResponse) {
+                yield {
+                    type: 'error',
+                    error: `Codex request returned a non-stream payload that could not be parsed: ${truncateForError(extractErrorDetail(text) || 'empty response')}`,
+                };
+                return;
+            }
+            yield* this.emitCompletedResponse(apiResponse);
+            return;
+        }
+        if (!response.body) {
+            yield { type: 'error', error: 'Codex response body is empty' };
+            return;
+        }
+        const decoder = new TextDecoder();
+        let buffer = '';
+        let activeToolCallId;
+        let activeToolCallName;
+        let completed = false;
+        const replayState = {
+            sawTextDelta: false,
+            sawThinkingDelta: false,
+            startedToolCallIds: new Set(),
+            completedToolCallIds: new Set(),
+        };
+        for await (const chunk of response.body) {
+            buffer += decoder.decode(chunk, { stream: true });
+            while (true) {
+                const boundary = buffer.indexOf('\n\n');
+                if (boundary === -1)
+                    break;
+                const rawEvent = buffer.slice(0, boundary);
+                buffer = buffer.slice(boundary + 2);
+                const lines = rawEvent.split(/\r?\n/);
+                let eventType = 'message';
+                const dataLines = [];
+                for (const line of lines) {
+                    if (line.startsWith('event:')) {
+                        eventType = line.slice(6).trim();
+                    }
+                    else if (line.startsWith('data:')) {
+                        dataLines.push(line.slice(5).trim());
+                    }
+                }
+                const dataString = dataLines.join('\n');
+                if (!dataString || dataString === '[DONE]') {
+                    continue;
+                }
+                const payload = safeJsonParse(dataString, {});
+                const eventName = typeof payload.type === 'string' ? payload.type : eventType;
+                switch (eventName) {
+                    case 'response.output_text.delta':
+                        if (payload.delta) {
+                            replayState.sawTextDelta = true;
+                        }
+                        yield { type: 'text', text: payload.delta || '' };
+                        break;
+                    case 'response.reasoning_summary_text.delta':
+                    case 'response.reasoning.delta':
+                        if (payload.delta) {
+                            replayState.sawThinkingDelta = true;
+                        }
+                        yield { type: 'thinking', thinking: payload.delta || '' };
+                        break;
+                    case 'response.output_item.added': {
+                        const item = payload.item || {};
+                        if (item.type === 'function_call') {
+                            activeToolCallId = getResponseToolCallId(item);
+                            activeToolCallName = item.name;
+                            replayState.startedToolCallIds.add(activeToolCallId);
+                            yield {
+                                type: 'tool_use_start',
+                                id: activeToolCallId,
+                                name: activeToolCallName,
+                            };
+                        }
+                        break;
+                    }
+                    case 'response.function_call_arguments.delta':
+                        yield {
+                            type: 'tool_use_delta',
+                            id: payload.call_id || activeToolCallId,
+                            input: payload.delta || '',
+                        };
+                        break;
+                    case 'response.function_call_arguments.done':
+                        if (payload.call_id || activeToolCallId) {
+                            replayState.completedToolCallIds.add(payload.call_id || activeToolCallId || '');
+                        }
+                        yield {
+                            type: 'tool_use_complete',
+                            id: payload.call_id || activeToolCallId,
+                            input: safeJsonParse(payload.arguments, {}),
+                        };
+                        break;
+                    case 'response.completed': {
+                        const apiResponse = payload.response;
+                        completed = true;
+                        yield* this.emitCompletedResponse(apiResponse, replayState);
+                        break;
+                    }
+                    case 'response.error':
+                        yield { type: 'error', error: payload.error?.message || payload.message || 'Codex stream error' };
+                        return;
+                }
+            }
+        }
+        const trailingText = buffer.trim();
+        if (!completed && trailingText) {
+            const apiResponse = parseResponsesApiResult(trailingText);
+            if (apiResponse) {
+                yield* this.emitCompletedResponse(apiResponse, replayState);
+                return;
+            }
+        }
+        if (!completed) {
+            yield {
+                type: 'error',
+                error: 'Codex stream ended without a completion event',
+            };
+        }
+    }
+    async callResponsesApi(messages, tools, systemPrompt, options, stream) {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(new Error('Codex request timed out')), this.timeout);
+        try {
+            const endpoint = buildResponsesEndpoint(this.baseUrl);
+            const response = await fetch(endpoint, {
+                method: 'POST',
+                headers: this.buildHeaders(),
+                body: JSON.stringify(this.buildRequestBody(messages, tools, systemPrompt, options, stream)),
+                signal: controller.signal,
+            });
+            if (!response.ok) {
+                const text = await response.text();
+                if (isCustomResponsesEndpoint(this.baseUrl) && shouldFallbackToChatCompletions(response, text)) {
+                    const fallback = await this.callChatCompletionsApi(messages, tools, systemPrompt, options, stream);
+                    return this.mapChatCompletionApiResultToResponses(fallback);
+                }
+                throw new Error(formatHttpErrorMessage('Codex', response, text));
+            }
+            return await response.json();
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                throw error;
+            }
+            throw new Error(`Codex request failed: ${String(error)}`);
+        }
+        finally {
+            clearTimeout(timeoutId);
+        }
+    }
+    async callChatCompletionsApi(messages, tools, systemPrompt, options, stream) {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(new Error('OpenAI-compatible request timed out')), this.timeout);
+        try {
+            const endpoint = buildChatCompletionsEndpoint(this.baseUrl);
+            const response = await fetch(endpoint, {
+                method: 'POST',
+                headers: this.buildHeaders(),
+                body: JSON.stringify(this.buildChatCompletionsBody(messages, tools, systemPrompt, options, stream)),
+                signal: controller.signal,
+            });
+            if (!response.ok) {
+                const text = await response.text();
+                throw new Error(formatHttpErrorMessage('OpenAI-compatible', response, text));
+            }
+            return await response.json();
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                throw error;
+            }
+            throw new Error(`OpenAI-compatible request failed: ${String(error)}`);
+        }
+        finally {
+            clearTimeout(timeoutId);
+        }
+    }
+    async *createChatCompletionsStream(messages, tools, systemPrompt, options) {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(new Error('OpenAI-compatible request timed out')), this.timeout);
+        if (options?.signal) {
+            options.signal.addEventListener('abort', () => controller.abort(options.signal?.reason), { once: true });
+        }
+        const endpoint = buildChatCompletionsEndpoint(this.baseUrl);
+        const response = await fetch(endpoint, {
+            method: 'POST',
+            headers: this.buildHeaders(),
+            body: JSON.stringify(this.buildChatCompletionsBody(messages, tools, systemPrompt, options, true)),
+            signal: controller.signal,
+        });
+        clearTimeout(timeoutId);
+        yield { type: 'response_headers', headers: response.headers };
+        if (!response.ok) {
+            const text = await response.text();
+            yield { type: 'error', error: formatHttpErrorMessage('OpenAI-compatible', response, text) };
+            return;
+        }
+        if (!response.body) {
+            yield { type: 'error', error: 'OpenAI-compatible response body is empty' };
+            return;
+        }
+        const decoder = new TextDecoder();
+        let buffer = '';
+        let finishReason = null;
+        let usage;
+        const toolCalls = new Map();
+        for await (const chunk of response.body) {
+            buffer += decoder.decode(chunk, { stream: true });
+            const lines = buffer.split(/\r?\n/);
+            buffer = lines.pop() || '';
+            for (const line of lines) {
+                if (!line.startsWith('data:')) {
+                    continue;
+                }
+                const data = line.slice(5).trim();
+                if (!data || data === '[DONE]') {
+                    continue;
+                }
+                const payload = safeJsonParse(data, {});
+                const choice = payload.choices?.[0];
+                if (payload.usage) {
+                    usage = payload.usage;
+                }
+                if (!choice) {
+                    continue;
+                }
+                const delta = choice.delta || {};
+                const reasoning = delta.reasoning_content;
+                if (reasoning) {
+                    yield { type: 'thinking', thinking: reasoning };
+                }
+                if (typeof delta.content === 'string' && delta.content) {
+                    yield { type: 'text', text: delta.content };
+                }
+                for (const toolCall of delta.tool_calls || []) {
+                    const index = toolCall.index ?? 0;
+                    const existing = toolCalls.get(index);
+                    if (!existing) {
+                        const next = {
+                            id: toolCall.id || `call_${Date.now()}_${index}`,
+                            name: toolCall.function?.name || 'unknown_tool',
+                            arguments: toolCall.function?.arguments || '',
+                        };
+                        toolCalls.set(index, next);
+                        yield {
+                            type: 'tool_use_start',
+                            id: next.id,
+                            name: next.name,
+                        };
+                        if (toolCall.function?.arguments) {
+                            yield {
+                                type: 'tool_use_delta',
+                                id: next.id,
+                                input: toolCall.function.arguments,
+                            };
+                        }
+                        continue;
+                    }
+                    if (toolCall.function?.name && existing.name === 'unknown_tool') {
+                        existing.name = toolCall.function.name;
+                    }
+                    if (toolCall.function?.arguments) {
+                        existing.arguments += toolCall.function.arguments;
+                        yield {
+                            type: 'tool_use_delta',
+                            id: existing.id,
+                            input: toolCall.function.arguments,
+                        };
+                    }
+                }
+                if (choice.finish_reason) {
+                    finishReason = choice.finish_reason;
+                }
+            }
+        }
+        for (const toolCall of toolCalls.values()) {
+            yield {
+                type: 'tool_use_complete',
+                id: toolCall.id,
+                input: safeJsonParse(toolCall.arguments, {}),
+            };
+        }
+        yield {
+            type: 'usage',
+            usage: {
+                inputTokens: usage?.prompt_tokens || 0,
+                outputTokens: usage?.completion_tokens || 0,
+                thinkingTokens: usage?.completion_tokens_details?.reasoning_tokens || 0,
+            },
+        };
+        yield {
+            type: 'stop',
+            stopReason: finishReason === 'tool_calls' ? 'tool_use' : finishReason === 'length' ? 'max_tokens' : 'end_turn',
+        };
+    }
+    buildChatCompletionsBody(messages, tools, systemPrompt, options, stream) {
+        const body = {
+            model: this.resolveModelName(),
+            messages: this.convertMessagesToChatCompletions(messages, systemPrompt, shouldIncludeThinkingHistory(options)),
+            stream,
+        };
+        if (stream) {
+            body.stream_options = { include_usage: true };
+        }
+        if (tools && tools.length > 0) {
+            body.tools = tools.map(tool => ({
+                type: 'function',
+                function: {
+                    name: tool.name,
+                    description: tool.description,
+                    parameters: tool.inputSchema,
+                },
+            }));
+        }
+        if (options?.toolChoice) {
+            if (options.toolChoice.type === 'tool') {
+                body.tool_choice = {
+                    type: 'function',
+                    function: { name: options.toolChoice.name },
+                };
+            }
+            else {
+                body.tool_choice = options.toolChoice.type;
+            }
+        }
+        return body;
+    }
+    convertMessagesToChatCompletions(messages, systemPrompt, includeThinkingHistory = true) {
+        const openAiMessages = [];
+        if (systemPrompt?.trim()) {
+            openAiMessages.push({
+                role: 'system',
+                content: systemPrompt.trim(),
+            });
+        }
+        for (const message of messages) {
+            const contentBlocks = typeof message.content === 'string'
+                ? [{ type: 'text', text: message.content }]
+                : message.content;
+            if (!Array.isArray(contentBlocks)) {
+                continue;
+            }
+            if (message.role === 'assistant') {
+                const textParts = [];
+                const toolCalls = [];
+                const reasoningParts = [];
+                for (const block of contentBlocks) {
+                    if (block.type === 'text' && block.text) {
+                        textParts.push(block.text);
+                        continue;
+                    }
+                    if (includeThinkingHistory && isThinkingBlock(block)) {
+                        const normalizedThinking = block.thinking.trim();
+                        if (normalizedThinking) {
+                            reasoningParts.push(normalizedThinking);
+                        }
+                        continue;
+                    }
+                    if (block.type === 'tool_use') {
+                        const toolUse = block;
+                        toolCalls.push({
+                            id: toolUse.id,
+                            type: 'function',
+                            function: {
+                                name: toolUse.name,
+                                arguments: JSON.stringify(toolUse.input || {}),
+                            },
+                        });
+                    }
+                }
+                const assistantMessage = {
+                    role: 'assistant',
+                    content: textParts.length > 0 ? textParts.join('') : null,
+                    ...(toolCalls.length > 0 ? { tool_calls: toolCalls } : {}),
+                };
+                const reasoningContent = reasoningParts.join('\n').trim();
+                if (reasoningContent) {
+                    assistantMessage.reasoning_content = reasoningContent;
+                }
+                else if (includeThinkingHistory && toolCalls.length > 0) {
+                    // 一些 OpenAI-compatible 网关在 assistant tool_calls 历史里强制要求该字段存在，
+                    // 即使当前无法恢复完整 reasoning trace，也至少补空字符串避免恢复会话时报错。
+                    assistantMessage.reasoning_content = '';
+                }
+                openAiMessages.push(assistantMessage);
+                continue;
+            }
+            const userTextParts = [];
+            const userVisionParts = [];
+            const toolResults = [];
+            for (const block of contentBlocks) {
+                if (block.type === 'text' && block.text) {
+                    userTextParts.push(block.text);
+                    continue;
+                }
+                if (isImageBlock(block)) {
+                    userVisionParts.push({
+                        type: 'image_url',
+                        image_url: {
+                            url: `data:${block.source.media_type};base64,${block.source.data}`,
+                        },
+                    });
+                    continue;
+                }
+                if (block.type === 'tool_result') {
+                    const toolResult = block;
+                    toolResults.push({
+                        tool_call_id: toolResult.tool_use_id,
+                        content: coerceTextContent(toolResult.content),
+                    });
+                }
+            }
+            for (const toolResult of toolResults) {
+                openAiMessages.push({
+                    role: 'tool',
+                    tool_call_id: toolResult.tool_call_id,
+                    content: toolResult.content,
+                });
+            }
+            if (userTextParts.length > 0 || userVisionParts.length > 0) {
+                if (userVisionParts.length > 0) {
+                    const content = [];
+                    if (userTextParts.length > 0) {
+                        content.push({
+                            type: 'text',
+                            text: userTextParts.join('\n'),
+                        });
+                    }
+                    content.push(...userVisionParts);
+                    openAiMessages.push({
+                        role: 'user',
+                        content,
+                    });
+                }
+                else {
+                    openAiMessages.push({
+                        role: 'user',
+                        content: userTextParts.join('\n'),
+                    });
+                }
+            }
+        }
+        return openAiMessages;
+    }
+    mapChatCompletionResponse(response) {
+        const choice = response.choices?.[0];
+        const message = choice?.message || {};
+        const content = [];
+        if (message.reasoning_content) {
+            content.push({ type: 'thinking', thinking: message.reasoning_content });
+        }
+        for (const toolCall of message.tool_calls || []) {
+            content.push({
+                type: 'tool_use',
+                id: toolCall.id || `call_${Date.now()}`,
+                name: toolCall.function?.name || 'unknown_tool',
+                input: safeJsonParse(toolCall.function?.arguments, {}),
+            });
+        }
+        if (typeof message.content === 'string' && message.content) {
+            content.push({ type: 'text', text: message.content });
+        }
+        return {
+            content,
+            stopReason: choice?.finish_reason === 'tool_calls' ? 'tool_use' : choice?.finish_reason === 'length' ? 'max_tokens' : 'end_turn',
+            usage: {
+                inputTokens: response.usage?.prompt_tokens || 0,
+                outputTokens: response.usage?.completion_tokens || 0,
+                thinkingTokens: response.usage?.completion_tokens_details?.reasoning_tokens || 0,
+            },
+            model: response.model || this.resolveModelName(),
+        };
+    }
+    mapChatCompletionApiResultToResponses(response) {
+        const mapped = this.mapChatCompletionResponse(response);
+        const output = [];
+        for (const block of mapped.content) {
+            if (block.type === 'thinking') {
+                output.push({
+                    type: 'reasoning',
+                    summary: [{ text: block.thinking }],
+                });
+                continue;
+            }
+            if (block.type === 'tool_use') {
+                const toolUse = block;
+                output.push({
+                    type: 'function_call',
+                    call_id: toolUse.id,
+                    name: toolUse.name,
+                    arguments: JSON.stringify(toolUse.input || {}),
+                });
+                continue;
+            }
+            if (block.type === 'text') {
+                output.push({
+                    type: 'message',
+                    content: [{ type: 'output_text', text: block.text }],
+                });
+            }
+        }
+        return {
+            model: mapped.model,
+            output,
+            usage: {
+                input_tokens: mapped.usage.inputTokens,
+                output_tokens: mapped.usage.outputTokens,
+                reasoning_tokens: mapped.usage.thinkingTokens,
+            },
+        };
+    }
+    shouldUseChatCompletionsTransport() {
+        return isCustomResponsesEndpoint(this.baseUrl) && !isCodexCompatibleModel(this.resolveModelName());
+    }
+    buildHeaders() {
+        const token = this.apiKey || this.authToken;
+        if (!token) {
+            throw new Error('Codex credentials are not configured');
+        }
+        const headers = {
+            'Content-Type': 'application/json',
+            'Authorization': `Bearer ${token}`,
+        };
+        if (this.authToken && this.accountId) {
+            headers['ChatGPT-Account-ID'] = this.accountId;
+        }
+        return headers;
+    }
+    buildRequestBody(messages, tools, systemPrompt, options, stream) {
+        const input = this.convertMessages(messages);
+        const instructions = systemPrompt?.trim() || DEFAULT_CODEX_INSTRUCTIONS;
+        const resolvedModel = this.resolveModelName();
+        const body = {
+            model: resolvedModel,
+            input,
+            stream,
+            store: false,
+            instructions,
+        };
+        if (tools && tools.length > 0) {
+            body.tools = tools.map(tool => ({
+                type: 'function',
+                name: tool.name,
+                description: tool.description,
+                parameters: tool.inputSchema,
+            }));
+        }
+        if (options?.toolChoice) {
+            if (options.toolChoice.type === 'tool') {
+                body.tool_choice = {
+                    type: 'function',
+                    name: options.toolChoice.name,
+                };
+            }
+            else {
+                body.tool_choice = options.toolChoice.type;
+            }
+        }
+        if (this.supportsReasoning(resolvedModel)) {
+            const reasoningEffort = options?.enableThinking === false
+                ? 'none'
+                : options?.reasoningEffort || (options?.enableThinking ? 'medium' : undefined);
+            if (reasoningEffort) {
+                body.reasoning = {
+                    effort: reasoningEffort,
+                    summary: 'auto',
+                };
+            }
+        }
+        return body;
+    }
+    convertMessages(messages) {
+        const input = [];
+        for (const message of messages) {
+            const contentBlocks = typeof message.content === 'string'
+                ? [{ type: 'text', text: message.content }]
+                : message.content;
+            const textParts = [];
+            const imageParts = [];
+            for (const block of contentBlocks) {
+                if (block.type === 'text') {
+                    textParts.push(block.text);
+                    continue;
+                }
+                if (isImageBlock(block)) {
+                    imageParts.push({
+                        type: 'input_image',
+                        image_url: `data:${block.source.media_type};base64,${block.source.data}`,
+                    });
+                    continue;
+                }
+                if (block.type === 'tool_result') {
+                    const toolResult = block;
+                    input.push({
+                        type: 'function_call_output',
+                        call_id: toolResult.tool_use_id,
+                        output: coerceTextContent(toolResult.content),
+                    });
+                    continue;
+                }
+                if (message.role === 'assistant' && block.type === 'tool_use') {
+                    const toolUse = block;
+                    input.push({
+                        type: 'function_call',
+                        call_id: toolUse.id,
+                        name: toolUse.name,
+                        arguments: JSON.stringify(toolUse.input || {}),
+                    });
+                }
+            }
+            if (textParts.length > 0 || imageParts.length > 0) {
+                const content = [];
+                if (textParts.length > 0) {
+                    content.push({
+                        type: getMessageTextContentType(message.role),
+                        text: textParts.join('\n'),
+                    });
+                }
+                if (message.role !== 'assistant') {
+                    content.push(...imageParts);
+                }
+                input.push({
+                    type: 'message',
+                    role: message.role,
+                    content,
+                });
+            }
+        }
+        return input;
+    }
+    mapOutputToContentBlocks(output) {
+        if (!Array.isArray(output)) {
+            return [{ type: 'text', text: '' }];
+        }
+        const contentBlocks = [];
+        for (const item of output) {
+            if (item.type === 'message' && Array.isArray(item.content)) {
+                const text = item.content
+                    .map(part => part.text || '')
+                    .join('');
+                if (text) {
+                    contentBlocks.push({ type: 'text', text });
+                }
+                continue;
+            }
+            if (item.type === 'reasoning' && Array.isArray(item.summary)) {
+                const text = item.summary.map(part => part.text || '').join('');
+                if (text) {
+                    contentBlocks.push({ type: 'thinking', thinking: text });
+                }
+                continue;
+            }
+            if (item.type === 'function_call') {
+                contentBlocks.push({
+                    type: 'tool_use',
+                    id: item.call_id || item.id || `call_${Date.now()}`,
+                    name: item.name || 'unknown_tool',
+                    input: safeJsonParse(item.arguments, {}),
+                });
+            }
+        }
+        if (contentBlocks.length === 0) {
+            const text = extractTextFromOutput(output);
+            if (text) {
+                contentBlocks.push({ type: 'text', text });
+            }
+        }
+        return contentBlocks;
+    }
+    *emitCompletedResponse(response, replayState) {
+        const output = response?.output || [];
+        for (const item of output) {
+            if (item.type === 'reasoning' && Array.isArray(item.summary)) {
+                if (replayState?.sawThinkingDelta) {
+                    continue;
+                }
+                const text = item.summary.map(part => part.text || '').join('');
+                if (text) {
+                    yield { type: 'thinking', thinking: text };
+                }
+                continue;
+            }
+            if (item.type === 'function_call') {
+                const callId = getResponseToolCallId(item);
+                if (!replayState?.startedToolCallIds.has(callId)) {
+                    yield {
+                        type: 'tool_use_start',
+                        id: callId,
+                        name: item.name || 'unknown_tool',
+                    };
+                }
+                if (!replayState?.completedToolCallIds.has(callId)) {
+                    yield {
+                        type: 'tool_use_complete',
+                        id: callId,
+                        input: safeJsonParse(item.arguments, {}),
+                    };
+                }
+                continue;
+            }
+            if (item.type === 'message' && Array.isArray(item.content)) {
+                if (replayState?.sawTextDelta) {
+                    continue;
+                }
+                for (const part of item.content) {
+                    if (part.type === 'output_text' && part.text) {
+                        yield { type: 'text', text: part.text };
+                    }
+                }
+            }
+        }
+        const hasToolUse = output.some(item => item.type === 'function_call');
+        yield {
+            type: 'usage',
+            usage: {
+                inputTokens: response?.usage?.input_tokens || 0,
+                outputTokens: response?.usage?.output_tokens || 0,
+                thinkingTokens: response?.usage?.reasoning_tokens || 0,
+            },
+        };
+        yield {
+            type: 'stop',
+            stopReason: hasToolUse ? 'tool_use' : 'end_turn',
+        };
+    }
+    resolveModelName() {
+        const allowArbitraryModel = isCustomResponsesEndpoint(this.baseUrl);
+        if (this.customModelName?.trim() && (allowArbitraryModel || isCodexCompatibleModel(this.customModelName))) {
+            return this.customModelName.trim();
+        }
+        const normalized = this.model.trim();
+        if (normalized && (allowArbitraryModel || isCodexCompatibleModel(normalized))) {
+            return normalized;
+        }
+        return 'gpt-5-codex';
+    }
+    supportsReasoning(model) {
+        return isCodexCompatibleModel(model);
+    }
+}
+//# sourceMappingURL=codex-client.js.map