coding-agents-sdk 0.0.1 → 0.2.0

package/dist/adapters/codex-cli/index.mjs

@@ -0,0 +1,626 @@
+import { n as AgentValidationError } from "../../types-aNMD8h3x.mjs";
+import { a as toArray, i as sumTokens, n as isRecord, r as parseJsonResponseText } from "../../util-B4RQZkKr.mjs";
+import { c as getInputText, l as toTextPart, o as createAgentEvent, s as createEventParser } from "../../classify-error-pL6jeu4T.mjs";
+import { t as Agent } from "../../Agent-D8WkUilj.mjs";
+import { z } from "zod/v4";
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+//#region src/adapters/codex-cli/events/schemas.ts
+const codexEventSchema = z.object({ type: z.string() }).passthrough();
+const codexUsageSchema = z.object({
+	input_tokens: z.number().optional(),
+	cached_input_tokens: z.number().optional(),
+	output_tokens: z.number().optional(),
+	reasoning_output_tokens: z.number().optional(),
+	total_tokens: z.number().optional()
+}).passthrough();
+const codexThreadStartedEventSchema = z.object({
+	type: z.literal("thread.started"),
+	thread_id: z.string()
+}).passthrough();
+const codexTurnCompletedEventSchema = z.object({
+	type: z.literal("turn.completed"),
+	usage: codexUsageSchema.optional(),
+	last_agent_message: z.string().optional(),
+	duration_ms: z.number().optional(),
+	num_turns: z.number().optional()
+}).passthrough();
+const codexTurnFailedEventSchema = z.object({
+	type: z.literal("turn.failed"),
+	usage: codexUsageSchema.optional(),
+	last_agent_message: z.string().optional(),
+	duration_ms: z.number().optional(),
+	num_turns: z.number().optional(),
+	message: z.string().optional(),
+	error: z.unknown().optional()
+}).passthrough();
+const codexItemSchema = z.object({
+	id: z.string(),
+	type: z.string()
+}).passthrough();
+const codexItemStartedEventSchema = z.object({
+	type: z.literal("item.started"),
+	item: codexItemSchema
+}).passthrough();
+const codexItemUpdatedEventSchema = z.object({
+	type: z.literal("item.updated"),
+	item: codexItemSchema
+}).passthrough();
+const codexItemCompletedEventSchema = z.object({
+	type: z.literal("item.completed"),
+	item: codexItemSchema
+}).passthrough();
+const codexErrorEventSchema = z.object({
+	type: z.literal("error"),
+	message: z.string().optional(),
+	error: z.unknown().optional()
+}).passthrough();
+//#endregion
+//#region src/adapters/codex-cli/events/mappers.ts
+const asRecord = (value) => {
+	return isRecord(value) ? value : void 0;
+};
+const getValue = (record, keys) => {
+	if (!record) return void 0;
+	for (const key of keys) if (key in record) return record[key];
+};
+const getString = (record, keys) => {
+	const value = getValue(record, keys);
+	return typeof value === "string" ? value : void 0;
+};
+const getNumber = (record, keys) => {
+	const value = getValue(record, keys);
+	return typeof value === "number" ? value : void 0;
+};
+const getCompactObject = (value) => {
+	const entries = Object.entries(value).filter(([, entry]) => entry !== void 0);
+	if (entries.length === 0) return;
+	return Object.fromEntries(entries);
+};
+const normalizeItemType = (value) => {
+	return value.replace(/([\da-z])([A-Z])/g, "$1_$2").toLowerCase();
+};
+const getErrorMessage = (value, fallback) => {
+	if (typeof value === "string" && value.trim() !== "") return value;
+	const record = asRecord(value);
+	if (!record) return fallback;
+	return getString(record, [
+		"message",
+		"error",
+		"status_message"
+	]) ?? getString(asRecord(record.additional_details), ["message"]) ?? fallback;
+};
+const toStats = (event) => {
+	const usage = asRecord(event.usage);
+	const inputTokens = getNumber(usage, ["input_tokens"]);
+	const cacheReadInputTokens = getNumber(usage, ["cached_input_tokens"]);
+	const outputTokens = getNumber(usage, ["output_tokens"]);
+	const reasoningOutputTokens = getNumber(usage, ["reasoning_output_tokens"]);
+	const totalTokens = getNumber(usage, ["total_tokens"]) ?? sumTokens(inputTokens, cacheReadInputTokens, outputTokens, reasoningOutputTokens);
+	return {
+		durationMs: getNumber(event, ["duration_ms", "durationMs"]) ?? 0,
+		apiDurationMs: getNumber(event, ["duration_ms", "durationMs"]) ?? 0,
+		turns: getNumber(event, ["num_turns", "numTurns"]) ?? 1,
+		costUsd: 0,
+		inputTokens,
+		cacheReadInputTokens,
+		outputTokens,
+		totalTokens
+	};
+};
+const getCommandToolRecord = (item) => ({
+	toolName: "Bash",
+	input: getCompactObject({
+		command: getString(item, ["command"]),
+		cwd: getString(item, ["cwd", "working_directory"]),
+		parsedCommand: getValue(item, ["parsed_cmd", "parsedCommand"])
+	})
+});
+const getMcpToolRecord = (item) => {
+	const toolName = getString(item, ["tool", "tool_name"]) ?? "mcp_tool_call";
+	const server = getString(item, ["server"]);
+	const argumentsValue = getValue(item, [
+		"arguments",
+		"invocation",
+		"input"
+	]);
+	return {
+		toolName,
+		input: server === void 0 ? argumentsValue : getCompactObject({
+			server,
+			arguments: argumentsValue
+		})
+	};
+};
+const getWebSearchToolRecord = (item) => ({
+	toolName: "WebSearch",
+	input: getCompactObject({
+		query: getString(item, ["query"]),
+		action: getValue(item, ["action"])
+	})
+});
+const getToolErrorState = (item) => {
+	const status = getString(item, ["status"]);
+	const exitCode = getNumber(item, ["exit_code", "exitCode"]);
+	const error = getString(item, ["error"]) ?? getString(asRecord(item.result), ["error"]);
+	return {
+		isError: status === "error" || status === "failed" || status === "errored" || status === "interrupted" || exitCode !== void 0 && exitCode !== 0 || error !== void 0,
+		error
+	};
+};
+const mapThreadStartedEvent = (event) => ({
+	events: [],
+	sessionId: event.thread_id
+});
+const mapTurnCompletedEvent = (event, context) => {
+	const state = {
+		stats: toStats(event),
+		status: "completed"
+	};
+	if (event.last_agent_message !== void 0) state.output = { text: event.last_agent_message };
+	if (context.schemaRequested && event.last_agent_message) try {
+		state.output = {
+			...state.output,
+			value: parseJsonResponseText(event.last_agent_message)
+		};
+	} catch {}
+	return {
+		events: [],
+		state
+	};
+};
+const mapTurnFailedEvent = (event) => ({
+	events: [],
+	state: {
+		stats: toStats(event),
+		status: "failed",
+		output: event.last_agent_message === void 0 ? void 0 : { text: event.last_agent_message },
+		error: {
+			kind: "provider",
+			message: getErrorMessage(event.error ?? event.message, "Codex turn failed.")
+		}
+	}
+});
+const mapErrorEvent = (event) => ({
+	events: [],
+	state: {
+		status: "failed",
+		error: {
+			kind: "provider",
+			message: getErrorMessage(event.error ?? event.message, "Codex emitted an error event.")
+		}
+	}
+});
+const mapToolCallStart = (item, context, toolRecord, options) => {
+	const toolCallId = getString(item, ["id"]);
+	if (!toolCallId) return { events: [] };
+	return {
+		events: [createAgentEvent(context.runId, "tool-call", {
+			sessionId: context.sessionId,
+			model: options.model ?? null,
+			toolCallId,
+			toolName: toolRecord.toolName,
+			input: toolRecord.input
+		})],
+		toolCalls: [{
+			toolCallId,
+			toolName: toolRecord.toolName,
+			input: toolRecord.input
+		}]
+	};
+};
+const getCommandOutput = (item) => getValue(item, [
+	"aggregated_output",
+	"aggregatedOutput",
+	"output",
+	"result",
+	"text"
+]) ?? "";
+const getMcpOutput = (item) => getValue(item, ["result", "output"]) ?? getString(item, ["error"]) ?? "";
+const getWebSearchOutput = (item) => getValue(item, [
+	"results",
+	"result",
+	"action"
+]) ?? "";
+const mapToolResultCompletion = (item, context, toolRecord, output, options) => {
+	const toolCallId = getString(item, ["id"]);
+	if (!toolCallId) return { events: [] };
+	const priorToolCall = context.toolCalls.get(toolCallId);
+	const resolvedTool = priorToolCall ?? toolRecord;
+	const errorState = getToolErrorState(item);
+	const events = [];
+	const toolCalls = [];
+	if (!priorToolCall) {
+		events.push(createAgentEvent(context.runId, "tool-call", {
+			sessionId: context.sessionId,
+			model: options.model ?? null,
+			toolCallId,
+			toolName: toolRecord.toolName,
+			input: toolRecord.input
+		}));
+		toolCalls.push({
+			toolCallId,
+			toolName: toolRecord.toolName,
+			input: toolRecord.input
+		});
+	}
+	events.push(createAgentEvent(context.runId, "tool-result", {
+		sessionId: context.sessionId,
+		toolCallId,
+		toolName: resolvedTool.toolName,
+		input: resolvedTool.input,
+		output,
+		isError: errorState.isError || void 0,
+		error: errorState.error
+	}));
+	return {
+		events,
+		toolCalls
+	};
+};
+const getReasoningText = (item) => {
+	const directText = getString(item, [
+		"summary_text",
+		"reasoning_text",
+		"text",
+		"summary",
+		"raw_content"
+	]);
+	if (directText) return directText;
+	const summaryParts = getValue(item, ["summary"]);
+	if (Array.isArray(summaryParts)) {
+		const joined = summaryParts.flatMap((part) => {
+			if (typeof part === "string") return [part];
+			const text = getString(asRecord(part), ["text", "summary_text"]);
+			return text ? [text] : [];
+		}).join("\n");
+		if (joined) return joined;
+	}
+};
+const cacheItem = (item, options) => {
+	const id = getString(item, ["id"]);
+	if (!id || !options.itemCache) return;
+	const existing = options.itemCache.get(id);
+	options.itemCache.set(id, existing ? {
+		...existing,
+		...item
+	} : { ...item });
+};
+const mergeWithCached = (item, options) => {
+	const id = getString(item, ["id"]);
+	if (!id || !options.itemCache) return item;
+	const cached = options.itemCache.get(id);
+	options.itemCache.delete(id);
+	if (!cached) return item;
+	return {
+		...cached,
+		...item
+	};
+};
+const mapItemStartedEvent = (event, context, options) => {
+	const item = asRecord(event.item);
+	if (!item) return { events: [] };
+	cacheItem(item, options);
+	switch (normalizeItemType(getString(item, ["type"]) ?? "")) {
+		case "command_execution": return mapToolCallStart(item, context, getCommandToolRecord(item), options);
+		case "mcp_tool_call": return mapToolCallStart(item, context, getMcpToolRecord(item), options);
+		case "web_search": return mapToolCallStart(item, context, getWebSearchToolRecord(item), options);
+		default: return { events: [] };
+	}
+};
+const mapItemUpdatedEvent = (event, options) => {
+	const item = asRecord(event.item);
+	if (item) cacheItem(item, options);
+	return { events: [] };
+};
+const mapItemCompletedEvent = (event, context, options) => {
+	const rawItem = asRecord(event.item);
+	if (!rawItem) return { events: [] };
+	const item = mergeWithCached(rawItem, options);
+	switch (normalizeItemType(getString(item, ["type"]) ?? "")) {
+		case "agent_message": {
+			const text = getString(item, ["text"]);
+			if (!text) return { events: [] };
+			const isFinalAnswer = context.schemaRequested && (getString(item, ["phase"]) === void 0 || getString(item, ["phase"]) === "final_answer");
+			let parsedOutput;
+			if (isFinalAnswer) try {
+				parsedOutput = parseJsonResponseText(text);
+			} catch {}
+			return {
+				events: [createAgentEvent(context.runId, "message", {
+					sessionId: context.sessionId,
+					model: options.model ?? null,
+					role: "assistant",
+					content: [toTextPart(text)],
+					text
+				})],
+				state: { output: {
+					text,
+					...parsedOutput === void 0 ? {} : { value: parsedOutput }
+				} }
+			};
+		}
+		case "reasoning": {
+			const text = getReasoningText(item);
+			if (!text) return { events: [] };
+			return { events: [createAgentEvent(context.runId, "reasoning", {
+				sessionId: context.sessionId,
+				model: options.model ?? null,
+				content: [toTextPart(text)],
+				text
+			})] };
+		}
+		case "command_execution": return mapToolResultCompletion(item, context, getCommandToolRecord(item), getCommandOutput(item), options);
+		case "mcp_tool_call": return mapToolResultCompletion(item, context, getMcpToolRecord(item), getMcpOutput(item), options);
+		case "web_search": return mapToolResultCompletion(item, context, getWebSearchToolRecord(item), getWebSearchOutput(item), options);
+		default: return { events: [] };
+	}
+};
+function mapCodexEventDetailed(event, context, options = {}) {
+	const threadStarted = codexThreadStartedEventSchema.safeParse(event);
+	if (threadStarted.success) return {
+		batch: mapThreadStartedEvent(threadStarted.data),
+		disposition: "mapped"
+	};
+	if (event.type === "turn.started") return {
+		batch: { events: [] },
+		disposition: "known-ignored"
+	};
+	const turnCompleted = codexTurnCompletedEventSchema.safeParse(event);
+	if (turnCompleted.success) return {
+		batch: mapTurnCompletedEvent(turnCompleted.data, context),
+		disposition: "mapped"
+	};
+	const turnFailed = codexTurnFailedEventSchema.safeParse(event);
+	if (turnFailed.success) return {
+		batch: mapTurnFailedEvent(turnFailed.data),
+		disposition: "mapped"
+	};
+	const errorEvent = codexErrorEventSchema.safeParse(event);
+	if (errorEvent.success) return {
+		batch: mapErrorEvent(errorEvent.data),
+		disposition: "mapped"
+	};
+	const itemStarted = codexItemStartedEventSchema.safeParse(event);
+	if (itemStarted.success) {
+		const batch = mapItemStartedEvent(itemStarted.data, context, options);
+		return {
+			batch,
+			disposition: batch.events.length > 0 || (batch.toolCalls?.length ?? 0) > 0 ? "mapped" : "known-ignored"
+		};
+	}
+	const itemUpdated = codexItemUpdatedEventSchema.safeParse(event);
+	if (itemUpdated.success) return {
+		batch: mapItemUpdatedEvent(itemUpdated.data, options),
+		disposition: "known-ignored"
+	};
+	const itemCompleted = codexItemCompletedEventSchema.safeParse(event);
+	if (itemCompleted.success) {
+		const batch = mapItemCompletedEvent(itemCompleted.data, context, options);
+		return {
+			batch,
+			disposition: batch.events.length > 0 || batch.state !== void 0 || (batch.toolCalls?.length ?? 0) > 0 || batch.sessionId !== void 0 ? "mapped" : "known-ignored"
+		};
+	}
+	switch (event.type) {
+		case "thread.started":
+		case "turn.started":
+		case "turn.completed":
+		case "turn.failed":
+		case "item.started":
+		case "item.updated":
+		case "item.completed":
+		case "error": return {
+			batch: { events: [] },
+			disposition: "known-malformed"
+		};
+		default: return {
+			batch: { events: [] },
+			disposition: "unknown"
+		};
+	}
+}
+//#endregion
+//#region src/adapters/codex-cli/events/parser.ts
+const parseCodexEvent = createEventParser(codexEventSchema);
+//#endregion
+//#region src/adapters/codex-cli/adapter.ts
+const CODEX_CLI_CAPABILITIES = {
+	structuredOutput: true,
+	sessionResume: true,
+	imageInput: false,
+	mcp: true,
+	eventStreaming: true
+};
+const isSafeKey = (value) => /^\w+$/.test(value);
+const formatConfigKey = (value) => isSafeKey(value) ? value : JSON.stringify(value);
+const joinConfigPath = (...parts) => parts.map(formatConfigKey).join(".");
+const fmtValue = (value) => JSON.stringify(value);
+const fmtArray = (values) => `[${values.map((v) => JSON.stringify(v)).join(",")}]`;
+const mcpServersToConfigArgs = (servers) => {
+	const args = [];
+	for (const [name, server] of Object.entries(servers)) {
+		const base = joinConfigPath("mcp_servers", name);
+		if (server.url) args.push("--config", `${base}.url=${fmtValue(server.url)}`);
+		if (server.command) args.push("--config", `${base}.command=${fmtValue(server.command)}`);
+		if (server.args && server.args.length > 0) args.push("--config", `${base}.args=${fmtArray(server.args)}`);
+		if (server.cwd) args.push("--config", `${base}.cwd=${fmtValue(server.cwd)}`);
+		if (server.headers) for (const [key, value] of Object.entries(server.headers)) args.push("--config", `${joinConfigPath("mcp_servers", name, "http_headers", key)}=${fmtValue(value)}`);
+		if (server.env) for (const [key, value] of Object.entries(server.env)) args.push("--config", `${joinConfigPath("mcp_servers", name, "env", key)}=${fmtValue(value)}`);
+	}
+	return args;
+};
+const readStringArray = (value, label) => {
+	if (value === void 0) return;
+	if (!Array.isArray(value) || value.some((entry) => typeof entry !== "string")) throw new AgentValidationError(`${label} must be an array of strings.`);
+	return [...value];
+};
+const readStringRecord = (value, label) => {
+	if (value === void 0) return;
+	if (!isRecord(value) || Array.isArray(value)) throw new AgentValidationError(`${label} must be an object.`);
+	const result = {};
+	for (const [key, entry] of Object.entries(value)) {
+		if (typeof entry !== "string") throw new AgentValidationError(`${label}.${key} must be a string.`);
+		result[key] = entry;
+	}
+	return result;
+};
+const readMcpServerConfig = (value, label) => {
+	if (!isRecord(value) || Array.isArray(value)) throw new AgentValidationError(`${label} must be an object.`);
+	const command = value.command;
+	const url = value.url;
+	const cwd = value.cwd;
+	if (command !== void 0 && typeof command !== "string") throw new AgentValidationError(`${label}.command must be a string.`);
+	if (url !== void 0 && typeof url !== "string") throw new AgentValidationError(`${label}.url must be a string.`);
+	if (cwd !== void 0 && typeof cwd !== "string") throw new AgentValidationError(`${label}.cwd must be a string.`);
+	return {
+		command,
+		url,
+		cwd,
+		args: readStringArray(value.args, `${label}.args`),
+		env: readStringRecord(value.env, `${label}.env`),
+		headers: readStringRecord(value.headers, `${label}.headers`)
+	};
+};
+const readMcpConfig = (configPath) => {
+	let parsed;
+	try {
+		parsed = JSON.parse(readFileSync(configPath, "utf8"));
+	} catch (error) {
+		if (error instanceof Error && "code" in error && error.code === "ENOENT") throw new AgentValidationError(`mcpConfig file not found: ${configPath}`);
+		throw new AgentValidationError(`mcpConfig must be valid JSON: ${configPath}`);
+	}
+	if (!isRecord(parsed) || Array.isArray(parsed)) throw new AgentValidationError(`mcpConfig must contain a JSON object: ${configPath}`);
+	const mcpServers = parsed.mcpServers;
+	if (mcpServers === void 0) return;
+	if (!isRecord(mcpServers) || Array.isArray(mcpServers)) throw new AgentValidationError(`mcpConfig.mcpServers must be an object: ${configPath}`);
+	const parsedServers = {};
+	for (const [name, server] of Object.entries(mcpServers)) parsedServers[name] = readMcpServerConfig(server, `mcpConfig.mcpServers.${name}`);
+	return parsedServers;
+};
+const buildMcpConfigArgs = (configPath) => {
+	const servers = readMcpConfig(configPath);
+	return servers ? mcpServersToConfigArgs(servers) : [];
+};
+var CodexCliAgentImpl = class extends Agent {
+	type = "codex-cli";
+	creationOptions;
+	runDefaults;
+	schemaDirs = /* @__PURE__ */ new Map();
+	runModels = /* @__PURE__ */ new Map();
+	itemCaches = /* @__PURE__ */ new Map();
+	constructor(options = {}) {
+		super({
+			type: "codex-cli",
+			capabilities: CODEX_CLI_CAPABILITIES,
+			defaults: {
+				cwd: options.cwd,
+				env: options.env,
+				command: toArray(options.command ?? "codex"),
+				sessionId: options.sessionId,
+				model: options.model
+			},
+			spawner: options.spawner,
+			container: options.container,
+			logPath: options.logPath,
+			onEvent: options.onEvent
+		});
+		this.creationOptions = options;
+		this.runDefaults = {
+			sandbox: options.sandbox,
+			additionalDirectories: options.additionalDirectories ? [...options.additionalDirectories] : void 0,
+			skipGitRepoCheck: options.skipGitRepoCheck,
+			permissionMode: options.permissionMode,
+			ephemeral: options.ephemeral,
+			mcpConfig: options.mcpConfig,
+			mcpServers: options.mcpServers ? { ...options.mcpServers } : void 0,
+			extraArgs: options.extraArgs ? [...options.extraArgs] : void 0
+		};
+	}
+	onValidateRun(request, _normalizedRequest) {
+		const mcpConfig = request.mcpConfig ?? this.runDefaults.mcpConfig;
+		if (mcpConfig) readMcpConfig(mcpConfig);
+	}
+	buildArgs(request, run) {
+		const args = ["exec", "--json"];
+		const sandbox = request.sandbox ?? this.runDefaults.sandbox;
+		const additionalDirectories = request.additionalDirectories ?? this.runDefaults.additionalDirectories;
+		const skipGitRepoCheck = request.skipGitRepoCheck ?? this.runDefaults.skipGitRepoCheck;
+		const permissionMode = request.permissionMode ?? this.runDefaults.permissionMode;
+		const ephemeral = request.ephemeral ?? this.runDefaults.ephemeral;
+		const extraArgs = request.extraArgs ?? this.runDefaults.extraArgs;
+		this.runModels.set(run.runId, request.model);
+		if (request.model) args.push("--model", request.model);
+		if (sandbox) args.push("--sandbox", sandbox);
+		if (permissionMode === "full-auto") args.push("--full-auto");
+		else if (permissionMode === "full-access") args.push("--dangerously-bypass-approvals-and-sandbox");
+		if (skipGitRepoCheck) args.push("--skip-git-repo-check");
+		if (ephemeral) args.push("--ephemeral");
+		for (const dir of additionalDirectories ?? []) args.push("--add-dir", dir);
+		if (request.schema.kind !== "none") args.push("--output-schema", this.createSchemaFile(run.runId, request.schema.jsonSchema));
+		const mcpConfig = request.mcpConfig ?? this.runDefaults.mcpConfig;
+		if (mcpConfig) args.push(...buildMcpConfigArgs(mcpConfig));
+		const mcpServers = request.mcpServers ?? this.runDefaults.mcpServers;
+		if (mcpServers) args.push(...mcpServersToConfigArgs(mcpServers));
+		if (extraArgs && extraArgs.length > 0) args.push(...extraArgs);
+		if (run.requestedSessionId) args.push("resume", run.requestedSessionId);
+		const inputText = getInputText(request.input);
+		if (inputText.trim().startsWith("-")) args.push("--", inputText);
+		else args.push(inputText);
+		return args;
+	}
+	buildEnv(_request, _run) {
+		return this.buildDefaultEnv(this.creationOptions.propagateEnv);
+	}
+	mapRawEvent(raw, context) {
+		this.appendRawLog(raw);
+		const parsed = parseCodexEvent(raw);
+		if (!parsed) {
+			this.onParseError(JSON.stringify(raw).slice(0, 200), /* @__PURE__ */ new Error("schema validation failed"));
+			return { events: [] };
+		}
+		let itemCache = this.itemCaches.get(context.runId);
+		if (!itemCache) {
+			itemCache = /* @__PURE__ */ new Map();
+			this.itemCaches.set(context.runId, itemCache);
+		}
+		const result = mapCodexEventDetailed(parsed, context, {
+			model: this.runModels.get(context.runId),
+			itemCache
+		});
+		if (result.disposition === "known-malformed") this.onParseError(JSON.stringify(raw).slice(0, 200), /* @__PURE__ */ new Error(`known Codex event "${parsed.type}" did not match the expected payload shape`));
+		return result.batch;
+	}
+	async onRunFinished(run) {
+		await super.onRunFinished(run);
+		this.runModels.delete(run.runId);
+		this.itemCaches.delete(run.runId);
+		const schemaDir = this.schemaDirs.get(run.runId);
+		if (!schemaDir) return;
+		this.schemaDirs.delete(run.runId);
+		rmSync(schemaDir, {
+			recursive: true,
+			force: true
+		});
+	}
+	createSchemaFile(runId, schema) {
+		const schemaDir = mkdtempSync(join(tmpdir(), "coding-agents-sdk-codex-cli-"));
+		const schemaPath = join(schemaDir, "output-schema.json");
+		writeFileSync(schemaPath, JSON.stringify(schema, null, 2), {
+			encoding: "utf8",
+			mode: 384
+		});
+		this.schemaDirs.set(runId, schemaDir);
+		return schemaPath;
+	}
+};
+const createCodexCliAgent = (options) => {
+	if (!options?.container) return new CodexCliAgentImpl(options);
+	return new CodexCliAgentImpl({
+		...options,
+		spawner: options.container.spawner
+	});
+};
+//#endregion
+export { createCodexCliAgent };

package/dist/adapters/codex-sdk/index.d.mts

@@ -0,0 +1,2 @@
+import { a as CodexSdkItem, i as CodexSdkEvent, n as CodexSdkAgent, o as CodexSdkPermissionMode, r as CodexSdkAgentOptions, s as CodexSdkRunOptions, t as createCodexSdkAgent } from "../../index-CFpNOmdA.mjs";
+export { CodexSdkAgent, CodexSdkAgentOptions, CodexSdkEvent, CodexSdkItem, CodexSdkPermissionMode, CodexSdkRunOptions, createCodexSdkAgent };