@openclaw/codex 2026.7.2-beta.7 → 2026.8.1-beta.3

package/dist/isolated-completion-DPMtlH9r.js

@@ -0,0 +1,75 @@
+import { h as readCodexPluginConfig, r as resolveCodexAppServerHomeScope } from "./config-CpNeo5AE.js";
+import { at as resolveCodexAppServerPreparedAuthHandoff, ut as isJsonObject } from "./shared-client-Dw-rzii0.js";
+import { t as runBoundedCodexAppServerTurn } from "./bounded-turn-4BjrZEwW.js";
+import { i as createAttributedCodexAssistantMessage } from "./event-projector-assistant-message-BwxV4d6N.js";
+//#region extensions/codex/src/app-server/isolated-completion.ts
+const ISOLATED_PASSIVE_ITEM_TYPES = /* @__PURE__ */ new Set(["agentMessage", "reasoning"]);
+function assertIsolatedCompletionItems(items, prompt) {
+	let promptEchoSeen = false;
+	for (const item of items) {
+		if (ISOLATED_PASSIVE_ITEM_TYPES.has(item.type)) continue;
+		if (item.type === "userMessage" && !promptEchoSeen) {
+			const content = Array.isArray(item.content) ? item.content : [];
+			const input = content[0];
+			if (content.length === 1 && isJsonObject(input) && input.type === "text" && input.text === prompt) {
+				promptEchoSeen = true;
+				continue;
+			}
+		}
+		throw new Error(`Codex isolated completion returned unexpected native item: ${item.type}`);
+	}
+}
+/** Runs prompt-only Codex inference on an ephemeral, ring-zero native thread. */
+async function runCodexIsolatedCompletion(params, options) {
+	const authorization = params.authorization;
+	if (authorization.owner !== "harness") throw new Error("Codex native isolated completion requires harness-owned authorization.");
+	const pluginConfig = readCodexPluginConfig(options.pluginConfig);
+	const authRequirement = authorization.plan.modelRoute?.authRequirement;
+	const authHandoff = await resolveCodexAppServerPreparedAuthHandoff({
+		authRequirement,
+		authProfileId: authorization.plan.forwardedAuthProfileId,
+		authProfileStore: authorization.authProfileStore,
+		agentDir: params.agentDir,
+		homeScope: resolveCodexAppServerHomeScope({ appServer: pluginConfig.appServer }),
+		config: params.config,
+		subscriptionProfileRequiredError: "Prepared Codex subscription route requires a scoped native OAuth or token profile.",
+		subscriptionProfileUnusableError: `Prepared Codex auth profile "${authorization.plan.forwardedAuthProfileId}" is unusable.`
+	});
+	const authSelection = authHandoff.preparedAuth ? { preparedAuth: authHandoff.preparedAuth } : { profile: authHandoff.authProfileId };
+	const result = await runBoundedCodexAppServerTurn({
+		config: params.config,
+		model: {
+			mode: "required",
+			id: params.modelId
+		},
+		...authSelection,
+		authRequirement,
+		timeoutMs: params.timeoutMs,
+		signal: params.abortSignal,
+		agentDir: params.agentDir,
+		authProfileStore: authorization.authProfileStore,
+		options,
+		taskLabel: "isolated completion",
+		developerInstructions: params.systemPrompt,
+		input: [{
+			type: "text",
+			text: params.prompt,
+			text_elements: []
+		}],
+		requiredModalities: ["text"],
+		isolation: "configured-transport",
+		requireNoExternalCapabilities: true
+	});
+	assertIsolatedCompletionItems(result.items, params.prompt);
+	return { assistant: createAttributedCodexAssistantMessage({
+		api: "openai-chatgpt-responses",
+		provider: params.provider,
+		modelId: result.model
+	}, result.text, {
+		tokenUsage: result.usage,
+		aborted: false,
+		promptError: null
+	}) };
+}
+//#endregion
+export { runCodexIsolatedCompletion };

package/dist/local-runtime-attribution-B_2mnqhb.js

@@ -0,0 +1,19 @@
+import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/string-coerce-runtime";
+//#region extensions/codex/src/app-server/local-runtime-attribution.ts
+const OPENAI_PROVIDER_ID = "openai";
+const OPENAI_RESPONSES_API = "openai-responses";
+const OPENAI_CODEX_RESPONSES_API = "openai-chatgpt-responses";
+/** Maps local Codex runtime plans onto the provider/api pair exposed to event projection. */
+function resolveCodexLocalRuntimeAttribution(params) {
+	const authProfileProvider = normalizeLowercaseStringOrEmpty(params.runtimePlan?.auth?.authProfileProviderForAuth);
+	if (normalizeLowercaseStringOrEmpty(params.runtimePlan?.observability.harnessId) === "codex" && authProfileProvider !== OPENAI_PROVIDER_ID && normalizeLowercaseStringOrEmpty(params.model.provider) === OPENAI_PROVIDER_ID && normalizeLowercaseStringOrEmpty(params.model.api) === OPENAI_RESPONSES_API) return {
+		provider: OPENAI_PROVIDER_ID,
+		api: OPENAI_CODEX_RESPONSES_API
+	};
+	return {
+		provider: params.provider,
+		api: params.model.api
+	};
+}
+//#endregion
+export { resolveCodexLocalRuntimeAttribution as t };

package/dist/managed-binary-By4FZC6i.js

@@ -0,0 +1,212 @@
+import { createRequire } from "node:module";
+import { access } from "node:fs/promises";
+import path from "node:path";
+import { constants, existsSync, readFileSync, realpathSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { expectDefined } from "openclaw/plugin-sdk/expect-runtime";
+//#region extensions/codex/src/app-server/version.ts
+/**
+* Version and package pins for the managed Codex app-server runtime.
+*/
+/** Exact Codex app-server version shipped by the OpenClaw Codex bridge. */
+const CODEX_APP_SERVER_VERSION = "0.149.1";
+/** Inclusive runtime compatibility floor for external app-server binaries. */
+const MIN_SUPPORTED_CODEX_APP_SERVER_VERSION = "0.147.0";
+/** npm package name for the managed Codex app-server binary. */
+const MANAGED_CODEX_APP_SERVER_PACKAGE = "@openai/codex";
+//#endregion
+//#region extensions/codex/src/app-server/managed-binary.ts
+/**
+* Resolves the managed Codex app-server binary shipped with or installed beside
+* the Codex plugin before stdio startup.
+*/
+const CODEX_PLUGIN_ROOT = resolveDefaultCodexPluginRoot(path.dirname(fileURLToPath(import.meta.url)));
+let registeredCodexPluginRoot;
+const MACOS_DESKTOP_CODEX_APP_SERVER_COMMANDS = ["/Applications/ChatGPT.app/Contents/Resources/codex", "/Applications/Codex.app/Contents/Resources/codex"];
+/** Records the process-stable plugin root prepared by OpenClaw's plugin loader. */
+function setManagedCodexPluginRoot(pluginRoot) {
+	registeredCodexPluginRoot = pluginRoot;
+}
+/** Rewrites managed stdio start options to point at an executable Codex binary path. */
+async function resolveManagedCodexAppServerStartOptions(startOptions, options = {}) {
+	if (startOptions.transport !== "stdio" || startOptions.commandSource !== "managed") return startOptions;
+	const platform = options.platform ?? process.platform;
+	const commandPaths = await findManagedCodexAppServerCommandPaths({
+		candidateCommandPaths: resolveManagedCodexAppServerCommandCandidates(options.pluginRoot ?? registeredCodexPluginRoot ?? CODEX_PLUGIN_ROOT, platform, startOptions.managedCommandOrder ?? "package-first"),
+		pathExists: options.pathExists ?? commandPathExists,
+		platform
+	});
+	const commandPath = expectDefined(commandPaths[0], "resolved managed Codex command path");
+	const managedFallbackCommandPaths = commandPaths.slice(1);
+	return {
+		...startOptions,
+		command: commandPath,
+		commandSource: "resolved-managed",
+		...managedFallbackCommandPaths.length > 0 ? { managedFallbackCommandPaths } : {}
+	};
+}
+/** Resolves the native artifact behind a successful managed launcher selection. */
+function resolveManagedCodexNativeCommand(command, options = {}) {
+	const platform = options.platform ?? process.platform;
+	if (isManagedCodexDesktopCommand(command, platform)) return command;
+	const target = resolveCodexNativeTarget(platform, options.arch ?? process.arch);
+	if (!target) return;
+	const packageRoot = resolveManagedCodexPackageRootForCommand(command, platform);
+	if (!packageRoot) return;
+	const resolvePackageJson = options.resolvePackageJson ?? resolvePackageJsonFromRoot;
+	const pathExists = options.pathExists ?? existsSync;
+	for (const packageName of [target.packageName, MANAGED_CODEX_APP_SERVER_PACKAGE]) {
+		const packageJsonPath = resolvePackageJson(packageName, packageRoot);
+		if (!packageJsonPath) continue;
+		const candidate = path.join(path.dirname(packageJsonPath), "vendor", target.triple, "bin", platform === "win32" ? "codex.exe" : "codex");
+		if (pathExists(candidate)) return candidate;
+	}
+}
+/** Returns whether a resolved managed command is owned by the macOS desktop app. */
+function isManagedCodexDesktopCommand(command, platform = process.platform) {
+	return platform === "darwin" && MACOS_DESKTOP_CODEX_APP_SERVER_COMMANDS.some((candidate) => candidate === command);
+}
+function resolveManagedCodexPackageRootForCommand(command, platform) {
+	const pathApi = pathForPlatform(platform);
+	const commandPaths = [command];
+	try {
+		commandPaths.unshift(realpathSync(command));
+	} catch {}
+	for (const commandPath of commandPaths) {
+		let current = pathApi.dirname(commandPath);
+		while (true) {
+			if (pathApi.basename(current) === "codex" && pathApi.basename(pathApi.dirname(current)) === "@openai") return current;
+			if (pathApi.basename(current) === ".bin") return pathApi.join(pathApi.dirname(current), "@openai", "codex");
+			const parent = pathApi.dirname(current);
+			if (parent === current) break;
+			current = parent;
+		}
+	}
+}
+function resolveCodexNativeTarget(platform, arch) {
+	if ((platform === "linux" || platform === "android") && arch === "x64") return {
+		packageName: "@openai/codex-linux-x64",
+		triple: "x86_64-unknown-linux-musl"
+	};
+	if ((platform === "linux" || platform === "android") && arch === "arm64") return {
+		packageName: "@openai/codex-linux-arm64",
+		triple: "aarch64-unknown-linux-musl"
+	};
+	if (platform === "darwin" && arch === "x64") return {
+		packageName: "@openai/codex-darwin-x64",
+		triple: "x86_64-apple-darwin"
+	};
+	if (platform === "darwin" && arch === "arm64") return {
+		packageName: "@openai/codex-darwin-arm64",
+		triple: "aarch64-apple-darwin"
+	};
+	if (platform === "win32" && arch === "x64") return {
+		packageName: "@openai/codex-win32-x64",
+		triple: "x86_64-pc-windows-msvc"
+	};
+	if (platform === "win32" && arch === "arm64") return {
+		packageName: "@openai/codex-win32-arm64",
+		triple: "aarch64-pc-windows-msvc"
+	};
+}
+function resolvePackageJsonFromRoot(packageName, root) {
+	try {
+		return createRequire(path.join(root, "package.json")).resolve(`${packageName}/package.json`);
+	} catch {
+		return;
+	}
+}
+function resolveManagedCodexAppServerCommandCandidates(pluginRoot, platform, managedCommandOrder) {
+	const pathApi = pathForPlatform(platform);
+	const commandName = platform === "win32" ? "codex.cmd" : "codex";
+	const roots = resolveManagedCodexAppServerCandidateRoots(pluginRoot, platform);
+	const packageCommandPaths = [...roots.map((root) => pathApi.join(root, "node_modules", ".bin", commandName)), ...resolveManagedCodexPackageBinCandidates(roots, platform)];
+	const desktopCommandPaths = resolveDesktopCodexAppServerCommandCandidates(platform);
+	const orderedCommandPaths = managedCommandOrder === "desktop-first" ? [...desktopCommandPaths, ...packageCommandPaths] : [...packageCommandPaths, ...desktopCommandPaths];
+	return [...new Set(orderedCommandPaths)];
+}
+function resolveDesktopCodexAppServerCommandCandidates(platform) {
+	return platform === "darwin" ? [...MACOS_DESKTOP_CODEX_APP_SERVER_COMMANDS] : [];
+}
+function resolveDefaultCodexPluginRoot(moduleDir) {
+	const moduleBaseName = path.basename(moduleDir);
+	if (moduleBaseName === "dist" || moduleBaseName === "dist-runtime") return path.dirname(moduleDir);
+	return path.resolve(moduleDir, "..", "..");
+}
+function resolveManagedCodexAppServerCandidateRoots(pluginRoot, platform) {
+	const pathApi = pathForPlatform(platform);
+	const directRoots = [
+		pluginRoot,
+		pathApi.dirname(pluginRoot),
+		pathApi.dirname(pathApi.dirname(pluginRoot)),
+		isDistExtensionRoot(pluginRoot, platform) ? pathApi.dirname(pathApi.dirname(pathApi.dirname(pluginRoot))) : null
+	].filter((root) => Boolean(root));
+	return [.../* @__PURE__ */ new Set([...directRoots, ...resolveNearestNodeModulesProjectRoots(directRoots, platform)])];
+}
+function resolveNearestNodeModulesProjectRoots(roots, platform) {
+	const pathApi = pathForPlatform(platform);
+	const projectRoots = [];
+	for (const root of roots) {
+		let current = pathApi.resolve(root);
+		while (true) {
+			if (pathApi.basename(current) === "node_modules") {
+				projectRoots.push(pathApi.dirname(current));
+				break;
+			}
+			const parent = pathApi.dirname(current);
+			if (parent === current) break;
+			current = parent;
+		}
+	}
+	return projectRoots;
+}
+function resolveManagedCodexPackageBinCandidates(roots, platform) {
+	if (platform === "win32") return [];
+	const candidates = [];
+	for (const root of roots) {
+		const candidate = resolveManagedCodexPackageBinCandidate(root);
+		if (candidate) candidates.push(candidate);
+	}
+	return candidates;
+}
+function resolveManagedCodexPackageBinCandidate(root) {
+	try {
+		const packageJsonPath = createRequire(path.join(root, "package.json")).resolve(`${MANAGED_CODEX_APP_SERVER_PACKAGE}/package.json`);
+		const packageRoot = path.dirname(packageJsonPath);
+		const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+		const packageBin = packageJson.bin && typeof packageJson.bin === "object" ? packageJson.bin : void 0;
+		const binPath = typeof packageJson.bin === "string" ? packageJson.bin : typeof packageBin?.codex === "string" ? packageBin.codex : null;
+		return binPath ? path.resolve(packageRoot, binPath) : null;
+	} catch {
+		return null;
+	}
+}
+function isDistExtensionRoot(pluginRoot, platform) {
+	const pathApi = pathForPlatform(platform);
+	const extensionsDir = pathApi.dirname(pluginRoot);
+	const distDir = pathApi.dirname(extensionsDir);
+	return pathApi.basename(extensionsDir) === "extensions" && (pathApi.basename(distDir) === "dist" || pathApi.basename(distDir) === "dist-runtime");
+}
+function pathForPlatform(platform) {
+	return platform === "win32" ? path.win32 : path.posix;
+}
+async function findManagedCodexAppServerCommandPaths(params) {
+	const commandPaths = [];
+	for (const commandPath of params.candidateCommandPaths) if (await params.pathExists(commandPath, params.platform)) commandPaths.push(commandPath);
+	if (commandPaths.length > 0) return commandPaths;
+	throw new Error([
+		`Managed Codex app-server binary was not found for ${MANAGED_CODEX_APP_SERVER_PACKAGE}.`,
+		"Reinstall or update OpenClaw, or run pnpm install in a source checkout.",
+		"Set plugins.entries.codex.config.appServer.command or OPENCLAW_CODEX_APP_SERVER_BIN to use a custom Codex binary."
+	].join(" "));
+}
+async function commandPathExists(filePath, platform) {
+	try {
+		await access(filePath, platform === "win32" ? constants.F_OK : constants.X_OK);
+		return true;
+	} catch {
+		return false;
+	}
+}
+//#endregion
+export { CODEX_APP_SERVER_VERSION as a, setManagedCodexPluginRoot as i, resolveManagedCodexAppServerStartOptions as n, MIN_SUPPORTED_CODEX_APP_SERVER_VERSION as o, resolveManagedCodexNativeCommand as r, isManagedCodexDesktopCommand as t };

package/dist/media-understanding-provider.js

@@ -1,4 +1,5 @@
-import { t as runBoundedCodexAppServerTurn } from "./bounded-turn-D2ZAgZVz.js";
+import { t as runBoundedCodexAppServerTurn } from "./bounded-turn-4BjrZEwW.js";
+import { isRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { validateJsonSchemaValue } from "openclaw/plugin-sdk/json-schema-runtime";
 //#region extensions/codex/media-understanding-provider.ts
 /**
@@ -49,6 +50,7 @@ async function describeCodexImages(req, options) {
 			mode: "required",
 			id: model
 		},
+		modelProvider: "openai",
 		profile: req.profile,
 		timeoutMs: req.timeoutMs,
 		signal: req.signal,
@@ -86,6 +88,7 @@ async function extractCodexStructured(req, options) {
 			mode: "required",
 			id: model
 		},
+		modelProvider: "openai",
 		profile: req.profile,
 		timeoutMs: req.timeoutMs,
 		signal: req.signal,
@@ -138,9 +141,6 @@ function buildStructuredExtractionPrompt(req) {
 		req.jsonMode === false ? "Return the extraction as concise text." : "Return valid JSON only. Do not wrap the JSON in Markdown fences."
 	].filter((part) => Boolean(part)).join("\n\n");
 }
-function isJsonSchemaObject(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
 function normalizeStructuredExtractionResult(params) {
 	const result = {
 		text: params.text,
@@ -154,7 +154,7 @@ function normalizeStructuredExtractionResult(params) {
 		} catch {
 			throw new Error("Codex structured extraction returned invalid JSON.");
 		}
-		if (isJsonSchemaObject(params.req.jsonSchema)) {
+		if (isRecord(params.req.jsonSchema)) {
 			const validation = validateJsonSchemaValue({
 				schema: params.req.jsonSchema,
 				cacheKey: "codex.media-understanding.extractStructured",

package/dist/model-catalog-CmGoqVKB.js

@@ -0,0 +1,48 @@
+import { r as buildCodexRuntimeModelParams } from "./harness-DoKQcF8n.js";
+import { h as readCodexPluginConfig } from "./config-CpNeo5AE.js";
+import { t as listAllCodexAppServerModels } from "./models-CZw1wClT.js";
+import { r as requestOptions } from "./command-rpc-xUIIonsO.js";
+//#region extensions/codex/src/app-server/model-catalog.ts
+const OPENAI_CODEX_BASE_URL = "https://chatgpt.com/backend-api/codex";
+const DEFAULT_MODEL_DISCOVERY_TIMEOUT_MS = 2500;
+const INPUT_TYPES = /* @__PURE__ */ new Set([
+	"text",
+	"image",
+	"audio",
+	"video",
+	"document"
+]);
+function isModelInputType(value) {
+	return INPUT_TYPES.has(value);
+}
+function codexAppServerModelsToCatalogEntries(models) {
+	return models.map((model, providerOrder) => {
+		const input = model.inputModalities.filter(isModelInputType);
+		const runtimeParams = buildCodexRuntimeModelParams(model.id, model.model);
+		return {
+			provider: "openai",
+			id: model.id,
+			name: model.displayName ?? model.id,
+			providerOrder,
+			api: "openai-chatgpt-responses",
+			baseUrl: OPENAI_CODEX_BASE_URL,
+			reasoning: model.supportedReasoningEfforts.length > 0,
+			...input.length > 0 ? { input } : {},
+			...runtimeParams ? { params: runtimeParams } : {},
+			compat: {
+				supportsReasoningEffort: model.supportedReasoningEfforts.length > 0,
+				supportedReasoningEfforts: model.supportedReasoningEfforts
+			}
+		};
+	});
+}
+async function loadCodexAppServerModelCatalog(params, pluginConfig) {
+	const discovery = readCodexPluginConfig(pluginConfig).discovery;
+	if (discovery?.enabled === false) return [];
+	return codexAppServerModelsToCatalogEntries((await listAllCodexAppServerModels({
+		...requestOptions(pluginConfig, 100, params.config, params.agentDir),
+		timeoutMs: discovery?.timeoutMs ?? DEFAULT_MODEL_DISCOVERY_TIMEOUT_MS
+	})).models);
+}
+//#endregion
+export { loadCodexAppServerModelCatalog };

package/dist/{models-BBMKU4jA.js → models-CZw1wClT.js}

@@ -1,5 +1,5 @@
-import { x as readCodexModelListResponse } from "./transcript-mirror-DzsdNCf5.js";
-import { uniqueStrings } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { t as assertCodexModelListResponse } from "./protocol-validators-VAVyEnDp.js";
+import { normalizeOptionalString, uniqueStrings } from "openclaw/plugin-sdk/string-coerce-runtime";
 //#region extensions/codex/src/app-server/models.ts
 /**
 * Lists and normalizes models exposed by the Codex app-server `model/list`
@@ -40,7 +40,7 @@ async function listAllCodexAppServerModels(options = {}) {
 async function withCodexAppServerModelClient(options, run) {
 	const timeoutMs = options.timeoutMs ?? 2500;
 	const useSharedClient = options.sharedClient !== false;
-	const { createIsolatedCodexAppServerClient, getLeasedSharedCodexAppServerClient, releaseLeasedSharedCodexAppServerClient } = await import("./shared-client-DTbvH-XV.js").then((n) => n.m);
+	const { createIsolatedCodexAppServerClient, getLeasedSharedCodexAppServerClient, releaseLeasedSharedCodexAppServerClient } = await import("./shared-client-Dw-rzii0.js").then((n) => n.m);
 	const client = useSharedClient ? await getLeasedSharedCodexAppServerClient({
 		startOptions: options.startOptions,
 		timeoutMs,
@@ -75,9 +75,8 @@ async function requestModelListPage(client, options) {
 }
 /** Parses a raw Codex app-server model/list response into OpenClaw's normalized shape. */
 function readModelListResult(value) {
-	const response = readCodexModelListResponse(value);
-	if (!response) return { models: [] };
-	const models = response.data.map((entry) => readCodexModel(entry)).filter((entry) => entry !== void 0);
+	const response = assertCodexModelListResponse(value);
+	const models = response.data.map((entry) => readCodexModel(entry));
 	const nextCursor = response.nextCursor ?? void 0;
 	return {
 		models,
@@ -85,27 +84,23 @@ function readModelListResult(value) {
 	};
 }
 function readCodexModel(value) {
-	const id = readNonEmptyString(value.id);
-	const model = readNonEmptyString(value.model) ?? id;
-	if (!id || !model) return;
+	const id = normalizeOptionalString(value.id);
+	const model = normalizeOptionalString(value.model);
+	if (!id || !model) throw new Error("Invalid Codex app-server model/list response: model id and name must be non-empty strings");
 	return {
 		id,
 		model,
-		...readNonEmptyString(value.displayName) ? { displayName: readNonEmptyString(value.displayName) } : {},
-		...readNonEmptyString(value.description) ? { description: readNonEmptyString(value.description) } : {},
+		...normalizeOptionalString(value.displayName) ? { displayName: normalizeOptionalString(value.displayName) } : {},
+		...normalizeOptionalString(value.description) ? { description: normalizeOptionalString(value.description) } : {},
 		hidden: value.hidden,
 		isDefault: value.isDefault,
 		inputModalities: value.inputModalities,
 		supportedReasoningEfforts: readReasoningEfforts(value.supportedReasoningEfforts),
-		...readNonEmptyString(value.defaultReasoningEffort) ? { defaultReasoningEffort: readNonEmptyString(value.defaultReasoningEffort) } : {}
+		...normalizeOptionalString(value.defaultReasoningEffort) ? { defaultReasoningEffort: normalizeOptionalString(value.defaultReasoningEffort) } : {}
 	};
 }
 function readReasoningEfforts(value) {
-	return uniqueStrings(value.map((entry) => readNonEmptyString(entry.reasoningEffort)).filter((entry) => entry !== void 0));
-}
-function readNonEmptyString(value) {
-	if (typeof value !== "string") return;
-	return value.trim() || void 0;
+	return uniqueStrings(value.map((entry) => normalizeOptionalString(entry.reasoningEffort)).filter((entry) => entry !== void 0));
 }
 function normalizeMaxPages(value) {
 	return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.floor(value) : 20;