@openclaw/codex 2026.9.3 → 2026.9.4

package/dist/{plugin-marketplace-discovery-3akBizzF.js → plugin-marketplace-discovery-P-Vndfqq.js}

@@ -12,21 +12,26 @@ function canMutateCodexHost(ctx) {
 //#endregion
 //#region extensions/codex/src/plugin-marketplace-discovery.ts
 /** Read-only discovery of Codex-owned local, curated, and remote plugin marketplaces. */
-const PLUGIN_SEGMENT_PATTERN = /^[A-Za-z0-9_-]+$/;
-const MAX_PLUGIN_DESCRIPTION_LENGTH = 160;
+const PLUGIN_NAME_PATTERN = /^[A-Za-z0-9_-]+(?:\.[A-Za-z0-9_-]+)*$/;
+const MARKETPLACE_NAME_PATTERN = /^[A-Za-z0-9_-]+$/;
+const MAX_PLUGIN_METADATA_LENGTH = 160;
 const SUPPLEMENTAL_MARKETPLACE_KINDS = [
 	"workspace-directory",
 	"shared-with-me",
 	"created-by-me-remote",
 	"vertical"
 ];
+function filterCodexMarketplacePlugins(plugins, query, marketplace) {
+	const normalizedQuery = query.trim().toLowerCase();
+	return plugins.filter((plugin) => (!marketplace || plugin.marketplaceName === marketplace) && (!normalizedQuery || `${plugin.id} ${plugin.displayName ?? ""} ${plugin.developerName ?? ""} ${plugin.description ?? ""}`.toLowerCase().includes(normalizedQuery)));
+}
 /** Validates the same identifier segments required by Codex's stable PluginId parser. */
 function parseCodexPluginMarketplaceId(value) {
 	const separator = value.lastIndexOf("@");
 	if (separator <= 0 || separator === value.length - 1) return;
 	const pluginName = value.slice(0, separator);
 	const marketplaceName = value.slice(separator + 1);
-	return PLUGIN_SEGMENT_PATTERN.test(pluginName) && PLUGIN_SEGMENT_PATTERN.test(marketplaceName) ? {
+	return PLUGIN_NAME_PATTERN.test(pluginName) && MARKETPLACE_NAME_PATTERN.test(marketplaceName) ? {
 		pluginName,
 		marketplaceName
 	} : void 0;
@@ -62,17 +67,21 @@ async function discoverCodexMarketplacePlugins(params) {
 	const discovered = /* @__PURE__ */ new Map();
 	const ambiguous = /* @__PURE__ */ new Set();
 	for (const marketplace of marketplaces) {
-		if (!PLUGIN_SEGMENT_PATTERN.test(marketplace.name)) continue;
+		if (!MARKETPLACE_NAME_PATTERN.test(marketplace.name)) continue;
 		for (const summary of marketplace.plugins) {
 			const pluginName = pluginSlug(summary, marketplace.name);
 			if (!pluginName) continue;
 			const id = `${pluginName}@${marketplace.name}`;
 			if (ambiguous.has(id)) continue;
 			const previous = discovered.get(id);
+			const pluginInterface = asOptionalRecord(summary.interface);
 			const next = {
 				id,
 				pluginName,
 				marketplaceName: marketplace.name,
+				displayName: boundedCatalogText(pluginInterface?.displayName) || void 0,
+				developerName: boundedCatalogText(pluginInterface?.developerName) || void 0,
+				description: boundedCatalogText(pluginInterface?.shortDescription) || boundedCatalogText(pluginInterface?.longDescription) || void 0,
 				installed: summary.installed,
 				enabled: summary.enabled,
 				available: summary.availability !== "DISABLED_BY_ADMIN" && summary.installPolicy !== "NOT_AVAILABLE",
@@ -85,8 +94,6 @@ async function discoverCodexMarketplacePlugins(params) {
 				} : {},
 				summaryId: summary.id
 			};
-			const description = pluginDescription(summary);
-			if (description) next.description = description;
 			if (previous && (previous.marketplacePath !== next.marketplacePath || previous.remotePluginId !== next.remotePluginId)) {
 				discovered.delete(id);
 				ambiguous.add(id);
@@ -114,21 +121,17 @@ function pluginSlug(summary, marketplaceName) {
 	const qualified = parseCodexPluginMarketplaceId(summary.id);
 	if (qualified?.marketplaceName === marketplaceName) return qualified.pluginName;
 	const identitySegment = summary.id.split("/").at(-1);
-	if (identitySegment && PLUGIN_SEGMENT_PATTERN.test(identitySegment)) return identitySegment;
-	return PLUGIN_SEGMENT_PATTERN.test(summary.name) ? summary.name : void 0;
-}
-function pluginDescription(summary) {
-	const description = asOptionalRecord(summary.interface)?.shortDescription;
-	if (typeof description !== "string") return;
-	return boundedCatalogText(description) || void 0;
+	if (identitySegment && PLUGIN_NAME_PATTERN.test(identitySegment)) return identitySegment;
+	return PLUGIN_NAME_PATTERN.test(summary.name) ? summary.name : void 0;
 }
 function boundedCatalogText(value) {
+	if (typeof value !== "string") return "";
 	let sanitized = "";
 	for (const character of value) {
 		const codePoint = character.codePointAt(0);
 		sanitized += codePoint !== void 0 && (codePoint <= 31 || codePoint >= 127 && codePoint <= 159) ? " " : character;
 	}
-	return sanitized.replace(/\s+/g, " ").trim().slice(0, MAX_PLUGIN_DESCRIPTION_LENGTH);
+	return sanitized.replace(/\s+/g, " ").trim().slice(0, MAX_PLUGIN_METADATA_LENGTH);
 }
 //#endregion
-export { CODEX_NATIVE_EXECUTION_AUTH_ERROR as a, CODEX_HOST_INSPECTION_AUTH_ERROR as i, parseCodexPluginMarketplaceId as n, canMutateCodexHost as o, CODEX_FULL_PERMISSIONS_AUTH_ERROR as r, hasCodexAdminScope as s, discoverCodexMarketplacePlugins as t };
+export { CODEX_HOST_INSPECTION_AUTH_ERROR as a, hasCodexAdminScope as c, CODEX_FULL_PERMISSIONS_AUTH_ERROR as i, filterCodexMarketplacePlugins as n, CODEX_NATIVE_EXECUTION_AUTH_ERROR as o, parseCodexPluginMarketplaceId as r, canMutateCodexHost as s, discoverCodexMarketplacePlugins as t };

package/dist/{plugin-metadata-cache-DgNfRAGA.js → plugin-metadata-cache-ClPJpRio.js}

@@ -1,12 +1,12 @@
-import { o as resolveCodexComputerUseConfig } from "./config-options-jnIFvwxD.js";
-import { s as resolveCodexAppServerHomeDir } from "./protocol-CAAcVIKF.js";
-import { c as isCodexAppServerIndeterminateTransportError, o as isCodexAppServerConnectionClosedError, s as isCodexAppServerIndeterminateRequestCancellationError } from "./client-BEKu4yDx.js";
-import { c as resolveMacOSDesktopCodexBundledMarketplaceCandidates, o as resolveFirstExistingMacOSDesktopCodexBundledMarketplacePath, t as isManagedCodexDesktopCommand } from "./managed-binary-DrjjRRUD.js";
-import { n as describeControlFailure } from "./capabilities-BeqLPbtM.js";
-import { i as requestCodexAppServerJson } from "./request-CGvGOpeR.js";
-import "./config-JDfTI4VI.js";
-import { n as resolveCodexAppServerRuntimeOptions } from "./config-runtime-BWf6JLWG.js";
-import { $ as assertNotSymlink, Q as resolveCodexManagedBundledMarketplacePath, T as acquireCodexNativeConfigFence, Y as reconcileCodexComputerUseStartArtifacts, b as waitForCodexAppServerClientDesktopGenerationDrain, c as getLeasedSharedCodexAppServerClient, d as readCodexAppServerClientDesktopGeneration, g as resolveCodexNativeConfigFenceKey, h as releaseLeasedSharedCodexAppServerClient, p as readCodexAppServerClientProcessIdentity, t as assertCodexAppServerClientStartSelectionCurrent, u as isCodexAppServerStartSelectionChangedError } from "./shared-client-CVhez2Uo.js";
+import { o as resolveCodexComputerUseConfig } from "./config-options-CXMq1T-C.js";
+import { s as resolveCodexAppServerHomeDir } from "./protocol-5bh1G-H7.js";
+import { c as isCodexAppServerIndeterminateTransportError, o as isCodexAppServerConnectionClosedError, s as isCodexAppServerIndeterminateRequestCancellationError } from "./client-B57KWPQx.js";
+import { l as resolveMacOSDesktopCodexBundledMarketplaceCandidates, s as resolveFirstExistingMacOSDesktopCodexBundledMarketplacePath, t as isManagedCodexDesktopCommand } from "./managed-binary-D22rNEcR.js";
+import { n as describeControlFailure } from "./capabilities-8vx68WLH.js";
+import { i as requestCodexAppServerJson } from "./request-B7hEkBGq.js";
+import "./config-oIORaQ5T.js";
+import { n as resolveCodexAppServerRuntimeOptions } from "./config-runtime-D0zGNIHu.js";
+import { $ as reconcileCodexComputerUseStartArtifacts, T as acquireCodexNativeConfigFence, b as waitForCodexAppServerClientDesktopGenerationDrain, c as getLeasedSharedCodexAppServerClient, d as readCodexAppServerClientDesktopGeneration, g as resolveCodexNativeConfigFenceKey, h as releaseLeasedSharedCodexAppServerClient, nt as resolveCodexManagedBundledMarketplacePath, p as readCodexAppServerClientProcessIdentity, rt as assertNotSymlink, t as assertCodexAppServerClientStartSelectionCurrent, u as isCodexAppServerStartSelectionChangedError } from "./shared-client-CscigXXL.js";
 import { existsSync } from "node:fs";
 import path from "node:path";
 import fs$1 from "node:fs/promises";
@@ -445,6 +445,7 @@ async function resolveMarketplaceRef(params) {
 		candidates = await listComputerUseMarketplaceCandidates(params.request, params.config);
 	}
 	const waitUntil = marketplaceDiscoveryWaitUntil(params);
+	if (candidates.length === 0 && waitUntil > Date.now() && await codexNativePluginsDisabled(params.request)) return { message: "Codex native plugin support is disabled (features.plugins = false). Enable it in the Codex config, then run /codex computer-use install." };
 	while (candidates.length === 0) {
 		if (Date.now() >= waitUntil) break;
 		await delay(Math.min(CURATED_MARKETPLACE_POLL_INTERVAL_MS, waitUntil - Date.now()), params.signal);
@@ -477,6 +478,9 @@ async function migrateLegacyBundledMarketplaceSource(params) {
 async function listComputerUseMarketplaceCandidates(request, config) {
 	return findComputerUseMarketplaces(await request("plugin/list", { cwds: [] }), config.pluginName);
 }
+async function codexNativePluginsDisabled(request) {
+	return (await request("experimentalFeature/list", {})).data.find(({ name }) => name === "plugins")?.enabled === false;
+}
 function blockUnsafeAutoInstallStatus(config) {
 	if (!config.marketplaceSource) return;
 	return unavailableStatus(config, "auto_install_blocked", "Computer Use auto-install only uses marketplaces Codex app-server has already discovered. Run /codex computer-use install to install from a configured marketplace source.");

package/dist/{protocol-CAAcVIKF.js → protocol-5bh1G-H7.js}

@@ -1,4 +1,4 @@
-import { g as CODEX_PLUGIN_MARKETPLACE_NAME_PATTERN, i as normalizeCodexServiceTier } from "./config-utils-C57JiJrU.js";
+import { i as normalizeCodexServiceTier, m as CODEX_PLUGIN_MARKETPLACE_NAME_PATTERN } from "./config-utils-DujwEnhg.js";
 import { n as normalizeCodexAppServerArgs } from "./launch-args-RXQwn8zV.js";
 import { asNullableRecord, isRecord, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { z } from "zod";

package/dist/provider-MQ8PVkuE.js

@@ -0,0 +1,50 @@
+//#region extensions/codex/src/migration/provider.ts
+function isMemoryOnlyMigration(ctx) {
+	return Boolean(ctx.itemKinds && ctx.itemKinds.length > 0 && ctx.itemKinds.every((kind) => kind === "memory"));
+}
+function isAuthOnlyMigration(ctx) {
+	return Boolean(ctx.itemKinds && ctx.itemKinds.length > 0 && ctx.itemKinds.every((kind) => kind === "auth"));
+}
+function buildCodexMigrationProvider(params = {}) {
+	return {
+		id: "codex",
+		label: "Codex",
+		description: "Import Codex memory and skills while keeping Codex native plugins and hooks explicit.",
+		supportedItemKinds: ["memory", "auth"],
+		async detect(ctx) {
+			const { discoverCodexSource, hasCodexSource } = await import("./source-CElXU0Oy.js").then((n) => n.i);
+			const source = await discoverCodexSource({
+				input: ctx.source,
+				memoryOnly: isMemoryOnlyMigration(ctx),
+				authOnly: isAuthOnlyMigration(ctx)
+			});
+			const found = isMemoryOnlyMigration(ctx) ? source.memoryFiles.length > 0 : isAuthOnlyMigration(ctx) ? Boolean(source.authPath) : hasCodexSource(source);
+			return {
+				found,
+				source: source.root,
+				label: "Codex",
+				confidence: found ? source.confidence : "low",
+				message: found ? "Codex state found." : "Codex state not found."
+			};
+		},
+		async plan(ctx) {
+			const { buildCodexMigrationPlan } = await import("./plan-7uG-Fp36.js");
+			return buildCodexMigrationPlan(ctx);
+		},
+		deferredApply: { retrySafe: true },
+		prepareApply(ctx) {
+			if (isMemoryOnlyMigration(ctx) || isAuthOnlyMigration(ctx)) return;
+			return import("./apply-CvT8tW5i.js").then(({ prepareTargetCodexAppServer }) => prepareTargetCodexAppServer(ctx));
+		},
+		async apply(ctx, plan) {
+			const { applyCodexMigrationPlan } = await import("./apply-CvT8tW5i.js");
+			return await applyCodexMigrationPlan({
+				ctx,
+				plan,
+				runtime: params.runtime
+			});
+		}
+	};
+}
+//#endregion
+export { buildCodexMigrationProvider as t };

package/dist/{provider-capabilities-W4tfK5Y5.js → provider-capabilities-BvCUL69A.js}

@@ -1,5 +1,5 @@
-import { h as releaseLeasedSharedCodexAppServerClient } from "./shared-client-CVhez2Uo.js";
-import { st as normalizeCodexDynamicToolName } from "./thread-lifecycle-D1pzRwHB.js";
+import { h as releaseLeasedSharedCodexAppServerClient } from "./shared-client-CscigXXL.js";
+import { ct as normalizeCodexDynamicToolName } from "./thread-lifecycle-DXl1-I6b.js";
 import { pinExecToolTarget } from "openclaw/plugin-sdk/codex-mcp-projection";
 import { loadNodeExecAvailability } from "openclaw/plugin-sdk/node-selection-runtime";
 //#region extensions/codex/src/app-server/shell-dynamic-tools.ts

package/dist/{rate-limits-Bqnx1N4z.js → rate-limits-CBMmWBr9.js}

@@ -1,4 +1,4 @@
-import { o as isJsonObject } from "./protocol-CAAcVIKF.js";
+import { o as isJsonObject } from "./protocol-5bh1G-H7.js";
 import { asBoolean, asFiniteNumber, normalizeOptionalString, parseStrictFiniteNumber } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { MAX_DATE_TIMESTAMP_MS, resolveExpiresAtMsFromEpochSeconds } from "openclaw/plugin-sdk/number-runtime";
 import { expectDefined } from "openclaw/plugin-sdk/expect-runtime";

package/dist/{request-CGvGOpeR.js → request-B7hEkBGq.js}

@@ -1,5 +1,5 @@
 import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
-import { n as withTimeout } from "./timeout-BVw8aaM1.js";
+import { n as withTimeout, t as withAbortableTimeout } from "./timeout-BVw8aaM1.js";
 //#region extensions/codex/src/app-server/request.ts
 var request_exports = /* @__PURE__ */ __exportAll({
 	CodexAppServerScopedRequestRejectedError: () => CodexAppServerScopedRequestRejectedError,
@@ -10,7 +10,7 @@ var request_exports = /* @__PURE__ */ __exportAll({
 });
 /** Sends one guarded request over a client lease owned by the caller. */
 async function requestCodexAppServerClientJson(params) {
-	const { resolveCodexAppServerDirectSandboxBypassBlock } = await import("./sandbox-guard-BcT66fWy.js").then((n) => n.r);
+	const { resolveCodexAppServerDirectSandboxBypassBlock } = await import("./sandbox-guard-BxgyoM8M.js").then((n) => n.r);
 	const sandboxBlock = resolveCodexAppServerDirectSandboxBypassBlock({
 		method: params.method,
 		requestParams: params.requestParams,
@@ -27,7 +27,7 @@ async function requestCodexAppServerClientJson(params) {
 	}), timeoutMs, `codex app-server ${params.method} timed out`);
 }
 async function requestCodexAppServerJson(params) {
-	const { resolveCodexAppServerDirectSandboxBypassBlock } = await import("./sandbox-guard-BcT66fWy.js").then((n) => n.r);
+	const { resolveCodexAppServerDirectSandboxBypassBlock } = await import("./sandbox-guard-BxgyoM8M.js").then((n) => n.r);
 	const sandboxBlock = resolveCodexAppServerDirectSandboxBypassBlock({
 		method: params.method,
 		requestParams: params.requestParams,
@@ -122,6 +122,7 @@ async function withCodexAppServerJsonClient(params, run) {
 	const deadline = Number.isFinite(timeoutMs) && timeoutMs > 0 ? Date.now() + timeoutMs : void 0;
 	const isPastDeadline = () => deadline !== void 0 && Date.now() >= deadline;
 	const throwIfAbandoned = () => {
+		if (timeoutController.signal.aborted && timeoutController.signal.reason instanceof Error) throw timeoutController.signal.reason;
 		if (timeoutController.signal.aborted || isPastDeadline()) throw new CodexAppServerScopedRequestRejectedError(timeoutMessage);
 	};
 	const remainingTimeoutMs = () => {
@@ -129,69 +130,82 @@ async function withCodexAppServerJsonClient(params, run) {
 		return deadline === void 0 ? timeoutMs : Math.max(1, deadline - Date.now());
 	};
 	try {
-		return await withTimeout((async () => {
-			const { resolveCodexAppServerDirectSandboxBypassBlock } = await import("./sandbox-guard-BcT66fWy.js").then((n) => n.r);
-			const { createIsolatedCodexAppServerClient, getLeasedSharedCodexAppServerClient, isCodexAppServerStartSelectionChangedError, releaseLeasedSharedCodexAppServerClient, retireSharedCodexAppServerClientIfCurrent } = await import("./shared-client-CVhez2Uo.js").then((n) => n.y);
-			for (let attempt = 0; attempt < 2; attempt += 1) {
-				throwIfAbandoned();
-				const client = await (params.isolated ? createIsolatedCodexAppServerClient : getLeasedSharedCodexAppServerClient)({
-					startOptions: params.startOptions,
-					pluginConfig: params.pluginConfig,
-					timeoutMs: remainingTimeoutMs(),
-					authProfileId: params.authProfileId,
-					authProfileStore: params.authProfileStore,
-					authBindingFingerprint: params.authBindingFingerprint,
-					preparedAuth: params.preparedAuth,
-					authRequirement: params.authRequirement,
-					agentDir: params.agentDir,
-					config: params.config,
-					abandonSignal: timeoutController.signal
-				});
-				let scopeActive = true;
-				const assertCurrent = () => {
+		return await withAbortableTimeout({
+			signal: timeoutController.signal,
+			timeoutMs,
+			timeoutMessage,
+			promise: (async () => {
+				const { resolveCodexAppServerDirectSandboxBypassBlock } = await import("./sandbox-guard-BxgyoM8M.js").then((n) => n.r);
+				const { createIsolatedCodexAppServerClient, getLeasedSharedCodexAppServerClient, isCodexAppServerStartSelectionChangedError, releaseLeasedSharedCodexAppServerClient, retireSharedCodexAppServerClientIfCurrent } = await import("./shared-client-CscigXXL.js").then((n) => n.y);
+				for (let attempt = 0; attempt < 2; attempt += 1) {
 					throwIfAbandoned();
-					if (!scopeActive) throw new CodexAppServerScopedRequestRejectedError("Codex app-server request scope is closed");
-					assertRequestOwnerCurrent(params.assertCurrent);
-				};
-				try {
-					assertCurrent();
-					const scopedRequest = async (request) => {
-						const sandboxBlock = resolveCodexAppServerDirectSandboxBypassBlock({
-							method: request.method,
-							requestParams: request.requestParams,
-							config: params.config,
-							sessionKey: params.sessionKey,
-							sessionId: params.sessionId
-						});
-						if (sandboxBlock) throw new CodexAppServerScopedRequestRejectedError(sandboxBlock);
+					const client = await (params.isolated ? createIsolatedCodexAppServerClient : getLeasedSharedCodexAppServerClient)({
+						startOptions: params.startOptions,
+						pluginConfig: params.pluginConfig,
+						timeoutMs: remainingTimeoutMs(),
+						authProfileId: params.authProfileId,
+						authProfileStore: params.authProfileStore,
+						authBindingFingerprint: params.authBindingFingerprint,
+						preparedAuth: params.preparedAuth,
+						authRequirement: params.authRequirement,
+						agentDir: params.agentDir,
+						config: params.config,
+						abandonSignal: timeoutController.signal
+					});
+					let scopeActive = true;
+					const assertCurrent = () => {
+						throwIfAbandoned();
+						if (!scopeActive) throw new CodexAppServerScopedRequestRejectedError("Codex app-server request scope is closed");
+						assertRequestOwnerCurrent(params.assertCurrent);
+					};
+					try {
 						assertCurrent();
-						return await client.request(request.method, request.requestParams, {
-							timeoutMs: remainingTimeoutMs(),
-							signal: timeoutController.signal,
-							assertCurrent
+						const scopedRequest = async (request) => {
+							const sandboxBlock = resolveCodexAppServerDirectSandboxBypassBlock({
+								method: request.method,
+								requestParams: request.requestParams,
+								config: params.config,
+								sessionKey: params.sessionKey,
+								sessionId: params.sessionId
+							});
+							if (sandboxBlock) throw new CodexAppServerScopedRequestRejectedError(sandboxBlock);
+							assertCurrent();
+							return await client.request(request.method, request.requestParams, {
+								timeoutMs: remainingTimeoutMs(),
+								signal: timeoutController.signal,
+								assertCurrent: () => {
+									assertCurrent();
+									request.assertCurrent?.();
+								}
+							});
+						};
+						return await run(scopedRequest, client, {
+							assertCurrent,
+							abort: (reason) => {
+								if (scopeActive) timeoutController.abort(reason);
+							}
 						});
-					};
-					return await run(scopedRequest, client, { assertCurrent });
-				} catch (error) {
-					if (!isCodexAppServerStartSelectionChangedError(error) || attempt > 0) throw error;
-					if (!params.isolated) retireSharedCodexAppServerClientIfCurrent(client);
-					throwIfAbandoned();
-				} finally {
-					scopeActive = false;
-					if (params.isolated) await client.closeAndWait({
-						exitTimeoutMs: params.isolatedShutdown?.exitTimeoutMs ?? 2e3,
-						forceKillDelayMs: params.isolatedShutdown?.forceKillDelayMs ?? 250
-					});
-					else releaseLeasedSharedCodexAppServerClient(client);
+					} catch (error) {
+						if (!isCodexAppServerStartSelectionChangedError(error) || attempt > 0) throw error;
+						if (!params.isolated) retireSharedCodexAppServerClientIfCurrent(client);
+						throwIfAbandoned();
+					} finally {
+						scopeActive = false;
+						if (params.isolated) await client.closeAndWait({
+							exitTimeoutMs: params.isolatedShutdown?.exitTimeoutMs ?? 2e3,
+							forceKillDelayMs: params.isolatedShutdown?.forceKillDelayMs ?? 250
+						});
+						else releaseLeasedSharedCodexAppServerClient(client);
+					}
 				}
-			}
-			throw new Error("Codex app-server selection retry loop exited unexpectedly");
-		})(), timeoutMs, timeoutMessage);
+				throw new Error("Codex app-server selection retry loop exited unexpectedly");
+			})()
+		});
 	} catch (error) {
 		if (isPastDeadline()) throw new Error(timeoutMessage, { cause: error });
 		throw error;
 	} finally {
-		timeoutController.abort();
+		timeoutController.abort(new CodexAppServerScopedRequestRejectedError(timeoutMessage));
 	}
 }
 //#endregion

package/dist/rpc-error-ttN_QjEm.js

@@ -0,0 +1,30 @@
+import { o as isJsonObject } from "./protocol-5bh1G-H7.js";
+//#region extensions/codex/src/app-server/rpc-error.ts
+/** RPC error wrapper that preserves app-server error code and data. */
+var CodexAppServerRpcError = class extends Error {
+	constructor(error, method) {
+		super(formatCodexAppServerRpcErrorMessage(error, method));
+		this.name = "CodexAppServerRpcError";
+		this.code = error.code;
+		this.data = error.data;
+		this.method = method;
+	}
+};
+function isCodexThreadReadMissingError(error, threadId) {
+	return error instanceof CodexAppServerRpcError && error.method === "thread/read" && error.code === -32600 && error.message === `thread not loaded: ${threadId}`;
+}
+function formatCodexAppServerRpcErrorMessage(error, method) {
+	const message = error.message || `${method} failed`;
+	const detail = readCodexAppServerRpcReloginDetail(error.data);
+	return detail && !message.includes(detail) ? `${message}: ${detail}` : message;
+}
+function readCodexAppServerRpcReloginDetail(data) {
+	const record = isJsonObject(data) ? data : void 0;
+	const nested = isJsonObject(record?.error) ? record.error : record;
+	if (!nested) return;
+	const isRelogin = nested.action === "relogin" || nested.reason === "cloudRequirements" && nested.errorCode === "Auth";
+	const detail = typeof nested.detail === "string" ? nested.detail.trim() : "";
+	return isRelogin && detail ? detail : void 0;
+}
+//#endregion
+export { isCodexThreadReadMissingError as n, CodexAppServerRpcError as t };