@mariozechner/pi-ai 0.46.0 → 0.48.0

package/dist/providers/openai-codex-responses.js

@@ -1,17 +1,43 @@
 import os from "node:os";
+import { PI_STATIC_INSTRUCTIONS } from "../constants.js";
 import { calculateCost } from "../models.js";
 import { getEnvApiKey } from "../stream.js";
 import { AssistantMessageEventStream } from "../utils/event-stream.js";
 import { parseStreamingJson } from "../utils/json-parse.js";
 import { sanitizeSurrogates } from "../utils/sanitize-unicode.js";
-import { CODEX_BASE_URL, JWT_CLAIM_PATH, OPENAI_HEADER_VALUES, OPENAI_HEADERS, URL_PATHS, } from "./openai-codex/constants.js";
-import { getCodexInstructions } from "./openai-codex/prompts/codex.js";
-import { buildCodexPiBridge } from "./openai-codex/prompts/pi-codex-bridge.js";
-import { buildCodexSystemPrompt } from "./openai-codex/prompts/system-prompt.js";
-import { transformRequestBody, } from "./openai-codex/request-transformer.js";
-import { parseCodexError, parseCodexSseStream } from "./openai-codex/response-handler.js";
 import { transformMessages } from "./transform-messages.js";
-const CODEX_DEBUG = process.env.PI_CODEX_DEBUG === "1" || process.env.PI_CODEX_DEBUG === "true";
+// ============================================================================
+// Configuration
+// ============================================================================
+const CODEX_URL = "https://chatgpt.com/backend-api/codex/responses";
+const JWT_CLAIM_PATH = "https://api.openai.com/auth";
+const MAX_RETRIES = 3;
+const BASE_DELAY_MS = 1000;
+// ============================================================================
+// Retry Helpers
+// ============================================================================
+function isRetryableError(status, errorText) {
+    if (status === 429 || status === 500 || status === 502 || status === 503 || status === 504) {
+        return true;
+    }
+    return /rate.?limit|overloaded|service.?unavailable|upstream.?connect|connection.?refused/i.test(errorText);
+}
+function sleep(ms, signal) {
+    return new Promise((resolve, reject) => {
+        if (signal?.aborted) {
+            reject(new Error("Request was aborted"));
+            return;
+        }
+        const timeout = setTimeout(resolve, ms);
+        signal?.addEventListener("abort", () => {
+            clearTimeout(timeout);
+            reject(new Error("Request was aborted"));
+        });
+    });
+}
+// ============================================================================
+// Main Stream Function
+// ============================================================================
 export const streamOpenAICodexResponses = (model, context, options) => {
     const stream = new AssistantMessageEventStream();
     (async () => {
@@ -37,492 +63,422 @@ export const streamOpenAICodexResponses = (model, context, options) => {
             if (!apiKey) {
                 throw new Error(`No API key for provider: ${model.provider}`);
             }
-            const accountId = getAccountId(apiKey);
-            const baseUrl = model.baseUrl || CODEX_BASE_URL;
-            const baseWithSlash = baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
-            const url = rewriteUrlForCodex(new URL(URL_PATHS.RESPONSES.slice(1), baseWithSlash).toString());
-            const messages = convertMessages(model, context);
-            const params = {
-                model: model.id,
-                input: messages,
-                stream: true,
-                prompt_cache_key: options?.sessionId,
-            };
-            if (options?.maxTokens) {
-                params.max_output_tokens = options.maxTokens;
-            }
-            if (options?.temperature !== undefined) {
-                params.temperature = options.temperature;
-            }
-            if (context.tools) {
-                params.tools = convertTools(context.tools);
-            }
-            const codexInstructions = getCodexInstructions();
-            const bridgeText = buildCodexPiBridge(context.tools);
-            const systemPrompt = buildCodexSystemPrompt({
-                codexInstructions,
-                bridgeText,
-                userSystemPrompt: context.systemPrompt,
-            });
-            params.instructions = systemPrompt.instructions;
-            const codexOptions = {
-                reasoningEffort: options?.reasoningEffort,
-                reasoningSummary: options?.reasoningSummary ?? undefined,
-                textVerbosity: options?.textVerbosity,
-                include: options?.include,
-            };
-            const transformedBody = await transformRequestBody(params, codexOptions, systemPrompt);
-            const reasoningEffort = transformedBody.reasoning?.effort ?? null;
-            const headers = createCodexHeaders(model.headers, accountId, apiKey, options?.sessionId);
-            logCodexDebug("codex request", {
-                url,
-                model: params.model,
-                reasoningEffort,
-                headers: redactHeaders(headers),
-            });
-            const response = await fetch(url, {
-                method: "POST",
-                headers,
-                body: JSON.stringify(transformedBody),
-                signal: options?.signal,
-            });
-            logCodexDebug("codex response", {
-                url: response.url,
-                status: response.status,
-                statusText: response.statusText,
-                contentType: response.headers.get("content-type") || null,
-                cfRay: response.headers.get("cf-ray") || null,
-            });
-            if (!response.ok) {
-                const info = await parseCodexError(response);
-                throw new Error(info.friendlyMessage || info.message);
-            }
-            if (!response.body) {
-                throw new Error("No response body");
-            }
-            stream.push({ type: "start", partial: output });
-            let currentItem = null;
-            let currentBlock = null;
-            const blocks = output.content;
-            const blockIndex = () => blocks.length - 1;
-            for await (const rawEvent of parseCodexSseStream(response)) {
-                const eventType = typeof rawEvent.type === "string" ? rawEvent.type : "";
-                if (!eventType)
-                    continue;
-                if (eventType === "response.output_item.added") {
-                    const item = rawEvent.item;
-                    if (item.type === "reasoning") {
-                        currentItem = item;
-                        currentBlock = { type: "thinking", thinking: "" };
-                        output.content.push(currentBlock);
-                        stream.push({ type: "thinking_start", contentIndex: blockIndex(), partial: output });
-                    }
-                    else if (item.type === "message") {
-                        currentItem = item;
-                        currentBlock = { type: "text", text: "" };
-                        output.content.push(currentBlock);
-                        stream.push({ type: "text_start", contentIndex: blockIndex(), partial: output });
-                    }
-                    else if (item.type === "function_call") {
-                        currentItem = item;
-                        currentBlock = {
-                            type: "toolCall",
-                            id: `${item.call_id}|${item.id}`,
-                            name: item.name,
-                            arguments: {},
-                            partialJson: item.arguments || "",
-                        };
-                        output.content.push(currentBlock);
-                        stream.push({ type: "toolcall_start", contentIndex: blockIndex(), partial: output });
-                    }
-                }
-                else if (eventType === "response.reasoning_summary_part.added") {
-                    if (currentItem && currentItem.type === "reasoning") {
-                        currentItem.summary = currentItem.summary || [];
-                        currentItem.summary.push(rawEvent.part);
-                    }
-                }
-                else if (eventType === "response.reasoning_summary_text.delta") {
-                    if (currentItem && currentItem.type === "reasoning" && currentBlock?.type === "thinking") {
-                        currentItem.summary = currentItem.summary || [];
-                        const lastPart = currentItem.summary[currentItem.summary.length - 1];
-                        if (lastPart) {
-                            const delta = rawEvent.delta || "";
-                            currentBlock.thinking += delta;
-                            lastPart.text += delta;
-                            stream.push({
-                                type: "thinking_delta",
-                                contentIndex: blockIndex(),
-                                delta,
-                                partial: output,
-                            });
-                        }
-                    }
-                }
-                else if (eventType === "response.reasoning_summary_part.done") {
-                    if (currentItem && currentItem.type === "reasoning" && currentBlock?.type === "thinking") {
-                        currentItem.summary = currentItem.summary || [];
-                        const lastPart = currentItem.summary[currentItem.summary.length - 1];
-                        if (lastPart) {
-                            currentBlock.thinking += "\n\n";
-                            lastPart.text += "\n\n";
-                            stream.push({
-                                type: "thinking_delta",
-                                contentIndex: blockIndex(),
-                                delta: "\n\n",
-                                partial: output,
-                            });
-                        }
-                    }
+            const accountId = extractAccountId(apiKey);
+            const body = buildRequestBody(model, context, options);
+            const headers = buildHeaders(model.headers, accountId, apiKey, options?.sessionId);
+            const bodyJson = JSON.stringify(body);
+            // Fetch with retry logic for rate limits and transient errors
+            let response;
+            let lastError;
+            for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+                if (options?.signal?.aborted) {
+                    throw new Error("Request was aborted");
                 }
-                else if (eventType === "response.content_part.added") {
-                    if (currentItem && currentItem.type === "message") {
-                        currentItem.content = currentItem.content || [];
-                        const part = rawEvent.part;
-                        if (part && (part.type === "output_text" || part.type === "refusal")) {
-                            currentItem.content.push(part);
-                        }
+                try {
+                    response = await fetch(CODEX_URL, {
+                        method: "POST",
+                        headers,
+                        body: bodyJson,
+                        signal: options?.signal,
+                    });
+                    if (response.ok) {
+                        break;
                     }
-                }
-                else if (eventType === "response.output_text.delta") {
-                    if (currentItem && currentItem.type === "message" && currentBlock?.type === "text") {
-                        const lastPart = currentItem.content[currentItem.content.length - 1];
-                        if (lastPart && lastPart.type === "output_text") {
-                            const delta = rawEvent.delta || "";
-                            currentBlock.text += delta;
-                            lastPart.text += delta;
-                            stream.push({
-                                type: "text_delta",
-                                contentIndex: blockIndex(),
-                                delta,
-                                partial: output,
-                            });
-                        }
+                    const errorText = await response.text();
+                    if (attempt < MAX_RETRIES && isRetryableError(response.status, errorText)) {
+                        const delayMs = BASE_DELAY_MS * 2 ** attempt;
+                        await sleep(delayMs, options?.signal);
+                        continue;
                     }
+                    // Parse error for friendly message on final attempt or non-retryable error
+                    const fakeResponse = new Response(errorText, {
+                        status: response.status,
+                        statusText: response.statusText,
+                    });
+                    const info = await parseErrorResponse(fakeResponse);
+                    throw new Error(info.friendlyMessage || info.message);
                 }
-                else if (eventType === "response.refusal.delta") {
-                    if (currentItem && currentItem.type === "message" && currentBlock?.type === "text") {
-                        const lastPart = currentItem.content[currentItem.content.length - 1];
-                        if (lastPart && lastPart.type === "refusal") {
-                            const delta = rawEvent.delta || "";
-                            currentBlock.text += delta;
-                            lastPart.refusal += delta;
-                            stream.push({
-                                type: "text_delta",
-                                contentIndex: blockIndex(),
-                                delta,
-                                partial: output,
-                            });
+                catch (error) {
+                    if (error instanceof Error) {
+                        if (error.name === "AbortError" || error.message === "Request was aborted") {
+                            throw new Error("Request was aborted");
                         }
                     }
-                }
-                else if (eventType === "response.function_call_arguments.delta") {
-                    if (currentItem && currentItem.type === "function_call" && currentBlock?.type === "toolCall") {
-                        const delta = rawEvent.delta || "";
-                        currentBlock.partialJson += delta;
-                        currentBlock.arguments = parseStreamingJson(currentBlock.partialJson);
-                        stream.push({
-                            type: "toolcall_delta",
-                            contentIndex: blockIndex(),
-                            delta,
-                            partial: output,
-                        });
+                    lastError = error instanceof Error ? error : new Error(String(error));
+                    // Network errors are retryable
+                    if (attempt < MAX_RETRIES && !lastError.message.includes("usage limit")) {
+                        const delayMs = BASE_DELAY_MS * 2 ** attempt;
+                        await sleep(delayMs, options?.signal);
+                        continue;
                     }
+                    throw lastError;
                 }
-                else if (eventType === "response.output_item.done") {
-                    const item = rawEvent.item;
-                    if (item.type === "reasoning" && currentBlock?.type === "thinking") {
-                        currentBlock.thinking = item.summary?.map((s) => s.text).join("\n\n") || "";
-                        currentBlock.thinkingSignature = JSON.stringify(item);
-                        stream.push({
-                            type: "thinking_end",
-                            contentIndex: blockIndex(),
-                            content: currentBlock.thinking,
-                            partial: output,
-                        });
-                        currentBlock = null;
-                    }
-                    else if (item.type === "message" && currentBlock?.type === "text") {
-                        currentBlock.text = item.content.map((c) => (c.type === "output_text" ? c.text : c.refusal)).join("");
-                        currentBlock.textSignature = item.id;
-                        stream.push({
-                            type: "text_end",
-                            contentIndex: blockIndex(),
-                            content: currentBlock.text,
-                            partial: output,
-                        });
-                        currentBlock = null;
-                    }
-                    else if (item.type === "function_call") {
-                        const toolCall = {
-                            type: "toolCall",
-                            id: `${item.call_id}|${item.id}`,
-                            name: item.name,
-                            arguments: JSON.parse(item.arguments),
-                        };
-                        stream.push({ type: "toolcall_end", contentIndex: blockIndex(), toolCall, partial: output });
-                    }
-                }
-                else if (eventType === "response.completed" || eventType === "response.done") {
-                    const response = rawEvent.response;
-                    if (response?.usage) {
-                        const cachedTokens = response.usage.input_tokens_details?.cached_tokens || 0;
-                        output.usage = {
-                            input: (response.usage.input_tokens || 0) - cachedTokens,
-                            output: response.usage.output_tokens || 0,
-                            cacheRead: cachedTokens,
-                            cacheWrite: 0,
-                            totalTokens: response.usage.total_tokens || 0,
-                            cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
-                        };
-                    }
-                    calculateCost(model, output.usage);
-                    output.stopReason = mapStopReason(response?.status);
-                    if (output.content.some((b) => b.type === "toolCall") && output.stopReason === "stop") {
-                        output.stopReason = "toolUse";
-                    }
-                }
-                else if (eventType === "error") {
-                    const code = rawEvent.code || "";
-                    const message = rawEvent.message || "";
-                    throw new Error(formatCodexErrorEvent(rawEvent, code, message));
-                }
-                else if (eventType === "response.failed") {
-                    throw new Error(formatCodexFailure(rawEvent) ?? "Codex response failed");
-                }
             }
+            if (!response?.ok) {
+                throw lastError ?? new Error("Failed after retries");
+            }
+            if (!response.body) {
+                throw new Error("No response body");
+            }
+            stream.push({ type: "start", partial: output });
+            await processStream(response, output, stream, model);
             if (options?.signal?.aborted) {
                 throw new Error("Request was aborted");
             }
-            if (output.stopReason === "aborted" || output.stopReason === "error") {
-                throw new Error("Codex response failed");
-            }
             stream.push({ type: "done", reason: output.stopReason, message: output });
             stream.end();
         }
         catch (error) {
-            for (const block of output.content)
-                delete block.index;
             output.stopReason = options?.signal?.aborted ? "aborted" : "error";
-            output.errorMessage = error instanceof Error ? error.message : JSON.stringify(error);
+            output.errorMessage = error instanceof Error ? error.message : String(error);
             stream.push({ type: "error", reason: output.stopReason, error: output });
             stream.end();
         }
     })();
     return stream;
 };
-function createCodexHeaders(initHeaders, accountId, accessToken, promptCacheKey) {
-    const headers = new Headers(initHeaders ?? {});
-    headers.delete("x-api-key");
-    headers.set("Authorization", `Bearer ${accessToken}`);
-    headers.set(OPENAI_HEADERS.ACCOUNT_ID, accountId);
-    headers.set(OPENAI_HEADERS.BETA, OPENAI_HEADER_VALUES.BETA_RESPONSES);
-    headers.set(OPENAI_HEADERS.ORIGINATOR, OPENAI_HEADER_VALUES.ORIGINATOR_CODEX);
-    headers.set("User-Agent", `pi (${os.platform()} ${os.release()}; ${os.arch()})`);
-    if (promptCacheKey) {
-        headers.set(OPENAI_HEADERS.CONVERSATION_ID, promptCacheKey);
-        headers.set(OPENAI_HEADERS.SESSION_ID, promptCacheKey);
+// ============================================================================
+// Request Building
+// ============================================================================
+function buildRequestBody(model, context, options) {
+    const systemPrompt = buildSystemPrompt(context.systemPrompt);
+    const messages = convertMessages(model, context);
+    // Prepend developer messages
+    const developerMessages = systemPrompt.developerMessages.map((text) => ({
+        type: "message",
+        role: "developer",
+        content: [{ type: "input_text", text }],
+    }));
+    const body = {
+        model: model.id,
+        store: false,
+        stream: true,
+        instructions: systemPrompt.instructions,
+        input: [...developerMessages, ...messages],
+        text: { verbosity: options?.textVerbosity || "medium" },
+        include: ["reasoning.encrypted_content"],
+        prompt_cache_key: options?.sessionId,
+        tool_choice: "auto",
+        parallel_tool_calls: true,
+    };
+    if (options?.temperature !== undefined) {
+        body.temperature = options.temperature;
     }
-    else {
-        headers.delete(OPENAI_HEADERS.CONVERSATION_ID);
-        headers.delete(OPENAI_HEADERS.SESSION_ID);
+    if (context.tools) {
+        body.tools = context.tools.map((tool) => ({
+            type: "function",
+            name: tool.name,
+            description: tool.description,
+            parameters: tool.parameters,
+            strict: null,
+        }));
     }
-    headers.set("accept", "text/event-stream");
-    headers.set("content-type", "application/json");
-    return headers;
-}
-function logCodexDebug(message, details) {
-    if (!CODEX_DEBUG)
-        return;
-    if (details) {
-        console.error(`[codex] ${message}`, details);
-        return;
+    if (options?.reasoningEffort !== undefined) {
+        body.reasoning = {
+            effort: clampReasoningEffort(model.id, options.reasoningEffort),
+            summary: options.reasoningSummary ?? "auto",
+        };
     }
-    console.error(`[codex] ${message}`);
+    return body;
 }
-function redactHeaders(headers) {
-    const redacted = {};
-    for (const [key, value] of headers.entries()) {
-        const lower = key.toLowerCase();
-        if (lower === "authorization") {
-            redacted[key] = "Bearer [redacted]";
-            continue;
-        }
-        if (lower.includes("account") ||
-            lower.includes("session") ||
-            lower.includes("conversation") ||
-            lower === "cookie") {
-            redacted[key] = "[redacted]";
-            continue;
+function buildSystemPrompt(userSystemPrompt) {
+    // PI_STATIC_INSTRUCTIONS is whitelisted and must be in the instructions field.
+    // User's system prompt goes in developer messages, with the static prefix stripped.
+    const staticPrefix = PI_STATIC_INSTRUCTIONS.trim();
+    const developerMessages = [];
+    if (userSystemPrompt?.trim()) {
+        let dynamicPart = userSystemPrompt.trim();
+        if (dynamicPart.startsWith(staticPrefix)) {
+            dynamicPart = dynamicPart.slice(staticPrefix.length).trim();
         }
-        redacted[key] = value;
+        if (dynamicPart)
+            developerMessages.push(dynamicPart);
     }
-    return redacted;
+    return { instructions: staticPrefix, developerMessages };
 }
-function rewriteUrlForCodex(url) {
-    return url.replace(URL_PATHS.RESPONSES, URL_PATHS.CODEX_RESPONSES);
+function clampReasoningEffort(modelId, effort) {
+    const id = modelId.includes("/") ? modelId.split("/").pop() : modelId;
+    if (id.startsWith("gpt-5.2") && effort === "minimal")
+        return "low";
+    if (id === "gpt-5.1" && effort === "xhigh")
+        return "high";
+    if (id === "gpt-5.1-codex-mini")
+        return effort === "high" || effort === "xhigh" ? "high" : "medium";
+    return effort;
 }
-function decodeJwt(token) {
-    try {
-        const parts = token.split(".");
-        if (parts.length !== 3)
-            return null;
-        const payload = parts[1] ?? "";
-        const decoded = Buffer.from(payload, "base64").toString("utf-8");
-        return JSON.parse(decoded);
+// ============================================================================
+// Message Conversion
+// ============================================================================
+function convertMessages(model, context) {
+    const messages = [];
+    const transformed = transformMessages(context.messages, model);
+    for (const msg of transformed) {
+        if (msg.role === "user") {
+            messages.push(convertUserMessage(msg, model));
+        }
+        else if (msg.role === "assistant") {
+            messages.push(...convertAssistantMessage(msg));
+        }
+        else if (msg.role === "toolResult") {
+            messages.push(...convertToolResult(msg, model));
+        }
     }
-    catch {
-        return null;
+    return messages.filter(Boolean);
+}
+function convertUserMessage(msg, model) {
+    if (typeof msg.content === "string") {
+        return {
+            role: "user",
+            content: [{ type: "input_text", text: sanitizeSurrogates(msg.content) }],
+        };
     }
+    const content = msg.content.map((item) => {
+        if (item.type === "text") {
+            return { type: "input_text", text: sanitizeSurrogates(item.text || "") };
+        }
+        return {
+            type: "input_image",
+            detail: "auto",
+            image_url: `data:${item.mimeType};base64,${item.data}`,
+        };
+    });
+    const filtered = model.input.includes("image") ? content : content.filter((c) => c.type !== "input_image");
+    return filtered.length > 0 ? { role: "user", content: filtered } : null;
 }
-function getAccountId(accessToken) {
-    const payload = decodeJwt(accessToken);
-    const auth = payload?.[JWT_CLAIM_PATH];
-    const accountId = auth?.chatgpt_account_id;
-    if (!accountId) {
-        throw new Error("Failed to extract accountId from token");
+function convertAssistantMessage(msg) {
+    const output = [];
+    for (const block of msg.content) {
+        if (block.type === "thinking" && msg.stopReason !== "error" && block.thinkingSignature) {
+            output.push(JSON.parse(block.thinkingSignature));
+        }
+        else if (block.type === "text") {
+            output.push({
+                type: "message",
+                role: "assistant",
+                content: [{ type: "output_text", text: sanitizeSurrogates(block.text), annotations: [] }],
+                status: "completed",
+            });
+        }
+        else if (block.type === "toolCall" && msg.stopReason !== "error") {
+            const [callId, id] = block.id.split("|");
+            output.push({
+                type: "function_call",
+                id,
+                call_id: callId,
+                name: block.name,
+                arguments: JSON.stringify(block.arguments),
+            });
+        }
     }
-    return accountId;
+    return output;
 }
-function shortHash(str) {
-    let h1 = 0xdeadbeef;
-    let h2 = 0x41c6ce57;
-    for (let i = 0; i < str.length; i++) {
-        const ch = str.charCodeAt(i);
-        h1 = Math.imul(h1 ^ ch, 2654435761);
-        h2 = Math.imul(h2 ^ ch, 1597334677);
+function convertToolResult(msg, model) {
+    const output = [];
+    const textResult = msg.content
+        .filter((c) => c.type === "text")
+        .map((c) => c.text || "")
+        .join("\n");
+    const hasImages = msg.content.some((c) => c.type === "image");
+    output.push({
+        type: "function_call_output",
+        call_id: msg.toolCallId.split("|")[0],
+        output: sanitizeSurrogates(textResult || "(see attached image)"),
+    });
+    if (hasImages && model.input.includes("image")) {
+        const imageParts = msg.content
+            .filter((c) => c.type === "image")
+            .map((c) => ({
+            type: "input_image",
+            detail: "auto",
+            image_url: `data:${c.mimeType};base64,${c.data}`,
+        }));
+        output.push({
+            role: "user",
+            content: [{ type: "input_text", text: "Attached image(s) from tool result:" }, ...imageParts],
+        });
     }
-    h1 = Math.imul(h1 ^ (h1 >>> 16), 2246822507) ^ Math.imul(h2 ^ (h2 >>> 13), 3266489909);
-    h2 = Math.imul(h2 ^ (h2 >>> 16), 2246822507) ^ Math.imul(h1 ^ (h1 >>> 13), 3266489909);
-    return (h2 >>> 0).toString(36) + (h1 >>> 0).toString(36);
+    return output;
 }
-function convertMessages(model, context) {
-    const messages = [];
-    const transformedMessages = transformMessages(context.messages, model);
-    let msgIndex = 0;
-    for (const msg of transformedMessages) {
-        if (msg.role === "user") {
-            if (typeof msg.content === "string") {
-                messages.push({
-                    role: "user",
-                    content: [{ type: "input_text", text: sanitizeSurrogates(msg.content) }],
-                });
+// ============================================================================
+// Response Processing
+// ============================================================================
+async function processStream(response, output, stream, model) {
+    let currentItem = null;
+    let currentBlock = null;
+    const blockIndex = () => output.content.length - 1;
+    for await (const event of parseSSE(response)) {
+        const type = event.type;
+        switch (type) {
+            case "response.output_item.added": {
+                const item = event.item;
+                if (item.type === "reasoning") {
+                    currentItem = item;
+                    currentBlock = { type: "thinking", thinking: "" };
+                    output.content.push(currentBlock);
+                    stream.push({ type: "thinking_start", contentIndex: blockIndex(), partial: output });
+                }
+                else if (item.type === "message") {
+                    currentItem = item;
+                    currentBlock = { type: "text", text: "" };
+                    output.content.push(currentBlock);
+                    stream.push({ type: "text_start", contentIndex: blockIndex(), partial: output });
+                }
+                else if (item.type === "function_call") {
+                    currentItem = item;
+                    currentBlock = {
+                        type: "toolCall",
+                        id: `${item.call_id}|${item.id}`,
+                        name: item.name,
+                        arguments: {},
+                        partialJson: item.arguments || "",
+                    };
+                    output.content.push(currentBlock);
+                    stream.push({ type: "toolcall_start", contentIndex: blockIndex(), partial: output });
+                }
+                break;
+            }
+            case "response.reasoning_summary_part.added": {
+                if (currentItem?.type === "reasoning") {
+                    currentItem.summary = currentItem.summary || [];
+                    currentItem.summary.push(event.part);
+                }
+                break;
             }
-            else {
-                const content = msg.content.map((item) => {
-                    if (item.type === "text") {
-                        return {
-                            type: "input_text",
-                            text: sanitizeSurrogates(item.text),
-                        };
+            case "response.reasoning_summary_text.delta": {
+                if (currentItem?.type === "reasoning" && currentBlock?.type === "thinking") {
+                    const delta = event.delta || "";
+                    const lastPart = currentItem.summary?.[currentItem.summary.length - 1];
+                    if (lastPart) {
+                        currentBlock.thinking += delta;
+                        lastPart.text += delta;
+                        stream.push({ type: "thinking_delta", contentIndex: blockIndex(), delta, partial: output });
                     }
-                    return {
-                        type: "input_image",
-                        detail: "auto",
-                        image_url: `data:${item.mimeType};base64,${item.data}`,
-                    };
-                });
-                const filteredContent = !model.input.includes("image")
-                    ? content.filter((c) => c.type !== "input_image")
-                    : content;
-                if (filteredContent.length === 0)
-                    continue;
-                messages.push({
-                    role: "user",
-                    content: filteredContent,
-                });
+                }
+                break;
             }
-        }
-        else if (msg.role === "assistant") {
-            const output = [];
-            for (const block of msg.content) {
-                if (block.type === "thinking" && msg.stopReason !== "error") {
-                    if (block.thinkingSignature) {
-                        const reasoningItem = JSON.parse(block.thinkingSignature);
-                        output.push(reasoningItem);
+            case "response.reasoning_summary_part.done": {
+                if (currentItem?.type === "reasoning" && currentBlock?.type === "thinking") {
+                    const lastPart = currentItem.summary?.[currentItem.summary.length - 1];
+                    if (lastPart) {
+                        currentBlock.thinking += "\n\n";
+                        lastPart.text += "\n\n";
+                        stream.push({ type: "thinking_delta", contentIndex: blockIndex(), delta: "\n\n", partial: output });
                     }
                 }
-                else if (block.type === "text") {
-                    const textBlock = block;
-                    let msgId = textBlock.textSignature;
-                    if (!msgId) {
-                        msgId = `msg_${msgIndex}`;
+                break;
+            }
+            case "response.content_part.added": {
+                if (currentItem?.type === "message") {
+                    currentItem.content = currentItem.content || [];
+                    const part = event.part;
+                    if (part && (part.type === "output_text" || part.type === "refusal")) {
+                        currentItem.content.push(part);
+                    }
+                }
+                break;
+            }
+            case "response.output_text.delta": {
+                if (currentItem?.type === "message" && currentBlock?.type === "text") {
+                    const lastPart = currentItem.content[currentItem.content.length - 1];
+                    if (lastPart?.type === "output_text") {
+                        const delta = event.delta || "";
+                        currentBlock.text += delta;
+                        lastPart.text += delta;
+                        stream.push({ type: "text_delta", contentIndex: blockIndex(), delta, partial: output });
                     }
-                    else if (msgId.length > 64) {
-                        msgId = `msg_${shortHash(msgId)}`;
+                }
+                break;
+            }
+            case "response.refusal.delta": {
+                if (currentItem?.type === "message" && currentBlock?.type === "text") {
+                    const lastPart = currentItem.content[currentItem.content.length - 1];
+                    if (lastPart?.type === "refusal") {
+                        const delta = event.delta || "";
+                        currentBlock.text += delta;
+                        lastPart.refusal += delta;
+                        stream.push({ type: "text_delta", contentIndex: blockIndex(), delta, partial: output });
                     }
-                    output.push({
-                        type: "message",
-                        role: "assistant",
-                        content: [{ type: "output_text", text: sanitizeSurrogates(textBlock.text), annotations: [] }],
-                        status: "completed",
-                        id: msgId,
+                }
+                break;
+            }
+            case "response.function_call_arguments.delta": {
+                if (currentItem?.type === "function_call" && currentBlock?.type === "toolCall") {
+                    const delta = event.delta || "";
+                    currentBlock.partialJson += delta;
+                    currentBlock.arguments = parseStreamingJson(currentBlock.partialJson);
+                    stream.push({ type: "toolcall_delta", contentIndex: blockIndex(), delta, partial: output });
+                }
+                break;
+            }
+            case "response.output_item.done": {
+                const item = event.item;
+                if (item.type === "reasoning" && currentBlock?.type === "thinking") {
+                    currentBlock.thinking = item.summary?.map((s) => s.text).join("\n\n") || "";
+                    currentBlock.thinkingSignature = JSON.stringify(item);
+                    stream.push({
+                        type: "thinking_end",
+                        contentIndex: blockIndex(),
+                        content: currentBlock.thinking,
+                        partial: output,
                     });
+                    currentBlock = null;
                 }
-                else if (block.type === "toolCall" && msg.stopReason !== "error") {
-                    const toolCall = block;
-                    output.push({
-                        type: "function_call",
-                        id: toolCall.id.split("|")[1],
-                        call_id: toolCall.id.split("|")[0],
-                        name: toolCall.name,
-                        arguments: JSON.stringify(toolCall.arguments),
+                else if (item.type === "message" && currentBlock?.type === "text") {
+                    currentBlock.text = item.content.map((c) => (c.type === "output_text" ? c.text : c.refusal)).join("");
+                    currentBlock.textSignature = item.id;
+                    stream.push({
+                        type: "text_end",
+                        contentIndex: blockIndex(),
+                        content: currentBlock.text,
+                        partial: output,
                     });
+                    currentBlock = null;
+                }
+                else if (item.type === "function_call") {
+                    const toolCall = {
+                        type: "toolCall",
+                        id: `${item.call_id}|${item.id}`,
+                        name: item.name,
+                        arguments: JSON.parse(item.arguments),
+                    };
+                    stream.push({ type: "toolcall_end", contentIndex: blockIndex(), toolCall, partial: output });
                 }
+                break;
             }
-            if (output.length === 0)
-                continue;
-            messages.push(...output);
-        }
-        else if (msg.role === "toolResult") {
-            const textResult = msg.content
-                .filter((c) => c.type === "text")
-                .map((c) => c.text)
-                .join("\n");
-            const hasImages = msg.content.some((c) => c.type === "image");
-            const hasText = textResult.length > 0;
-            messages.push({
-                type: "function_call_output",
-                call_id: msg.toolCallId.split("|")[0],
-                output: sanitizeSurrogates(hasText ? textResult : "(see attached image)"),
-            });
-            if (hasImages && model.input.includes("image")) {
-                const contentParts = [];
-                contentParts.push({
-                    type: "input_text",
-                    text: "Attached image(s) from tool result:",
-                });
-                for (const block of msg.content) {
-                    if (block.type === "image") {
-                        contentParts.push({
-                            type: "input_image",
-                            detail: "auto",
-                            image_url: `data:${block.mimeType};base64,${block.data}`,
-                        });
-                    }
+            case "response.completed":
+            case "response.done": {
+                const resp = event.response;
+                if (resp?.usage) {
+                    const cached = resp.usage.input_tokens_details?.cached_tokens || 0;
+                    output.usage = {
+                        input: (resp.usage.input_tokens || 0) - cached,
+                        output: resp.usage.output_tokens || 0,
+                        cacheRead: cached,
+                        cacheWrite: 0,
+                        totalTokens: resp.usage.total_tokens || 0,
+                        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+                    };
+                    calculateCost(model, output.usage);
                 }
-                messages.push({
-                    role: "user",
-                    content: contentParts,
-                });
+                output.stopReason = mapStopReason(resp?.status);
+                if (output.content.some((b) => b.type === "toolCall") && output.stopReason === "stop") {
+                    output.stopReason = "toolUse";
+                }
+                break;
+            }
+            case "error": {
+                const code = event.code || "";
+                const message = event.message || "";
+                throw new Error(`Codex error: ${message || code || JSON.stringify(event)}`);
+            }
+            case "response.failed": {
+                const msg = event.response?.error?.message;
+                throw new Error(msg || "Codex response failed");
             }
         }
-        msgIndex++;
     }
-    return messages;
-}
-function convertTools(tools) {
-    return tools.map((tool) => ({
-        type: "function",
-        name: tool.name,
-        description: tool.description,
-        parameters: tool.parameters,
-        strict: null,
-    }));
 }
 function mapStopReason(status) {
-    if (!status)
-        return "stop";
     switch (status) {
         case "completed":
             return "stop";
@@ -531,70 +487,101 @@ function mapStopReason(status) {
         case "failed":
         case "cancelled":
             return "error";
-        case "in_progress":
-        case "queued":
-            return "stop";
         default:
             return "stop";
     }
 }
-function asRecord(value) {
-    if (value && typeof value === "object") {
-        return value;
+// ============================================================================
+// SSE Parsing
+// ============================================================================
+async function* parseSSE(response) {
+    if (!response.body)
+        return;
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        buffer += decoder.decode(value, { stream: true });
+        let idx = buffer.indexOf("\n\n");
+        while (idx !== -1) {
+            const chunk = buffer.slice(0, idx);
+            buffer = buffer.slice(idx + 2);
+            const dataLines = chunk
+                .split("\n")
+                .filter((l) => l.startsWith("data:"))
+                .map((l) => l.slice(5).trim());
+            if (dataLines.length > 0) {
+                const data = dataLines.join("\n").trim();
+                if (data && data !== "[DONE]") {
+                    try {
+                        yield JSON.parse(data);
+                    }
+                    catch { }
+                }
+            }
+            idx = buffer.indexOf("\n\n");
+        }
     }
-    return null;
-}
-function getString(value) {
-    return typeof value === "string" ? value : undefined;
-}
-function truncate(text, limit) {
-    if (text.length <= limit)
-        return text;
-    return `${text.slice(0, limit)}...[truncated ${text.length - limit}]`;
 }
-function formatCodexFailure(rawEvent) {
-    const response = asRecord(rawEvent.response);
-    const error = asRecord(rawEvent.error) ?? (response ? asRecord(response.error) : null);
-    const message = getString(error?.message) ?? getString(rawEvent.message) ?? getString(response?.message);
-    const code = getString(error?.code) ?? getString(error?.type) ?? getString(rawEvent.code);
-    const status = getString(response?.status) ?? getString(rawEvent.status);
-    const meta = [];
-    if (code)
-        meta.push(`code=${code}`);
-    if (status)
-        meta.push(`status=${status}`);
-    if (message) {
-        const metaText = meta.length ? ` (${meta.join(", ")})` : "";
-        return `Codex response failed: ${message}${metaText}`;
-    }
-    if (meta.length) {
-        return `Codex response failed (${meta.join(", ")})`;
-    }
+// ============================================================================
+// Error Handling
+// ============================================================================
+async function parseErrorResponse(response) {
+    const raw = await response.text();
+    let message = raw || response.statusText || "Request failed";
+    let friendlyMessage;
     try {
-        return `Codex response failed: ${truncate(JSON.stringify(rawEvent), 800)}`;
-    }
-    catch {
-        return "Codex response failed";
+        const parsed = JSON.parse(raw);
+        const err = parsed?.error;
+        if (err) {
+            const code = err.code || err.type || "";
+            if (/usage_limit_reached|usage_not_included|rate_limit_exceeded/i.test(code) || response.status === 429) {
+                const plan = err.plan_type ? ` (${err.plan_type.toLowerCase()} plan)` : "";
+                const mins = err.resets_at
+                    ? Math.max(0, Math.round((err.resets_at * 1000 - Date.now()) / 60000))
+                    : undefined;
+                const when = mins !== undefined ? ` Try again in ~${mins} min.` : "";
+                friendlyMessage = `You have hit your ChatGPT usage limit${plan}.${when}`.trim();
+            }
+            message = err.message || friendlyMessage || message;
+        }
     }
+    catch { }
+    return { message, friendlyMessage };
 }
-function formatCodexErrorEvent(rawEvent, code, message) {
-    const detail = formatCodexFailure(rawEvent);
-    if (detail) {
-        return detail.replace("response failed", "error event");
-    }
-    const meta = [];
-    if (code)
-        meta.push(`code=${code}`);
-    if (message)
-        meta.push(`message=${message}`);
-    if (meta.length > 0) {
-        return `Codex error event (${meta.join(", ")})`;
-    }
+// ============================================================================
+// Auth & Headers
+// ============================================================================
+function extractAccountId(token) {
     try {
-        return `Codex error event: ${truncate(JSON.stringify(rawEvent), 800)}`;
+        const parts = token.split(".");
+        if (parts.length !== 3)
+            throw new Error("Invalid token");
+        const payload = JSON.parse(Buffer.from(parts[1], "base64").toString("utf-8"));
+        const accountId = payload?.[JWT_CLAIM_PATH]?.chatgpt_account_id;
+        if (!accountId)
+            throw new Error("No account ID in token");
+        return accountId;
     }
     catch {
-        return "Codex error event";
+        throw new Error("Failed to extract accountId from token");
+    }
+}
+function buildHeaders(initHeaders, accountId, token, sessionId) {
+    const headers = new Headers(initHeaders);
+    headers.set("Authorization", `Bearer ${token}`);
+    headers.set("chatgpt-account-id", accountId);
+    headers.set("OpenAI-Beta", "responses=experimental");
+    headers.set("originator", "pi");
+    headers.set("User-Agent", `pi (${os.platform()} ${os.release()}; ${os.arch()})`);
+    headers.set("accept", "text/event-stream");
+    headers.set("content-type", "application/json");
+    if (sessionId) {
+        headers.set("session_id", sessionId);
     }
+    return headers;
 }
 //# sourceMappingURL=openai-codex-responses.js.map