@openclaw/codex 2026.6.8 → 2026.6.9-beta.1

package/dist/media-understanding-provider.js

@@ -1,356 +1,2 @@
-import { CODEX_PROVIDER_ID, FALLBACK_CODEX_MODELS } from "./provider-catalog.js";
-import { d as resolveCodexAppServerRuntimeOptions } from "./config-DJXpBkGf.js";
-import { i as assertCodexTurnStartResponse, l as readCodexTurnCompletedNotification, o as readCodexErrorNotification, r as assertCodexThreadStartResponse } from "./protocol-validators-B48C6S9O.js";
-import { i as readModelListResult } from "./models-DRKnOpzF.js";
-import { t as isJsonObject } from "./protocol-oeJQu4rs.js";
-import { r as buildCodexRuntimeThreadConfig } from "./thread-lifecycle-cban34w3.js";
-import { validateJsonSchemaValue } from "openclaw/plugin-sdk/json-schema-runtime";
-import { resolveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";
-//#region extensions/codex/media-understanding-provider.ts
-/**
-* Codex-backed media understanding provider for bounded image description and
-* structured extraction turns.
-*/
-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.";
-/**
-* Builds the media-understanding provider that delegates image tasks to an
-* isolated Codex app-server session.
-*/
-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),
-		extractStructured: async (req) => extractCodexStructured(req, options)
-	};
-}
-async function describeCodexImages(req, options) {
-	const model = req.model.trim();
-	if (!model) throw new Error("Codex image understanding requires model id.");
-	return {
-		text: await runBoundedCodexVisionTurn({
-			model,
-			profile: req.profile,
-			timeoutMs: req.timeoutMs,
-			agentDir: req.agentDir,
-			authStore: req.authStore,
-			cfg: req.cfg,
-			options,
-			taskLabel: "image understanding",
-			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.",
-			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")}`
-			}))],
-			requiredModalities: ["text", "image"]
-		}),
-		model
-	};
-}
-async function runBoundedCodexVisionTurn(params) {
-	const appServer = resolveCodexAppServerRuntimeOptions({ pluginConfig: params.options.pluginConfig });
-	const timeoutMs = resolveTimerTimeoutMs(params.timeoutMs, 100, 100);
-	const agentDir = params.agentDir?.trim() || void 0;
-	const cwd = agentDir ?? process.cwd();
-	const ownsClient = !params.options.clientFactory;
-	const client = params.options.clientFactory ? await params.options.clientFactory(appServer.start, params.profile, agentDir, params.cfg) : await import("./shared-client-jFMumCOe.js").then((n) => n.c).then(({ createIsolatedCodexAppServerClient }) => createIsolatedCodexAppServerClient({
-		startOptions: appServer.start,
-		timeoutMs,
-		authProfileId: params.profile,
-		agentDir,
-		authProfileStore: params.authStore,
-		config: params.cfg
-	}));
-	const abortController = new AbortController();
-	const timeout = setTimeout(() => abortController.abort("timeout"), timeoutMs);
-	timeout.unref?.();
-	try {
-		await assertCodexModelSupportsInput({
-			client,
-			model: params.model,
-			requiredModalities: params.requiredModalities,
-			timeoutMs,
-			signal: abortController.signal
-		});
-		const thread = assertCodexThreadStartResponse(await client.request("thread/start", {
-			model: params.model,
-			modelProvider: "openai",
-			cwd,
-			approvalPolicy: "on-request",
-			sandbox: "read-only",
-			serviceName: "OpenClaw",
-			developerInstructions: params.developerInstructions,
-			config: buildCodexRuntimeThreadConfig(void 0, { nativeCodeModeEnabled: false }),
-			environments: [],
-			dynamicTools: [],
-			experimentalRawEvents: true,
-			persistExtendedHistory: false,
-			ephemeral: true
-		}, {
-			timeoutMs,
-			signal: abortController.signal
-		}));
-		const collector = createCodexTurnCollector(thread.thread.id, params.taskLabel);
-		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: params.input,
-				cwd,
-				approvalPolicy: "on-request",
-				model: params.model,
-				effort: "low"
-			}, {
-				timeoutMs,
-				signal: abortController.signal
-			}));
-			return await collector.collect(turn.turn, {
-				timeoutMs,
-				signal: abortController.signal
-			});
-		} finally {
-			requestCleanup();
-			cleanup();
-		}
-	} finally {
-		clearTimeout(timeout);
-		if (ownsClient) client.close();
-	}
-}
-async function extractCodexStructured(req, options) {
-	const model = req.model.trim();
-	if (!model) throw new Error("Codex structured extraction requires model id.");
-	if (!req.instructions.trim()) throw new Error("Codex structured extraction requires instructions.");
-	if (req.input.length === 0) throw new Error("Codex structured extraction requires at least one input.");
-	if (!req.input.some((entry) => entry.type === "image")) throw new Error("Codex structured extraction requires at least one image input.");
-	return normalizeStructuredExtractionResult({
-		text: await runBoundedCodexVisionTurn({
-			model,
-			profile: req.profile,
-			timeoutMs: req.timeoutMs,
-			agentDir: req.agentDir,
-			authStore: req.authStore,
-			cfg: req.cfg,
-			options,
-			taskLabel: "structured extraction",
-			developerInstructions: "You are OpenClaw's bounded structured-extraction worker. Return only the requested extraction. Do not call tools, edit files, ask follow-up questions, or include secrets.",
-			input: buildCodexStructuredInput(req),
-			requiredModalities: requiredStructuredModalities()
-		}),
-		model,
-		provider: req.provider,
-		req
-	});
-}
-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 assertCodexModelSupportsInput(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 (params.requiredModalities.includes("image") && !match.inputModalities.includes("image")) throw new Error(`Codex app-server model does not support images: ${params.model}`);
-	if (params.requiredModalities.includes("text") && !match.inputModalities.includes("text")) throw new Error(`Codex app-server model does not support text: ${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 requiredStructuredModalities() {
-	return ["text", "image"];
-}
-function buildCodexStructuredInput(req) {
-	return [{
-		type: "text",
-		text: buildStructuredExtractionPrompt(req),
-		text_elements: []
-	}, ...req.input.map((entry) => {
-		if (entry.type === "text") return {
-			type: "text",
-			text: entry.text,
-			text_elements: []
-		};
-		return {
-			type: "image",
-			url: `data:${entry.mime ?? "image/png"};base64,${entry.buffer.toString("base64")}`
-		};
-	})];
-}
-function buildStructuredExtractionPrompt(req) {
-	return [
-		req.instructions.trim(),
-		req.schemaName ? `Schema name: ${req.schemaName}` : void 0,
-		req.jsonSchema ? `JSON schema:\n${JSON.stringify(req.jsonSchema)}` : void 0,
-		req.jsonMode === false ? "Return the extraction as concise text." : "Return valid JSON only. Do not wrap the JSON in Markdown fences."
-	].filter((part) => Boolean(part)).join("\n\n");
-}
-function isJsonSchemaObject(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function normalizeStructuredExtractionResult(params) {
-	const result = {
-		text: params.text,
-		model: params.model,
-		provider: params.provider,
-		contentType: params.req.jsonMode === false ? "text" : "json"
-	};
-	if (params.req.jsonMode !== false) {
-		try {
-			result.parsed = JSON.parse(params.text);
-		} catch {
-			throw new Error("Codex structured extraction returned invalid JSON.");
-		}
-		if (isJsonSchemaObject(params.req.jsonSchema)) {
-			const validation = validateJsonSchemaValue({
-				schema: params.req.jsonSchema,
-				cacheKey: "codex.media-understanding.extractStructured",
-				value: result.parsed,
-				cache: false
-			});
-			if (!validation.ok) {
-				const message = validation.errors.map((error) => error.text).join("; ") || "invalid";
-				throw new Error(`Codex structured extraction JSON did not match schema: ${message}`);
-			}
-			result.parsed = validation.value;
-		}
-	}
-	return result;
-}
-function createCodexTurnCollector(threadId, taskLabel) {
-	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 ${taskLabel} 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,
-				taskLabel
-			});
-			if (promptError) throw new Error(promptError);
-			if (completedTurn?.status === "failed") throw new Error(completedTurn.error?.message ?? `codex app-server ${taskLabel} 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 ${taskLabel} 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 ${params.taskLabel} turn timed out`)), params.timeoutMs);
-			timeout.unref?.();
-			const abortListener = () => reject(/* @__PURE__ */ new Error(`codex app-server ${params.taskLabel} 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
+import { t as buildCodexMediaUnderstandingProvider } from "./media-understanding-provider-CiwPkR58.js";
 export { buildCodexMediaUnderstandingProvider };

package/dist/{models-DRKnOpzF.js → models-BsyV1Psm.js}

@@ -1,5 +1,5 @@
 import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
-import { s as readCodexModelListResponse } from "./protocol-validators-B48C6S9O.js";
+import { s as readCodexModelListResponse } from "./protocol-validators-B19q5BIX.js";
 import { uniqueStrings } from "openclaw/plugin-sdk/string-coerce-runtime";
 //#region extensions/codex/src/app-server/models.ts
 /**
@@ -46,7 +46,7 @@ async function listAllCodexAppServerModels(options = {}) {
 async function withCodexAppServerModelClient(options, run) {
 	const timeoutMs = options.timeoutMs ?? 2500;
 	const useSharedClient = options.sharedClient !== false;
-	const { createIsolatedCodexAppServerClient, getLeasedSharedCodexAppServerClient, releaseLeasedSharedCodexAppServerClient } = await import("./shared-client-jFMumCOe.js").then((n) => n.c);
+	const { createIsolatedCodexAppServerClient, getLeasedSharedCodexAppServerClient, releaseLeasedSharedCodexAppServerClient } = await import("./shared-client-Bg5d7VV9.js").then((n) => n.c);
 	const client = useSharedClient ? await getLeasedSharedCodexAppServerClient({
 		startOptions: options.startOptions,
 		timeoutMs,

package/dist/{plugin-app-cache-key-kIqpGTQj.js → plugin-app-cache-key-CN9zBiCG.js}

@@ -1,6 +1,6 @@
-import { n as CodexAppServerRpcError } from "./client-DovmVtbr.js";
-import { S as buildCodexAppInventoryCacheKey } from "./thread-lifecycle-cban34w3.js";
-import { h as resolveCodexAppServerHomeDir } from "./shared-client-jFMumCOe.js";
+import { I as buildCodexAppInventoryCacheKey } from "./thread-lifecycle-CbJqqnEw.js";
+import { n as CodexAppServerRpcError } from "./client-m7XiCQpO.js";
+import { h as resolveCodexAppServerHomeDir } from "./shared-client-Bg5d7VV9.js";
 import { createHash } from "node:crypto";
 //#region extensions/codex/src/app-server/capabilities.ts
 /**
@@ -35,12 +35,23 @@ function isUnsupportedControlError(error) {
 /** Builds the full app inventory cache key for Codex plugin/app discovery. */
 function buildCodexPluginAppCacheKey(params) {
 	return buildCodexAppInventoryCacheKey({
-		codexHome: resolveCodexPluginAppCacheCodexHome(params.appServer, params.agentDir),
+		codexHome: params.runtimeIdentity?.codexHome ?? resolveCodexPluginAppCacheCodexHome(params.appServer, params.agentDir),
 		endpoint: resolveCodexPluginAppCacheEndpoint(params.appServer),
 		authProfileId: params.authProfileId,
 		accountId: params.accountId,
 		envApiKeyFingerprint: params.envApiKeyFingerprint,
-		appServerVersion: params.appServerVersion
+		appServerVersion: params.appServerVersion ?? params.runtimeIdentity?.serverVersion,
+		runtimeIdentity: params.runtimeIdentity
+	});
+}
+/** Builds a durable thread-binding fingerprint for one initialized app-server runtime. */
+function buildCodexAppServerRuntimeFingerprint(params) {
+	return JSON.stringify({
+		endpoint: resolveCodexPluginAppCacheEndpoint(params.appServer),
+		connectionClass: params.appServer.connectionClass,
+		remoteWorkspaceRoot: params.appServer.remoteWorkspaceRoot ?? null,
+		appServerVersion: params.appServerVersion ?? params.runtimeIdentity?.serverVersion ?? null,
+		runtimeIdentity: params.runtimeIdentity ?? null
 	});
 }
 /** Serializes app-server endpoint identity, including credential fingerprints. */
@@ -76,4 +87,4 @@ function fingerprintCodexPluginAppCacheCredentials(startOptions) {
 	return `sha256:${hash.digest("hex")}`;
 }
 //#endregion
-export { CODEX_CONTROL_METHODS as n, describeControlFailure as r, buildCodexPluginAppCacheKey as t };
+export { describeControlFailure as i, buildCodexPluginAppCacheKey as n, CODEX_CONTROL_METHODS as r, buildCodexAppServerRuntimeFingerprint as t };

package/dist/{protocol-oeJQu4rs.js → protocol-dh-ETiNd.js}

@@ -1,4 +1,7 @@
 //#region extensions/codex/src/app-server/protocol.ts
+function flattenCodexDynamicToolFunctions(tools) {
+	return (tools ?? []).flatMap((tool) => tool.type === "namespace" ? tool.tools : [tool]);
+}
 function isJsonObject(value) {
 	return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
@@ -6,4 +9,4 @@ function isRpcResponse(message) {
 	return "id" in message && !("method" in message);
 }
 //#endregion
-export { isRpcResponse as n, isJsonObject as t };
+export { isJsonObject as n, isRpcResponse as r, flattenCodexDynamicToolFunctions as t };