@openclaw/codex 2026.9.4 → 2026.9.6

package/dist/binding-connection-D3udKbIE.js

@@ -1,60 +0,0 @@
-import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
-import { x as readCodexPluginConfig } from "./protocol-5bh1G-H7.js";
-import { a as resolveCodexCatalogConnectionHome, t as buildCodexAppServerConnectionFingerprint } from "./plugin-app-cache-key-d0eKxy7b.js";
-import { n as resolveCodexAppServerRuntimeOptions, r as resolveCodexSupervisionAppServerRuntimeOptions } from "./config-runtime-D0zGNIHu.js";
-import { AgentHarnessPreflightError } from "openclaw/plugin-sdk/agent-harness-registration";
-//#region extensions/codex/src/app-server/binding-connection.ts
-var binding_connection_exports = /* @__PURE__ */ __exportAll({
-	assertCodexSessionRuntimeOwnership: () => assertCodexSessionRuntimeOwnership,
-	requireCodexSupervisionModelSelection: () => requireCodexSupervisionModelSelection,
-	resolveCodexBindingAppServerConnection: () => resolveCodexBindingAppServerConnection
-});
-/** Prevents a prepared native session from becoming a fresh thread after its binding changes. */
-function assertCodexSessionRuntimeOwnership(binding, expected) {
-	if (!expected) return;
-	const auth = binding?.connectionScope === "supervision" ? "native" : "host";
-	const hostModelChanged = expected.auth === "host" && (!expected.modelRef || binding?.model !== expected.modelRef.model || binding?.modelProvider !== expected.modelRef.provider);
-	if (binding?.preserveNativeModel !== true || auth !== expected.auth || hostModelChanged) throw new AgentHarnessPreflightError("Codex native session ownership is missing or changed. Reattach the original native session or create a new chat with a concrete model; no replacement thread was started.");
-}
-/** Requires the native model pair after a supervised pending branch has materialized. */
-function requireCodexSupervisionModelSelection(binding) {
-	const model = binding.model?.trim();
-	const modelProvider = binding.modelProvider?.trim();
-	if (binding.connectionScope !== "supervision" || !model || !modelProvider) throw new Error("Codex supervised binding is missing its native model and provider; refusing request selection");
-	return {
-		model,
-		modelProvider
-	};
-}
-/** Resolves connection and auth ownership exclusively from the private thread binding. */
-function resolveCodexBindingAppServerConnection(params) {
-	const { binding, authProfileId, ...runtimeParams } = params;
-	const usesSupervisionConnection = binding?.connectionScope === "supervision";
-	if (usesSupervisionConnection && readCodexPluginConfig(runtimeParams.pluginConfig).supervision?.enabled !== true) throw new Error("Codex supervision is disabled; refusing to open a native user-home supervised session");
-	let appServer = (usesSupervisionConnection ? resolveCodexSupervisionAppServerRuntimeOptions : resolveCodexAppServerRuntimeOptions)(runtimeParams);
-	if (usesSupervisionConnection) {
-		const persistedFingerprint = binding.pendingSupervisionBranch?.connectionFingerprint ?? binding.appServerRuntimeFingerprint;
-		const catalogHome = persistedFingerprint ? resolveCodexCatalogConnectionHome(persistedFingerprint, runtimeParams.agentDir) : void 0;
-		if (catalogHome) appServer = {
-			...appServer,
-			start: {
-				...appServer.start,
-				homeScope: "user",
-				env: {
-					...appServer.start.env,
-					CODEX_HOME: catalogHome
-				}
-			}
-		};
-		const currentFingerprint = buildCodexAppServerConnectionFingerprint(appServer, runtimeParams.agentDir);
-		if (!persistedFingerprint || persistedFingerprint !== currentFingerprint) throw new Error("Codex supervision connection changed; refusing to operate on its bound native thread");
-	}
-	return {
-		appServer,
-		usesSupervisionConnection,
-		requestAuthProfileId: usesSupervisionConnection ? void 0 : authProfileId,
-		clientAuthProfileId: usesSupervisionConnection ? null : authProfileId
-	};
-}
-//#endregion
-export { resolveCodexBindingAppServerConnection as i, binding_connection_exports as n, requireCodexSupervisionModelSelection as r, assertCodexSessionRuntimeOwnership as t };

package/dist/event-projector-usage-BfXmpOec.js

@@ -1,102 +0,0 @@
-import { o as isJsonObject } from "./protocol-5bh1G-H7.js";
-import { asSafeIntegerInRange, readStringField } from "openclaw/plugin-sdk/string-coerce-runtime";
-import { normalizeUsage } from "openclaw/plugin-sdk/agent-harness-runtime";
-//#region extensions/codex/src/app-server/event-projector-usage.ts
-function readTokenCount(record, key) {
-	return asSafeIntegerInRange(record[key], { min: 0 });
-}
-function readCodexThreadTokenUsage(params) {
-	const tokenUsage = isJsonObject(params.tokenUsage) ? params.tokenUsage : void 0;
-	const last = tokenUsage && isJsonObject(tokenUsage.last) ? tokenUsage.last : void 0;
-	return last ? normalizeCodexResponseTokenUsage(last) : void 0;
-}
-function readCodexThreadContextSnapshot(params) {
-	const tokenUsage = isJsonObject(params.tokenUsage) ? params.tokenUsage : void 0;
-	const last = tokenUsage && isJsonObject(tokenUsage.last) ? tokenUsage.last : void 0;
-	const modelContextWindow = tokenUsage ? readTokenCount(tokenUsage, "modelContextWindow") : void 0;
-	const activeContextTokens = last ? readTokenCount(last, "totalTokens") : void 0;
-	const inputTokens = last ? readTokenCount(last, "inputTokens") : void 0;
-	const cachedInputTokens = last ? readTokenCount(last, "cachedInputTokens") : void 0;
-	const cacheWriteInputTokens = last ? readTokenCount(last, "cacheWriteInputTokens") : void 0;
-	const reasoningOutputTokens = last ? readTokenCount(last, "reasoningOutputTokens") : void 0;
-	return {
-		...activeContextTokens !== void 0 ? { activeContextTokens } : {},
-		...cachedInputTokens !== void 0 ? { cachedInputTokens } : {},
-		...cacheWriteInputTokens !== void 0 ? { cacheWriteInputTokens } : {},
-		...inputTokens !== void 0 ? { inputTokens } : {},
-		...modelContextWindow && modelContextWindow > 0 ? { modelContextWindow } : {},
-		...inputTokens !== void 0 ? { promptTokens: inputTokens } : {},
-		...reasoningOutputTokens !== void 0 ? { reasoningOutputTokens } : {}
-	};
-}
-function normalizeCodexResponseTokenUsage(record) {
-	const totalTokens = readTokenCount(record, "totalTokens");
-	const inputTokens = readTokenCount(record, "inputTokens");
-	const cacheRead = readTokenCount(record, "cachedInputTokens");
-	const output = readTokenCount(record, "outputTokens");
-	const reasoningTokens = readTokenCount(record, "reasoningOutputTokens");
-	const cacheWrite = record.cacheWriteInputTokens === void 0 ? 0 : readTokenCount(record, "cacheWriteInputTokens");
-	const hasCoherentInput = inputTokens !== void 0 && cacheRead !== void 0 && cacheWrite !== void 0 && cacheRead + cacheWrite <= inputTokens;
-	const hasCoherentContext = hasCoherentInput && totalTokens !== void 0 && output !== void 0 && totalTokens === inputTokens + output;
-	const usage = normalizeUsage({
-		input: hasCoherentInput ? inputTokens - cacheRead - cacheWrite : void 0,
-		output,
-		cacheRead,
-		cacheWrite,
-		reasoningTokens,
-		total: totalTokens
-	});
-	if (!usage) return;
-	return {
-		...usage,
-		contextUsage: hasCoherentContext ? {
-			state: "available",
-			promptTokens: inputTokens,
-			totalTokens
-		} : { state: "unavailable" }
-	};
-}
-var CodexUsageProjection = class {
-	constructor() {
-		this.responseIds = /* @__PURE__ */ new Set();
-	}
-	get usage() {
-		const usage = this.responseUsage ?? this.threadUsage;
-		return usage ? {
-			...usage,
-			contextUsage: this.contextUsage
-		} : void 0;
-	}
-	get modelIterations() {
-		return this.responseIds.size;
-	}
-	invalidateContext() {
-		this.contextUsage = { state: "unavailable" };
-	}
-	recordThread(params) {
-		const usage = readCodexThreadTokenUsage(params);
-		this.threadUsage = usage ?? this.threadUsage;
-		if (!this.responseUsage && usage) this.contextUsage = usage.contextUsage;
-		return readCodexThreadContextSnapshot(params);
-	}
-	record(params, reportOutputTokens) {
-		const responseId = readStringField(params, "responseId");
-		if (!responseId || this.responseIds.has(responseId)) return;
-		this.responseIds.add(responseId);
-		const usage = isJsonObject(params.usage) ? normalizeCodexResponseTokenUsage(params.usage) : void 0;
-		this.contextUsage = usage?.contextUsage ?? { state: "unavailable" };
-		this.responseUsage ??= {};
-		for (const field of [
-			"input",
-			"output",
-			"cacheRead",
-			"cacheWrite",
-			"reasoningTokens",
-			"total"
-		]) if (usage?.[field] !== void 0) this.responseUsage[field] = (this.responseUsage[field] ?? 0) + usage[field];
-		const outputTokens = usage?.output;
-		if (outputTokens !== void 0) reportOutputTokens?.(outputTokens);
-	}
-};
-//#endregion
-export { readCodexThreadContextSnapshot as n, CodexUsageProjection as t };

package/dist/inference-proxy-HGXKUIre.js

@@ -1,311 +0,0 @@
-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/launch-args-RXQwn8zV.js

@@ -1,90 +0,0 @@
-//#region extensions/codex/src/app-server/launch-args.ts
-const CODEX_VALUE_OPTIONS = /* @__PURE__ */ new Set([
-	"-m",
-	"--model",
-	"--local-provider",
-	"-p",
-	"--profile",
-	"-s",
-	"--sandbox",
-	"-a",
-	"--ask-for-approval",
-	"-C",
-	"--cd",
-	"--add-dir",
-	"--remote",
-	"--remote-auth-token-env",
-	"-c",
-	"--config",
-	"--enable",
-	"--disable",
-	"--listen",
-	"--code-mode-host",
-	"--ws-auth",
-	"--ws-token-file",
-	"--ws-token-sha256",
-	"--ws-shared-secret-file",
-	"--ws-issuer",
-	"--ws-audience",
-	"--ws-max-clock-skew-seconds"
-]);
-/** One tokenization owner for launch, turn policy, reviewer trust, and private turns. */
-function readCodexArgs(args) {
-	const tokens = [];
-	let nativeSubcommand = false;
-	let end = 0;
-	for (const [index, arg] of args.entries()) {
-		if (index < end) continue;
-		end = index + 1;
-		const attached = /^(--[^=]+)=([\s\S]*)$/u.exec(arg) ?? /^(-[cmpisaC])=?([\s\S]+)$/u.exec(arg);
-		const name = attached?.[1] ?? arg;
-		let value = attached?.[2];
-		if (name === "-i" || name === "--image") while (args[end]?.startsWith("-") === false) end += 1;
-		else if (!attached && CODEX_VALUE_OPTIONS.has(name)) {
-			value = args[end];
-			if (value !== void 0) end += 1;
-		}
-		tokens.push({
-			index,
-			end,
-			name,
-			value
-		});
-		if (name === "app-server") nativeSubcommand = true;
-		if (name === "--" && nativeSubcommand) break;
-	}
-	return tokens;
-}
-function readCodexAppServerConfigOptions(args) {
-	return readCodexArgs(args).filter(({ name }) => name === "-c" || name === "--config" || name === "-p" || name === "--profile");
-}
-/** The stdio proxy forwards to an external server; it does not own that runtime. */
-function isCodexAppServerProxyLaunch(args) {
-	const tokens = readCodexArgs(args);
-	const server = tokens.findLastIndex(({ name }) => name === "app-server");
-	return server >= 0 && tokens.slice(server + 1).find(({ name }) => !name.startsWith("-"))?.name === "proxy";
-}
-/** Keeps Codex overrides in one CLI scope without rewriting raw TOML or wrapper prefixes. */
-function normalizeCodexAppServerArgs(rawArgs, enforcedOverride) {
-	const tokens = readCodexArgs(rawArgs);
-	const subcommandIndex = tokens.findLast(({ name }) => name === "app-server")?.index ?? -1;
-	const prefix = subcommandIndex < 0 ? [...rawArgs] : rawArgs.slice(0, subcommandIndex);
-	const suffix = [];
-	if (subcommandIndex >= 0) for (const token of tokens) {
-		if (token.index <= subcommandIndex) continue;
-		if (token.name === "--") {
-			suffix.push(...rawArgs.slice(token.index));
-			break;
-		}
-		(token.name === "-c" || token.name === "--config" ? prefix : suffix).push(...rawArgs.slice(token.index, token.end));
-	}
-	if (enforcedOverride && !(prefix.at(-2) === "-c" && prefix.at(-1) === enforcedOverride)) prefix.push("-c", enforcedOverride);
-	const normalized = subcommandIndex < 0 ? prefix : [
-		...prefix,
-		"app-server",
-		...suffix
-	];
-	return normalized.length === rawArgs.length && normalized.every((arg, index) => arg === rawArgs[index]) ? rawArgs : normalized;
-}
-//#endregion
-export { normalizeCodexAppServerArgs as n, readCodexAppServerConfigOptions as r, isCodexAppServerProxyLaunch as t };

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

@@ -1,34 +0,0 @@
-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 };