@openclaw/codex 2026.5.2 → 2026.5.3-beta.2

package/dist/index.js

@@ -0,0 +1,351 @@
+import { createCodexAppServerAgentHarness } from "./harness.js";
+import { buildCodexMediaUnderstandingProvider } from "./media-understanding-provider.js";
+import { buildCodexProvider } from "./provider.js";
+import { n as handleCodexConversationInboundClaim, t as handleCodexConversationBindingResolved } from "./conversation-binding-D12ISGdf.js";
+import { resolveLivePluginConfigObject } from "openclaw/plugin-sdk/plugin-config-runtime";
+import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { resolveAgentConfig, resolveAgentWorkspaceDir, resolveDefaultAgentId } from "openclaw/plugin-sdk/agent-runtime";
+import { MIGRATION_REASON_TARGET_EXISTS, createMigrationItem, createMigrationManualItem, summarizeMigrationItems } from "openclaw/plugin-sdk/migration";
+import { archiveMigrationItem, copyMigrationFileItem, writeMigrationReport } from "openclaw/plugin-sdk/migration-runtime";
+import os from "node:os";
+//#region extensions/codex/src/commands.ts
+function createCodexCommand(options) {
+	return {
+		name: "codex",
+		description: "Inspect and control the Codex app-server harness",
+		ownership: "reserved",
+		agentPromptGuidance: ["Native Codex app-server plugin is available (`/codex ...`). For Codex bind/control/thread/resume/steer/stop requests, prefer `/codex bind`, `/codex threads`, `/codex resume`, `/codex steer`, and `/codex stop` over ACP.", "Use ACP for Codex only when the user explicitly asks for ACP/acpx or wants to test the ACP path."],
+		acceptsArgs: true,
+		requireAuth: true,
+		handler: (ctx) => handleCodexCommand(ctx, options)
+	};
+}
+async function handleCodexCommand(ctx, options = {}) {
+	const { handleCodexSubcommand } = await import("./command-handlers-Dxx2slu2.js");
+	return await handleCodexSubcommand(ctx, options);
+}
+//#endregion
+//#region extensions/codex/src/migration/helpers.ts
+async function exists(filePath) {
+	try {
+		await fs.access(filePath);
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function isDirectory(filePath) {
+	if (!filePath) return false;
+	try {
+		return (await fs.stat(filePath)).isDirectory();
+	} catch {
+		return false;
+	}
+}
+function resolveUserHomeDir() {
+	return process.env.HOME?.trim() || os.homedir();
+}
+function resolveHomePath(value) {
+	if (value === "~") return resolveUserHomeDir();
+	if (value.startsWith("~/")) return path.join(resolveUserHomeDir(), value.slice(2));
+	return path.resolve(value);
+}
+function sanitizeName(value) {
+	return value.trim().toLowerCase().replaceAll(/[^a-z0-9._-]+/gu, "-").replaceAll(/^-+|-+$/gu, "").slice(0, 64);
+}
+async function readJsonObject(filePath) {
+	if (!filePath) return {};
+	try {
+		const parsed = JSON.parse(await fs.readFile(filePath, "utf8"));
+		return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+	} catch {
+		return {};
+	}
+}
+//#endregion
+//#region extensions/codex/src/migration/source.ts
+const SKILL_FILENAME = "SKILL.md";
+const MAX_SCAN_DEPTH = 6;
+const MAX_DISCOVERED_DIRS = 2e3;
+function defaultCodexHome() {
+	return resolveHomePath(process.env.CODEX_HOME?.trim() || "~/.codex");
+}
+function personalAgentsSkillsDir() {
+	return path.join(resolveUserHomeDir(), ".agents", "skills");
+}
+async function safeReadDir(dir) {
+	return await fs.readdir(dir, { withFileTypes: true }).catch(() => []);
+}
+async function discoverSkillDirs(params) {
+	if (!params.root || !await isDirectory(params.root)) return [];
+	const discovered = [];
+	async function visit(dir, depth) {
+		if (discovered.length >= MAX_DISCOVERED_DIRS || depth > MAX_SCAN_DEPTH) return;
+		const name = path.basename(dir);
+		if (params.excludeSystem && depth === 1 && name === ".system") return;
+		if (await exists(path.join(dir, SKILL_FILENAME))) {
+			discovered.push({
+				name,
+				source: dir,
+				sourceLabel: params.sourceLabel
+			});
+			return;
+		}
+		for (const entry of await safeReadDir(dir)) {
+			if (!entry.isDirectory()) continue;
+			await visit(path.join(dir, entry.name), depth + 1);
+		}
+	}
+	await visit(params.root, 0);
+	return discovered;
+}
+async function discoverPluginDirs(codexHome) {
+	const root = path.join(codexHome, "plugins", "cache");
+	if (!await isDirectory(root)) return [];
+	const discovered = /* @__PURE__ */ new Map();
+	async function visit(dir, depth) {
+		if (discovered.size >= MAX_DISCOVERED_DIRS || depth > MAX_SCAN_DEPTH) return;
+		const manifestPath = path.join(dir, ".codex-plugin", "plugin.json");
+		if (await exists(manifestPath)) {
+			const manifest = await readJsonObject(manifestPath);
+			const name = (typeof manifest.name === "string" ? manifest.name.trim() : "") || path.basename(dir);
+			discovered.set(dir, {
+				name,
+				source: dir,
+				manifestPath
+			});
+			return;
+		}
+		for (const entry of await safeReadDir(dir)) {
+			if (!entry.isDirectory()) continue;
+			await visit(path.join(dir, entry.name), depth + 1);
+		}
+	}
+	await visit(root, 0);
+	return [...discovered.values()].toSorted((a, b) => a.source.localeCompare(b.source));
+}
+async function discoverCodexSource(input) {
+	const codexHome = resolveHomePath(input?.trim() || defaultCodexHome());
+	const codexSkillsDir = path.join(codexHome, "skills");
+	const agentsSkillsDir = personalAgentsSkillsDir();
+	const configPath = path.join(codexHome, "config.toml");
+	const hooksPath = path.join(codexHome, "hooks", "hooks.json");
+	const codexSkills = await discoverSkillDirs({
+		root: codexSkillsDir,
+		sourceLabel: "Codex CLI skill",
+		excludeSystem: true
+	});
+	const personalAgentSkills = await discoverSkillDirs({
+		root: agentsSkillsDir,
+		sourceLabel: "personal AgentSkill"
+	});
+	const plugins = await discoverPluginDirs(codexHome);
+	const archivePaths = [];
+	if (await exists(configPath)) archivePaths.push({
+		id: "archive:config.toml",
+		path: configPath,
+		relativePath: "config.toml",
+		message: "Codex config is archived for manual review; it is not activated automatically."
+	});
+	if (await exists(hooksPath)) archivePaths.push({
+		id: "archive:hooks/hooks.json",
+		path: hooksPath,
+		relativePath: "hooks/hooks.json",
+		message: "Codex native hooks are archived for manual review because they can execute commands."
+	});
+	const skills = [...codexSkills, ...personalAgentSkills].toSorted((a, b) => a.source.localeCompare(b.source));
+	const high = Boolean(codexSkills.length || plugins.length || archivePaths.length);
+	const medium = personalAgentSkills.length > 0;
+	return {
+		root: codexHome,
+		confidence: high ? "high" : medium ? "medium" : "low",
+		codexHome,
+		...await isDirectory(codexSkillsDir) ? { codexSkillsDir } : {},
+		...await isDirectory(agentsSkillsDir) ? { personalAgentsSkillsDir: agentsSkillsDir } : {},
+		...await exists(configPath) ? { configPath } : {},
+		...await exists(hooksPath) ? { hooksPath } : {},
+		skills,
+		plugins,
+		archivePaths
+	};
+}
+function hasCodexSource(source) {
+	return source.confidence !== "low";
+}
+//#endregion
+//#region extensions/codex/src/migration/targets.ts
+function resolveCodexMigrationTargets(ctx) {
+	const cfg = ctx.config;
+	const agentId = resolveDefaultAgentId(cfg);
+	const workspaceDir = resolveAgentWorkspaceDir(cfg, agentId);
+	const configuredAgentDir = resolveAgentConfig(cfg, agentId)?.agentDir?.trim();
+	return {
+		workspaceDir,
+		agentDir: ctx.runtime?.agent?.resolveAgentDir(cfg, agentId) ?? (configuredAgentDir ? resolveHomePath(configuredAgentDir) : void 0) ?? path.join(ctx.stateDir, "agents", agentId, "agent")
+	};
+}
+//#endregion
+//#region extensions/codex/src/migration/plan.ts
+function uniqueSkillName(skill, counts) {
+	const base = sanitizeName(skill.name) || "codex-skill";
+	if ((counts.get(base) ?? 0) <= 1) return base;
+	return sanitizeName([
+		"codex",
+		sanitizeName(path.basename(path.dirname(skill.source))),
+		base
+	].filter(Boolean).join("-")) || base;
+}
+async function buildSkillItems(params) {
+	const baseCounts = /* @__PURE__ */ new Map();
+	for (const skill of params.skills) {
+		const base = sanitizeName(skill.name) || "codex-skill";
+		baseCounts.set(base, (baseCounts.get(base) ?? 0) + 1);
+	}
+	const resolvedCounts = /* @__PURE__ */ new Map();
+	const planned = params.skills.map((skill) => {
+		const name = uniqueSkillName(skill, baseCounts);
+		resolvedCounts.set(name, (resolvedCounts.get(name) ?? 0) + 1);
+		return {
+			skill,
+			name,
+			target: path.join(params.workspaceDir, "skills", name)
+		};
+	});
+	const items = [];
+	for (const item of planned) {
+		const collides = (resolvedCounts.get(item.name) ?? 0) > 1;
+		const targetExists = await exists(item.target);
+		items.push(createMigrationItem({
+			id: `skill:${item.name}`,
+			kind: "skill",
+			action: "copy",
+			source: item.skill.source,
+			target: item.target,
+			status: collides ? "conflict" : targetExists && !params.overwrite ? "conflict" : "planned",
+			reason: collides ? `multiple Codex skills normalize to "${item.name}"` : targetExists && !params.overwrite ? MIGRATION_REASON_TARGET_EXISTS : void 0,
+			message: `Copy ${item.skill.sourceLabel} into this OpenClaw agent workspace.`,
+			details: {
+				skillName: item.name,
+				sourceLabel: item.skill.sourceLabel
+			}
+		}));
+	}
+	return items;
+}
+async function buildCodexMigrationPlan(ctx) {
+	const source = await discoverCodexSource(ctx.source);
+	if (!hasCodexSource(source)) throw new Error(`Codex state was not found at ${source.root}. Pass --from <path> if it lives elsewhere.`);
+	const targets = resolveCodexMigrationTargets(ctx);
+	const items = [];
+	items.push(...await buildSkillItems({
+		skills: source.skills,
+		workspaceDir: targets.workspaceDir,
+		overwrite: ctx.overwrite
+	}));
+	for (const [index, plugin] of source.plugins.entries()) items.push(createMigrationManualItem({
+		id: `plugin:${sanitizeName(plugin.name) || sanitizeName(path.basename(plugin.source))}:${index + 1}`,
+		source: plugin.source,
+		message: `Codex native plugin "${plugin.name}" was found but not activated automatically.`,
+		recommendation: "Review the plugin bundle first, then install trusted compatible plugins with openclaw plugins install <path>."
+	}));
+	for (const archivePath of source.archivePaths) items.push(createMigrationItem({
+		id: archivePath.id,
+		kind: "archive",
+		action: "archive",
+		source: archivePath.path,
+		message: archivePath.message ?? "Archived in the migration report for manual review; not imported into live config.",
+		details: { archiveRelativePath: archivePath.relativePath }
+	}));
+	const warnings = [
+		...items.some((item) => item.status === "conflict") ? ["Conflicts were found. Re-run with --overwrite to replace conflicting skill targets after item-level backups."] : [],
+		...source.plugins.length > 0 ? ["Codex native plugins are reported for manual review only. OpenClaw does not auto-activate plugin bundles, hooks, MCP servers, or apps from another Codex home."] : [],
+		...source.archivePaths.length > 0 ? ["Codex config and hook files are archive-only. They are preserved in the migration report, not loaded into OpenClaw automatically."] : []
+	];
+	return {
+		providerId: "codex",
+		source: source.root,
+		target: targets.workspaceDir,
+		summary: summarizeMigrationItems(items),
+		items,
+		warnings,
+		nextSteps: ["Run openclaw doctor after applying the migration.", "Review skipped Codex plugin/config/hook items before installing or recreating them in OpenClaw."],
+		metadata: {
+			agentDir: targets.agentDir,
+			codexHome: source.codexHome,
+			codexSkillsDir: source.codexSkillsDir,
+			personalAgentsSkillsDir: source.personalAgentsSkillsDir
+		}
+	};
+}
+//#endregion
+//#region extensions/codex/src/migration/apply.ts
+async function applyCodexMigrationPlan(params) {
+	const plan = params.plan ?? await buildCodexMigrationPlan(params.ctx);
+	const reportDir = params.ctx.reportDir ?? path.join(params.ctx.stateDir, "migration", "codex");
+	const items = [];
+	for (const item of plan.items) {
+		if (item.status !== "planned") {
+			items.push(item);
+			continue;
+		}
+		if (item.action === "archive") items.push(await archiveMigrationItem(item, reportDir));
+		else items.push(await copyMigrationFileItem(item, reportDir, { overwrite: params.ctx.overwrite }));
+	}
+	const result = {
+		...plan,
+		items,
+		summary: summarizeMigrationItems(items),
+		backupPath: params.ctx.backupPath,
+		reportDir
+	};
+	await writeMigrationReport(result, { title: "Codex Migration Report" });
+	return result;
+}
+//#endregion
+//#region extensions/codex/src/migration/provider.ts
+function buildCodexMigrationProvider() {
+	return {
+		id: "codex",
+		label: "Codex",
+		description: "Inventory and promote Codex CLI skills while keeping Codex native plugins and hooks explicit.",
+		async detect(ctx) {
+			const source = await discoverCodexSource(ctx.source);
+			const found = hasCodexSource(source);
+			return {
+				found,
+				source: source.root,
+				label: "Codex",
+				confidence: found ? source.confidence : "low",
+				message: found ? "Codex state found." : "Codex state not found."
+			};
+		},
+		plan: buildCodexMigrationPlan,
+		async apply(ctx, plan) {
+			return await applyCodexMigrationPlan({
+				ctx,
+				plan
+			});
+		}
+	};
+}
+//#endregion
+//#region extensions/codex/index.ts
+var codex_default = definePluginEntry({
+	id: "codex",
+	name: "Codex",
+	description: "Codex app-server harness and Codex-managed GPT model catalog.",
+	register(api) {
+		const resolveCurrentPluginConfig = () => resolveLivePluginConfigObject(api.runtime.config?.current ? () => api.runtime.config.current() : void 0, "codex", api.pluginConfig) ?? api.pluginConfig;
+		api.registerAgentHarness(createCodexAppServerAgentHarness({ pluginConfig: api.pluginConfig }));
+		api.registerProvider(buildCodexProvider({ pluginConfig: api.pluginConfig }));
+		api.registerMediaUnderstandingProvider(buildCodexMediaUnderstandingProvider({ pluginConfig: api.pluginConfig }));
+		api.registerMigrationProvider(buildCodexMigrationProvider());
+		api.registerCommand(createCodexCommand({ pluginConfig: api.pluginConfig }));
+		api.on("inbound_claim", (event, ctx) => handleCodexConversationInboundClaim(event, ctx, { pluginConfig: resolveCurrentPluginConfig() }));
+		api.onConversationBindingResolved?.(handleCodexConversationBindingResolved);
+	}
+});
+//#endregion
+export { codex_default as default };

package/dist/media-understanding-provider.js

@@ -0,0 +1,234 @@
+import { CODEX_PROVIDER_ID, FALLBACK_CODEX_MODELS } from "./provider-catalog.js";
+import { i as resolveCodexAppServerRuntimeOptions } from "./config-CkkoMeqF.js";
+import { a as readCodexErrorNotification, c as readCodexTurnCompletedNotification, n as assertCodexThreadStartResponse, r as assertCodexTurnStartResponse } from "./protocol-validators-Cpopom3_.js";
+import { i as readModelListResult } from "./models-Ddmxtdog.js";
+import { t as isJsonObject } from "./protocol-C9UWI98H.js";
+//#region extensions/codex/media-understanding-provider.ts
+const DEFAULT_CODEX_IMAGE_MODEL = FALLBACK_CODEX_MODELS.find((model) => model.inputModalities.includes("image"))?.id ?? FALLBACK_CODEX_MODELS[0]?.id;
+const DEFAULT_CODEX_IMAGE_PROMPT = "Describe the image.";
+function buildCodexMediaUnderstandingProvider(options = {}) {
+	return {
+		id: CODEX_PROVIDER_ID,
+		capabilities: ["image"],
+		...DEFAULT_CODEX_IMAGE_MODEL ? { defaultModels: { image: DEFAULT_CODEX_IMAGE_MODEL } } : {},
+		describeImage: async (req) => describeCodexImages({
+			images: [{
+				buffer: req.buffer,
+				fileName: req.fileName,
+				mime: req.mime
+			}],
+			provider: req.provider,
+			model: req.model,
+			prompt: req.prompt,
+			maxTokens: req.maxTokens,
+			timeoutMs: req.timeoutMs,
+			profile: req.profile,
+			preferredProfile: req.preferredProfile,
+			authStore: req.authStore,
+			agentDir: req.agentDir,
+			cfg: req.cfg
+		}, options),
+		describeImages: async (req) => describeCodexImages(req, options)
+	};
+}
+async function describeCodexImages(req, options) {
+	const model = req.model.trim();
+	if (!model) throw new Error("Codex image understanding requires model id.");
+	const appServer = resolveCodexAppServerRuntimeOptions({ pluginConfig: options.pluginConfig });
+	const timeoutMs = Math.max(100, req.timeoutMs);
+	const ownsClient = !options.clientFactory;
+	const client = options.clientFactory ? await options.clientFactory(appServer.start, req.profile) : await import("./shared-client-DEzBJ9G1.js").then((n) => n.r).then(({ createIsolatedCodexAppServerClient }) => createIsolatedCodexAppServerClient({
+		startOptions: appServer.start,
+		timeoutMs,
+		authProfileId: req.profile
+	}));
+	const abortController = new AbortController();
+	const timeout = setTimeout(() => abortController.abort("timeout"), timeoutMs);
+	timeout.unref?.();
+	try {
+		await assertCodexModelSupportsImage({
+			client,
+			model,
+			timeoutMs,
+			signal: abortController.signal
+		});
+		const thread = assertCodexThreadStartResponse(await client.request("thread/start", {
+			model,
+			modelProvider: "openai",
+			cwd: req.agentDir || process.cwd(),
+			approvalPolicy: "on-request",
+			sandbox: "read-only",
+			serviceName: "OpenClaw",
+			developerInstructions: "You are OpenClaw's bounded image-understanding worker. Describe only the provided image content. Do not call tools, edit files, or ask follow-up questions.",
+			dynamicTools: [],
+			experimentalRawEvents: true,
+			persistExtendedHistory: false,
+			ephemeral: true
+		}, {
+			timeoutMs,
+			signal: abortController.signal
+		}));
+		const collector = createCodexImageTurnCollector(thread.thread.id);
+		const cleanup = client.addNotificationHandler(collector.handleNotification);
+		const requestCleanup = client.addRequestHandler(denyCodexImageApprovalRequest);
+		try {
+			const turn = assertCodexTurnStartResponse(await client.request("turn/start", {
+				threadId: thread.thread.id,
+				input: [{
+					type: "text",
+					text: buildCodexImagePrompt(req),
+					text_elements: []
+				}, ...req.images.map((image) => ({
+					type: "image",
+					url: `data:${image.mime ?? "image/png"};base64,${image.buffer.toString("base64")}`
+				}))],
+				cwd: req.agentDir || process.cwd(),
+				approvalPolicy: "on-request",
+				model,
+				effort: "low"
+			}, {
+				timeoutMs,
+				signal: abortController.signal
+			}));
+			return {
+				text: await collector.collect(turn.turn, {
+					timeoutMs,
+					signal: abortController.signal
+				}),
+				model
+			};
+		} finally {
+			requestCleanup();
+			cleanup();
+		}
+	} finally {
+		clearTimeout(timeout);
+		if (ownsClient) client.close();
+	}
+}
+function denyCodexImageApprovalRequest(request) {
+	if (request.method === "item/commandExecution/requestApproval" || request.method === "item/fileChange/requestApproval") return {
+		decision: "decline",
+		reason: "OpenClaw Codex image understanding does not grant tool or file approvals."
+	};
+	if (request.method === "item/permissions/requestApproval") return {
+		permissions: {},
+		scope: "turn"
+	};
+	if (request.method.includes("requestApproval")) return {
+		decision: "decline",
+		reason: "OpenClaw Codex image understanding does not grant native approvals."
+	};
+	if (request.method === "mcpServer/elicitation/request") return { action: "decline" };
+}
+async function assertCodexModelSupportsImage(params) {
+	const match = readModelListResult(await params.client.request("model/list", {
+		limit: 100,
+		cursor: null,
+		includeHidden: false
+	}, {
+		timeoutMs: Math.min(params.timeoutMs, 5e3),
+		signal: params.signal
+	})).models.find((entry) => entry.model === params.model || entry.id === params.model);
+	if (!match) throw new Error(`Codex app-server model not found: ${params.model}`);
+	if (!match.inputModalities.includes("image")) throw new Error(`Codex app-server model does not support images: ${params.model}`);
+}
+function buildCodexImagePrompt(req) {
+	const prompt = req.prompt?.trim() || DEFAULT_CODEX_IMAGE_PROMPT;
+	if (req.images.length <= 1) return prompt;
+	return `${prompt}\n\nAnalyze all ${req.images.length} images together.`;
+}
+function createCodexImageTurnCollector(threadId) {
+	let turnId;
+	let completedTurn;
+	let promptError;
+	const pending = [];
+	const assistantTextByItem = /* @__PURE__ */ new Map();
+	const assistantItemOrder = [];
+	let resolveCompletion;
+	const completion = new Promise((resolve) => {
+		resolveCompletion = resolve;
+	});
+	const rememberAssistantText = (itemId, text) => {
+		if (!text) return;
+		if (!assistantTextByItem.has(itemId)) assistantItemOrder.push(itemId);
+		assistantTextByItem.set(itemId, text);
+	};
+	const handleNotification = (notification) => {
+		const params = isJsonObject(notification.params) ? notification.params : void 0;
+		if (!params || readString(params, "threadId") !== threadId) return;
+		if (!turnId) {
+			pending.push(notification);
+			return;
+		}
+		if (readNotificationTurnId(params) !== turnId) return;
+		if (notification.method === "item/agentMessage/delta") {
+			const itemId = readString(params, "itemId") ?? readString(params, "id") ?? "assistant";
+			const delta = readString(params, "delta") ?? "";
+			rememberAssistantText(itemId, `${assistantTextByItem.get(itemId) ?? ""}${delta}`);
+			return;
+		}
+		if (notification.method === "turn/completed") {
+			completedTurn = readCodexTurnCompletedNotification(notification.params)?.turn ?? completedTurn;
+			resolveCompletion?.();
+			return;
+		}
+		if (notification.method === "error") {
+			promptError = readCodexErrorNotification(notification.params)?.error.message ?? "codex app-server image turn failed";
+			resolveCompletion?.();
+		}
+	};
+	return {
+		handleNotification,
+		async collect(startedTurn, options) {
+			turnId = startedTurn.id;
+			if (isTerminalTurn(startedTurn)) completedTurn = startedTurn;
+			for (const notification of pending.splice(0)) handleNotification(notification);
+			if (!completedTurn && !promptError) await waitForTurnCompletion({
+				completion,
+				timeoutMs: options.timeoutMs,
+				signal: options.signal
+			});
+			if (promptError) throw new Error(promptError);
+			if (completedTurn?.status === "failed") throw new Error(completedTurn.error?.message ?? "codex app-server image turn failed");
+			const itemText = collectAssistantTextFromItems(completedTurn?.items);
+			const deltaText = assistantItemOrder.map((itemId) => assistantTextByItem.get(itemId)?.trim()).filter((text) => Boolean(text)).join("\n\n").trim();
+			const text = (itemText || deltaText).trim();
+			if (!text) throw new Error("Codex app-server image turn returned no text.");
+			return text;
+		}
+	};
+}
+async function waitForTurnCompletion(params) {
+	let timeout;
+	let cleanupAbort;
+	try {
+		await Promise.race([params.completion, new Promise((_, reject) => {
+			timeout = setTimeout(() => reject(/* @__PURE__ */ new Error("codex app-server image turn timed out")), params.timeoutMs);
+			timeout.unref?.();
+			const abortListener = () => reject(/* @__PURE__ */ new Error("codex app-server image turn aborted"));
+			params.signal.addEventListener("abort", abortListener, { once: true });
+			cleanupAbort = () => params.signal.removeEventListener("abort", abortListener);
+		})]);
+	} finally {
+		if (timeout) clearTimeout(timeout);
+		cleanupAbort?.();
+	}
+}
+function collectAssistantTextFromItems(items) {
+	return (items ?? []).filter((item) => item.type === "agentMessage").map((item) => item.text.trim()).filter(Boolean).join("\n\n").trim();
+}
+function readNotificationTurnId(record) {
+	const direct = readString(record, "turnId");
+	if (direct) return direct;
+	return isJsonObject(record.turn) ? readString(record.turn, "id") : void 0;
+}
+function readString(record, key) {
+	const value = record[key];
+	return typeof value === "string" ? value : void 0;
+}
+function isTerminalTurn(turn) {
+	return turn.status === "completed" || turn.status === "interrupted" || turn.status === "failed";
+}
+//#endregion
+export { buildCodexMediaUnderstandingProvider };

package/dist/models-Ddmxtdog.js

@@ -0,0 +1,108 @@
+import { t as __exportAll } from "./rolldown-runtime-DUslC3ob.js";
+import { o as readCodexModelListResponse } from "./protocol-validators-Cpopom3_.js";
+//#region extensions/codex/src/app-server/models.ts
+var models_exports = /* @__PURE__ */ __exportAll({
+	listAllCodexAppServerModels: () => listAllCodexAppServerModels,
+	listCodexAppServerModels: () => listCodexAppServerModels,
+	readModelListResult: () => readModelListResult
+});
+async function listCodexAppServerModels(options = {}) {
+	return await withCodexAppServerModelClient(options, async ({ client, timeoutMs }) => requestModelListPage(client, {
+		...options,
+		timeoutMs
+	}));
+}
+async function listAllCodexAppServerModels(options = {}) {
+	const maxPages = normalizeMaxPages(options.maxPages);
+	return await withCodexAppServerModelClient(options, async ({ client, timeoutMs }) => {
+		const models = [];
+		let cursor = options.cursor;
+		let nextCursor;
+		for (let page = 0; page < maxPages; page += 1) {
+			const result = await requestModelListPage(client, {
+				...options,
+				timeoutMs,
+				cursor
+			});
+			models.push(...result.models);
+			nextCursor = result.nextCursor;
+			if (!nextCursor) return { models };
+			cursor = nextCursor;
+		}
+		return {
+			models,
+			nextCursor,
+			truncated: true
+		};
+	});
+}
+async function withCodexAppServerModelClient(options, run) {
+	const timeoutMs = options.timeoutMs ?? 2500;
+	const useSharedClient = options.sharedClient !== false;
+	const { createIsolatedCodexAppServerClient, getSharedCodexAppServerClient } = await import("./shared-client-DEzBJ9G1.js").then((n) => n.r);
+	const client = useSharedClient ? await getSharedCodexAppServerClient({
+		startOptions: options.startOptions,
+		timeoutMs,
+		authProfileId: options.authProfileId,
+		agentDir: options.agentDir
+	}) : await createIsolatedCodexAppServerClient({
+		startOptions: options.startOptions,
+		timeoutMs,
+		authProfileId: options.authProfileId,
+		agentDir: options.agentDir
+	});
+	try {
+		return await run({
+			client,
+			timeoutMs
+		});
+	} finally {
+		if (!useSharedClient) client.close();
+	}
+}
+async function requestModelListPage(client, options) {
+	return readModelListResult(await client.request("model/list", {
+		limit: options.limit ?? null,
+		cursor: options.cursor ?? null,
+		includeHidden: options.includeHidden ?? null
+	}, { timeoutMs: options.timeoutMs }));
+}
+function readModelListResult(value) {
+	const response = readCodexModelListResponse(value);
+	if (!response) return { models: [] };
+	const models = response.data.map((entry) => readCodexModel(entry)).filter((entry) => entry !== void 0);
+	const nextCursor = response.nextCursor ?? void 0;
+	return {
+		models,
+		...nextCursor ? { nextCursor } : {}
+	};
+}
+function readCodexModel(value) {
+	const id = readNonEmptyString(value.id);
+	const model = readNonEmptyString(value.model) ?? id;
+	if (!id || !model) return;
+	return {
+		id,
+		model,
+		...readNonEmptyString(value.displayName) ? { displayName: readNonEmptyString(value.displayName) } : {},
+		...readNonEmptyString(value.description) ? { description: readNonEmptyString(value.description) } : {},
+		hidden: value.hidden,
+		isDefault: value.isDefault,
+		inputModalities: value.inputModalities,
+		supportedReasoningEfforts: readReasoningEfforts(value.supportedReasoningEfforts),
+		...readNonEmptyString(value.defaultReasoningEffort) ? { defaultReasoningEffort: readNonEmptyString(value.defaultReasoningEffort) } : {}
+	};
+}
+function readReasoningEfforts(value) {
+	const efforts = value.map((entry) => readNonEmptyString(entry.reasoningEffort)).filter((entry) => entry !== void 0);
+	return [...new Set(efforts)];
+}
+function readNonEmptyString(value) {
+	if (typeof value !== "string") return;
+	return value.trim() || void 0;
+}
+function normalizeMaxPages(value) {
+	return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.floor(value) : 20;
+}
+//#endregion
+export { readModelListResult as i, listCodexAppServerModels as n, models_exports as r, listAllCodexAppServerModels as t };