@openclaw/codex 2026.9.3 → 2026.9.4

package/dist/inference-context-Dr_mzvk4.js

@@ -0,0 +1,94 @@
+import { o as isJsonObject } from "./protocol-5bh1G-H7.js";
+import { randomUUID } from "node:crypto";
+//#region extensions/codex/src/app-server/inference-context.ts
+const MAX_CONTEXT_BYTES = 262144;
+const MAX_ACTIVE_ROOTS = 64;
+const CODEX_INFERENCE_GENERATION_KEY = "openclaw_inference_generation";
+/** One physical inference transport owns these confidential, nonpersistent snapshots. */
+function createCodexInferenceContext(assertClientCurrent) {
+	const roots = /* @__PURE__ */ new Map();
+	let closed = false;
+	const assertOpen = () => {
+		if (closed) throw new Error("Codex parent-local inference transport is closed");
+		assertClientCurrent();
+	};
+	return {
+		register(params) {
+			assertOpen();
+			params.signal.throwIfAborted();
+			params.assertCurrent();
+			if (Buffer.byteLength(params.text) > MAX_CONTEXT_BYTES) throw new Error("Codex parent-local context exceeds the 256 KiB inference limit");
+			if (!roots.has(params.threadId) && roots.size >= MAX_ACTIVE_ROOTS) throw new Error("Codex parent-local inference root limit reached");
+			roots.get(params.threadId)?.release();
+			const controller = new AbortController();
+			const registration = {
+				generation: randomUUID(),
+				text: params.text,
+				controller,
+				assertCurrent: () => {
+					assertOpen();
+					controller.signal.throwIfAborted();
+					params.signal.throwIfAborted();
+					params.assertCurrent();
+					if (roots.get(params.threadId) !== registration) throw new Error("Codex parent-local inference generation was replaced");
+				},
+				release: () => {
+					if (roots.get(params.threadId) === registration) roots.delete(params.threadId);
+					registration.text = "";
+					controller.abort();
+					params.signal.removeEventListener("abort", registration.release);
+				}
+			};
+			roots.set(params.threadId, registration);
+			params.signal.addEventListener("abort", registration.release, { once: true });
+			return {
+				generation: registration.generation,
+				release: registration.release
+			};
+		},
+		/** Caller must authenticate its private transport before parsing any model request. */
+		prepare(body) {
+			assertOpen();
+			const metadata = isJsonObject(body.client_metadata) ? body.client_metadata : void 0;
+			const raw = metadata?.["x-codex-turn-metadata"];
+			if (typeof raw !== "string" || Buffer.byteLength(raw) > 1048576) throw new Error("Codex inference request is missing bounded native metadata");
+			const value = JSON.parse(raw);
+			if (!isJsonObject(value)) throw new Error("Codex inference request has invalid native metadata");
+			const threadId = value.thread_id;
+			if (metadata?.thread_id != null && threadId != null && metadata.thread_id !== threadId) throw new Error("Codex inference thread metadata disagrees");
+			const child = Boolean(value.parent_thread_id || value.subagent_kind || metadata?.["x-openai-subagent"] || metadata?.["x-codex-parent-thread-id"]);
+			const kind = value.request_kind;
+			if (child || kind === "compaction" || kind === "memory") return {
+				body,
+				assertCurrent: assertOpen,
+				signal: void 0
+			};
+			if (kind !== "turn" && kind !== "prewarm") throw new Error("Codex inference request has an unsupported native purpose");
+			const registration = typeof threadId === "string" ? roots.get(threadId) : void 0;
+			const generation = value[CODEX_INFERENCE_GENERATION_KEY];
+			if (kind === "prewarm" && body.generate === false && generation == null) return {
+				body,
+				assertCurrent: assertOpen,
+				signal: void 0
+			};
+			if (!registration || generation !== registration.generation) throw new Error("Codex inference has no current admitted parent generation");
+			registration.assertCurrent();
+			const instructions = body.instructions;
+			if (instructions !== void 0 && typeof instructions !== "string") throw new Error("Codex inference request has invalid top-level instructions");
+			return {
+				body: registration.text ? {
+					...body,
+					instructions: instructions === void 0 ? registration.text : instructions + "\n\n" + registration.text
+				} : body,
+				assertCurrent: registration.assertCurrent,
+				signal: registration.controller.signal
+			};
+		},
+		close() {
+			closed = true;
+			for (const registration of roots.values()) registration.release();
+		}
+	};
+}
+//#endregion
+export { createCodexInferenceContext as n, CODEX_INFERENCE_GENERATION_KEY as t };

package/dist/inference-proxy-HGXKUIre.js

@@ -0,0 +1,311 @@
+import { o as isJsonObject } from "./protocol-5bh1G-H7.js";
+import { n as createCodexInferenceContext } from "./inference-context-Dr_mzvk4.js";
+import { zstdCompress, zstdDecompress } from "node:zlib";
+import { promisify } from "node:util";
+import { Writable } from "node:stream";
+import WebSocket, { WebSocketServer } from "ws";
+import { createServer } from "node:http";
+import { createNodeProxyAgent } from "openclaw/plugin-sdk/fetch-runtime";
+import { generateSecureToken } from "openclaw/plugin-sdk/secure-random-runtime";
+import { fetchWithSsrFGuard, isBlockedHostnameOrIp, resolvePinnedHostnameWithPolicy } from "openclaw/plugin-sdk/ssrf-runtime";
+//#region extensions/codex/src/app-server/inference-proxy.ts
+const MAX_BODY_BYTES = 33554432;
+const MAX_ERROR_BODY_BYTES = 1048576;
+const MAX_CONNECTIONS = 16;
+const compress = promisify(zstdCompress);
+const decompress = promisify(zstdDecompress);
+const HOP_HEADERS = /* @__PURE__ */ new Set([
+	"connection",
+	"keep-alive",
+	"proxy-authenticate",
+	"proxy-authorization",
+	"te",
+	"trailer",
+	"transfer-encoding",
+	"upgrade",
+	"host",
+	"content-length"
+]);
+const FAILURE = "Codex parent-local inference transport failed; retry on a fresh connection.";
+/** Private, fixed-destination relay. No upstream credentials or model content are retained. */
+async function createCodexInferenceProxy(params) {
+	const upstream = new URL(params.upstream);
+	if (upstream.protocol !== "https:" || upstream.username || upstream.password || upstream.hash) throw new Error("Codex inference requires a credential-free HTTPS upstream URL");
+	const lifetime = new AbortController();
+	const assertCurrent = () => {
+		lifetime.signal.throwIfAborted();
+		params.assertCurrent();
+	};
+	const context = createCodexInferenceContext(assertCurrent);
+	const pathPrefix = "/" + generateSecureToken({
+		bytes: 32,
+		redact: true
+	}) + upstream.pathname.replace(/\/$/, "");
+	const active = /* @__PURE__ */ new Set();
+	const sockets = /* @__PURE__ */ new Set();
+	const wss = new WebSocketServer({
+		noServer: true,
+		maxPayload: MAX_BODY_BYTES,
+		perMessageDeflate: false
+	});
+	const handshakeHeaders = /* @__PURE__ */ new WeakMap();
+	wss.on("headers", (headers, request) => {
+		for (const [key, value] of Object.entries(handshakeHeaders.get(request) ?? {})) if (!key.startsWith("sec-websocket-")) headers.push(key + ": " + value);
+		handshakeHeaders.delete(request);
+	});
+	const resolveTarget = (request) => {
+		assertCurrent();
+		if (request.headers.origin || !request.url?.startsWith(pathPrefix + "/") || isBlockedHostnameOrIp(upstream.hostname)) throw new Error(FAILURE);
+		const suffix = request.url.slice(pathPrefix.length);
+		if (suffix.startsWith("//") || suffix.includes("\\") || /%2e|%2f|%5c|(?:^|\/)\.\.?(?:\/|\?|$)/i.test(suffix)) throw new Error(FAILURE);
+		const target = new URL(upstream);
+		const incoming = new URL(suffix, "http://localhost");
+		target.pathname = upstream.pathname.replace(/\/$/, "") + incoming.pathname;
+		for (const [key, value] of incoming.searchParams) target.searchParams.append(key, value);
+		return {
+			target,
+			sampling: incoming.pathname === "/responses"
+		};
+	};
+	const prepare = (bytes, sampling) => {
+		assertCurrent();
+		if (!sampling) return {
+			bytes,
+			assertCurrent,
+			signal: void 0
+		};
+		const value = JSON.parse(bytes.toString("utf8"));
+		if (!isJsonObject(value)) throw new Error(FAILURE);
+		const prepared = context.prepare(value);
+		const rewritten = Buffer.from(JSON.stringify(prepared.body));
+		if (rewritten.length > MAX_BODY_BYTES) throw new Error(FAILURE);
+		return {
+			...prepared,
+			bytes: rewritten
+		};
+	};
+	const server = createServer((req, res) => {
+		const controller = new AbortController();
+		let guarded;
+		const abort = () => controller.abort();
+		req.once("aborted", abort);
+		res.once("close", abort);
+		(async () => {
+			try {
+				const { target, sampling } = resolveTarget(req);
+				if (req.method !== "POST" || active.size >= MAX_CONNECTIONS) throw new Error(FAILURE);
+				active.add(controller);
+				const wire = await readProxyBody(req, MAX_BODY_BYTES);
+				const encoding = req.headers["content-encoding"];
+				if (encoding && encoding !== "identity" && encoding !== "zstd") throw new Error(FAILURE);
+				const decoded = encoding === "zstd" ? await decompress(wire, { maxOutputLength: MAX_BODY_BYTES }) : wire;
+				assertCurrent();
+				const prepared = prepare(decoded, sampling);
+				const body = Buffer.from(encoding === "zstd" ? await compress(prepared.bytes) : prepared.bytes);
+				prepared.assertCurrent();
+				const signal = AbortSignal.any([
+					lifetime.signal,
+					controller.signal,
+					...prepared.signal ? [prepared.signal] : []
+				]);
+				guarded = await fetchWithSsrFGuard({
+					url: target.toString(),
+					init: {
+						method: "POST",
+						headers: relayHeaders(req.headers),
+						body,
+						signal
+					},
+					signal,
+					beforeRequest: prepared.assertCurrent,
+					requireHttps: true,
+					maxRedirects: 0,
+					capture: false,
+					mode: "trusted_env_proxy",
+					auditContext: "codex-parent-local-inference"
+				});
+				prepared.assertCurrent();
+				const headers = Object.fromEntries(guarded.response.headers);
+				delete headers["content-encoding"];
+				res.writeHead(guarded.response.status, relayHeaders(headers));
+				if (!guarded.response.body) res.end();
+				else await guarded.response.body.pipeTo(Writable.toWeb(res), { signal });
+			} catch {
+				if (!res.headersSent && !res.destroyed) res.writeHead(502, { "content-type": "text/plain" }).end(FAILURE);
+				else res.destroy();
+			} finally {
+				active.delete(controller);
+				req.off("aborted", abort);
+				res.off("close", abort);
+				await guarded?.release().catch(() => void 0);
+			}
+		})();
+	});
+	server.maxConnections = MAX_CONNECTIONS;
+	server.requestTimeout = 3e4;
+	server.headersTimeout = 1e4;
+	server.on("upgrade", (req, socket, head) => {
+		(async () => {
+			let remote;
+			let local;
+			let proxyAgent;
+			const controller = new AbortController();
+			const close = () => {
+				controller.abort();
+				active.delete(controller);
+				remote?.terminate();
+				local?.terminate();
+				proxyAgent?.destroy();
+				if (remote) sockets.delete(remote);
+				if (local) sockets.delete(local);
+				socket.destroy();
+			};
+			try {
+				const { target, sampling } = resolveTarget(req);
+				if (!sampling || active.size >= MAX_CONNECTIONS) throw new Error(FAILURE);
+				active.add(controller);
+				socket.once("close", close);
+				socket.once("error", close);
+				const signal = AbortSignal.any([lifetime.signal, controller.signal]);
+				proxyAgent = createNodeProxyAgent({
+					mode: "env",
+					targetUrl: target.href
+				});
+				const lookup = proxyAgent ? void 0 : (await resolvePinnedHostnameWithPolicy(target.hostname, { signal })).lookup;
+				assertCurrent();
+				signal.throwIfAborted();
+				target.protocol = "wss:";
+				const headers = relayHeaders(req.headers);
+				for (const key of Object.keys(headers)) if (key.startsWith("sec-websocket-")) delete headers[key];
+				remote = new WebSocket(target, {
+					headers,
+					...proxyAgent ? { agent: proxyAgent } : { lookup },
+					followRedirects: false,
+					perMessageDeflate: false,
+					maxPayload: MAX_BODY_BYTES,
+					handshakeTimeout: 1e4
+				});
+				sockets.add(remote);
+				remote.once("upgrade", (response) => {
+					handshakeHeaders.set(req, relayHeaders(response.headers));
+				});
+				remote.once("error", close);
+				remote.once("close", close);
+				remote.once("unexpected-response", (_request, response) => {
+					(async () => {
+						try {
+							const body = await readProxyBody(response, MAX_ERROR_BODY_BYTES);
+							assertCurrent();
+							signal.throwIfAborted();
+							const failureHeaders = Object.entries(relayHeaders(response.headers)).map(([key, value]) => key + ": " + value);
+							failureHeaders.push("Connection: close", "Content-Length: " + body.length);
+							const status = "HTTP/1.1 " + response.statusCode + " " + (response.statusMessage ?? "Upstream refused");
+							socket.end(Buffer.concat([Buffer.from(status + "\r\n" + failureHeaders.join("\r\n") + "\r\n\r\n"), body]), close);
+						} catch {
+							close();
+						}
+					})();
+				});
+				remote.once("open", () => {
+					try {
+						assertCurrent();
+						signal.throwIfAborted();
+						wss.handleUpgrade(req, socket, head, (accepted) => {
+							local = accepted;
+							sockets.add(accepted);
+							accepted.once("error", close);
+							accepted.once("close", close);
+							let releaseFrame = () => {};
+							accepted.on("message", (data, binary) => {
+								try {
+									if (binary) throw new Error(FAILURE);
+									const prepared = prepare(rawBytes(data), true);
+									prepared.assertCurrent();
+									releaseFrame();
+									const onAbort = () => close();
+									prepared.signal?.addEventListener("abort", onAbort, { once: true });
+									releaseFrame = () => prepared.signal?.removeEventListener("abort", onAbort);
+									if (!remote || remote.readyState !== WebSocket.OPEN || remote.bufferedAmount + prepared.bytes.length > MAX_BODY_BYTES) throw new Error(FAILURE);
+									remote.send(prepared.bytes, { binary: false }, (error) => {
+										if (error) close();
+									});
+								} catch {
+									close();
+								}
+							});
+							accepted.once("close", () => releaseFrame());
+							remote.on("message", (data, binary) => {
+								if (accepted.readyState !== WebSocket.OPEN || accepted.bufferedAmount + rawBytes(data).length > MAX_BODY_BYTES) {
+									close();
+									return;
+								}
+								accepted.send(data, { binary }, (error) => {
+									if (error) close();
+								});
+							});
+						});
+					} catch {
+						close();
+					}
+				});
+			} catch {
+				close();
+			}
+		})();
+	});
+	const close = () => {
+		lifetime.abort();
+		context.close();
+		for (const controller of active) controller.abort();
+		for (const socket of sockets) socket.terminate();
+		server.close();
+		server.closeAllConnections();
+		wss.close();
+	};
+	try {
+		await new Promise((resolve, reject) => {
+			server.once("error", reject);
+			server.listen(0, "127.0.0.1", () => {
+				server.off("error", reject);
+				resolve();
+			});
+		});
+		assertCurrent();
+		server.on("error", close);
+		const address = server.address();
+		if (!address || typeof address === "string") throw new Error(FAILURE);
+		return {
+			context,
+			upstream: upstream.toString(),
+			baseUrl: "http://127.0.0.1:" + address.port + pathPrefix,
+			assertCurrent,
+			close
+		};
+	} catch (error) {
+		close();
+		throw error;
+	}
+}
+async function readProxyBody(stream, maxBytes) {
+	const chunks = [];
+	let size = 0;
+	for await (const chunk of stream) {
+		const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+		size += bytes.length;
+		if (size > maxBytes) throw new Error(FAILURE);
+		chunks.push(bytes);
+	}
+	return Buffer.concat(chunks);
+}
+function rawBytes(data) {
+	return Array.isArray(data) ? Buffer.concat(data) : Buffer.isBuffer(data) ? data : Buffer.from(data);
+}
+function relayHeaders(input) {
+	const excluded = new Set(HOP_HEADERS);
+	for (const token of (input.connection ?? "").split(",")) excluded.add(token.trim().toLowerCase());
+	const output = {};
+	for (const [key, value] of Object.entries(input)) if (value !== void 0 && !excluded.has(key.toLowerCase())) output[key.toLowerCase()] = Array.isArray(value) ? value.join(", ") : value;
+	return output;
+}
+//#endregion
+export { createCodexInferenceProxy };

package/dist/{isolated-completion-DHBefrzg.js → isolated-completion-DWVb5U2J.js}

@@ -1,9 +1,9 @@
-import { i as resolveCodexAppServerHomeScope } from "./config-options-jnIFvwxD.js";
-import { x as readCodexPluginConfig } from "./protocol-CAAcVIKF.js";
-import { g as assertCodexPassiveTurnItems } from "./client-BEKu4yDx.js";
-import "./config-JDfTI4VI.js";
-import { Z as resolveCodexAppServerPreparedAuthHandoff } from "./shared-client-CVhez2Uo.js";
-import { runBoundedCodexAppServerTurn } from "./bounded-turn-lRpmZHFv.js";
+import { i as resolveCodexAppServerHomeScope } from "./config-options-CXMq1T-C.js";
+import { x as readCodexPluginConfig } from "./protocol-5bh1G-H7.js";
+import { g as assertCodexPassiveTurnItems } from "./client-B57KWPQx.js";
+import "./config-oIORaQ5T.js";
+import { tt as resolveCodexAppServerPreparedAuthHandoff } from "./shared-client-CscigXXL.js";
+import { runBoundedCodexAppServerTurn } from "./bounded-turn-C_Hneydj.js";
 import { a as createAttributedCodexAssistantMessage } from "./event-projector-assistant-message-BmBM4qBV.js";
 //#region extensions/codex/src/app-server/isolated-completion.ts
 /** Runs prompt-only Codex inference on an ephemeral, ring-zero native thread. */

package/dist/{managed-binary-DrjjRRUD.js → managed-binary-D22rNEcR.js}

@@ -1,3 +1,4 @@
+import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
 import { n as MANAGED_CODEX_APP_SERVER_PACKAGE } from "./version-omm6IPI3.js";
 import { createRequire } from "node:module";
 import { constants, existsSync, realpathSync } from "node:fs";
@@ -47,6 +48,14 @@ function resolveFirstExistingMacOSDesktopCodexBundledMarketplacePath(params = {}
 * Resolves the managed Codex app-server binary shipped with or installed beside
 * the Codex plugin before stdio startup.
 */
+var managed_binary_exports = /* @__PURE__ */ __exportAll({
+	isManagedCodexDesktopCommand: () => isManagedCodexDesktopCommand,
+	resolveManagedCodexAppServerStartOptions: () => resolveManagedCodexAppServerStartOptions,
+	resolveManagedCodexNativeCommand: () => resolveManagedCodexNativeCommand,
+	resolveManagedCodexPackageEntrypoint: () => resolveManagedCodexPackageEntrypoint,
+	resolvePackagedCodexNativeCommand: () => resolvePackagedCodexNativeCommand,
+	setManagedCodexPluginRoot: () => setManagedCodexPluginRoot
+});
 const registeredCodexPlugin = resolveGlobalSingleton(Symbol.for("openclaw.codexManagedPluginRoot"), () => ({}));
 /** Records the process-stable plugin root prepared by OpenClaw's plugin loader. */
 function setManagedCodexPluginRoot(pluginRoot) {
@@ -183,4 +192,4 @@ async function commandPathExists(filePath, platform) {
 	}
 }
 //#endregion
-export { setManagedCodexPluginRoot as a, resolveMacOSDesktopCodexBundledMarketplaceCandidates as c, resolvePackagedCodexNativeCommand as i, resolveMacOSDesktopCodexComputerUseServiceAppCandidates as l, resolveManagedCodexAppServerStartOptions as n, resolveFirstExistingMacOSDesktopCodexBundledMarketplacePath as o, resolveManagedCodexNativeCommand as r, resolveMacOSDesktopCodexAppPathCandidates as s, isManagedCodexDesktopCommand as t };
+export { resolvePackagedCodexNativeCommand as a, resolveMacOSDesktopCodexAppPathCandidates as c, resolveManagedCodexNativeCommand as i, resolveMacOSDesktopCodexBundledMarketplaceCandidates as l, managed_binary_exports as n, setManagedCodexPluginRoot as o, resolveManagedCodexAppServerStartOptions as r, resolveFirstExistingMacOSDesktopCodexBundledMarketplacePath as s, isManagedCodexDesktopCommand as t, resolveMacOSDesktopCodexComputerUseServiceAppCandidates as u };

package/dist/media-understanding-provider.js

@@ -43,7 +43,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("./bounded-turn-lRpmZHFv.js");
+	const { runBoundedCodexAppServerTurn } = await import("./bounded-turn-C_Hneydj.js");
 	req.signal?.throwIfAborted();
 	const { text } = await runBoundedCodexAppServerTurn({
 		config: req.cfg,
@@ -83,7 +83,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("./bounded-turn-lRpmZHFv.js");
+	const { runBoundedCodexAppServerTurn } = await import("./bounded-turn-C_Hneydj.js");
 	req.signal?.throwIfAborted();
 	const { text } = await runBoundedCodexAppServerTurn({
 		config: req.cfg,

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-B_6M04Wo.js → model-catalog-Dq2n8f_p.js}

@@ -1,9 +1,9 @@
-import { r as buildCodexRuntimeModelParams } from "./harness-FR6eQgyO.js";
-import { o as isJsonObject, x as readCodexPluginConfig } from "./protocol-CAAcVIKF.js";
-import { o as withCodexAppServerJsonClient } from "./request-CGvGOpeR.js";
-import { n as resolveCodexAppServerRuntimeOptions } from "./config-runtime-BWf6JLWG.js";
-import { r as captureSharedCodexAppServerCatalogLifetime } from "./shared-client-CVhez2Uo.js";
-import { t as listAllCodexAppServerModels } from "./models-P9k2qAof.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-P9k2qAof.js → models-PCKOim-h.js}

@@ -1,4 +1,4 @@
-import { h as assertCodexModelListResponse } from "./client-BEKu4yDx.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-CVhez2Uo.js").then((n) => n.y);
-	const { requestCodexAppServerClientJson } = await import("./request-CGvGOpeR.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-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 };