@openclaw/codex 2026.7.2-beta.1 → 2026.7.2-beta.2

package/openclaw.plugin.json

@@ -1,8 +1,7 @@
 {
   "id": "codex",
   "name": "Codex",
-  "description": "Codex app-server harness, model provider, and native session catalog.",
-  "providers": ["codex"],
+  "description": "Codex app-server harness and native session catalog.",
   "contracts": {
     "mediaUnderstandingProviders": ["codex"],
     "migrationProviders": ["codex"],
@@ -24,9 +23,6 @@
       }
     }
   },
-  "providerCatalogEntry": "./provider-discovery.ts",
-  "syntheticAuthRefs": ["codex"],
-  "nonSecretAuthMarkers": ["codex-app-server"],
   "activation": {
     "onStartup": false,
     "onAgentHarnesses": ["codex"],
@@ -269,6 +265,10 @@
             "type": "boolean",
             "default": false
           },
+          "loopDetectionPreToolUseRelay": {
+            "type": "boolean",
+            "default": true
+          },
           "requestTimeoutMs": {
             "type": "number",
             "minimum": 1,
@@ -586,6 +586,11 @@
       "help": "Expose Codex's code-mode-only tool surface. OpenClaw dynamic tools remain available through Codex nested tool calls.",
       "advanced": true
     },
+    "appServer.loopDetectionPreToolUseRelay": {
+      "label": "Loop Detection Pre-tool Relay",
+      "help": "Install the Codex PreToolUse subprocess used only for OpenClaw loop detection and its no-policy marker. Disable to reduce per-tool process fan-out; before-tool and trusted policy relays remain enforced.",
+      "advanced": true
+    },
     "appServer.requestTimeoutMs": {
       "label": "Request Timeout",
       "help": "Maximum time to wait for Codex app-server control-plane requests.",

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@openclaw/codex",
-  "version": "2026.7.2-beta.1",
-  "description": "OpenClaw Codex app-server harness, model provider, and native session supervision plugin.",
+  "version": "2026.7.2-beta.2",
+  "description": "OpenClaw Codex app-server harness and native session supervision plugin.",
   "repository": {
     "type": "git",
     "url": "https://github.com/openclaw/openclaw"
   },
   "type": "module",
   "dependencies": {
-    "@openai/codex": "0.144.4",
+    "@openai/codex": "0.144.5",
     "semver": "7.8.5",
     "smol-toml": "1.7.0",
     "typebox": "1.3.3",
@@ -36,10 +36,10 @@
       ]
     },
     "compat": {
-      "pluginApi": ">=2026.7.2-beta.1"
+      "pluginApi": ">=2026.7.2-beta.2"
     },
     "build": {
-      "openclawVersion": "2026.7.2-beta.1"
+      "openclawVersion": "2026.7.2-beta.2"
     },
     "release": {
       "publishToClawHub": true,
@@ -60,7 +60,7 @@
     "README.md"
   ],
   "peerDependencies": {
-    "openclaw": ">=2026.7.2-beta.1"
+    "openclaw": ">=2026.7.2-beta.2"
   },
   "peerDependenciesMeta": {
     "openclaw": {

package/dist/capabilities-42Dfn2TV.js

@@ -1,33 +0,0 @@
-import { O as CodexAppServerRpcError } from "./shared-client-D4mFI9al.js";
-//#region extensions/codex/src/app-server/capabilities.ts
-/**
-* Capability helpers for optional Codex app-server control-plane methods.
-*/
-/** Known app-server methods used by OpenClaw control surfaces. */
-const CODEX_CONTROL_METHODS = {
-	account: "account/read",
-	compact: "thread/compact/start",
-	feedback: "feedback/upload",
-	forkThread: "thread/fork",
-	listMcpServers: "mcpServerStatus/list",
-	listSkills: "skills/list",
-	listThreads: "thread/list",
-	listThreadTurns: "thread/turns/list",
-	readThread: "thread/read",
-	rateLimits: "account/rateLimits/read",
-	archiveThread: "thread/archive",
-	renameThread: "thread/name/set",
-	resumeThread: "thread/resume",
-	review: "review/start",
-	unarchiveThread: "thread/unarchive"
-};
-/** Formats unsupported control calls differently from ordinary RPC failures. */
-function describeControlFailure(error) {
-	if (isUnsupportedControlError(error)) return "unsupported by this Codex app-server";
-	return error instanceof Error ? error.message : String(error);
-}
-function isUnsupportedControlError(error) {
-	return error instanceof CodexAppServerRpcError && error.code === -32601;
-}
-//#endregion
-export { describeControlFailure as n, CODEX_CONTROL_METHODS as t };

package/dist/prompt-overlay.js

@@ -1,15 +0,0 @@
-import { GPT5_BEHAVIOR_CONTRACT, GPT5_HEARTBEAT_PROMPT_OVERLAY, resolveGpt5SystemPromptContribution } from "openclaw/plugin-sdk/provider-model-shared";
-//#region extensions/codex/prompt-overlay.ts
-/**
-* Codex prompt-overlay facade for GPT-5 behavior and heartbeat guidance.
-*/
-/** GPT-5 behavior contract re-exported under the Codex provider namespace. */
-const CODEX_GPT5_BEHAVIOR_CONTRACT = GPT5_BEHAVIOR_CONTRACT;
-/** Heartbeat prompt overlay re-exported under the Codex provider namespace. */
-const CODEX_GPT5_HEARTBEAT_PROMPT_OVERLAY = GPT5_HEARTBEAT_PROMPT_OVERLAY;
-/** Resolves the Codex system-prompt contribution for GPT-5-family models. */
-function resolveCodexSystemPromptContribution(params) {
-	return resolveGpt5SystemPromptContribution(params);
-}
-//#endregion
-export { CODEX_GPT5_BEHAVIOR_CONTRACT, CODEX_GPT5_HEARTBEAT_PROMPT_OVERLAY, resolveCodexSystemPromptContribution };

package/dist/protocol-BMifTfdW.js

@@ -1,15 +0,0 @@
-//#region extensions/codex/src/app-server/protocol.ts
-/** Namespace Codex keeps directly model-visible without exposing it to Code Mode guests. */
-const CODEX_OPENCLAW_DIRECT_DYNAMIC_TOOL_NAMESPACE = "openclaw_direct";
-function flattenCodexDynamicToolFunctions(tools) {
-	return (tools ?? []).flatMap((tool) => tool.type === "namespace" ? tool.tools : [tool]);
-}
-const CODEX_INTERACTIVE_THREAD_SOURCE_KINDS = ["cli", "vscode"];
-function isJsonObject(value) {
-	return Boolean(value && typeof value === "object" && !Array.isArray(value));
-}
-function isRpcResponse(message) {
-	return "id" in message && !("method" in message);
-}
-//#endregion
-export { isRpcResponse as a, isJsonObject as i, CODEX_OPENCLAW_DIRECT_DYNAMIC_TOOL_NAMESPACE as n, flattenCodexDynamicToolFunctions as r, CODEX_INTERACTIVE_THREAD_SOURCE_KINDS as t };

package/dist/provider-catalog.js

@@ -1,118 +0,0 @@
-//#region extensions/codex/provider-catalog.ts
-/** Provider id used by Codex model refs. */
-const CODEX_PROVIDER_ID = "codex";
-/** Synthetic base URL used to route Codex app-server model requests. */
-const CODEX_BASE_URL = "https://chatgpt.com/backend-api";
-/** Synthetic auth marker understood by Codex app-server runtime paths. */
-const CODEX_APP_SERVER_AUTH_MARKER = "codex-app-server";
-const DEFAULT_CONTEXT_WINDOW = 272e3;
-const DEFAULT_MAX_TOKENS = 128e3;
-const KNOWN_CONTEXT_WINDOW_BY_MODEL_ID = Object.freeze({
-	"gpt-5.6-sol": 372e3,
-	"gpt-5.6-terra": 372e3,
-	"gpt-5.6-luna": 372e3
-});
-/** Offline fallback catalog used when live app-server discovery is unavailable. */
-const FALLBACK_CODEX_MODELS = [
-	{
-		id: "gpt-5.6-sol",
-		model: "gpt-5.6-sol",
-		displayName: "GPT-5.6 Sol",
-		description: "Latest frontier agentic coding model.",
-		isDefault: true,
-		contextWindow: 372e3,
-		inputModalities: ["text", "image"],
-		supportedReasoningEfforts: [
-			"low",
-			"medium",
-			"high",
-			"xhigh",
-			"max",
-			"ultra"
-		]
-	},
-	{
-		id: "gpt-5.6-luna",
-		model: "gpt-5.6-luna",
-		displayName: "GPT-5.6 Luna",
-		description: "High-throughput frontier agentic coding model.",
-		contextWindow: 372e3,
-		inputModalities: ["text", "image"],
-		supportedReasoningEfforts: [
-			"low",
-			"medium",
-			"high",
-			"xhigh",
-			"max"
-		]
-	},
-	{
-		id: "gpt-5.5",
-		model: "gpt-5.5",
-		displayName: "GPT-5.5",
-		description: "Previous frontier agentic coding model.",
-		inputModalities: ["text", "image"],
-		supportedReasoningEfforts: [
-			"low",
-			"medium",
-			"high",
-			"xhigh"
-		]
-	},
-	{
-		id: "gpt-5.4-mini",
-		model: "gpt-5.4-mini",
-		displayName: "GPT-5.4-Mini",
-		description: "Smaller frontier agentic coding model.",
-		inputModalities: ["text", "image"],
-		supportedReasoningEfforts: [
-			"low",
-			"medium",
-			"high",
-			"xhigh"
-		]
-	}
-];
-/**
-* Converts a Codex app-server model record into OpenClaw provider model config.
-*/
-function buildCodexModelDefinition(model) {
-	const id = model.id.trim() || model.model.trim();
-	const supportedReasoningEfforts = model.supportedReasoningEfforts;
-	return {
-		id,
-		name: model.displayName?.trim() || id,
-		api: "openai-chatgpt-responses",
-		reasoning: supportedReasoningEfforts !== void 0 ? supportedReasoningEfforts.length > 0 : shouldDefaultToReasoningModel(id),
-		input: model.inputModalities.includes("image") ? ["text", "image"] : ["text"],
-		cost: {
-			input: 0,
-			output: 0,
-			cacheRead: 0,
-			cacheWrite: 0
-		},
-		contextWindow: model.contextWindow ?? KNOWN_CONTEXT_WINDOW_BY_MODEL_ID[id] ?? DEFAULT_CONTEXT_WINDOW,
-		maxTokens: DEFAULT_MAX_TOKENS,
-		compat: {
-			...supportedReasoningEfforts !== void 0 ? { supportsReasoningEffort: supportedReasoningEfforts.length > 0 } : {},
-			...supportedReasoningEfforts && supportedReasoningEfforts.length > 0 ? { supportedReasoningEfforts: [...supportedReasoningEfforts] } : {},
-			supportsUsageInStreaming: true
-		}
-	};
-}
-/** Builds the synthetic Codex provider config for a model list. */
-function buildCodexProviderConfig(models) {
-	return {
-		baseUrl: CODEX_BASE_URL,
-		apiKey: CODEX_APP_SERVER_AUTH_MARKER,
-		auth: "token",
-		api: "openai-chatgpt-responses",
-		models: models.map(buildCodexModelDefinition)
-	};
-}
-function shouldDefaultToReasoningModel(modelId) {
-	const lower = modelId.toLowerCase();
-	return lower.startsWith("gpt-5") || lower.startsWith("o1") || lower.startsWith("o3") || lower.startsWith("o4");
-}
-//#endregion
-export { CODEX_APP_SERVER_AUTH_MARKER, CODEX_BASE_URL, CODEX_PROVIDER_ID, FALLBACK_CODEX_MODELS, buildCodexModelDefinition, buildCodexProviderConfig };

package/dist/provider-discovery.js

@@ -1,34 +0,0 @@
-import { CODEX_APP_SERVER_AUTH_MARKER, CODEX_PROVIDER_ID, FALLBACK_CODEX_MODELS, buildCodexProviderConfig } from "./provider-catalog.js";
-//#region extensions/codex/provider-discovery.ts
-function resolveCodexPluginConfig(ctx) {
-	return (ctx.config.plugins?.entries)?.codex?.config;
-}
-async function runCodexCatalog(ctx) {
-	const { buildCodexProviderCatalog } = await import("./provider.js");
-	return await buildCodexProviderCatalog({
-		env: ctx.env,
-		pluginConfig: resolveCodexPluginConfig(ctx)
-	});
-}
-/** Provider discovery descriptor with static fallback and synthetic auth. */
-const codexProviderDiscovery = {
-	id: CODEX_PROVIDER_ID,
-	label: "Codex",
-	docsPath: "/providers/models",
-	auth: [],
-	catalog: {
-		order: "late",
-		run: runCodexCatalog
-	},
-	staticCatalog: {
-		order: "late",
-		run: async () => ({ provider: buildCodexProviderConfig(FALLBACK_CODEX_MODELS) })
-	},
-	resolveSyntheticAuth: () => ({
-		apiKey: CODEX_APP_SERVER_AUTH_MARKER,
-		source: "codex-app-server",
-		mode: "token"
-	})
-};
-//#endregion
-export { codexProviderDiscovery, codexProviderDiscovery as default };

package/dist/provider.js

@@ -1,307 +0,0 @@
-import { CODEX_APP_SERVER_AUTH_MARKER, CODEX_BASE_URL, CODEX_PROVIDER_ID, FALLBACK_CODEX_MODELS, buildCodexModelDefinition, buildCodexProviderConfig } from "./provider-catalog.js";
-import { d as readCodexPluginConfig, f as resolveCodexAppServerRuntimeOptions } from "./config-c48K5HP9.js";
-import { resolveCodexSystemPromptContribution } from "./prompt-overlay.js";
-import { t as buildCodexAppServerUsageSnapshot } from "./rate-limits-Dhp04Rqo.js";
-import { resolvePluginConfigObject } from "openclaw/plugin-sdk/plugin-config-runtime";
-import { expectDefined } from "openclaw/plugin-sdk/expect-runtime";
-import { normalizeModelCompat } from "openclaw/plugin-sdk/provider-model-shared";
-import { createSubsystemLogger } from "openclaw/plugin-sdk/core";
-//#region extensions/codex/provider.ts
-/**
-* Codex provider plugin and live app-server model catalog discovery.
-*/
-const DEFAULT_DISCOVERY_TIMEOUT_MS = 2500;
-const LIVE_DISCOVERY_ENV = "OPENCLAW_CODEX_DISCOVERY_LIVE";
-const MODEL_DISCOVERY_PAGE_LIMIT = 100;
-const CODEX_APP_SERVER_SETUP_METHOD_ID = "app-server";
-const CODEX_DEFAULT_MODEL_REF = `${CODEX_PROVIDER_ID}/${expectDefined(FALLBACK_CODEX_MODELS[0], "Codex fallback model catalog must not be empty").id}`;
-const codexCatalogLog = createSubsystemLogger("codex/catalog");
-const CODEX_REASONING_EFFORTS = [
-	"minimal",
-	"low",
-	"medium",
-	"high",
-	"xhigh",
-	"max",
-	"ultra"
-];
-const GPT_56_MAX_REASONING_EFFORTS = [
-	"low",
-	"medium",
-	"high",
-	"xhigh",
-	"max"
-];
-const GPT_56_ULTRA_REASONING_EFFORTS = [...GPT_56_MAX_REASONING_EFFORTS, "ultra"];
-const GPT_56_ULTRA_MODEL_IDS = /* @__PURE__ */ new Set(["gpt-5.6-sol", "gpt-5.6-terra"]);
-const GPT_56_MAX_MODEL_IDS = /* @__PURE__ */ new Set([...GPT_56_ULTRA_MODEL_IDS, "gpt-5.6-luna"]);
-const GPT_56_DEFAULT_REASONING_EFFORTS = /* @__PURE__ */ new Map([
-	["gpt-5.6-sol", "low"],
-	["gpt-5.6-terra", "medium"],
-	["gpt-5.6-luna", "medium"]
-]);
-const GPT_5_PRO_REASONING_EFFORTS = [
-	"medium",
-	"high",
-	"xhigh"
-];
-/**
-* Builds the Codex provider plugin, including setup metadata, catalog discovery,
-* dynamic model resolution, and prompt/thinking hooks.
-*/
-function buildCodexProvider(options = {}) {
-	return {
-		id: CODEX_PROVIDER_ID,
-		label: "Codex",
-		docsPath: "/providers/models",
-		auth: [{
-			id: CODEX_APP_SERVER_SETUP_METHOD_ID,
-			label: "Codex app-server",
-			hint: "Use the Codex app-server runtime and managed model catalog.",
-			kind: "custom",
-			wizard: {
-				choiceId: CODEX_PROVIDER_ID,
-				choiceLabel: "Codex app-server",
-				choiceHint: "Use the Codex app-server runtime and managed model catalog.",
-				assistantPriority: -40,
-				groupId: CODEX_PROVIDER_ID,
-				groupLabel: "Codex",
-				groupHint: "Codex app-server model provider",
-				onboardingScopes: ["text-inference"]
-			},
-			run: async () => ({
-				profiles: [],
-				defaultModel: CODEX_DEFAULT_MODEL_REF
-			})
-		}],
-		catalog: {
-			order: "late",
-			run: async (ctx) => {
-				const pluginConfig = resolvePluginConfigObject(ctx.config, "codex") ?? (ctx.config ? void 0 : options.pluginConfig);
-				return await buildCodexProviderCatalog({
-					env: ctx.env,
-					pluginConfig,
-					listModels: options.listModels
-				});
-			}
-		},
-		staticCatalog: {
-			order: "late",
-			run: async () => ({ provider: buildCodexProviderConfig(FALLBACK_CODEX_MODELS) })
-		},
-		resolveDynamicModel: (ctx) => resolveCodexDynamicModel(ctx.modelId),
-		resolveSyntheticAuth: () => ({
-			apiKey: CODEX_APP_SERVER_AUTH_MARKER,
-			source: "codex-app-server",
-			mode: "token"
-		}),
-		fetchUsageSnapshot: async (ctx) => {
-			if (ctx.token !== "codex-app-server") return null;
-			const appServer = resolveCodexAppServerRuntimeOptions({ pluginConfig: resolvePluginConfigObject(ctx.config, "codex") ?? (ctx.config ? void 0 : options.pluginConfig) });
-			const usage = await (options.readUsage ?? requestCodexAppServerUsageLazy)({
-				timeoutMs: ctx.timeoutMs,
-				agentDir: ctx.agentDir,
-				...ctx.authProfileId ? { authProfileId: ctx.authProfileId } : {},
-				config: ctx.config,
-				startOptions: appServer.start
-			});
-			const snapshot = buildCodexAppServerUsageSnapshot(usage.rateLimits);
-			const accountEmail = ctx.email ?? usage.accountEmail;
-			return accountEmail && !snapshot.error ? {
-				...snapshot,
-				accountEmail
-			} : snapshot;
-		},
-		resolveThinkingProfile: ({ modelId, compat }) => {
-			const efforts = resolveCodexThinkingEfforts({
-				modelId,
-				supportedReasoningEfforts: readCodexSupportedReasoningEfforts(compat)
-			});
-			const defaultLevel = GPT_56_DEFAULT_REASONING_EFFORTS.get(modelId.trim().toLowerCase());
-			return {
-				levels: [{ id: "off" }, ...efforts.map((id) => ({ id }))],
-				...defaultLevel && efforts.includes(defaultLevel) ? { defaultLevel } : {}
-			};
-		},
-		resolveSystemPromptContribution: ({ config, modelId }) => resolveCodexSystemPromptContribution({
-			config,
-			modelId
-		}),
-		isModernModelRef: ({ modelId }) => isModernCodexModel(modelId)
-	};
-}
-/**
-* Builds the Codex model catalog from live app-server discovery, falling back
-* to built-in model records when discovery is disabled or unavailable.
-*/
-async function buildCodexProviderCatalog(options = {}) {
-	const config = readCodexPluginConfig(options.pluginConfig);
-	const appServer = resolveCodexAppServerRuntimeOptions({ pluginConfig: options.pluginConfig });
-	const timeoutMs = normalizeTimeoutMs(config.discovery?.timeoutMs);
-	let discovered = [];
-	if (config.discovery?.enabled !== false && !shouldSkipLiveDiscovery(options.env)) discovered = await listModelsBestEffort({
-		listModels: options.listModels ?? listCodexAppServerModelsLazy,
-		timeoutMs,
-		startOptions: appServer.start,
-		onDiscoveryFailure: options.onDiscoveryFailure
-	});
-	return { provider: buildCodexProviderConfig(discovered.length > 0 ? discovered : FALLBACK_CODEX_MODELS) };
-}
-function resolveCodexDynamicModel(modelId) {
-	const id = modelId.trim();
-	if (!id) return;
-	const fallbackModel = FALLBACK_CODEX_MODELS.find((model) => model.id === id);
-	return normalizeModelCompat({
-		...buildCodexModelDefinition({
-			id,
-			model: id,
-			inputModalities: fallbackModel?.inputModalities ?? ["text"],
-			supportedReasoningEfforts: fallbackModel?.supportedReasoningEfforts
-		}),
-		provider: CODEX_PROVIDER_ID,
-		baseUrl: CODEX_BASE_URL
-	});
-}
-async function listModelsBestEffort(params) {
-	try {
-		const models = [];
-		let cursor;
-		do {
-			const result = await params.listModels({
-				timeoutMs: params.timeoutMs,
-				limit: MODEL_DISCOVERY_PAGE_LIMIT,
-				cursor,
-				startOptions: params.startOptions,
-				sharedClient: false
-			});
-			models.push(...result.models.filter((model) => !model.hidden));
-			cursor = result.nextCursor;
-		} while (cursor);
-		return models;
-	} catch (error) {
-		params.onDiscoveryFailure?.(error);
-		codexCatalogLog.debug("codex model discovery failed; using fallback catalog", { error: error instanceof Error ? error.message : String(error) });
-		return [];
-	}
-}
-async function listCodexAppServerModelsLazy(options) {
-	const { listCodexAppServerModels } = await import("./models-DuKzZA6G.js").then((n) => n.r);
-	return listCodexAppServerModels(options);
-}
-function extractCodexAccountEmail(value) {
-	if (!value || typeof value !== "object") return;
-	const record = value;
-	const account = record.account && typeof record.account === "object" ? record.account : record;
-	const email = account.email ?? account.accountEmail;
-	return typeof email === "string" && email.trim() ? email.trim() : void 0;
-}
-async function requestCodexAppServerUsageLazy(options) {
-	const { withCodexAppServerJsonClient } = await import("./request-DborTWgw.js").then((n) => n.r);
-	const deadline = Date.now() + options.timeoutMs;
-	return await withCodexAppServerJsonClient({
-		timeoutMs: options.timeoutMs,
-		timeoutMessage: "codex app-server usage read timed out",
-		agentDir: options.agentDir,
-		...options.authProfileId ? { authProfileId: options.authProfileId } : {},
-		config: options.config,
-		startOptions: options.startOptions,
-		isolated: true,
-		isolatedShutdown: CODEX_USAGE_ISOLATED_SHUTDOWN
-	}, async (request) => {
-		const rateLimits = await request({ method: "account/rateLimits/read" });
-		const accountEmail = await readCodexAccountEmailBestEffort(request, deadline);
-		return {
-			rateLimits,
-			...accountEmail ? { accountEmail } : {}
-		};
-	});
-}
-const CODEX_USAGE_ISOLATED_SHUTDOWN = {
-	forceKillDelayMs: 200,
-	exitTimeoutMs: 300
-};
-const CODEX_ACCOUNT_READ_MAX_TIMEOUT_MS = 4e3;
-const CODEX_USAGE_DEADLINE_RESERVE_MS = CODEX_USAGE_ISOLATED_SHUTDOWN.forceKillDelayMs + CODEX_USAGE_ISOLATED_SHUTDOWN.exitTimeoutMs + 250;
-async function readCodexAccountEmailBestEffort(request, deadline) {
-	const boundMs = Math.min(CODEX_ACCOUNT_READ_MAX_TIMEOUT_MS, deadline - Date.now() - CODEX_USAGE_DEADLINE_RESERVE_MS);
-	if (boundMs <= 0) return;
-	const read = request({
-		method: "account/read",
-		requestParams: {}
-	}).then((account) => extractCodexAccountEmail(account), () => void 0);
-	let timer;
-	const timeout = new Promise((resolve) => {
-		timer = setTimeout(() => resolve(void 0), boundMs);
-		timer.unref?.();
-	});
-	try {
-		return await Promise.race([read, timeout]);
-	} finally {
-		if (timer) clearTimeout(timer);
-	}
-}
-function normalizeTimeoutMs(value) {
-	return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : DEFAULT_DISCOVERY_TIMEOUT_MS;
-}
-function shouldSkipLiveDiscovery(env = process.env) {
-	const override = env[LIVE_DISCOVERY_ENV]?.trim().toLowerCase();
-	if (override === "0" || override === "false") return true;
-	return Boolean(env.VITEST) && override !== "1";
-}
-function isKnownXHighCodexModel(modelId) {
-	const lower = modelId.trim().toLowerCase();
-	return lower.startsWith("gpt-5") || lower.startsWith("o3") || lower.startsWith("o4") || lower.includes("codex");
-}
-function normalizeCodexReasoningEfforts(efforts) {
-	if (!efforts) return [];
-	const supported = new Set(efforts.map((effort) => effort.trim().toLowerCase()));
-	return CODEX_REASONING_EFFORTS.filter((effort) => supported.has(effort));
-}
-/** Read app-server reasoning metadata from a runtime model compat union. */
-function readCodexSupportedReasoningEfforts(compat) {
-	if (!compat || typeof compat !== "object" || Array.isArray(compat)) return;
-	const efforts = compat.supportedReasoningEfforts;
-	if (!Array.isArray(efforts)) return;
-	const strings = efforts.filter((effort) => typeof effort === "string");
-	return strings.some((effort) => effort.trim().toLowerCase() === "none") ? void 0 : strings;
-}
-function resolveCodexThinkingEfforts(params) {
-	if (params.supportedReasoningEfforts) return normalizeCodexReasoningEfforts(params.supportedReasoningEfforts);
-	const fallbackEfforts = resolveCodexFallbackReasoningEfforts(params.modelId);
-	if (fallbackEfforts) return [...fallbackEfforts];
-	return [
-		"minimal",
-		"low",
-		"medium",
-		"high",
-		...isKnownXHighCodexModel(params.modelId) ? ["xhigh"] : [],
-		...isMaxReasoningCodexModel(params.modelId) ? ["max"] : []
-	];
-}
-/** Map a requested effort onto the authoritative app-server model contract. */
-function resolveCodexSupportedReasoningEffort(params) {
-	const supported = normalizeCodexReasoningEfforts(params.supportedReasoningEfforts);
-	if (supported.includes(params.requested)) return params.requested;
-	const fallbackEfforts = params.requested === "ultra" ? supported : supported.filter((effort) => effort !== "ultra");
-	const requestedRank = CODEX_REASONING_EFFORTS.indexOf(params.requested);
-	return fallbackEfforts.find((effort) => CODEX_REASONING_EFFORTS.indexOf(effort) >= requestedRank) ?? fallbackEfforts.at(-1);
-}
-/** Return the known effort contract when app-server model metadata is unavailable. */
-function resolveCodexFallbackReasoningEfforts(modelId) {
-	const normalized = modelId.trim().toLowerCase();
-	if (GPT_56_ULTRA_MODEL_IDS.has(normalized)) return GPT_56_ULTRA_REASONING_EFFORTS;
-	if (normalized === "gpt-5.6-luna") return GPT_56_MAX_REASONING_EFFORTS;
-	if (normalized === "gpt-5.5-pro" || normalized === "gpt-5.4-pro") return GPT_5_PRO_REASONING_EFFORTS;
-}
-/** Return whether the model uses the modern Codex reasoning profile. */
-function isModernCodexModel(modelId) {
-	const lower = modelId.trim().toLowerCase();
-	return GPT_56_MAX_MODEL_IDS.has(lower) || lower === "gpt-5.5" || lower === "gpt-5.5-pro" || lower === "gpt-5.4" || lower === "gpt-5.4-pro" || lower === "gpt-5.4-mini" || lower === "gpt-5.3-codex-spark";
-}
-/** Return whether Codex accepts the preview GPT-5.6 `max` reasoning effort. */
-function isMaxReasoningCodexModel(modelId) {
-	const lower = modelId.trim().toLowerCase();
-	return GPT_56_MAX_MODEL_IDS.has(lower);
-}
-//#endregion
-export { buildCodexProvider, buildCodexProviderCatalog, isMaxReasoningCodexModel, isModernCodexModel, readCodexSupportedReasoningEfforts, resolveCodexFallbackReasoningEfforts, resolveCodexSupportedReasoningEffort };