@openclaw/codex 2026.9.2 → 2026.9.4

package/dist/managed-thread-store-D1t5jh3G.js

@@ -0,0 +1,66 @@
+import { createHash } from "node:crypto";
+import { embeddedAgentLog } from "openclaw/plugin-sdk/agent-harness-registration";
+import { z } from "zod";
+//#region extensions/codex/src/app-server/managed-thread-store.ts
+const CODEX_MANAGED_THREAD_NAMESPACE = "app-server-managed-threads";
+const CODEX_MANAGED_THREAD_MAX_ENTRIES = 2e4;
+const managedThreadSchema = z.object({
+	version: z.literal(1),
+	kind: z.literal("managed-thread"),
+	sourceHomeId: z.string().min(1),
+	threadId: z.string().min(1),
+	rolloutPath: z.string().min(1).optional()
+});
+async function markStartedCodexManagedThread(store, params) {
+	if (!store) return;
+	try {
+		await store.mark({
+			sourceHomeId: params.sourceHomeId,
+			threadId: params.threadId,
+			...params.rolloutPath ? { rolloutPath: params.rolloutPath } : {}
+		});
+	} catch (error) {
+		embeddedAgentLog.warn("failed to record Codex managed thread ownership", { error });
+	}
+}
+function managedThreadStoreKey(sourceHomeId, threadId) {
+	return `sha256:${createHash("sha256").update("openclaw:codex-managed-thread:v1\0").update(sourceHomeId).update("\0").update(threadId).digest("hex")}`;
+}
+/** Durable ownership index for Codex threads created by OpenClaw. */
+function createCodexManagedThreadStore(state) {
+	return {
+		async has(sourceHomeId, threadId) {
+			const parsed = managedThreadSchema.safeParse(state.lookup(managedThreadStoreKey(sourceHomeId, threadId)));
+			return parsed.success && parsed.data.sourceHomeId === sourceHomeId && parsed.data.threadId === threadId;
+		},
+		async mark(params) {
+			try {
+				const value = managedThreadSchema.parse({
+					version: 1,
+					kind: "managed-thread",
+					sourceHomeId: params.sourceHomeId.trim(),
+					threadId: params.threadId.trim(),
+					...params.rolloutPath?.trim() ? { rolloutPath: params.rolloutPath.trim() } : {}
+				});
+				state.registerIfAbsent(managedThreadStoreKey(value.sourceHomeId, value.threadId), value);
+				return true;
+			} catch (error) {
+				embeddedAgentLog.warn("failed to record Codex managed thread ownership", { error });
+				return false;
+			}
+		},
+		async snapshot() {
+			const byHome = /* @__PURE__ */ new Map();
+			for (const entry of state.entries()) {
+				const parsed = managedThreadSchema.safeParse(entry.value);
+				if (!parsed.success) continue;
+				const ids = byHome.get(parsed.data.sourceHomeId) ?? /* @__PURE__ */ new Set();
+				ids.add(parsed.data.threadId);
+				byHome.set(parsed.data.sourceHomeId, ids);
+			}
+			return byHome;
+		}
+	};
+}
+//#endregion
+export { markStartedCodexManagedThread as i, CODEX_MANAGED_THREAD_NAMESPACE as n, createCodexManagedThreadStore as r, CODEX_MANAGED_THREAD_MAX_ENTRIES as t };

package/dist/media-understanding-provider.js

@@ -1,4 +1,3 @@
-import { t as runBoundedCodexAppServerTurn } from "./bounded-turn-DxGJRYbY.js";
 import { isRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { validateJsonSchemaValue } from "openclaw/plugin-sdk/json-schema-runtime";
 //#region extensions/codex/media-understanding-provider.ts
@@ -44,6 +43,8 @@ async function describeCodexImages(req, options) {
 	const model = req.model.trim();
 	if (!model) throw new Error("Codex image understanding requires model id.");
 	req.signal?.throwIfAborted();
+	const { runBoundedCodexAppServerTurn } = await import("./bounded-turn-C_Hneydj.js");
+	req.signal?.throwIfAborted();
 	const { text } = await runBoundedCodexAppServerTurn({
 		config: req.cfg,
 		model: {
@@ -82,6 +83,8 @@ async function extractCodexStructured(req, options) {
 	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.");
 	req.signal?.throwIfAborted();
+	const { runBoundedCodexAppServerTurn } = await import("./bounded-turn-C_Hneydj.js");
+	req.signal?.throwIfAborted();
 	const { text } = await runBoundedCodexAppServerTurn({
 		config: req.cfg,
 		model: {

package/dist/migration-provider-api.js

@@ -0,0 +1,2 @@
+import { t as buildCodexMigrationProvider } from "./provider-MQ8PVkuE.js";
+export { buildCodexMigrationProvider as buildMigrationProvider };

package/dist/{model-catalog-DT5vo6qo.js → model-catalog-Dq2n8f_p.js}

@@ -1,8 +1,9 @@
-import { r as buildCodexRuntimeModelParams } from "./harness-Czh2Sdoc.js";
-import { B as isJsonObject, O as readCodexPluginConfig, i as resolveCodexAppServerRuntimeOptions } from "./config-CyapYSji.js";
-import { r as captureSharedCodexAppServerCatalogLifetime } from "./shared-client-CKhX2kFt.js";
-import { t as listAllCodexAppServerModels } from "./models-CcrgSMQR.js";
-import { o as withCodexAppServerJsonClient } from "./request-C8H22rPi.js";
+import { r as buildCodexRuntimeModelParams } from "./harness-C7rRa7bm.js";
+import { o as isJsonObject, x as readCodexPluginConfig } from "./protocol-5bh1G-H7.js";
+import { o as withCodexAppServerJsonClient } from "./request-B7hEkBGq.js";
+import { n as resolveCodexAppServerRuntimeOptions } from "./config-runtime-D0zGNIHu.js";
+import { r as captureSharedCodexAppServerCatalogLifetime } from "./shared-client-CscigXXL.js";
+import { t as listAllCodexAppServerModels } from "./models-PCKOim-h.js";
 //#region extensions/codex/src/app-server/model-catalog.ts
 const DEFAULT_MODEL_DISCOVERY_TIMEOUT_MS = 2500;
 const INPUT_TYPES = /* @__PURE__ */ new Set([

package/dist/{models-CcrgSMQR.js → models-PCKOim-h.js}

@@ -1,4 +1,4 @@
-import { X as assertCodexModelListResponse } from "./shared-client-CKhX2kFt.js";
+import { h as assertCodexModelListResponse } from "./client-B57KWPQx.js";
 import { normalizeOptionalString, uniqueStrings } from "openclaw/plugin-sdk/string-coerce-runtime";
 //#region extensions/codex/src/app-server/models.ts
 /**
@@ -37,8 +37,8 @@ async function withCodexAppServerModelRequest(options, run) {
 	if (options.request) return await run(options.request);
 	const timeoutMs = options.timeoutMs ?? 2500;
 	const useSharedClient = options.sharedClient !== false;
-	const { createIsolatedCodexAppServerClient, getLeasedSharedCodexAppServerClient, releaseLeasedSharedCodexAppServerClient } = await import("./shared-client-CKhX2kFt.js").then((n) => n.x);
-	const { requestCodexAppServerClientJson } = await import("./request-C8H22rPi.js").then((n) => n.a);
+	const { createIsolatedCodexAppServerClient, getLeasedSharedCodexAppServerClient, releaseLeasedSharedCodexAppServerClient } = await import("./shared-client-CscigXXL.js").then((n) => n.y);
+	const { requestCodexAppServerClientJson } = await import("./request-B7hEkBGq.js").then((n) => n.a);
 	const client = await (useSharedClient ? getLeasedSharedCodexAppServerClient : createIsolatedCodexAppServerClient)({
 		startOptions: options.startOptions,
 		timeoutMs,

package/dist/native-execution-policy-umd0tgh4.js

@@ -0,0 +1,128 @@
+import { resolveAgentConfig, tryResolveDefaultAgentId } from "openclaw/plugin-sdk/agent-scope-runtime";
+import { normalizeAgentId, parseAgentSessionKey } from "openclaw/plugin-sdk/routing";
+import { getSessionEntry } from "openclaw/plugin-sdk/session-store-runtime";
+import { resolveSandboxRuntimeStatus } from "openclaw/plugin-sdk/sandbox";
+//#region extensions/codex/src/app-server/native-execution-policy.ts
+/** Projects node execution ownership into the runtime tool factory options. */
+function resolveCodexNodeExecToolOverrides(policy) {
+	if (policy.effectiveExecHost !== "node") return;
+	const node = policy.node?.trim();
+	return {
+		host: "node",
+		...node ? { node } : {}
+	};
+}
+/** Resolves node/gateway/sandbox execution ownership from overrides, session, agent, and config. */
+function resolveCodexNativeExecutionPolicy(params) {
+	const config = params.config ?? {};
+	const sessionKey = params.sessionKey?.trim() || params.sessionId?.trim() || void 0;
+	const agentId = resolvePolicyAgentId({
+		config,
+		sessionKey,
+		agentId: params.agentId
+	});
+	const canReadSessionEntry = Boolean(agentId) && params.readRuntimeSessionEntry && shouldReadRuntimeSessionEntry({
+		config,
+		sessionKey,
+		agentId
+	});
+	const sessionEntry = params.sessionEntry ?? (canReadSessionEntry && sessionKey && agentId ? readRuntimeSessionEntryBestEffort({
+		sessionKey,
+		agentId
+	}) : void 0);
+	const sandboxAgentId = parseAgentSessionKey(sessionKey)?.agentId ?? agentId;
+	const sandboxAvailable = params.sandboxAvailable ?? (sessionKey && sandboxAgentId ? resolveSandboxRuntimeStatus({
+		cfg: config,
+		sessionKey,
+		agentId: sandboxAgentId,
+		classificationAgentId: sandboxAgentId
+	}).sandboxed : false);
+	const agentExec = agentId ? resolvePolicyAgentExec({
+		config,
+		agentId
+	}) : void 0;
+	const globalExec = config.tools?.exec;
+	const requestedExecHost = normalizeExecTarget(params.execOverrides?.host) ?? normalizeExecTarget(sessionEntry?.execHost) ?? normalizeExecTarget(agentExec?.host) ?? normalizeExecTarget(globalExec?.host) ?? "auto";
+	const effectiveExecHost = resolveEffectiveExecHost({
+		requestedExecHost,
+		sandboxAvailable
+	});
+	const node = params.execOverrides?.node ?? sessionEntry?.execNode ?? agentExec?.node ?? globalExec?.node;
+	if (effectiveExecHost !== "node") return {
+		nativeToolSurfaceAllowed: true,
+		requestedExecHost,
+		effectiveExecHost,
+		node
+	};
+	return {
+		nativeToolSurfaceAllowed: false,
+		requestedExecHost,
+		effectiveExecHost,
+		node,
+		blockReason: "OpenClaw exec host=node is active for this session. Codex app-server native execution cannot route shell, filesystem, MCP, or app-backed work through the selected OpenClaw node."
+	};
+}
+/** Formats the user-facing explanation shown when native tools are blocked by exec host=node. */
+function formatCodexNativeNodeExecBlock(params) {
+	return [
+		`Codex-native ${params.surface} is unavailable because OpenClaw exec host=node is active for this session.`,
+		params.reason ?? "Codex app-server native execution cannot route execution through the selected OpenClaw node.",
+		"Use a normal Codex harness turn so OpenClaw exec/process tools run on the node, or switch exec host to gateway for native Codex app-server execution."
+	].join(" ");
+}
+function resolvePolicyAgentId(params) {
+	const explicitAgentId = normalizeAgentIdOrDefault(params.agentId);
+	if (explicitAgentId) return explicitAgentId;
+	const sessionAgentId = parseAgentIdFromSessionKey(params.sessionKey);
+	if (sessionAgentId) return sessionAgentId;
+	return tryResolveDefaultAgentId(params.config);
+}
+function resolvePolicyAgentExec(params) {
+	return resolveAgentConfig(params.config, params.agentId)?.tools?.exec;
+}
+function parseAgentIdFromSessionKey(sessionKey) {
+	const raw = sessionKey?.trim();
+	if (!raw) return;
+	const parts = raw.toLowerCase().split(":").filter(Boolean);
+	if (parts.length < 3 || parts[0] !== "agent" || !parts[2]) return;
+	return normalizeAgentIdOrDefault(parts[1]);
+}
+function shouldReadRuntimeSessionEntry(params) {
+	if (!params.sessionKey) return false;
+	const explicitAgentId = normalizeAgentIdOrDefault(params.agentId);
+	if (!explicitAgentId) return true;
+	const sessionAgentId = parseAgentIdFromSessionKey(params.sessionKey);
+	if (!sessionAgentId) return isDefaultAgentSessionKeyForAgent({
+		config: params.config,
+		agentId: explicitAgentId
+	});
+	return sessionAgentId === explicitAgentId;
+}
+function isDefaultAgentSessionKeyForAgent(params) {
+	return normalizeAgentId(params.agentId) === tryResolveDefaultAgentId(params.config);
+}
+function normalizeAgentIdOrDefault(value) {
+	const normalized = normalizeAgentId(value);
+	return normalized === "main" && !(value ?? "").trim() ? void 0 : normalized;
+}
+function normalizeExecTarget(value) {
+	const normalized = value?.trim().toLowerCase();
+	if (normalized === "auto" || normalized === "sandbox" || normalized === "gateway" || normalized === "node") return normalized;
+}
+function resolveEffectiveExecHost(params) {
+	if (params.requestedExecHost === "auto") return params.sandboxAvailable ? "sandbox" : "gateway";
+	return params.requestedExecHost;
+}
+function readRuntimeSessionEntryBestEffort(params) {
+	try {
+		return getSessionEntry({
+			sessionKey: params.sessionKey,
+			agentId: params.agentId,
+			hydrateSkillPromptRefs: false
+		});
+	} catch {
+		return;
+	}
+}
+//#endregion
+export { resolveCodexNativeExecutionPolicy as n, resolveCodexNodeExecToolOverrides as r, formatCodexNativeNodeExecBlock as t };

package/dist/native-subagent-history-DjtPloaU.js

@@ -0,0 +1,140 @@
+import { l as sessionBindingIdentity } from "./session-binding-record-Bcvslnhf.js";
+import { t as readCodexThreadHistoryPage } from "./thread-history-page-D0JIp48V.js";
+import { r as readMirrorIdentity } from "./upstream-prompt-provenance-LphB8slG.js";
+import { r as projectCodexThreadHistoryItem } from "./transcript-history-projection-v17wXgdK.js";
+import { n as buildCodexAppServerRuntimeFingerprint, t as buildCodexAppServerConnectionFingerprint } from "./plugin-app-cache-key-d0eKxy7b.js";
+import { i as resolveCodexBindingAppServerConnection } from "./binding-connection-D3udKbIE.js";
+import { c as getLeasedSharedCodexAppServerClient, h as releaseLeasedSharedCodexAppServerClient } from "./shared-client-CscigXXL.js";
+import { c as itemToolArgs, d as itemTranscriptResultText, n as CODEX_NATIVE_SUBAGENT_RUN_ID_PREFIX } from "./native-subagent-task-ids-BzTdT0Uw.js";
+import { r as readCodexNativeSubagentHistoryOwner, t as codexNativeSubagentHistoryConnectionFingerprint } from "./native-subagent-history-owner-Pcp7JuVF.js";
+import { resolveAgentDir } from "openclaw/plugin-sdk/agent-runtime";
+import { getSessionEntry, resolveStorePath } from "openclaw/plugin-sdk/session-store-runtime";
+//#region extensions/codex/src/app-server/native-subagent-history.ts
+const MAX_SUBAGENT_ANCESTRY_READS = 32;
+const taskHistoryToolItems = {
+	itemToolArgs,
+	itemTranscriptResultText
+};
+function parentThreadId(thread) {
+	const source = thread.source;
+	const spawn = source && typeof source === "object" && "subAgent" in source && typeof source.subAgent === "object" && "thread_spawn" in source.subAgent ? source.subAgent.thread_spawn : void 0;
+	return thread.parentThreadId?.trim() ?? spawn?.parent_thread_id.trim();
+}
+/** Resolves history from the parent binding's native store without adopting the child. */
+async function readCodexNativeSubagentHistory(params, options) {
+	params.assertCurrent();
+	const { task, cfg } = params;
+	const sessionKey = task.requesterSessionKey;
+	const agentId = task.agentId;
+	const threadId = task.runId?.startsWith("codex-thread:") ? task.runId.slice(CODEX_NATIVE_SUBAGENT_RUN_ID_PREFIX.length) : void 0;
+	if (task.taskKind !== "codex-native" || !sessionKey || !agentId || !threadId) throw new Error("Subagent transcript owner is unavailable.");
+	const storePath = resolveStorePath(cfg.session?.store, { agentId });
+	const readSession = () => getSessionEntry({
+		agentId,
+		sessionKey,
+		storePath,
+		hydrateSkillPromptRefs: false,
+		readConsistency: "latest"
+	});
+	const session = readSession();
+	if (!session?.sessionId) throw new Error("Subagent parent session is unavailable.");
+	const sessionId = session.sessionId;
+	const lifecycleRevision = session.lifecycleRevision;
+	const historyOwner = readCodexNativeSubagentHistoryOwner(task.detail);
+	if (historyOwner && (historyOwner.lifecycleRevision ? historyOwner.lifecycleRevision !== lifecycleRevision : historyOwner.sessionId !== sessionId)) throw new Error("Subagent history owner changed; reconnect its parent session.");
+	const identity = sessionBindingIdentity({
+		agentId,
+		sessionId,
+		sessionKey,
+		config: cfg
+	});
+	const binding = options.bindingStore.read(identity);
+	if (!binding || binding.pendingSupervisionBranch) throw new Error("Subagent parent thread is unavailable.");
+	if (historyOwner && historyOwner.connectionFingerprint !== codexNativeSubagentHistoryConnectionFingerprint(binding)) throw new Error("Subagent history owner changed; reconnect its parent session.");
+	const historyParentThreadId = historyOwner?.parentThreadId ?? binding.threadId;
+	const assertCurrent = () => {
+		params.assertCurrent();
+		const currentSession = readSession();
+		const current = options.bindingStore.read(identity);
+		if (currentSession?.sessionId !== sessionId || currentSession?.lifecycleRevision !== lifecycleRevision || current?.threadId !== binding.threadId || current?.appServerRuntimeFingerprint !== binding.appServerRuntimeFingerprint || current?.connectionScope !== binding.connectionScope || current?.authProfileId !== binding.authProfileId) throw new Error("Subagent parent changed; refresh its transcript.");
+	};
+	const agentDir = resolveAgentDir(cfg, agentId);
+	const connection = resolveCodexBindingAppServerConnection({
+		binding,
+		pluginConfig: options.pluginConfig,
+		agentDir,
+		authProfileId: binding.authProfileId
+	});
+	const client = await getLeasedSharedCodexAppServerClient({
+		startOptions: connection.appServer.start,
+		timeoutMs: connection.appServer.requestTimeoutMs,
+		authProfileId: connection.clientAuthProfileId,
+		agentDir,
+		config: cfg,
+		assertCurrent
+	});
+	try {
+		assertCurrent();
+		const fingerprint = binding.connectionScope === "supervision" ? buildCodexAppServerConnectionFingerprint(connection.appServer, agentDir) : buildCodexAppServerRuntimeFingerprint({
+			appServer: connection.appServer,
+			appServerVersion: client.getServerVersion(),
+			runtimeIdentity: client.getRuntimeIdentity()
+		});
+		if (!binding.appServerRuntimeFingerprint || fingerprint !== binding.appServerRuntimeFingerprint) throw new Error("Subagent connection changed; reconnect its parent session.");
+		const { thread } = await client.request("thread/read", {
+			threadId,
+			includeTurns: false
+		}, { assertCurrent });
+		assertCurrent();
+		if (thread.id !== threadId || threadId === historyParentThreadId) throw new Error("Subagent transcript does not belong to this parent session.");
+		const visited = /* @__PURE__ */ new Set([threadId]);
+		let ancestor = thread;
+		for (;;) {
+			const parentId = parentThreadId(ancestor);
+			if (parentId === historyParentThreadId) break;
+			if (!parentId || visited.has(parentId) || visited.size >= MAX_SUBAGENT_ANCESTRY_READS) throw new Error("Subagent transcript does not belong to this parent session.");
+			visited.add(parentId);
+			const response = await client.request("thread/read", {
+				threadId: parentId,
+				includeTurns: false
+			}, { assertCurrent });
+			assertCurrent();
+			if (response.thread.id !== parentId) throw new Error("Subagent transcript does not belong to this parent session.");
+			ancestor = response.thread;
+		}
+		const page = await readCodexThreadHistoryPage({
+			listItemPage: async (request) => {
+				assertCurrent();
+				const result = await client.request("thread/items/list", request, { assertCurrent });
+				assertCurrent();
+				return result;
+			},
+			listTurnPage: async (request) => {
+				assertCurrent();
+				const result = await client.request("thread/turns/list", request, { assertCurrent });
+				assertCurrent();
+				return result;
+			}
+		}, thread, {
+			threadId,
+			cursor: params.cursor,
+			limit: Math.max(1, Math.floor(Math.min(params.limit, 200) / 2))
+		}, {
+			project: (entries) => entries.map((entry) => projectCodexThreadHistoryItem(thread, entry, taskHistoryToolItems).map((message) => {
+				const messageIdentity = readMirrorIdentity(message);
+				if (!messageIdentity) throw new Error("Subagent history message is missing its native identity.");
+				return Object.assign(message, { messageId: JSON.stringify([threadId, messageIdentity]) });
+			})),
+			fits: (result) => Buffer.byteLength(JSON.stringify(result), "utf8") <= 524288
+		});
+		assertCurrent();
+		return {
+			messages: page.items.toReversed().flat(),
+			...page.nextCursor ? { nextCursor: page.nextCursor } : {}
+		};
+	} finally {
+		releaseLeasedSharedCodexAppServerClient(client);
+	}
+}
+//#endregion
+export { readCodexNativeSubagentHistory };

package/dist/native-subagent-history-owner-Pcp7JuVF.js

@@ -0,0 +1,34 @@
+import { asOptionalRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { createHash } from "node:crypto";
+//#region extensions/codex/src/app-server/native-subagent-history-owner.ts
+function codexNativeSubagentHistoryConnectionFingerprint(binding) {
+	if (!binding.appServerRuntimeFingerprint) return;
+	return createHash("sha256").update(JSON.stringify([
+		binding.appServerRuntimeFingerprint,
+		binding.connectionScope ?? null,
+		binding.authProfileId ?? null
+	])).digest("hex");
+}
+function createCodexNativeSubagentHistoryOwner(params) {
+	const connectionFingerprint = codexNativeSubagentHistoryConnectionFingerprint(params.binding);
+	return connectionFingerprint ? {
+		parentThreadId: params.parentThreadId,
+		sessionId: params.sessionId,
+		...params.lifecycleRevision ? { lifecycleRevision: params.lifecycleRevision } : {},
+		connectionFingerprint
+	} : void 0;
+}
+function readCodexNativeSubagentHistoryOwner(detail) {
+	const value = asOptionalRecord(detail)?.nativeHistory;
+	if (value === void 0) return;
+	const owner = asOptionalRecord(value);
+	if (typeof owner?.parentThreadId !== "string" || !owner.parentThreadId.trim() || typeof owner.sessionId !== "string" || !owner.sessionId.trim() || owner.lifecycleRevision !== void 0 && (typeof owner.lifecycleRevision !== "string" || !owner.lifecycleRevision.trim()) || typeof owner.connectionFingerprint !== "string" || !/^[a-f0-9]{64}$/u.test(owner.connectionFingerprint)) throw new Error("Subagent history owner is invalid.");
+	return {
+		parentThreadId: owner.parentThreadId,
+		sessionId: owner.sessionId,
+		...typeof owner.lifecycleRevision === "string" ? { lifecycleRevision: owner.lifecycleRevision } : {},
+		connectionFingerprint: owner.connectionFingerprint
+	};
+}
+//#endregion
+export { createCodexNativeSubagentHistoryOwner as n, readCodexNativeSubagentHistoryOwner as r, codexNativeSubagentHistoryConnectionFingerprint as t };