@compyle/unagent 1.0.0

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

@@ -0,0 +1,906 @@
+import * as fs from "fs";
+import { BaseClient, } from "../base-client.js";
+import { ClientType, } from "../../events/index.js";
+import { MessageRole, createAssistantMessage, createToolCallResultMessage, normalizeMessage, } from "../../messages/index.js";
+import { loadConfigFromToml, writeCodexConfigUpdates, writeSkillsConfig, } from "./config/index.js";
+import { extractCustomTools, isRegisteredTool } from "../../tools/define-tool.js";
+import { getAgentToolServiceCommand, resolveToolServiceOwner } from "../../tools/tool-service-manager.js";
+import { stringifyContent, buildToolUseFromRecord, ToolCallTracker, } from "../transformers/content-utils.js";
+import { convertSnakeCaseToCamelCase } from "../config-utils.js";
+import { CODEX_FIELD_MAPPINGS } from "../field-mappings.js";
+import { resolveCodexHomeDir } from "./codex-home.js";
+const DEFAULT_CUSTOM_TOOL_TIMEOUT_SEC = 5184000;
+export class CodexClient extends BaseClient {
+    codex;
+    thread;
+    toolCallTracker = new ToolCallTracker();
+    streamBuffer = "";
+    isStreamingAssistant = false;
+    codexConfig;
+    codexOptions;
+    threadOptions = {};
+    customTools = [];
+    customToolsInitialized = false;
+    userProvidedCodexHome = false;
+    codexHomeDir;
+    constructor(config) {
+        super(ClientType.CODEX, config);
+        const resolvedEnv = { ...(config.env ?? {}) };
+        const normalizedConfig = convertSnakeCaseToCamelCase({ ...config, env: resolvedEnv }, CODEX_FIELD_MAPPINGS);
+        const codexHomeKey = resolveString(normalizedConfig.codexHomeKey);
+        const explicitCodexHome = resolveString(resolvedEnv.CODEX_HOME);
+        const codexHomeResolution = resolveCodexHomeDir(explicitCodexHome, codexHomeKey);
+        this.userProvidedCodexHome = codexHomeResolution.userProvided;
+        this.codexHomeDir = codexHomeResolution.codexHomeDir;
+        if (!explicitCodexHome) {
+            resolvedEnv.CODEX_HOME = this.codexHomeDir;
+        }
+        this.codexConfig = normalizedConfig;
+        const agents = this.codexConfig.agents;
+        const systemPrompt = resolveString(this.codexConfig.systemPrompt) ?? resolveAgentSystemPrompt(agents);
+        const model = resolveString(this.codexConfig.model);
+        const addDirs = resolveStringArray(this.codexConfig.addDirs);
+        const workingDirectory = resolveString(this.codexConfig.cwd ?? this.codexConfig.workingDirectory);
+        const mcpServers = resolveMcpServers(this.codexConfig.mcpServers);
+        const skillDir = resolveString(this.codexConfig.skillDir);
+        const allowWriteWithUserCodexHome = this.codexConfig.allowConfigWriteWithUserCodexHome === true;
+        const codexHome = this.userProvidedCodexHome && !allowWriteWithUserCodexHome
+            ? undefined
+            : this.codexHomeDir;
+        const sandboxMode = mapPermissionModeToSandboxMode(this.codexConfig.permissionMode);
+        const codexOptions = {};
+        const threadOptions = {};
+        if (sandboxMode) {
+            threadOptions.sandboxMode = sandboxMode;
+        }
+        if (this.codexConfig.apiKey) {
+            codexOptions.apiKey = this.codexConfig.apiKey;
+        }
+        if (this.codexConfig.baseURL) {
+            codexOptions.baseUrl = this.codexConfig.baseURL;
+        }
+        codexOptions.env = resolvedEnv;
+        const sdkConfig = isRecord(this.codexConfig.config)
+            ? this.codexConfig.config
+            : undefined;
+        if (sdkConfig && Object.keys(sdkConfig).length > 0) {
+            codexOptions.config = sdkConfig;
+        }
+        const modelProviderOverride = buildModelProviderOverride(sdkConfig, resolvedEnv);
+        const configUpdates = {};
+        if (modelProviderOverride) {
+            if (codexHome) {
+                configUpdates.modelProviders = {
+                    [modelProviderOverride.name]: modelProviderOverride.config,
+                };
+                configUpdates.modelProvider = modelProviderOverride.name;
+            }
+            else if (this.userProvidedCodexHome) {
+                console.warn("Model provider headers must be configured in config.toml. " +
+                    "Set allowConfigWriteWithUserCodexHome=true or update CODEX_HOME/config.toml manually.");
+            }
+        }
+        if (systemPrompt) {
+            if (codexHome) {
+                configUpdates.developerInstructions = systemPrompt;
+            }
+            else if (!this.userProvidedCodexHome) {
+                console.warn("Codex system prompt must be configured in config.toml developer_instructions. " +
+                    "Set env.CODEX_HOME to write it automatically.");
+            }
+        }
+        if (model) {
+            threadOptions.model = model;
+            if (codexHome) {
+                configUpdates.model = model;
+            }
+        }
+        if (addDirs.length > 0) {
+            threadOptions.additionalDirectories = [...addDirs];
+            if (codexHome) {
+                configUpdates.writableRoots = [...addDirs];
+            }
+        }
+        if (workingDirectory) {
+            threadOptions.workingDirectory = workingDirectory;
+        }
+        if (mcpServers && codexHome) {
+            configUpdates.mcpServers = mcpServers;
+        }
+        else if (mcpServers && Object.keys(mcpServers).length > 0) {
+            console.warn("MCP servers must be configured in config.toml. " +
+                "Set allowConfigWriteWithUserCodexHome=true or update CODEX_HOME/config.toml manually.");
+        }
+        if (codexHome && Object.keys(configUpdates).length > 0) {
+            writeCodexConfigUpdates(configUpdates, codexHome);
+        }
+        if (skillDir && codexHome) {
+            writeSkillsConfig(skillDir, codexHome);
+        }
+        else if (skillDir && this.userProvidedCodexHome && !allowWriteWithUserCodexHome) {
+            console.warn("Skills must be linked at CODEX_HOME/skills. " +
+                "Set allowConfigWriteWithUserCodexHome=true or create the symlink manually.");
+        }
+        const customTools = safeExtractCustomTools(this.codexConfig.tools);
+        this.customTools = customTools;
+        if (codexHome && this.codexConfig.loadConfigFromFile !== false) {
+            try {
+                const fileConfig = loadConfigFromToml(codexHome);
+                if (fileConfig) {
+                    const modelName = resolveModelName(model, fileConfig.model);
+                    if (modelName && !threadOptions.model) {
+                        threadOptions.model = modelName;
+                    }
+                }
+            }
+            catch (error) {
+                console.warn(`Failed to load config from ${codexHome}:`, error);
+            }
+        }
+        this.codexOptions = codexOptions;
+        this.threadOptions = threadOptions;
+    }
+    async getCodex() {
+        if (this.codex) {
+            return this.codex;
+        }
+        const allowWriteWithUserCodexHome = this.codexConfig.allowConfigWriteWithUserCodexHome === true;
+        const canWriteCustomTools = !this.userProvidedCodexHome || allowWriteWithUserCodexHome;
+        if (this.customTools.length > 0 && !this.customToolsInitialized && canWriteCustomTools) {
+            const toolServiceOwner = resolveToolServiceOwner(this.codexConfig) ?? this;
+            const toolServiceCommand = await getAgentToolServiceCommand(toolServiceOwner, this.customTools, {
+                name: "custom-tools",
+                version: "1.0.0",
+            });
+            this.customToolsInitialized = true;
+            const mcpServersConfig = {
+                "custom-tools": {
+                    command: toolServiceCommand.command,
+                    args: toolServiceCommand.args,
+                    ...(toolServiceCommand.env ? { env: toolServiceCommand.env } : {}),
+                    tool_timeout_sec: DEFAULT_CUSTOM_TOOL_TIMEOUT_SEC,
+                },
+            };
+            let codexHome = this.codexOptions.env?.CODEX_HOME;
+            if (!codexHome) {
+                const fallbackKey = resolveString(this.codexConfig.codexHomeKey);
+                codexHome = resolveCodexHomeDir(undefined, fallbackKey).codexHomeDir;
+                this.codexOptions.env = {
+                    ...(this.codexOptions.env || {}),
+                    CODEX_HOME: codexHome,
+                };
+            }
+            writeCodexConfigUpdates({ mcpServers: mcpServersConfig }, codexHome);
+        }
+        else if (this.customTools.length > 0 && !this.customToolsInitialized && this.userProvidedCodexHome) {
+            console.warn("Custom tools require MCP server configuration in config.toml. " +
+                "Set allowConfigWriteWithUserCodexHome=true or update CODEX_HOME/config.toml manually.");
+        }
+        const { Codex } = await import("@openai/codex-sdk");
+        this.codex = new Codex(this.codexOptions);
+        return this.codex;
+    }
+    buildThreadOptions() {
+        return {
+            ...this.threadOptions,
+            skipGitRepoCheck: true,
+        };
+    }
+    resetEventState() {
+        this.streamBuffer = "";
+        this.isStreamingAssistant = false;
+    }
+    isTextMessageItem(item) {
+        const type = item?.type;
+        return type === "message" || type === "text" || type === "agent_message";
+    }
+    createStartMessage(message) {
+        return { ...message, content: [] };
+    }
+    createChunkMessage(role, delta) {
+        if (role === MessageRole.USER) {
+            return {
+                type: MessageRole.USER,
+                content: [{ type: "text", content: delta }],
+            };
+        }
+        return createAssistantMessage({
+            text: delta,
+            model: this.threadOptions.model,
+        });
+    }
+    buildFallbackMessage(item) {
+        const content = item?.content ??
+            item?.text ??
+            item?.value?.[0]?.text?.value ??
+            item?.text?.value ??
+            stringifyContent(item);
+        return createAssistantMessage({
+            text: typeof content === "string" ? content : stringifyContent(content),
+            model: this.threadOptions.model,
+        });
+    }
+    async run(params) {
+        const events = [];
+        let sessionStarted = false;
+        this.toolCallTracker.reset();
+        this.resetEventState();
+        const { controller, cleanup } = this.createAbortController(params.signal);
+        try {
+            const codex = await this.getCodex();
+            this.thread = codex.startThread(this.buildThreadOptions());
+            const { events: codexEvents } = await this.thread.runStreamed(params.query, {
+                signal: controller.signal,
+            });
+            const messageContents = [];
+            for await (const codexEvent of codexEvents) {
+                if (!sessionStarted && codexEvent?.type === "thread.started") {
+                    const threadId = typeof codexEvent.thread_id === "string"
+                        ? codexEvent.thread_id
+                        : undefined;
+                    await this.emitSessionStart(params, events, threadId);
+                    await this.emitUserItemEvents(params.query, events);
+                    sessionStarted = true;
+                    continue;
+                }
+                if (typeof codexEvent.type === "string" &&
+                    (codexEvent.type.startsWith("thread.") || codexEvent.type.startsWith("turn."))) {
+                    continue;
+                }
+                if (codexEvent.type === "item.updated") {
+                    continue;
+                }
+                if (codexEvent.type === "delta") {
+                    const delta = typeof codexEvent.delta === "string"
+                        ? codexEvent.delta
+                        : stringifyContent(codexEvent.delta ?? "");
+                    if (!this.isStreamingAssistant) {
+                        this.isStreamingAssistant = true;
+                        this.streamBuffer = "";
+                        await this.emitItemStart({ type: MessageRole.ASSISTANT, content: [] }, events);
+                    }
+                    this.streamBuffer += delta;
+                    await this.emitItemChunk(this.createChunkMessage(MessageRole.ASSISTANT, delta), events);
+                    continue;
+                }
+                if (codexEvent.type === "item.started" || codexEvent.type === "item.completed") {
+                    const codexItem = codexEvent.item;
+                    if (codexEvent.type === "item.completed" &&
+                        (codexItem.type === "agent_message" || codexItem.type === "message")) {
+                        messageContents.push(codexItem);
+                    }
+                    const message = this.convertToMessage(codexItem, codexEvent.type);
+                    if (codexEvent.type === "item.completed" &&
+                        this.isStreamingAssistant &&
+                        this.isTextMessageItem(codexItem)) {
+                        const finalMessage = message ??
+                            (this.streamBuffer
+                                ? createAssistantMessage({
+                                    text: this.streamBuffer,
+                                    model: this.threadOptions.model,
+                                })
+                                : this.buildFallbackMessage(codexItem));
+                        await this.emitItemEnd(finalMessage, events);
+                        this.isStreamingAssistant = false;
+                        this.streamBuffer = "";
+                        continue;
+                    }
+                    const finalMessage = message ?? this.buildFallbackMessage(codexItem);
+                    await this.emitItemStart(this.createStartMessage(finalMessage), events);
+                    await this.emitItemChunk(finalMessage, events);
+                    await this.emitItemEnd(finalMessage, events);
+                    continue;
+                }
+                const fallbackMessage = this.buildFallbackMessage(codexEvent);
+                await this.emitItemStart(this.createStartMessage(fallbackMessage), events);
+                await this.emitItemChunk(fallbackMessage, events);
+                await this.emitItemEnd(fallbackMessage, events);
+            }
+            if (this.isStreamingAssistant && this.streamBuffer) {
+                const finalMessage = createAssistantMessage({
+                    text: this.streamBuffer,
+                    model: this.threadOptions.model,
+                });
+                await this.emitItemEnd(finalMessage, events);
+                this.isStreamingAssistant = false;
+                this.streamBuffer = "";
+            }
+            if (this.isAbortRequested()) {
+                await this.emitSessionEnd(events, "aborted");
+                return {
+                    success: false,
+                    error: new Error("Aborted"),
+                    events,
+                };
+            }
+            await this.emitSessionEnd(events);
+            return {
+                success: true,
+                data: { messageContents },
+                events,
+            };
+        }
+        catch (error) {
+            if (this.isAbortRequested()) {
+                await this.emitSessionEnd(events, "aborted");
+                return {
+                    success: false,
+                    error: error,
+                    events,
+                };
+            }
+            await this.emitErrorEvent("run", error, events);
+            await this.emitSessionEnd(events, "error");
+            return {
+                success: false,
+                error: error,
+                events,
+            };
+        }
+        finally {
+            cleanup();
+        }
+    }
+    async runStream(params) {
+        this.toolCallTracker.reset();
+        this.resetEventState();
+        const { controller, cleanup } = this.createAbortController(params.signal);
+        try {
+            const codex = await this.getCodex();
+            this.thread = codex.startThread(this.buildThreadOptions());
+            const { events: codexEvents } = await this.thread.runStreamed(params.query, {
+                signal: controller.signal,
+            });
+            const eventStream = this.createEventStream(codexEvents, params, params.query);
+            return {
+                events: this.wrapEventStream(eventStream, cleanup),
+            };
+        }
+        catch (error) {
+            const aborted = this.isAbortRequested();
+            cleanup();
+            if (aborted) {
+                const sessionEndEvent = await this.emitSessionEnd(undefined, "aborted");
+                return {
+                    events: (async function* () {
+                        yield sessionEndEvent;
+                    })(),
+                };
+            }
+            const errorEvent = await this.emitErrorEvent("runStream", error);
+            const sessionEndEvent = await this.emitSessionEnd(undefined, "error");
+            return {
+                events: (async function* () {
+                    yield errorEvent;
+                    yield sessionEndEvent;
+                })(),
+            };
+        }
+    }
+    async resume(params) {
+        this.toolCallTracker.reset();
+        this.resetEventState();
+        const { controller, cleanup } = this.createAbortController();
+        try {
+            const codex = await this.getCodex();
+            this.thread = codex.resumeThread(params.sessionId);
+            const query = params.query || "Pick up where you left off";
+            const { events: codexEvents } = await this.thread.runStreamed(query, {
+                signal: controller.signal,
+            });
+            const sessionParams = { query: params.query || "[resuming session]", sessionId: params.sessionId };
+            const eventStream = this.createEventStream(codexEvents, sessionParams, params.query);
+            return {
+                events: this.wrapEventStream(eventStream, cleanup),
+            };
+        }
+        catch (error) {
+            const aborted = this.isAbortRequested();
+            cleanup();
+            if (aborted) {
+                const sessionEndEvent = await this.emitSessionEnd(undefined, "aborted");
+                return {
+                    events: (async function* () {
+                        yield sessionEndEvent;
+                    })(),
+                };
+            }
+            const errorEvent = await this.emitErrorEvent("resume", error, undefined, {
+                threadId: params.sessionId,
+            });
+            const sessionEndEvent = await this.emitSessionEnd(undefined, "error");
+            return {
+                events: (async function* () {
+                    yield errorEvent;
+                    yield sessionEndEvent;
+                })(),
+            };
+        }
+    }
+    async *createEventStream(codexEvents, sessionParams, userQuery) {
+        let endReason;
+        let sessionStarted = false;
+        try {
+            for await (const codexEvent of codexEvents) {
+                if (!sessionStarted && codexEvent?.type === "thread.started") {
+                    const threadId = typeof codexEvent.thread_id === "string"
+                        ? codexEvent.thread_id
+                        : undefined;
+                    const sessionStartEvent = await this.emitSessionStart(sessionParams, undefined, threadId);
+                    yield sessionStartEvent;
+                    const userEvents = await this.emitUserItemEvents(userQuery);
+                    for (const event of userEvents) {
+                        yield event;
+                    }
+                    sessionStarted = true;
+                    continue;
+                }
+                if (typeof codexEvent.type === "string" &&
+                    (codexEvent.type.startsWith("thread.") || codexEvent.type.startsWith("turn."))) {
+                    continue;
+                }
+                if (codexEvent.type === "item.updated") {
+                    continue;
+                }
+                if (codexEvent.type === "delta") {
+                    const delta = typeof codexEvent.delta === "string"
+                        ? codexEvent.delta
+                        : stringifyContent(codexEvent.delta ?? "");
+                    if (!this.isStreamingAssistant) {
+                        this.isStreamingAssistant = true;
+                        this.streamBuffer = "";
+                        const startEvent = await this.emitItemStart({ type: MessageRole.ASSISTANT, content: [] });
+                        yield startEvent;
+                    }
+                    this.streamBuffer += delta;
+                    const chunkEvent = await this.emitItemChunk(this.createChunkMessage(MessageRole.ASSISTANT, delta));
+                    yield chunkEvent;
+                    continue;
+                }
+                if (codexEvent.type === "item.started" || codexEvent.type === "item.completed") {
+                    const codexItem = codexEvent.item;
+                    const message = this.convertToMessage(codexItem, codexEvent.type);
+                    if (codexEvent.type === "item.completed" &&
+                        this.isStreamingAssistant &&
+                        this.isTextMessageItem(codexItem)) {
+                        const finalMessage = message ??
+                            (this.streamBuffer
+                                ? createAssistantMessage({
+                                    text: this.streamBuffer,
+                                    model: this.threadOptions.model,
+                                })
+                                : this.buildFallbackMessage(codexItem));
+                        const endEvent = await this.emitItemEnd(finalMessage);
+                        yield endEvent;
+                        this.isStreamingAssistant = false;
+                        this.streamBuffer = "";
+                        continue;
+                    }
+                    const finalMessage = message ?? this.buildFallbackMessage(codexItem);
+                    const startEvent = await this.emitItemStart(this.createStartMessage(finalMessage));
+                    yield startEvent;
+                    const chunkEvent = await this.emitItemChunk(finalMessage);
+                    yield chunkEvent;
+                    const endEvent = await this.emitItemEnd(finalMessage);
+                    yield endEvent;
+                    continue;
+                }
+                const fallbackMessage = this.buildFallbackMessage(codexEvent);
+                const startEvent = await this.emitItemStart(this.createStartMessage(fallbackMessage));
+                yield startEvent;
+                const chunkEvent = await this.emitItemChunk(fallbackMessage);
+                yield chunkEvent;
+                const endEvent = await this.emitItemEnd(fallbackMessage);
+                yield endEvent;
+            }
+            if (this.isStreamingAssistant && this.streamBuffer) {
+                const finalMessage = createAssistantMessage({
+                    text: this.streamBuffer,
+                    model: this.threadOptions.model,
+                });
+                const endEvent = await this.emitItemEnd(finalMessage);
+                yield endEvent;
+                this.isStreamingAssistant = false;
+                this.streamBuffer = "";
+            }
+        }
+        catch (error) {
+            if (this.isAbortRequested()) {
+                endReason = "aborted";
+            }
+            else {
+                const errorEvent = {
+                    type: "error",
+                    ...this.createBaseEvent(),
+                    error: error,
+                    context: { stage: "streamIteration" },
+                };
+                await this.emit(errorEvent);
+                yield errorEvent;
+                endReason = "error";
+            }
+        }
+        if (!endReason && this.isAbortRequested()) {
+            endReason = "aborted";
+        }
+        const sessionEndEvent = await this.emitSessionEnd(undefined, endReason);
+        yield sessionEndEvent;
+    }
+    getThread() {
+        return this.thread;
+    }
+    resetThread() {
+        this.thread = undefined;
+    }
+    getSessionDir() {
+        return this.codexHomeDir;
+    }
+    convertToMessage(codexItem, eventType) {
+        let msg = null;
+        switch (codexItem.type) {
+            case "message":
+            case "text":
+            case "agent_message":
+                const textContent = codexItem.text || codexItem.content;
+                if (textContent) {
+                    msg = createAssistantMessage({ text: textContent, model: this.threadOptions.model });
+                }
+                break;
+            case "reasoning":
+                if (codexItem.content || codexItem.text) {
+                    msg = createAssistantMessage({
+                        thinking: {
+                            content: codexItem.content || codexItem.text,
+                        },
+                        model: this.threadOptions.model,
+                    });
+                }
+                break;
+            case "mcp_tool_call": {
+                const innerItem = codexItem.item ?? codexItem;
+                const itemRecord = innerItem;
+                const status = innerItem.status ?? codexItem.status;
+                const toolLabel = typeof innerItem.tool === "string" && innerItem.tool.length > 0
+                    ? innerItem.tool
+                    : undefined;
+                const serverLabel = typeof innerItem.server === "string" && innerItem.server.length > 0
+                    ? innerItem.server
+                    : undefined;
+                const fallbackName = toolLabel
+                    ? (serverLabel ? `${serverLabel}.${toolLabel}` : toolLabel)
+                    : serverLabel ?? "mcp_tool_call";
+                const isCompletedEvent = eventType === "item.completed";
+                const isCompletedStatus = status === "completed" || status === "error";
+                if (isCompletedEvent || isCompletedStatus) {
+                    const isError = status === "error" ||
+                        innerItem.is_error ||
+                        innerItem.isError ||
+                        codexItem.is_error ||
+                        codexItem.isError ||
+                        Boolean(innerItem.error ?? codexItem.error);
+                    let outputSource = innerItem.result ??
+                        innerItem.output ??
+                        innerItem.content ??
+                        innerItem.text ??
+                        codexItem.result ??
+                        codexItem.output ??
+                        codexItem.content ??
+                        codexItem.text ??
+                        "";
+                    if (outputSource &&
+                        typeof outputSource === "object" &&
+                        "content" in outputSource) {
+                        const outputRecord = outputSource;
+                        outputSource = outputRecord.content ?? outputSource;
+                    }
+                    const output = stringifyContent(outputSource);
+                    const { id: toolUseId } = this.toolCallTracker.resolveToolResult(itemRecord, fallbackName);
+                    msg = createToolCallResultMessage([
+                        {
+                            tool_use_id: toolUseId,
+                            content: output,
+                            isError,
+                        },
+                    ]);
+                    break;
+                }
+                const argsValue = innerItem.arguments ?? innerItem.input ?? innerItem.args ?? {};
+                const args = typeof argsValue === "string"
+                    ? argsValue
+                    : stringifyContent(argsValue ?? {});
+                const { id, name } = this.toolCallTracker.registerToolUse(itemRecord, fallbackName);
+                const toolUse = {
+                    id,
+                    name,
+                    args,
+                };
+                msg = createAssistantMessage({ toolCalls: [toolUse], model: this.threadOptions.model });
+                break;
+            }
+            case "command_execution":
+            case "item.started": {
+                const innerItem = codexItem.item ?? codexItem;
+                const command = innerItem.command ?? codexItem.command;
+                const itemRecord = innerItem;
+                const fallbackName = command
+                    ? "Bash"
+                    : typeof innerItem.type === "string"
+                        ? innerItem.type
+                        : "tool";
+                const status = innerItem.status ?? codexItem.status;
+                const exitCode = typeof innerItem.exit_code === "number"
+                    ? innerItem.exit_code
+                    : typeof innerItem.exitCode === "number"
+                        ? innerItem.exitCode
+                        : undefined;
+                const isCompletedEvent = eventType === "item.completed";
+                const isCompletedStatus = status === "completed" || status === "error";
+                if (isCompletedEvent || isCompletedStatus) {
+                    const isError = status === "error" ||
+                        innerItem.is_error ||
+                        innerItem.isError ||
+                        codexItem.is_error ||
+                        codexItem.isError ||
+                        (exitCode !== undefined && exitCode !== 0);
+                    let output = innerItem.aggregated_output ??
+                        innerItem.output ??
+                        innerItem.result ??
+                        innerItem.stdout ??
+                        innerItem.stderr ??
+                        innerItem.content ??
+                        innerItem.text ??
+                        codexItem.content ??
+                        codexItem.text ??
+                        "";
+                    if (command && output === command) {
+                        output = "";
+                    }
+                    if (output !== undefined && output !== null && typeof output !== "string") {
+                        output = stringifyContent(output);
+                    }
+                    else if (!output) {
+                        output = "";
+                    }
+                    const { id: toolUseId } = this.toolCallTracker.resolveToolResult(itemRecord, fallbackName);
+                    msg = createToolCallResultMessage([
+                        {
+                            tool_use_id: toolUseId,
+                            content: output,
+                            isError,
+                        },
+                    ]);
+                    break;
+                }
+                if (command) {
+                    const { id } = this.toolCallTracker.registerToolUse(itemRecord, "Bash");
+                    const toolUse = {
+                        id,
+                        name: "Bash",
+                        args: JSON.stringify({ command }),
+                    };
+                    msg = createAssistantMessage({ toolCalls: [toolUse], model: this.threadOptions.model });
+                }
+                else if (innerItem.type && !innerItem.type.includes('.')) {
+                    const { id, name } = this.toolCallTracker.registerToolUse(itemRecord, fallbackName);
+                    const toolUse = {
+                        id,
+                        name,
+                        args: JSON.stringify(innerItem),
+                    };
+                    msg = createAssistantMessage({ toolCalls: [toolUse], model: this.threadOptions.model });
+                }
+                break;
+            }
+            case "function_call":
+            case "tool_call":
+            case "tool_use":
+            case "apply_patch": {
+                const toolRecord = codexItem;
+                const { id, name } = this.toolCallTracker.registerToolUse(toolRecord);
+                const toolUse = buildToolUseFromRecord(toolRecord, id);
+                toolUse.id = id;
+                toolUse.name = name;
+                msg = createAssistantMessage({ toolCalls: [toolUse], model: this.threadOptions.model });
+                break;
+            }
+            case "function_output":
+            case "tool_output":
+            case "tool_result":
+                const outputRecord = codexItem;
+                const { id: outputToolUseId } = this.toolCallTracker.resolveToolResult(outputRecord);
+                msg = createToolCallResultMessage([
+                    {
+                        tool_use_id: outputToolUseId,
+                        content: stringifyContent(codexItem.content || codexItem.output || codexItem.text || ""),
+                        isError: codexItem.is_error || codexItem.isError || false,
+                    },
+                ]);
+                break;
+            default: {
+                if (codexItem.type && !codexItem.type.includes('.')) {
+                    const fallbackName = typeof codexItem.type === "string" ? codexItem.type : "tool";
+                    const { id: itemId } = this.toolCallTracker.resolveToolResult(codexItem, fallbackName);
+                    const isError = codexItem.status === "error" || codexItem.is_error || codexItem.isError || false;
+                    const result = stringifyContent(codexItem.content || codexItem.output || codexItem.text || codexItem);
+                    msg = createToolCallResultMessage([
+                        {
+                            tool_use_id: itemId,
+                            content: result,
+                            isError,
+                        },
+                    ]);
+                    break;
+                }
+                const defaultText = codexItem.content || codexItem.text;
+                if (defaultText) {
+                    msg = createAssistantMessage({
+                        text: defaultText,
+                        model: this.threadOptions.model,
+                    });
+                }
+                break;
+            }
+        }
+        const parentToolUseId = typeof codexItem?.parent_tool_use_id === "string"
+            ? codexItem.parent_tool_use_id
+            : typeof codexItem?.parentToolUseId === "string"
+                ? codexItem.parentToolUseId
+                : undefined;
+        if (msg && parentToolUseId) {
+            msg = { ...msg, parent_tool_use_id: parentToolUseId };
+        }
+        return msg ? normalizeMessage(this.applyParentToolUseId(msg)) : null;
+    }
+    cleanup() {
+        if (!this.userProvidedCodexHome && this.codexHomeDir) {
+            try {
+                fs.rmSync(this.codexHomeDir, { recursive: true, force: true });
+            }
+            catch (error) {
+                console.warn(`[CodexClient] Failed to remove CODEX_HOME at ${this.codexHomeDir}:`, error);
+            }
+        }
+    }
+    [Symbol.dispose]() {
+        this.cleanup();
+    }
+}
+function resolveModelName(explicitModel, fileModel) {
+    if (explicitModel) {
+        return explicitModel;
+    }
+    if (!fileModel) {
+        return undefined;
+    }
+    if (typeof fileModel === "string") {
+        return fileModel;
+    }
+    if (typeof fileModel === "object" && fileModel !== null && "name" in fileModel) {
+        const name = fileModel.name;
+        return typeof name === "string" && name.length > 0 ? name : undefined;
+    }
+    return undefined;
+}
+function resolveAgentSystemPrompt(agents) {
+    if (!isRecord(agents)) {
+        return undefined;
+    }
+    const entries = Object.entries(agents);
+    if (entries.length !== 1) {
+        return undefined;
+    }
+    const agent = entries[0]?.[1];
+    if (!isRecord(agent)) {
+        return undefined;
+    }
+    const otherConfig = isRecord(agent.otherConfig)
+        ? agent.otherConfig
+        : undefined;
+    const codexPrompt = resolveString(otherConfig?.developer_instructions);
+    if (codexPrompt) {
+        return codexPrompt;
+    }
+    return resolveString(agent.systemPrompt ??
+        agent.prompt);
+}
+function mapPermissionModeToSandboxMode(permissionMode) {
+    if (!permissionMode) {
+        return undefined;
+    }
+    switch (permissionMode) {
+        case "acceptEdits":
+            return "workspace-write";
+        case "bypassPermissions":
+            return "danger-full-access";
+        case "auto":
+        case "default":
+        case "dontAsk":
+        case "plan":
+            return "read-only";
+        default:
+            return undefined;
+    }
+}
+function resolveString(value) {
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function resolveStringArray(value) {
+    if (!value) {
+        return [];
+    }
+    if (Array.isArray(value)) {
+        return value.filter((item) => typeof item === "string" && item.length > 0);
+    }
+    if (typeof value === "string" && value.length > 0) {
+        return [value];
+    }
+    return [];
+}
+function resolveMcpServers(value) {
+    if (!isRecord(value)) {
+        return undefined;
+    }
+    return value;
+}
+function buildModelProviderOverride(sdkConfig, env) {
+    if (!isRecord(sdkConfig)) {
+        return undefined;
+    }
+    const providersValue = sdkConfig.model_providers;
+    if (!isRecord(providersValue)) {
+        return undefined;
+    }
+    const openaiProvider = providersValue.openai;
+    if (!isRecord(openaiProvider)) {
+        return undefined;
+    }
+    const httpHeaders = openaiProvider.http_headers;
+    const envHttpHeaders = openaiProvider.env_http_headers;
+    const hasHttpHeaders = isRecord(httpHeaders) && Object.keys(httpHeaders).length > 0;
+    const hasEnvHttpHeaders = isRecord(envHttpHeaders) && Object.keys(envHttpHeaders).length > 0;
+    if (!hasHttpHeaders && !hasEnvHttpHeaders) {
+        return undefined;
+    }
+    const providerName = "openai-custom";
+    const providerConfig = {
+        name: "OpenAI custom",
+        wire_api: "responses",
+        requires_openai_auth: true,
+        supports_websockets: true,
+    };
+    const baseUrl = env.OPENAI_BASE_URL ?? process.env.OPENAI_BASE_URL;
+    if (typeof baseUrl === "string" && baseUrl.length > 0) {
+        providerConfig.base_url = baseUrl;
+    }
+    else {
+        console.warn("OPENAI_BASE_URL is not set; openai-custom provider base_url is unset.");
+    }
+    if (hasHttpHeaders) {
+        providerConfig.http_headers = httpHeaders;
+    }
+    if (hasEnvHttpHeaders) {
+        providerConfig.env_http_headers = envHttpHeaders;
+    }
+    return { name: providerName, config: providerConfig };
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}
+function safeExtractCustomTools(tools) {
+    if (tools === undefined || tools === null) {
+        return [];
+    }
+    if (Array.isArray(tools)) {
+        if (tools.every((tool) => typeof tool === "string")) {
+            return [];
+        }
+        if (tools.every(isRegisteredTool)) {
+            return extractCustomTools(tools);
+        }
+    }
+    if (isRegisteredTool(tools)) {
+        return extractCustomTools(tools);
+    }
+    throw new Error("Tools must be RegisteredTool instances created by defineTool");
+}
+//# sourceMappingURL=codex-client.js.map