@openclaw/codex 2026.10.5-beta.4 → 2026.10.10-beta.2

package/dist/media-understanding-provider.js

@@ -33,7 +33,7 @@ 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("./.setup/bounded-turn-DfIJtRlv.mjs");
+	const { runBoundedCodexAppServerTurn } = await import("./.setup/bounded-turn-BQkmyyjB.mjs");
 	req.signal?.throwIfAborted();
 	const { text } = await runBoundedCodexAppServerTurn({
 		config: req.cfg,
@@ -73,7 +73,7 @@ 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("./.setup/bounded-turn-DfIJtRlv.mjs");
+	const { runBoundedCodexAppServerTurn } = await import("./.setup/bounded-turn-BQkmyyjB.mjs");
 	req.signal?.throwIfAborted();
 	const { text } = await runBoundedCodexAppServerTurn({
 		config: req.cfg,

package/dist/migration-provider-api.js

@@ -1,2 +1 @@
-import { t as buildCodexMigrationProvider } from "./.setup/provider-LWKll6dV.mjs";
-export { buildCodexMigrationProvider as buildMigrationProvider };
+export { t as buildMigrationProvider } from "./.setup/provider-C_1fMsyD.mjs";

package/dist/native-session-binding-api.js

@@ -1,2 +1 @@
-import { a as readStoredCodexAppServerBinding } from "./.setup/session-binding-record-codec-BpH8u_G9.mjs";
-export { readStoredCodexAppServerBinding as readNativeSessionBindingRecord };
+export { a as readNativeSessionBindingRecord } from "./.setup/session-binding-record-codec-DvmOI7g_.mjs";

package/dist/provider-discovery.js

@@ -5,7 +5,7 @@ const codexProviderDiscovery = {
 	auth: [],
 	prepareSyntheticAuth: async ({ config, provider, env, signal, pluginRoot }) => {
 		if (provider !== "codex") return;
-		const { probeCodexNativeAuth } = await import("./.setup/native-auth-esN5MdIv.mjs");
+		const { probeCodexNativeAuth } = await import("./.setup/native-auth-DpZIaY8N.mjs");
 		return await probeCodexNativeAuth({
 			config,
 			env,

package/dist/session-history-worker-entrypoint.js

@@ -0,0 +1,12 @@
+//#region extensions/codex/session-history-worker-entrypoint.ts
+const codexHistoryWorkerEntrypoint = {
+	currentModuleUrl: import.meta.url,
+	sourceWorkerName: "session-history.worker",
+	distWorkerPath: "extensions/codex/session-history.worker.js",
+	package: {
+		name: "@openclaw/codex",
+		distWorkerPath: "session-history.worker.js"
+	}
+};
+//#endregion
+export { codexHistoryWorkerEntrypoint };

package/dist/session-history-worker-runtime.js

@@ -1,21 +1,12 @@
+import { codexHistoryWorkerEntrypoint } from "./session-history-worker-entrypoint.js";
 import { n as codexHistoryRejectionReason } from "./.setup/history-rejection-B4nOXNXF.mjs";
 import { t as consumeCodexHistory } from "./.setup/session-history-read-BI_2jRED.mjs";
-import { n as projectVerifiedSettledCodexMessages, t as runCodexHistoryWorkerInput } from "./.setup/session-history.worker-DJQfek5p.mjs";
-import { n as resolveCodexHistoryTarget } from "./.setup/session-history-BO6i_pfk.mjs";
+import { n as resolveCodexHistoryTarget } from "./.setup/session-history-7W0cgTXF.mjs";
+import { t as projectVerifiedSettledCodexMessages } from "./.setup/settled-turn-evidence--tRW6fSm.mjs";
 import { WorkerTaskPool, resolveRuntimeWorkerArgv, resolveRuntimeWorkerUrl } from "openclaw/plugin-sdk/process-runtime";
-import { isIncognitoSessionKey } from "openclaw/plugin-sdk/session-key-runtime";
 import { fileURLToPath } from "node:url";
 import { SessionTranscriptReadFenceError, captureCodexSessionContextReader, readCodexSessionContextProjection } from "openclaw/plugin-sdk/codex-session-transcript-runtime";
 //#region extensions/codex/session-history-worker-runtime.ts
-const codexHistoryWorkerEntrypoint = {
-	currentModuleUrl: import.meta.url,
-	sourceWorkerName: "session-history.worker",
-	distWorkerPath: "extensions/codex/session-history.worker.js",
-	package: {
-		name: "@openclaw/codex",
-		distWorkerPath: "session-history.worker.js"
-	}
-};
 const sourceWorkerUrl = resolveRuntimeWorkerUrl(codexHistoryWorkerEntrypoint);
 const sourceNeedsBuiltFallback = /\.[cm]?ts$/u.test(sourceWorkerUrl.pathname) && (typeof process.versions.bun === "string" || resolveRuntimeWorkerArgv(sourceWorkerUrl).length === 1);
 const historyReads = new WorkerTaskPool({
@@ -23,14 +14,12 @@ const historyReads = new WorkerTaskPool({
 		...codexHistoryWorkerEntrypoint,
 		root: fileURLToPath(new URL("../..", import.meta.url))
 	}) : sourceWorkerUrl,
-	workerClass: "reader",
-	maxWorkers: 1
+	workerClass: "reader"
 });
 async function projectCodexSettledHistoryInWorker(target, signal, contextReader) {
 	signal?.throwIfAborted();
-	if (contextReader && !target.sessionTarget) throw new Error("Actor history requires a captured sessionTarget");
-	const resolved = resolveCodexHistoryTarget(target);
-	const reader = contextReader ?? (target.sessionTarget && resolved.kind === "sqlite" ? captureCodexSessionContextReader({
+	const resolved = await resolveCodexHistoryTarget(target);
+	const reader = contextReader ?? (resolved.kind === "sqlite" ? captureCodexSessionContextReader({
 		...target.sessionTarget,
 		...resolved.target
 	}, signal) : void 0);
@@ -79,7 +68,7 @@ async function projectCodexSettledHistoryInWorker(target, signal, contextReader)
 				physicalSource,
 				evidence
 			};
-			const result = isIncognitoSessionKey(captured.sessionKey) ? await runCodexHistoryWorkerInput(input) : await historyReads.run(input, {
+			const result = await historyReads.run(input, {
 				timeoutMs: 6e4,
 				signal
 			});

package/dist/session-history.worker.js

@@ -1,2 +1,18 @@
-import { t as runCodexHistoryWorkerInput } from "./.setup/session-history.worker-DJQfek5p.mjs";
-export { runCodexHistoryWorkerInput };
+import { n as readCodexNativeHistory } from "./.setup/session-history-read-BI_2jRED.mjs";
+import { t as projectVerifiedSettledCodexMessages } from "./.setup/settled-turn-evidence--tRW6fSm.mjs";
+import { serveWorkerTasks } from "openclaw/plugin-sdk/worker-task-server";
+//#region extensions/codex/session-history.worker.ts
+async function runCodexHistoryWorkerInput(input) {
+	const request = input;
+	let version;
+	const onSnapshot = (value) => {
+		version = value;
+	};
+	return {
+		result: await readCodexNativeHistory(request.target, request.sessionId, (messages) => projectVerifiedSettledCodexMessages(messages, request.evidence), request.admission, onSnapshot, request.physicalSource),
+		version
+	};
+}
+serveWorkerTasks(runCodexHistoryWorkerInput);
+//#endregion
+export {};

package/openclaw.plugin.json

@@ -753,7 +753,7 @@
     },
     "sessionCatalog.homes": {
       "label": "Additional Codex Homes",
-      "help": "Existing local Codex home directories to include in native session discovery. String paths use the canonical directory basename as their label; object entries can override it with label. Paths are canonicalized and deduplicated. Requires appServer.transport=stdio and a Gateway restart.",
+      "help": "Existing local Codex home directories to include in native session discovery. String paths use the last directory name of the resolved path as their label; object entries can override it with label. Paths are resolved and duplicates are removed. Requires appServer.transport=stdio and a Gateway restart.",
       "advanced": true
     },
     "codexDynamicToolsLoading": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openclaw/codex",
-  "version": "2026.10.5-beta.4",
+  "version": "2026.10.10-beta.2",
   "description": "OpenClaw Codex app-server harness and native session supervision plugin.",
   "repository": {
     "type": "git",
@@ -9,10 +9,10 @@
   "type": "module",
   "dependencies": {
     "@openai/codex": "0.160.0",
-    "@openclaw/fs-safe": "0.25.0",
+    "@openclaw/fs-safe": "0.26.5",
     "semver": "7.8.5",
     "smol-toml": "1.9.0",
-    "typebox": "1.3.34",
+    "typebox": "1.3.35",
     "ws": "8.22.0",
     "zod": "4.6.5"
   },
@@ -38,10 +38,10 @@
       ]
     },
     "compat": {
-      "pluginApi": ">=2026.10.5-beta.4"
+      "pluginApi": ">=2026.10.10-beta.2"
     },
     "build": {
-      "openclawVersion": "2026.10.5-beta.4",
+      "openclawVersion": "2026.10.10-beta.2",
       "workerEntries": [
         "./catalog-page.worker.ts"
       ]
@@ -66,7 +66,7 @@
     "assets/activity.svg"
   ],
   "peerDependencies": {
-    "openclaw": ">=2026.10.5-beta.4"
+    "openclaw": ">=2026.10.10-beta.2"
   },
   "peerDependenciesMeta": {
     "openclaw": {

package/dist/.setup/attempt-terminal-jO5IMj9K.mjs

@@ -1,2 +0,0 @@
-import { agentHarnessAttemptTerminal as attemptTerminal } from "openclaw/plugin-sdk/agent-harness-runtime";
-export { attemptTerminal as t };

package/dist/.setup/command-rpc-HIvsy3wS.mjs

@@ -1,247 +0,0 @@
-import { i as isJsonObject } from "./protocol-CANUwXJ3.mjs";
-import { o as isCodexAppServerOverloadError, r as CodexAppServerRpcError } from "./rpc-error-C98SHchT.mjs";
-import { n as describeControlFailure, t as CODEX_CONTROL_METHODS } from "./capabilities-DbOzOglY.mjs";
-import { a as withCodexAppServerJsonClient, r as requestCodexAppServerJson } from "./request-Bo0kKABI.mjs";
-import "./config-C1YVVLEA.mjs";
-import { n as resolveCodexAppServerRuntimeOptions, r as resolveCodexSupervisionAppServerRuntimeOptions } from "./config-runtime-DWzK-k0n.mjs";
-import { a as resolveCodexAppServerAuthProfileStore, r as resolveCodexAppServerAuthProfileId } from "./auth-profile-CgHQ8Vot.mjs";
-import { nt as resolveCodexAppServerPreparedAuthHandoff } from "./shared-client-BCx1wbyA.mjs";
-import { a as isCodexAppServerIndeterminateRequestCancellationError, o as isCodexAppServerIndeterminateTransportError } from "./client-D93nbdB8.mjs";
-import { o as closeCodexStartupClientBestEffort } from "./attempt-client-cleanup-zNuNTKVr.mjs";
-import { r as prepareCodexAppServerAuthBinding } from "./auth-binding-BaxlhaNx.mjs";
-import { r as listCodexAppServerModels } from "./models-BHpbAuz8.mjs";
-import { n as createCodexSessionGenerationSupersededError } from "./session-binding-JEHNMPsr.mjs";
-import { t as resumeCodexAppServerThread } from "./thread-resume-D-3bsr1j.mjs";
-import { t as __exportAll } from "./session-binding-sidecars-DD-enC8w.mjs";
-import { resolveAgentDir, resolveSessionAgentIdsStrict } from "openclaw/plugin-sdk/agent-scope-runtime";
-import { resolveAgentWorkspaceDir } from "openclaw/plugin-sdk/agent-runtime";
-import { prepareAgentRuntimeAuth } from "openclaw/plugin-sdk/agent-harness-runtime";
-import { getSessionEntry, resolveStorePath } from "openclaw/plugin-sdk/session-store-runtime";
-import { resolveSessionModelRef } from "openclaw/plugin-sdk/model-session-runtime";
-import { resolveApiKeyForProvider } from "openclaw/plugin-sdk/provider-auth-runtime";
-//#region extensions/codex/src/command-rpc.ts
-var command_rpc_exports = /* @__PURE__ */ __exportAll({
-	codexControlRequest: () => codexControlRequest,
-	prepareCodexControlSessionAuth: () => prepareCodexControlSessionAuth,
-	readCodexStatusProbes: () => readCodexStatusProbes,
-	requestOptions: () => requestOptions,
-	safeCodexControlRequest: () => safeCodexControlRequest
-});
-/** Selects the same prepared auth partition as an admitted session turn. */
-async function prepareCodexControlSessionAuth(options, startOptions) {
-	if (!options.config || !options.sessionKey || !options.sessionId) {
-		if (options.onResponse) throw new Error("Codex control subscription requires admitted session authority.");
-		return {
-			authProfileId: options.authProfileId ?? void 0,
-			clientOptions: { authProfileId: options.authProfileId }
-		};
-	}
-	const config = options.config;
-	const { sessionAgentId } = resolveSessionAgentIdsStrict({
-		config,
-		sessionKey: options.sessionKey,
-		agentId: options.agentId
-	});
-	const agentDir = options.agentDir ?? resolveAgentDir(config, sessionAgentId);
-	const workspaceDir = resolveAgentWorkspaceDir(config, sessionAgentId);
-	const entry = getSessionEntry({
-		agentId: sessionAgentId,
-		storePath: options.storePath?.trim() || resolveStorePath(config.session?.store, { agentId: sessionAgentId }),
-		sessionKey: options.sessionKey,
-		hydrateSkillPromptRefs: false,
-		readConsistency: "latest"
-	});
-	if (entry?.sessionId !== options.sessionId) throw createCodexSessionGenerationSupersededError(options.sessionId);
-	if (options.authProfileId === null || startOptions.homeScope === "user") return {
-		authProfileId: options.authProfileId ?? void 0,
-		clientOptions: { authProfileId: options.authProfileId }
-	};
-	const model = resolveSessionModelRef(config, entry, sessionAgentId);
-	const authProfileId = entry?.authProfileOverride ?? options.authProfileId;
-	const store = resolveCodexAppServerAuthProfileStore({
-		agentDir,
-		config,
-		authProfileId
-	});
-	const { plan, attempts } = prepareAgentRuntimeAuth({
-		provider: model.provider,
-		modelId: model.model,
-		config,
-		agentDir,
-		workspaceDir,
-		authProfileStore: store,
-		sessionAuthProfileId: authProfileId,
-		sessionAuthProfileSource: entry?.authProfileOverrideSource,
-		harnessId: "codex",
-		harnessAuthBootstrap: "harness"
-	});
-	const route = plan.modelRoute;
-	const resolvedAuth = route ? await resolveApiKeyForProvider({
-		provider: route.provider,
-		modelId: route.modelId,
-		modelApi: route.api,
-		cfg: config,
-		agentDir,
-		workspaceDir,
-		store,
-		profileId: attempts[0]?.profileId,
-		lockedProfile: plan.forwardedAuthProfileSource === "user",
-		allowAuthProfileFallback: attempts[0]?.allowAuthProfileFallback,
-		skipSetupProviderFallback: true
-	}) : void 0;
-	const handoff = await resolveCodexAppServerPreparedAuthHandoff({
-		authRequirement: route?.authRequirement,
-		resolvedApiKey: resolvedAuth?.apiKey,
-		authProfileId: route ? plan.forwardedAuthProfileId : resolveCodexAppServerAuthProfileId({
-			authProfileId: plan.forwardedAuthProfileId,
-			store,
-			config
-		}),
-		authProfileStore: store,
-		agentDir,
-		homeScope: startOptions.homeScope ?? "agent",
-		config,
-		subscriptionProfileRequiredError: "Prepared Codex subscription route requires a forwarded OpenAI OAuth or token profile.",
-		subscriptionProfileUnusableError: "Prepared Codex subscription auth profile is unusable."
-	});
-	const binding = handoff.authProfileId ? await prepareCodexAppServerAuthBinding({
-		authProfileId: handoff.authProfileId,
-		authProfileStore: store,
-		agentDir,
-		config
-	}) : void 0;
-	return {
-		authProfileId: handoff.authProfileId,
-		clientOptions: {
-			...handoff.preparedAuth ? { preparedAuth: handoff.preparedAuth } : { authProfileId: handoff.authProfileId },
-			authRequirement: route?.authRequirement,
-			authProfileStore: binding?.authProfileStore ?? store,
-			authBindingFingerprint: binding?.fingerprint,
-			agentDir
-		}
-	};
-}
-function requestOptions(pluginConfig, limit, config, agentDir) {
-	const runtime = resolveCodexAppServerRuntimeOptions({ pluginConfig });
-	return {
-		limit,
-		timeoutMs: runtime.requestTimeoutMs,
-		startOptions: runtime.start,
-		config,
-		agentDir
-	};
-}
-async function codexControlRequest(pluginConfig, method, requestParams, inputOptions = {}) {
-	const options = { ...inputOptions };
-	try {
-		options.controlObservation?.phase("prepare");
-	} catch {}
-	const runtime = options.startOptions ? resolveCodexSupervisionAppServerRuntimeOptions({ pluginConfig }) : resolveCodexAppServerRuntimeOptions({ pluginConfig });
-	const startOptions = options.startOptions ?? runtime.start;
-	const nativeAuthFork = method === "thread/fork" && options.startOptions !== void 0 && options.authProfileId === null;
-	const auth = options.onResponse && !nativeAuthFork ? await prepareCodexControlSessionAuth(options, startOptions) : {
-		authProfileId: options.authProfileId ?? void 0,
-		clientOptions: { authProfileId: options.authProfileId }
-	};
-	const controlRequestOptions = {
-		timeoutMs: options.timeoutMs ?? runtime.requestTimeoutMs,
-		assertCurrent: options.assertCurrent,
-		startOptions,
-		config: options.config,
-		sessionKey: options.sessionKey,
-		sessionId: options.sessionId,
-		agentDir: options.agentDir,
-		isolated: options.isolated,
-		...options.catalogPreview ? {
-			catalogPreview: true,
-			catalogPreviewCache: options.catalogPreviewCache,
-			catalogRows: options.catalogRows
-		} : {},
-		...options.controlObservation ? { controlObservation: options.controlObservation } : {},
-		...auth.clientOptions
-	};
-	if (options.onResponse || options.beforeRequest) return await withCodexAppServerJsonClient(controlRequestOptions, async (request, client, scope) => {
-		await options.beforeRequest?.(request, client, scope);
-		scope.assertCurrent();
-		let response;
-		if (method === "thread/resume") {
-			if (!isJsonObject(requestParams) || typeof requestParams.threadId !== "string") throw new Error("Codex thread/resume requires a thread id.");
-			response = await resumeCodexAppServerThread({
-				client,
-				request: {
-					...requestParams,
-					threadId: requestParams.threadId
-				},
-				requestResume: () => request({
-					method,
-					requestParams,
-					assertCurrent: options.assertOwnerCurrent
-				}),
-				abandonClient: () => closeCodexStartupClientBestEffort(client)
-			});
-		} else try {
-			response = await request({
-				method,
-				requestParams,
-				assertCurrent: options.assertOwnerCurrent
-			});
-		} catch (error) {
-			if (nativeAuthFork && (isCodexAppServerIndeterminateRequestCancellationError(error) || isCodexAppServerIndeterminateTransportError(error) || error instanceof CodexAppServerRpcError && !isCodexAppServerOverloadError(error))) await closeCodexStartupClientBestEffort(client);
-			throw error;
-		}
-		if (options.onResponse) await options.onResponse(response, client, {
-			authProfileId: auth.authProfileId,
-			assertCurrent: scope.assertCurrent
-		});
-		else scope.assertCurrent();
-		return response;
-	});
-	return await requestCodexAppServerJson({
-		method,
-		requestParams,
-		...controlRequestOptions,
-		...options.assertOwnerCurrent ? { assertCurrent: () => {
-			options.assertOwnerCurrent?.();
-			options.assertCurrent?.();
-		} } : {}
-	});
-}
-async function safeCodexControlRequest(pluginConfig, method, requestParams, options = {}) {
-	return await safeValue(async () => await codexControlRequest(pluginConfig, method, requestParams, options));
-}
-async function readCodexStatusProbes(pluginConfig, config, agentDir) {
-	const options = {
-		config,
-		agentDir
-	};
-	const probe = (method, params) => safeCodexControlRequest(pluginConfig, method, params, options);
-	const [models, account, limits, mcps, skills] = await Promise.all([
-		safeValue(() => listCodexAppServerModels(requestOptions(pluginConfig, 20, config, agentDir))),
-		probe(CODEX_CONTROL_METHODS.account, { refreshToken: false }),
-		probe(CODEX_CONTROL_METHODS.rateLimits, void 0),
-		probe(CODEX_CONTROL_METHODS.listMcpServers, { limit: 100 }),
-		probe(CODEX_CONTROL_METHODS.listSkills, {})
-	]);
-	return {
-		models,
-		account,
-		limits,
-		mcps,
-		skills
-	};
-}
-async function safeValue(read) {
-	try {
-		return {
-			ok: true,
-			value: await read()
-		};
-	} catch (error) {
-		return {
-			ok: false,
-			error: describeControlFailure(error)
-		};
-	}
-}
-//#endregion
-export { requestOptions as a, readCodexStatusProbes as i, command_rpc_exports as n, safeCodexControlRequest as o, prepareCodexControlSessionAuth as r, codexControlRequest as t };