pulseed 0.6.4 → 0.6.6

package/dist/base/llm/codex-llm-client.js

@@ -2,15 +2,28 @@ import * as fsp from "node:fs/promises";
 import * as os from "node:os";
 import * as path from "node:path";
 import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
 import { BaseLLMClient } from "./base-llm-client.js";
 import { sleep } from "../utils/sleep.js";
 import { LLMError } from "../utils/errors.js";
+import { signalProcessGroup } from "../utils/process-pid.js";
+import { isTextFileSizeLimitError, readTextFileWithinLimit } from "../utils/json-io.js";
 // ─── Constants ───
 const DEFAULT_TIMEOUT_MS = 120_000; // 2 minutes per call
 const DEFAULT_RETRY_ATTEMPTS = 3;
 const MAX_RETRY_ATTEMPTS = 5;
 const RETRY_DELAYS_MS = [1000, 2000, 4000, 8000];
 const SIGKILL_DELAY_MS = 5000;
+const DEFAULT_CODEX_RESPONSES_BASE_URL = "https://chatgpt.com/backend-api/codex";
+export const CODEX_RESPONSE_TEXT_MAX_BYTES = 8 * 1024 * 1024;
+function codexLLMError(message, code, agentLoopFailureReason) {
+    const error = new LLMError(message);
+    if (code)
+        error.code = code;
+    if (agentLoopFailureReason)
+        error.agentLoopFailureReason = agentLoopFailureReason;
+    return error;
+}
 /**
  * Build a single prompt string from messages and system prompt.
  * Format:
@@ -27,10 +40,23 @@ function buildPrompt(messages, system) {
         parts.push("");
     }
     for (const msg of messages) {
-        parts.push(`${msg.role}: ${msg.content}`);
+        if (msg.role === "tool") {
+            parts.push(`tool result${msg.name ? ` for ${msg.name}` : ""}: ${msg.content}`);
+        }
+        else {
+            parts.push(`${msg.role}: ${msg.content}`);
+        }
     }
     return parts.join("\n");
 }
+export function isCodexOAuthAccessToken(token) {
+    const trimmed = token?.trim();
+    if (!trimmed || trimmed.startsWith("sk-"))
+        return false;
+    const payload = decodeJwtPayload(trimmed);
+    const exp = payload?.exp;
+    return typeof exp === "number" && exp > Math.floor(Date.now() / 1000);
+}
 /**
  * ILLMClient implementation that uses the `codex exec` CLI for LLM calls.
  * Routes all PulSeed internal LLM calls through the Codex CLI, which uses
@@ -43,6 +69,8 @@ function buildPrompt(messages, system) {
  * Set PULSEED_LLM_PROVIDER=codex to activate via CLIRunner / provider-factory.
  */
 export class CodexLLMClient extends BaseLLMClient {
+    apiKey;
+    baseURL;
     cliPath;
     model;
     repoPath;
@@ -54,6 +82,8 @@ export class CodexLLMClient extends BaseLLMClient {
     skipGitRepoCheck;
     constructor(config = {}) {
         super();
+        this.apiKey = isCodexOAuthAccessToken(config.apiKey) ? config.apiKey.trim() : undefined;
+        this.baseURL = canonicalizeCodexResponsesBaseUrl(config.baseURL);
         this.cliPath = config.cliPath ?? "codex";
         this.model = config.model;
         this.lightModel = config.lightModel;
@@ -75,13 +105,16 @@ export class CodexLLMClient extends BaseLLMClient {
      * Retries up to MAX_RETRY_ATTEMPTS times with exponential backoff on spawn failures.
      */
     async sendMessage(messages, options) {
+        if (this.apiKey) {
+            return this.sendViaCodexResponsesStream(messages, options, {});
+        }
         const model = this.resolveEffectiveModel(options?.model ?? this.model ?? "", options?.model_tier) || undefined;
         const system = options?.system;
         const prompt = buildPrompt(messages, system);
         let lastError;
         for (let attempt = 0; attempt < this.retryAttempts; attempt++) {
             try {
-                const content = await this._spawnCodex(prompt, model, options?.abortSignal);
+                const content = await this._spawnCodex(prompt, model, options?.abortSignal, options?.sandboxPolicy ?? this.sandboxPolicy, options?.cwd, options?.timeoutMs, options?.idleTimeoutMs);
                 return {
                     content,
                     usage: {
@@ -103,15 +136,25 @@ export class CodexLLMClient extends BaseLLMClient {
         }
         throw lastError;
     }
-    /** CodexLLMClient does not support native provider function/tool calling. */
-    supportsToolCalling() { return false; }
+    /** OAuth-backed Codex Responses supports native provider function/tool calling. */
+    supportsToolCalling() { return Boolean(this.apiKey); }
+    usesExternalAgentRuntime() { return !this.apiKey; }
+    async sendMessageStream(messages, options, handlers) {
+        if (!this.apiKey) {
+            const response = await this.sendMessage(messages, options);
+            if (response.content)
+                handlers.onTextDelta?.(response.content);
+            return response;
+        }
+        return this.sendViaCodexResponsesStream(messages, options, handlers);
+    }
     /**
      * Spawn `codex exec -s <sandbox> [-o <tmpfile>] [--model <model>] "PROMPT"`
      * and return the response content read from the temp output file.
      */
-    async _spawnCodex(prompt, model, abortSignal) {
+    async _spawnCodex(prompt, model, abortSignal, sandboxPolicy = this.sandboxPolicy, cwd = this.repoPath, timeoutMs = this.totalTimeoutMs, idleTimeoutMs = this.idleTimeoutMs) {
         if (abortSignal?.aborted) {
-            throw new LLMError("CodexLLMClient: request aborted by operator stop");
+            throw codexLLMError("CodexLLMClient: request aborted by operator stop", "ABORT_ERR", "model_request_aborted");
         }
         // Create a temporary directory asynchronously to avoid blocking the event loop
         const tmpDir = await fsp.mkdtemp(path.join(os.tmpdir(), "pulseed-codex-"));
@@ -123,7 +166,7 @@ export class CodexLLMClient extends BaseLLMClient {
             const spawnArgs = [
                 "exec",
                 "-s",
-                this.sandboxPolicy,
+                sandboxPolicy,
                 "-o",
                 tmpFile,
             ];
@@ -140,7 +183,7 @@ export class CodexLLMClient extends BaseLLMClient {
             const child = spawn(this.cliPath, spawnArgs, {
                 stdio: ["pipe", "pipe", "pipe"],
                 env: { ...process.env, TERM: "dumb" },
-                cwd: this.repoPath,
+                cwd,
                 detached: process.platform !== "win32",
             });
             let timedOut = false;
@@ -149,19 +192,21 @@ export class CodexLLMClient extends BaseLLMClient {
             let idleTimeoutHandle;
             let sigkillHandle;
             let stderrData = "";
-            const clearTimers = () => {
+            const clearTimers = (options = {}) => {
                 if (totalTimeoutHandle)
                     clearTimeout(totalTimeoutHandle);
                 if (idleTimeoutHandle)
                     clearTimeout(idleTimeoutHandle);
-                if (sigkillHandle)
+                if (!options.keepSigkill && sigkillHandle)
                     clearTimeout(sigkillHandle);
             };
             const killChild = (signal) => {
                 if (process.platform !== "win32" && typeof child.pid === "number") {
                     try {
-                        process.kill(-child.pid, signal);
-                        return;
+                        const groupSignal = signalProcessGroup(child.pid, signal);
+                        if (groupSignal.status === "sent") {
+                            return;
+                        }
                     }
                     catch {
                         // Fall back to the immediate child below.
@@ -169,6 +214,14 @@ export class CodexLLMClient extends BaseLLMClient {
                 }
                 child.kill(signal);
             };
+            const forceKillChild = () => {
+                try {
+                    killChild("SIGKILL");
+                }
+                catch {
+                    // process already exited
+                }
+            };
             const cleanupTmp = () => {
                 clearTimers();
                 abortSignal?.removeEventListener("abort", triggerAbort);
@@ -176,34 +229,25 @@ export class CodexLLMClient extends BaseLLMClient {
                     console.debug("CodexLLMClient: _cleanupTmp failed (non-critical)", String(cleanupErr));
                 });
             };
+            const scheduleForceKill = () => {
+                if (sigkillHandle)
+                    return;
+                sigkillHandle = setTimeout(forceKillChild, SIGKILL_DELAY_MS);
+            };
             const triggerTimeout = (reason) => {
                 if (timedOut)
                     return;
                 timedOut = true;
                 timeoutReason = reason;
                 killChild("SIGTERM");
-                sigkillHandle = setTimeout(() => {
-                    try {
-                        killChild("SIGKILL");
-                    }
-                    catch {
-                        // process already exited
-                    }
-                }, SIGKILL_DELAY_MS);
+                scheduleForceKill();
             };
             const triggerAbort = () => {
                 if (aborted || timedOut)
                     return;
                 aborted = true;
                 killChild("SIGTERM");
-                sigkillHandle = setTimeout(() => {
-                    try {
-                        killChild("SIGKILL");
-                    }
-                    catch {
-                        // process already exited
-                    }
-                }, SIGKILL_DELAY_MS);
+                scheduleForceKill();
             };
             if (abortSignal?.aborted) {
                 triggerAbort();
@@ -212,16 +256,18 @@ export class CodexLLMClient extends BaseLLMClient {
                 abortSignal?.addEventListener("abort", triggerAbort, { once: true });
             }
             const armIdleTimeout = () => {
-                if (this.idleTimeoutMs <= 0)
+                if (idleTimeoutMs <= 0)
                     return;
                 if (idleTimeoutHandle)
                     clearTimeout(idleTimeoutHandle);
-                idleTimeoutHandle = setTimeout(() => triggerTimeout("idle"), this.idleTimeoutMs);
+                idleTimeoutHandle = setTimeout(() => triggerTimeout("idle"), idleTimeoutMs);
             };
             const markActivity = () => {
                 armIdleTimeout();
             };
-            const totalTimeoutHandle = setTimeout(() => triggerTimeout("total"), this.totalTimeoutMs);
+            const totalTimeoutHandle = timeoutMs > 0
+                ? setTimeout(() => triggerTimeout("total"), timeoutMs)
+                : undefined;
             child.stdout?.on("data", markActivity);
             child.stderr.on("data", (chunk) => {
                 stderrData += chunk.toString();
@@ -240,16 +286,18 @@ export class CodexLLMClient extends BaseLLMClient {
                 reject(new LLMError(`CodexLLMClient: spawn error — ${err.message}`));
             });
             child.on("close", (code) => {
-                clearTimers();
+                clearTimers({ keepSigkill: timedOut || aborted });
                 if (timedOut) {
+                    forceKillChild();
                     cleanupTmp();
                     const timeoutLabel = timeoutReason === "idle" ? "idle timed out" : "request timed out";
-                    reject(new LLMError(`CodexLLMClient: ${timeoutLabel} after ${timeoutReason === "idle" ? this.idleTimeoutMs : this.totalTimeoutMs}ms`));
+                    reject(codexLLMError(`CodexLLMClient: ${timeoutLabel} after ${timeoutReason === "idle" ? idleTimeoutMs : timeoutMs}ms`, "ETIMEDOUT", "model_request_timeout"));
                     return;
                 }
                 if (aborted) {
+                    forceKillChild();
                     cleanupTmp();
-                    reject(new LLMError("CodexLLMClient: request aborted by operator stop"));
+                    reject(codexLLMError("CodexLLMClient: request aborted by operator stop", "ABORT_ERR", "model_request_aborted"));
                     return;
                 }
                 if (code !== 0) {
@@ -259,18 +307,366 @@ export class CodexLLMClient extends BaseLLMClient {
                     return;
                 }
                 // Read response from temp file
-                fsp.readFile(tmpFile, "utf-8")
+                readTextFileWithinLimit(tmpFile, { maxBytes: CODEX_RESPONSE_TEXT_MAX_BYTES })
                     .then((raw) => {
                     cleanupTmp();
                     resolve(raw.trim());
                 })
                     .catch((readErr) => {
                     cleanupTmp();
+                    if (isTextFileSizeLimitError(readErr)) {
+                        reject(new LLMError(`CodexLLMClient: output file exceeds ${CODEX_RESPONSE_TEXT_MAX_BYTES} bytes`));
+                        return;
+                    }
                     reject(new LLMError(`CodexLLMClient: failed to read output file — ${String(readErr)}`));
                 });
             });
         });
     }
+    async sendViaCodexResponsesStream(messages, options, handlers) {
+        const apiKey = this.apiKey;
+        if (!apiKey) {
+            throw new LLMError("CodexLLMClient: Codex Responses streaming requires a ChatGPT OAuth token");
+        }
+        const model = this.resolveEffectiveModel(options?.model ?? this.model ?? "", options?.model_tier) || "gpt-5.4-mini";
+        const abortController = new AbortController();
+        const abortFromParent = () => abortController.abort(options?.abortSignal?.reason);
+        if (options?.abortSignal?.aborted) {
+            abortFromParent();
+        }
+        else {
+            options?.abortSignal?.addEventListener("abort", abortFromParent, { once: true });
+        }
+        let timer;
+        let timeoutError;
+        try {
+            const timeoutMs = options?.timeoutMs ?? this.totalTimeoutMs;
+            if (timeoutMs > 0) {
+                timer = setTimeout(() => {
+                    timeoutError = codexLLMError(`CodexLLMClient: Codex Responses stream timed out after ${timeoutMs}ms`, "ETIMEDOUT", "model_request_timeout");
+                    abortController.abort(timeoutError);
+                }, timeoutMs);
+            }
+            const response = await fetch(`${this.baseURL}/responses`, {
+                method: "POST",
+                headers: {
+                    authorization: `Bearer ${apiKey}`,
+                    ...codexAccountHeader(apiKey),
+                    originator: "pi",
+                    "openai-beta": "responses=experimental",
+                    accept: "text/event-stream",
+                    "content-type": "application/json",
+                },
+                body: JSON.stringify(buildCodexResponsesPayload({
+                    model,
+                    messages,
+                    options,
+                    system: options?.system,
+                    reasoningEffort: this.reasoningEffort,
+                })),
+                signal: abortController.signal,
+            });
+            if (!response.ok || !response.body) {
+                const detail = await safeResponseText(response);
+                throw new LLMError(`CodexLLMClient: Codex Responses request failed with HTTP ${response.status}${detail ? ` - ${detail}` : ""}`);
+            }
+            return await readCodexResponsesStream(response.body, handlers, abortController.signal);
+        }
+        catch (err) {
+            if (abortController.signal.aborted || options?.abortSignal?.aborted) {
+                if (timeoutError && abortController.signal.reason === timeoutError) {
+                    throw timeoutError;
+                }
+                throw codexLLMError("CodexLLMClient: Codex Responses stream aborted", "ABORT_ERR", "model_request_aborted");
+            }
+            throw err;
+        }
+        finally {
+            if (timer)
+                clearTimeout(timer);
+            abortController.abort();
+            options?.abortSignal?.removeEventListener("abort", abortFromParent);
+        }
+    }
+}
+function canonicalizeCodexResponsesBaseUrl(baseURL) {
+    const trimmed = baseURL?.trim();
+    if (!trimmed)
+        return DEFAULT_CODEX_RESPONSES_BASE_URL;
+    const normalized = trimmed.replace(/\/+$/, "");
+    if (/^https?:\/\/chatgpt\.com\/backend-api(?:\/codex)?(?:\/v1)?$/i.test(normalized)) {
+        return DEFAULT_CODEX_RESPONSES_BASE_URL;
+    }
+    return DEFAULT_CODEX_RESPONSES_BASE_URL;
+}
+function decodeJwtPayload(token) {
+    const parts = token.split(".");
+    if (parts.length < 2 || !parts[1])
+        return undefined;
+    try {
+        return JSON.parse(Buffer.from(parts[1], "base64url").toString("utf8"));
+    }
+    catch {
+        return undefined;
+    }
+}
+function codexAccountHeader(token) {
+    const payload = decodeJwtPayload(token);
+    const auth = payload?.["https://api.openai.com/auth"];
+    const accountId = auth && typeof auth === "object"
+        ? auth["chatgpt_account_id"]
+        : undefined;
+    return typeof accountId === "string" && accountId.trim()
+        ? { "chatgpt-account-id": accountId.trim() }
+        : {};
+}
+function buildCodexResponsesPayload(params) {
+    const input = codexResponsesInput(params.messages);
+    const tools = params.options?.tools?.map((tool) => ({
+        type: "function",
+        name: tool.function.name,
+        description: tool.function.description,
+        parameters: tool.function.parameters,
+        strict: null,
+    }));
+    return {
+        model: params.model,
+        store: false,
+        stream: true,
+        instructions: params.system?.trim() || "You are PulSeed's configured chat model. Follow the user request and answer concisely.",
+        input: input.length > 0 ? input : [{ role: "user", content: [{ type: "input_text", text: " " }] }],
+        text: { verbosity: "low" },
+        reasoning: { effort: params.reasoningEffort ?? "low", summary: "auto" },
+        include: ["reasoning.encrypted_content"],
+        prompt_cache_key: "pulseed-codex-responses",
+        ...(tools?.length ? { tools, tool_choice: "auto", parallel_tool_calls: true } : {}),
+    };
+}
+function codexResponsesInput(messages) {
+    return messages.flatMap((message, index) => {
+        const text = message.content || " ";
+        if (message.role === "user") {
+            return [{ role: "user", content: [{ type: "input_text", text }] }];
+        }
+        if (message.role === "tool") {
+            return [{
+                    type: "function_call_output",
+                    call_id: message.tool_call_id,
+                    output: text,
+                }];
+        }
+        if (message.tool_calls?.length) {
+            const items = [];
+            if (message.content.trim()) {
+                items.push({
+                    type: "message",
+                    id: `msg_${index}`,
+                    role: "assistant",
+                    content: [{ type: "output_text", text, annotations: [] }],
+                    status: "completed",
+                });
+            }
+            for (const call of message.tool_calls) {
+                items.push({
+                    type: "function_call",
+                    id: call.id,
+                    call_id: call.id,
+                    name: call.function.name,
+                    arguments: call.function.arguments,
+                    status: "completed",
+                });
+            }
+            return items;
+        }
+        return [{
+                type: "message",
+                id: `msg_${index}`,
+                role: "assistant",
+                content: [{ type: "output_text", text, annotations: [] }],
+                status: "completed",
+            }];
+    });
+}
+async function safeResponseText(response) {
+    try {
+        return (await response.text()).trim().slice(0, 500);
+    }
+    catch {
+        return "";
+    }
+}
+async function readCodexResponsesStream(body, handlers, abortSignal) {
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let content = "";
+    let finalResponse;
+    const toolCalls = new Map();
+    const toolArgumentBuffers = new Map();
+    const toolCallIdsByItemId = new Map();
+    const handleEvent = (event) => {
+        if (event.type === "response.output_text.delta" || event.type === "response.refusal.delta") {
+            const delta = typeof event.delta === "string" ? event.delta : "";
+            if (delta) {
+                content += delta;
+                handlers.onTextDelta?.(delta);
+            }
+        }
+        else if (event.type === "response.output_item.added" && isRecord(event.item) && event.item["type"] === "function_call") {
+            rememberResponseToolCall(toolCallIdsByItemId, event.item);
+            upsertToolCall(toolCalls, event.item, toolArgumentBuffers.get(responseToolCallItemId(event.item)));
+        }
+        else if (event.type === "response.function_call_arguments.delta") {
+            const itemId = responseToolCallItemId(event);
+            const delta = typeof event.delta === "string" ? event.delta : "";
+            toolArgumentBuffers.set(itemId, `${toolArgumentBuffers.get(itemId) ?? ""}${delta}`);
+        }
+        else if (event.type === "response.function_call_arguments.done") {
+            const itemId = responseToolCallItemId(event);
+            if (typeof event.arguments === "string") {
+                toolArgumentBuffers.set(itemId, event.arguments);
+            }
+            if (typeof event.call_id === "string" || typeof event.id === "string" || typeof event.name === "string") {
+                rememberResponseToolCall(toolCallIdsByItemId, event);
+            }
+            const callId = toolCallIdsByItemId.get(itemId);
+            const existing = callId ? toolCalls.get(callId) : undefined;
+            if (callId && existing) {
+                toolCalls.set(callId, {
+                    ...existing,
+                    function: {
+                        ...existing.function,
+                        arguments: toolArgumentBuffers.get(itemId) ?? existing.function.arguments,
+                    },
+                });
+            }
+            else if (callId) {
+                upsertToolCall(toolCalls, event, toolArgumentBuffers.get(itemId));
+            }
+        }
+        else if (event.type === "response.output_item.done" && isRecord(event.item) && event.item["type"] === "function_call") {
+            rememberResponseToolCall(toolCallIdsByItemId, event.item);
+            upsertToolCall(toolCalls, event.item, toolArgumentBuffers.get(responseToolCallItemId(event.item)));
+        }
+        else if (event.type === "response.completed" || event.type === "response.done") {
+            finalResponse = isRecord(event.response) ? event.response : {};
+        }
+        else if (event.type === "response.incomplete") {
+            const response = isRecord(event.response) ? event.response : undefined;
+            const details = isRecord(response?.["incomplete_details"]) ? response["incomplete_details"] : undefined;
+            throw new LLMError(`CodexLLMClient: Codex Responses stream incomplete: ${String(details?.["reason"] ?? response?.["status"] ?? "unknown reason")}`);
+        }
+        else if (event.type === "response.failed") {
+            const response = isRecord(event.response) ? event.response : undefined;
+            const error = isRecord(response?.["error"]) ? response["error"] : undefined;
+            throw new LLMError(`CodexLLMClient: Codex Responses stream failed: ${String(error?.["message"] ?? response?.["status"] ?? "unknown failure")}`);
+        }
+        else if (event.type === "error") {
+            throw new LLMError(`CodexLLMClient: Codex Responses stream error: ${String(event.message ?? "unknown error")}`);
+        }
+    };
+    while (true) {
+        if (abortSignal.aborted) {
+            throw codexLLMError("CodexLLMClient: Codex Responses stream aborted", "ABORT_ERR", "model_request_aborted");
+        }
+        const chunk = await reader.read();
+        if (chunk.done)
+            break;
+        buffer += decoder.decode(chunk.value, { stream: true });
+        let frameBoundary = findSseFrameBoundary(buffer);
+        while (frameBoundary !== null) {
+            const frame = buffer.slice(0, frameBoundary.index);
+            buffer = buffer.slice(frameBoundary.index + frameBoundary.length);
+            for (const event of parseSseFrame(frame)) {
+                handleEvent(event);
+            }
+            frameBoundary = findSseFrameBoundary(buffer);
+        }
+    }
+    buffer += decoder.decode();
+    if (buffer.trim()) {
+        for (const event of parseSseFrame(buffer)) {
+            handleEvent(event);
+        }
+    }
+    if (!finalResponse) {
+        throw new LLMError("CodexLLMClient: Codex Responses stream ended without a terminal response");
+    }
+    return responseFromCodexResponses(finalResponse, content, [...toolCalls.values()]);
+}
+function findSseFrameBoundary(buffer) {
+    const match = /(?:\r\n|\r|\n)(?:\r\n|\r|\n)/.exec(buffer);
+    return match ? { index: match.index, length: match[0].length } : null;
+}
+function parseSseFrame(frame) {
+    const data = frame
+        .replace(/\r\n/g, "\n")
+        .replace(/\r/g, "\n")
+        .split("\n")
+        .filter((line) => line.startsWith("data:"))
+        .map((line) => line.slice(5).replace(/^ /, ""))
+        .join("\n")
+        .trim();
+    if (!data || data === "[DONE]")
+        return [];
+    try {
+        const parsed = JSON.parse(data);
+        return isRecord(parsed) ? [parsed] : [];
+    }
+    catch {
+        return [];
+    }
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function upsertToolCall(toolCalls, item, argumentBuffer) {
+    const id = responseToolCallId(item);
+    toolCalls.set(id, {
+        id,
+        type: "function",
+        function: {
+            name: typeof item["name"] === "string" ? item["name"] : toolCalls.get(id)?.function.name ?? "",
+            arguments: typeof item["arguments"] === "string"
+                ? item["arguments"]
+                : argumentBuffer ?? toolCalls.get(id)?.function.arguments ?? "{}",
+        },
+    });
+}
+function rememberResponseToolCall(toolCallIdsByItemId, item) {
+    toolCallIdsByItemId.set(responseToolCallItemId(item), responseToolCallId(item));
+}
+function responseToolCallId(item) {
+    return typeof item["call_id"] === "string"
+        ? item["call_id"]
+        : typeof item["id"] === "string"
+            ? item["id"]
+            : typeof item["item_id"] === "string"
+                ? item["item_id"]
+                : randomUUID();
+}
+function responseToolCallItemId(item) {
+    return typeof item["item_id"] === "string"
+        ? item["item_id"]
+        : typeof item["id"] === "string"
+            ? item["id"]
+            : typeof item["call_id"] === "string"
+                ? item["call_id"]
+                : randomUUID();
+}
+function responseFromCodexResponses(finalResponse, content, toolCalls) {
+    const usage = isRecord(finalResponse?.["usage"]) ? finalResponse["usage"] : {};
+    return {
+        content: typeof finalResponse?.["output_text"] === "string" && finalResponse["output_text"]
+            ? finalResponse["output_text"]
+            : content,
+        usage: {
+            input_tokens: typeof usage["input_tokens"] === "number" ? usage["input_tokens"] : 0,
+            output_tokens: typeof usage["output_tokens"] === "number" ? usage["output_tokens"] : 0,
+        },
+        stop_reason: typeof finalResponse?.["status"] === "string" ? finalResponse["status"] : "completed",
+        ...(toolCalls.length > 0 ? { tool_calls: toolCalls } : {}),
+    };
 }
 function isRetryableCodexError(err) {
     const message = err instanceof Error ? err.message : String(err);
@@ -295,12 +691,13 @@ async function _cleanupTmp(tmpDir, tmpFile) {
 function sleepWithAbort(ms, abortSignal) {
     if (!abortSignal)
         return sleep(ms);
-    if (abortSignal.aborted)
-        return Promise.reject(new LLMError("CodexLLMClient: request aborted by operator stop"));
+    if (abortSignal.aborted) {
+        return Promise.reject(codexLLMError("CodexLLMClient: request aborted by operator stop", "ABORT_ERR", "model_request_aborted"));
+    }
     return new Promise((resolve, reject) => {
         const onAbort = () => {
             clearTimeout(timer);
-            reject(new LLMError("CodexLLMClient: request aborted by operator stop"));
+            reject(codexLLMError("CodexLLMClient: request aborted by operator stop", "ABORT_ERR", "model_request_aborted"));
         };
         const timer = setTimeout(() => {
             abortSignal.removeEventListener("abort", onAbort);