@openclaw/codex 2026.7.1-beta.2 → 2026.7.1-beta.4

package/dist/{sandbox-guard-pTY2COoC.js → sandbox-guard-DA2TQfZW.js}

@@ -130,7 +130,7 @@ function readRuntimeSessionEntryBestEffort(params) {
 }
 //#endregion
 //#region extensions/codex/src/app-server/sandbox-guard.ts
-const DIRECT_METHOD_POLICIES = new Map([
+const DIRECT_METHOD_POLICIES = /* @__PURE__ */ new Map([
 	["account/rateLimits/read", "allowed-control-plane"],
 	["account/read", "allowed-control-plane"],
 	["app/list", "allowed-control-plane"],
@@ -153,7 +153,7 @@ const DIRECT_METHOD_POLICIES = new Map([
 	["thread/inject_items", "allowed-control-plane"],
 	["thread/list", "allowed-control-plane"],
 	["thread/metadata/update", "allowed-control-plane"],
-	["thread/name/update", "allowed-control-plane"],
+	["thread/name/set", "allowed-control-plane"],
 	["thread/read", "allowed-control-plane"],
 	["thread/rollback", "allowed-control-plane"],
 	["thread/start", "requires-openclaw-environment"],
@@ -184,7 +184,7 @@ const BLOCKED_DIRECT_METHOD_PREFIXES = [
 	"fs/",
 	"windowsSandbox/"
 ];
-const NODE_EXEC_BLOCKED_CONTROL_PLANE_METHODS = new Set(["config/mcpServer/reload"]);
+const NODE_EXEC_BLOCKED_CONTROL_PLANE_METHODS = /* @__PURE__ */ new Set(["config/mcpServer/reload"]);
 /** Returns a block message when a direct app-server method would bypass OpenClaw execution policy. */
 function resolveCodexAppServerDirectSandboxBypassBlock(params) {
 	const policy = resolveDirectMethodPolicy(params.method);

package/dist/session-binding-Dc03iwRF.js

@@ -0,0 +1,595 @@
+import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
+import { l as normalizeCodexServiceTier, t as CODEX_PLUGINS_MARKETPLACE_NAME } from "./config-CYEDnLJ2.js";
+import { n as CODEX_APP_SERVER_BINDING_NAMESPACE, t as CODEX_APP_SERVER_BINDING_MAX_ENTRIES } from "./session-binding-meta-B7aEMU7g.js";
+import { createHash, randomUUID } from "node:crypto";
+import { ensureAuthProfileStore, resolveDefaultAgentDir, resolveProviderIdForAuth, resolveSessionAgentIds } from "openclaw/plugin-sdk/agent-runtime";
+import { z } from "zod";
+import { embeddedAgentLog } from "openclaw/plugin-sdk/agent-harness-runtime";
+import { AsyncLocalStorage } from "node:async_hooks";
+import { loadSessionStore, resolveSessionStoreEntry, resolveStorePath } from "openclaw/plugin-sdk/session-store-runtime";
+//#region extensions/codex/src/app-server/session-binding.ts
+/** SQLite-backed Codex app-server thread bindings. */
+var session_binding_exports = /* @__PURE__ */ __exportAll({
+	CODEX_APP_SERVER_BINDING_GUARDED_REQUEST_TIMEOUT_MS: () => CODEX_APP_SERVER_BINDING_GUARDED_REQUEST_TIMEOUT_MS,
+	CODEX_APP_SERVER_BINDING_MAX_ENTRIES: () => CODEX_APP_SERVER_BINDING_MAX_ENTRIES,
+	CODEX_APP_SERVER_BINDING_NAMESPACE: () => CODEX_APP_SERVER_BINDING_NAMESPACE,
+	bindingStoreKey: () => bindingStoreKey,
+	createCodexAppServerBindingStore: () => createCodexAppServerBindingStore,
+	createStoredCodexAppServerBinding: () => createStoredCodexAppServerBinding,
+	isCodexAppServerNativeAuthProfile: () => isCodexAppServerNativeAuthProfile,
+	normalizeCodexAppServerBindingModelProvider: () => normalizeCodexAppServerBindingModelProvider,
+	readCodexAppServerThreadBinding: () => readCodexAppServerThreadBinding,
+	reclaimCurrentCodexSessionGeneration: () => reclaimCurrentCodexSessionGeneration,
+	resolveCodexAppServerBindingModelProvider: () => resolveCodexAppServerBindingModelProvider,
+	sessionBindingIdentity: () => sessionBindingIdentity
+});
+const CODEX_APP_SERVER_NATIVE_AUTH_PROVIDER = "openai";
+const PUBLIC_OPENAI_MODEL_PROVIDER = "openai";
+const BINDING_LEASE_RETRY_INTERVAL_MS = 1e3;
+const CODEX_APP_SERVER_BINDING_GUARDED_REQUEST_TIMEOUT_MS = 6e4;
+const BINDING_LEASE_STALE_MS = 65e3;
+const BINDING_LEASE_WAIT_MS = 7e4;
+const BINDING_LEASE_RENEW_INTERVAL_MS = Math.floor(BINDING_LEASE_STALE_MS / 3);
+const PHYSICAL_SESSION_RETIRE_TTL_MS = BINDING_LEASE_WAIT_MS;
+/** Resolves the same agent scope OpenClaw uses for transcript/session ownership. */
+function sessionBindingIdentity(params) {
+	const { sessionAgentId } = resolveSessionAgentIds(params);
+	const sessionKey = params.sessionKey?.trim();
+	return {
+		kind: "session",
+		agentId: sessionAgentId,
+		sessionId: params.sessionId,
+		...sessionKey ? { sessionKey } : {}
+	};
+}
+const optionalStringSchema = z.string().optional().catch(void 0);
+const optionalBooleanSchema = z.boolean().optional().catch(void 0);
+const optionalNonBlankStringSchema = z.string().refine((value) => Boolean(value.trim())).optional().catch(void 0);
+const optionalTimestampSchema = z.string().refine((value) => Number.isFinite(Date.parse(value))).optional().catch(void 0);
+const contextEngineProjectionSchema = z.object({
+	schemaVersion: z.literal(1),
+	mode: z.literal("thread_bootstrap"),
+	epoch: z.string().refine((value) => Boolean(value.trim())),
+	fingerprint: optionalStringSchema
+}).strict();
+const contextEngineSchema = z.object({
+	schemaVersion: z.literal(1),
+	engineId: z.string(),
+	policyFingerprint: z.string(),
+	projection: contextEngineProjectionSchema.optional().catch(void 0)
+}).strict();
+const destructiveApprovalModeSchema = z.enum([
+	"allow",
+	"deny",
+	"auto",
+	"ask"
+]).optional().catch(void 0);
+const accountAppPolicyEntrySchema = z.object({
+	source: z.literal("account"),
+	appName: z.string(),
+	allowDestructiveActions: z.boolean(),
+	destructiveApprovalMode: destructiveApprovalModeSchema,
+	mcpServerNames: z.array(z.string())
+}).strict();
+const pluginAppPolicyEntrySchema = z.object({
+	source: z.literal("plugin").optional(),
+	configKey: z.string(),
+	marketplaceName: z.literal(CODEX_PLUGINS_MARKETPLACE_NAME),
+	pluginName: z.string(),
+	allowDestructiveActions: z.boolean(),
+	destructiveApprovalMode: destructiveApprovalModeSchema,
+	mcpServerNames: z.array(z.string())
+}).strict();
+const pluginAppPolicyContextSchema = z.object({
+	fingerprint: z.string(),
+	apps: z.record(z.string(), z.union([accountAppPolicyEntrySchema, pluginAppPolicyEntrySchema])),
+	pluginAppIds: z.record(z.string(), z.array(z.string())).default({})
+}).strict();
+const threadBindingSchema = z.object({
+	threadId: z.string().refine((value) => Boolean(value.trim())),
+	cwd: z.string(),
+	authProfileId: optionalStringSchema,
+	model: optionalStringSchema,
+	modelProvider: z.string().transform((value) => value.trim()).pipe(z.string().min(1)).optional().catch(void 0),
+	approvalPolicy: z.preprocess((value) => value === "on-failure" ? "on-request" : value, z.enum([
+		"never",
+		"on-request",
+		"untrusted"
+	]).optional()).catch(void 0),
+	sandbox: z.enum([
+		"read-only",
+		"workspace-write",
+		"danger-full-access"
+	]).optional().catch(void 0),
+	serviceTier: z.preprocess(normalizeCodexServiceTier, z.custom((value) => typeof value === "string").optional()).optional().catch(void 0),
+	networkProxyProfileName: optionalStringSchema,
+	networkProxyConfigFingerprint: optionalStringSchema,
+	dynamicToolsFingerprint: optionalStringSchema,
+	dynamicToolsContainDeferred: optionalBooleanSchema,
+	webSearchThreadConfigFingerprint: optionalStringSchema,
+	userMcpServersFingerprint: optionalStringSchema,
+	mcpServersFingerprint: optionalStringSchema,
+	nativeHookRelayGeneration: optionalNonBlankStringSchema,
+	appServerRuntimeFingerprint: optionalStringSchema,
+	pluginAppsFingerprint: optionalStringSchema,
+	pluginAppsInputFingerprint: optionalStringSchema,
+	pluginAppPolicyContext: pluginAppPolicyContextSchema.optional().catch(void 0),
+	contextEngine: contextEngineSchema.optional().catch(void 0),
+	environmentSelectionFingerprint: optionalStringSchema,
+	conversationStartId: optionalStringSchema,
+	conversationSourceTransferComplete: z.literal(true).optional().catch(void 0),
+	historyCoveredThrough: optionalTimestampSchema
+});
+const bindingLeaseSchema = z.object({
+	token: z.string().refine((value) => Boolean(value.trim())),
+	expiresAt: z.number().finite()
+});
+const storedSessionIdSchema = z.string().transform((value) => value.trim()).pipe(z.string().min(1)).optional().catch(void 0);
+const storedBindingSchema = z.discriminatedUnion("state", [z.object({
+	version: z.literal(1),
+	state: z.literal("active"),
+	binding: threadBindingSchema,
+	sessionId: storedSessionIdSchema,
+	lease: bindingLeaseSchema.optional().catch(void 0)
+}), z.object({
+	version: z.literal(1),
+	state: z.literal("cleared"),
+	sessionId: storedSessionIdSchema,
+	lease: bindingLeaseSchema.optional().catch(void 0),
+	retired: z.literal(true).optional().catch(void 0)
+})]);
+/** Encodes a migrated sidecar binding as one canonical plugin-state row. */
+function createStoredCodexAppServerBinding(value, options = {}) {
+	const record = asRecord(value);
+	if (!record) return;
+	if (record.schemaVersion !== 1 && record.schemaVersion !== 2) return;
+	const pluginAppPolicyContext = readPluginAppPolicyContext(record.pluginAppPolicyContext, record.schemaVersion);
+	const historyCoveredThrough = readTimestamp(record.historyCoveredThrough) ?? readTimestamp(record.updatedAt) ?? readTimestamp(record.createdAt) ?? readTimestamp(options.now) ?? (/* @__PURE__ */ new Date()).toISOString();
+	const authProfileId = typeof record.authProfileId === "string" ? record.authProfileId : void 0;
+	const binding = readCodexAppServerThreadBinding({
+		...record,
+		modelProvider: normalizeCodexAppServerBindingModelProvider({
+			...options.lookup,
+			authProfileId,
+			modelProvider: typeof record.modelProvider === "string" ? record.modelProvider : void 0
+		}),
+		cwd: typeof record.cwd === "string" ? record.cwd : "",
+		pluginAppPolicyContext,
+		historyCoveredThrough
+	});
+	return binding ? {
+		version: 1,
+		state: "active",
+		binding: stripUndefinedBinding(binding)
+	} : void 0;
+}
+function bindingLeaseLostError(key, cause) {
+	return new Error(`Lost Codex binding lease: ${key}`, cause === void 0 ? void 0 : { cause });
+}
+/** Lets the authoritative OpenClaw session generation claim a stale stable binding row. */
+async function reclaimCurrentCodexSessionGeneration(params) {
+	const sessionKey = params.identity.sessionKey?.trim();
+	if (!sessionKey) return true;
+	const plan = await params.bindingStore.prepareSessionGenerationReclaim(params.identity);
+	if (plan.kind === "resolved") return plan.result;
+	try {
+		if (resolveSessionStoreEntry({
+			store: loadSessionStore(resolveStorePath(params.config?.session?.store, { agentId: params.identity.agentId }), {
+				skipCache: true,
+				hydrateSkillPromptRefs: false
+			}),
+			sessionKey
+		}).existing?.sessionId !== params.identity.sessionId) return false;
+	} catch {
+		return false;
+	}
+	return await params.bindingStore.mutate(params.identity, {
+		kind: "reclaim-generation",
+		expectedPreviousSessionId: plan.expectedPreviousSessionId
+	});
+}
+/** Creates the single binding facade owned by the Codex plugin runtime. */
+function createCodexAppServerBindingStore(state) {
+	const update = state.update?.bind(state);
+	if (!update) throw new Error("Codex app-server bindings require atomic plugin-state updates");
+	const leaseContext = new AsyncLocalStorage();
+	const renewLease = (key, owner) => {
+		if (owner.failure) return;
+		try {
+			let renewed = false;
+			const stored = update(key, (raw) => {
+				const current = readStoredBinding(raw);
+				if (raw !== void 0 && !current) throw new Error(`Invalid Codex app-server binding row: ${key}`);
+				const lease = current?.lease;
+				const now = Date.now();
+				if (!lease || lease.token !== owner.token || lease.expiresAt <= now) return;
+				renewed = true;
+				return {
+					...current,
+					lease: {
+						token: owner.token,
+						expiresAt: now + BINDING_LEASE_STALE_MS
+					}
+				};
+			});
+			if (!renewed || !stored) owner.failure = bindingLeaseLostError(key);
+		} catch (error) {
+			owner.failure = bindingLeaseLostError(key, error);
+		}
+	};
+	const transactKey = async (key, apply, ttlMs) => {
+		const deadline = Date.now() + BINDING_LEASE_WAIT_MS;
+		while (true) {
+			let busy = false;
+			let leaseLost = false;
+			let result;
+			const ownedLease = leaseContext.getStore()?.get(key);
+			if (ownedLease?.failure) throw ownedLease.failure;
+			const ownedToken = ownedLease?.token;
+			update(key, (raw) => {
+				const current = readStoredBinding(raw);
+				if (raw !== void 0 && !current) throw new Error(`Invalid Codex app-server binding row: ${key}`);
+				const activeLease = current?.lease;
+				const now = Date.now();
+				if (ownedToken && (!activeLease || activeLease.token !== ownedToken || activeLease.expiresAt <= now)) {
+					leaseLost = true;
+					return;
+				}
+				if (activeLease && activeLease.token !== ownedToken && activeLease.expiresAt > now) {
+					busy = true;
+					return;
+				}
+				const applied = apply(current, ownedToken);
+				result = applied.result;
+				return applied.next;
+			}, ttlMs == null ? void 0 : { ttlMs });
+			if (leaseLost) {
+				const failure = bindingLeaseLostError(key);
+				if (ownedLease) ownedLease.failure = failure;
+				throw failure;
+			}
+			if (!busy) return result;
+			if (Date.now() >= deadline) throw new Error(`Timed out waiting for Codex binding lease: ${key}`);
+			await sleep(BINDING_LEASE_RETRY_INTERVAL_MS);
+		}
+	};
+	return {
+		async read(identity) {
+			const key = bindingStoreKey(identity);
+			const raw = state.lookup(key);
+			const stored = readStoredBinding(raw);
+			if (raw !== void 0 && !stored) throw new Error(`Invalid Codex app-server binding row: ${key}`);
+			return stored?.state === "active" && ownsStoredSessionGeneration(identity, stored) ? stored.binding : void 0;
+		},
+		async prepareSessionGenerationReclaim(identity) {
+			const key = bindingStoreKey(identity);
+			const raw = state.lookup(key);
+			const current = readStoredBinding(raw);
+			if (raw !== void 0 && !current) throw new Error(`Invalid Codex app-server binding row: ${key}`);
+			if (!current) return {
+				kind: "resolved",
+				result: true
+			};
+			const currentSessionId = current.sessionId;
+			if (!currentSessionId || currentSessionId === identity.sessionId) return {
+				kind: "resolved",
+				result: current.state !== "cleared" || current.retired !== true
+			};
+			return {
+				kind: "verify",
+				expectedPreviousSessionId: currentSessionId
+			};
+		},
+		async mutate(identity, mutation) {
+			const key = bindingStoreKey(identity);
+			const retainLegacyClear = mutation.kind === "clear" && key.startsWith("conversation:legacy-");
+			return await transactKey(key, (current, leaseToken) => {
+				const ownsGeneration = ownsStoredSessionGeneration(identity, current);
+				const ownedLease = current?.lease && current.lease.token === leaseToken ? { lease: current.lease } : {};
+				if (mutation.kind === "reclaim-generation") {
+					if (identity.kind !== "session" || !identity.sessionKey?.trim()) return { result: false };
+					if (!current) return { result: true };
+					if (ownsGeneration) return { result: current.state !== "cleared" || current.retired !== true };
+					if (current.sessionId !== mutation.expectedPreviousSessionId) return { result: false };
+					return {
+						result: true,
+						next: {
+							version: 1,
+							state: "cleared",
+							sessionId: identity.sessionId,
+							...ownedLease
+						}
+					};
+				}
+				const storedActive = current?.state === "active" ? current : void 0;
+				const active = ownsGeneration ? storedActive : void 0;
+				const retiredGeneration = current?.state === "cleared" && current.retired === true && ownsGeneration;
+				if (mutation.kind === "set" && (mutation.if?.kind === "absent" && storedActive || current !== void 0 && !ownsGeneration || retiredGeneration) || mutation.kind === "patch" && active?.binding.threadId !== mutation.threadId || mutation.kind === "clear" && (mutation.threadId !== void 0 && active?.binding.threadId !== mutation.threadId || !ownsGeneration)) return { result: false };
+				if (mutation.kind === "clear" && retiredGeneration) return { result: true };
+				if (mutation.kind === "clear") return {
+					result: true,
+					next: {
+						version: 1,
+						state: "cleared",
+						...storedSessionGeneration(identity, current),
+						...ownedLease
+					}
+				};
+				let binding;
+				if (mutation.kind === "set") binding = validateBindingForWrite(mutation.binding);
+				else binding = validateBindingForWrite({
+					...active.binding,
+					...mutation.patch,
+					threadId: mutation.threadId
+				});
+				return {
+					result: true,
+					next: {
+						version: 1,
+						state: "active",
+						binding,
+						...storedSessionGeneration(identity, current),
+						...ownedLease
+					}
+				};
+			}, mutation.kind === "clear" && !retainLegacyClear && !leaseContext.getStore()?.has(key) ? 1 : void 0);
+		},
+		async adoptSessionGeneration(identity, expectedPreviousSessionId) {
+			const key = bindingStoreKey(identity);
+			const expectedSessionId = expectedPreviousSessionId.trim();
+			const targetSessionId = identity.sessionId.trim();
+			if (!expectedSessionId) throw new Error("Codex session generation adoption requires the previous session id");
+			return await transactKey(key, (current) => {
+				if (current?.state !== "active") return { result: "absent" };
+				if (current.sessionId === targetSessionId) return { result: "current" };
+				if (current.sessionId !== expectedSessionId) return { result: "conflict" };
+				return {
+					result: "adopted",
+					next: {
+						...current,
+						sessionId: targetSessionId
+					}
+				};
+			});
+		},
+		async retireSessionGeneration(identity) {
+			const key = bindingStoreKey(identity);
+			return await transactKey(key, (current, leaseToken) => {
+				if (!current) return { result: "absent" };
+				if (!ownsStoredSessionGeneration(identity, current)) return { result: "conflict" };
+				if (current.state === "cleared" && current.retired === true) return { result: "applied" };
+				return {
+					result: "applied",
+					next: {
+						version: 1,
+						state: "cleared",
+						retired: true,
+						...storedSessionGeneration(identity, current),
+						...current.lease && current.lease.token === leaseToken ? { lease: current.lease } : {}
+					}
+				};
+			}, identity.sessionKey?.trim() ? void 0 : PHYSICAL_SESSION_RETIRE_TTL_MS);
+		},
+		async withLease(identity, run) {
+			const key = bindingStoreKey(identity);
+			const owned = leaseContext.getStore();
+			const existingOwner = owned?.get(key);
+			if (existingOwner) {
+				const failureBeforeRun = existingOwner.failure;
+				if (failureBeforeRun) throw failureBeforeRun;
+				const result = await run();
+				const failureAfterRun = existingOwner.failure;
+				if (failureAfterRun) throw failureAfterRun;
+				return result;
+			}
+			const token = randomUUID();
+			if (!await transactKey(key, (current) => {
+				if (current?.state === "cleared" && current.retired === true && ownsStoredSessionGeneration(identity, current)) return { result: false };
+				const lease = {
+					token,
+					expiresAt: Date.now() + BINDING_LEASE_STALE_MS
+				};
+				if (current?.state === "active") return {
+					result: true,
+					next: {
+						...current,
+						...preservedSessionGeneration(identity, current),
+						lease
+					}
+				};
+				if (current?.state === "cleared" && current.retired === true) return {
+					result: true,
+					next: {
+						...current,
+						lease
+					}
+				};
+				return {
+					result: true,
+					next: {
+						version: 1,
+						state: "cleared",
+						...preservedSessionGeneration(identity, current),
+						lease
+					}
+				};
+			})) throw new Error(`Codex binding generation was retired: ${key}`);
+			const owner = { token };
+			const nested = new Map(owned);
+			nested.set(key, owner);
+			const heartbeat = setInterval(() => renewLease(key, owner), BINDING_LEASE_RENEW_INTERVAL_MS);
+			heartbeat.unref();
+			try {
+				const result = await leaseContext.run(nested, run);
+				if (owner.failure) throw owner.failure;
+				return result;
+			} finally {
+				clearInterval(heartbeat);
+				try {
+					const removeOwnedLease = (raw, matches) => {
+						const current = readStoredBinding(raw);
+						if (!current || !matches(current) || current.lease?.token !== token) return;
+						const { lease: _lease, ...released } = current;
+						return released;
+					};
+					if (!update(key, (raw) => removeOwnedLease(raw, (current) => current.state === "active"))) {
+						if (!update(key, (raw) => removeOwnedLease(raw, (current) => current.state === "cleared" && current.retired === true), key.startsWith("session:") ? { ttlMs: PHYSICAL_SESSION_RETIRE_TTL_MS } : void 0)) update(key, (raw) => removeOwnedLease(raw, (current) => current.state === "cleared"), { ttlMs: 1 });
+					}
+				} catch (error) {
+					embeddedAgentLog.warn("failed to release codex app-server binding lease", {
+						key,
+						error
+					});
+				}
+			}
+		}
+	};
+}
+/** Stable plugin-state key for one current binding owner. */
+function bindingStoreKey(identity) {
+	if (identity.kind === "session") {
+		const rawAgentId = identity.agentId.trim();
+		const sessionId = identity.sessionId.trim();
+		if (!rawAgentId) throw new Error("Codex app-server binding requires an agent id");
+		if (!sessionId) throw new Error("Codex app-server binding requires a session id");
+		const agentId = resolveSessionAgentIds({ agentId: rawAgentId }).sessionAgentId;
+		const sessionKey = identity.sessionKey?.trim();
+		if (sessionKey) return `session-key:${agentId}:${createHash("sha256").update(sessionKey).digest("base64url")}`;
+		return `session:${agentId}:${sessionId}`;
+	}
+	const bindingId = identity.bindingId.trim();
+	if (!bindingId) throw new Error("Codex app-server conversation binding requires a binding id");
+	return `conversation:${bindingId}`;
+}
+function readStoredBinding(value) {
+	const result = storedBindingSchema.safeParse(value);
+	return result.success ? stripUndefinedValue(result.data) : void 0;
+}
+function storedSessionGeneration(identity, current) {
+	if (identity.kind === "session") return { sessionId: identity.sessionId };
+	return current?.sessionId ? { sessionId: current.sessionId } : {};
+}
+function preservedSessionGeneration(identity, current) {
+	if (current?.sessionId) return { sessionId: current.sessionId };
+	return storedSessionGeneration(identity, current);
+}
+function ownsStoredSessionGeneration(identity, current) {
+	return identity.kind !== "session" || !current?.sessionId || current.sessionId === identity.sessionId;
+}
+function validateBindingForWrite(binding) {
+	const validated = readCodexAppServerThreadBinding(binding);
+	if (!validated) throw new Error("Invalid Codex app-server thread binding");
+	return stripUndefinedBinding(validated);
+}
+/** Parses stored or shipped sidecar data into the current domain value. */
+function readCodexAppServerThreadBinding(value) {
+	const result = threadBindingSchema.safeParse(value);
+	if (!result.success) return;
+	return result.data;
+}
+function stripUndefinedBinding(binding) {
+	return stripUndefinedValue(binding);
+}
+function stripUndefinedValue(value) {
+	if (Array.isArray(value)) return value.map(stripUndefinedValue);
+	if (!value || typeof value !== "object") return value;
+	return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== void 0).map(([key, entry]) => [key, stripUndefinedValue(entry)]));
+}
+function asRecord(value) {
+	return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function readTimestamp(value) {
+	return optionalTimestampSchema.parse(value);
+}
+function readPluginAppPolicyContext(value, bindingSchemaVersion) {
+	const record = asRecord(value);
+	if (!record || typeof record.fingerprint !== "string") return;
+	const apps = asRecord(record.apps);
+	if (!apps) return;
+	const parsedApps = {};
+	for (const [appId, rawEntry] of Object.entries(apps)) {
+		const entry = asRecord(rawEntry);
+		if (!entry) return;
+		const destructiveApprovalMode = readDestructiveApprovalMode(entry.destructiveApprovalMode, bindingSchemaVersion);
+		const mcpServerNamesValid = Array.isArray(entry.mcpServerNames) && entry.mcpServerNames.every((serverName) => typeof serverName === "string");
+		if (entry.source === "account") {
+			if ("appId" in entry || typeof entry.appName !== "string" || typeof entry.allowDestructiveActions !== "boolean" || destructiveApprovalMode === "invalid" || !mcpServerNamesValid) return;
+			parsedApps[appId] = {
+				source: "account",
+				appName: entry.appName,
+				allowDestructiveActions: entry.allowDestructiveActions,
+				...destructiveApprovalMode ? { destructiveApprovalMode } : {},
+				mcpServerNames: entry.mcpServerNames
+			};
+			continue;
+		}
+		if ("appId" in entry || entry.source !== void 0 && entry.source !== "plugin" || typeof entry.configKey !== "string" || entry.marketplaceName !== "openai-curated" || typeof entry.pluginName !== "string" || typeof entry.allowDestructiveActions !== "boolean" || destructiveApprovalMode === "invalid" || !mcpServerNamesValid) return;
+		parsedApps[appId] = {
+			configKey: entry.configKey,
+			marketplaceName: entry.marketplaceName,
+			pluginName: entry.pluginName,
+			allowDestructiveActions: entry.allowDestructiveActions,
+			...destructiveApprovalMode ? { destructiveApprovalMode } : {},
+			mcpServerNames: entry.mcpServerNames
+		};
+	}
+	const parsedPluginAppIds = {};
+	if (record.pluginAppIds !== void 0 && (!record.pluginAppIds || typeof record.pluginAppIds !== "object" || Array.isArray(record.pluginAppIds))) return;
+	if (record.pluginAppIds && typeof record.pluginAppIds === "object") for (const [configKey, appIds] of Object.entries(record.pluginAppIds)) {
+		if (!Array.isArray(appIds) || appIds.some((appId) => typeof appId !== "string")) return;
+		parsedPluginAppIds[configKey] = appIds;
+	}
+	return {
+		fingerprint: record.fingerprint,
+		apps: parsedApps,
+		pluginAppIds: parsedPluginAppIds
+	};
+}
+function readDestructiveApprovalMode(value, bindingSchemaVersion) {
+	if (value === void 0) return;
+	if (value === "allow" || value === "deny") return value;
+	if (value === "auto") return bindingSchemaVersion === 1 ? "allow" : "auto";
+	if (value === "ask" && bindingSchemaVersion === 2) return "ask";
+	if (value === "on-request" && bindingSchemaVersion === 1) return "auto";
+	return "invalid";
+}
+function sleep(ms) {
+	return new Promise((resolve) => {
+		setTimeout(resolve, ms);
+	});
+}
+/** Returns true when an auth profile uses native Codex/OpenAI app-server auth. */
+function isCodexAppServerNativeAuthProfile(lookup) {
+	const authProfileId = lookup.authProfileId?.trim();
+	if (!authProfileId) return false;
+	try {
+		const credential = (lookup.authProfileStore ?? ensureAuthProfileStore(lookup.agentDir?.trim() || resolveDefaultAgentDir(lookup.config ?? {}), {
+			allowKeychainPrompt: false,
+			config: lookup.config,
+			externalCliProviderIds: [CODEX_APP_SERVER_NATIVE_AUTH_PROVIDER],
+			externalCliProfileIds: [authProfileId]
+		})).profiles[authProfileId];
+		if (!credential || credential.type === "api_key") return false;
+		const provider = credential.provider?.trim();
+		return Boolean(provider && resolveProviderIdForAuth(provider, { config: lookup.config }) === CODEX_APP_SERVER_NATIVE_AUTH_PROVIDER);
+	} catch (error) {
+		embeddedAgentLog.debug("failed to resolve codex app-server auth profile provider", {
+			authProfileId,
+			error
+		});
+		return false;
+	}
+}
+/** Hides redundant OpenAI provider attribution for native Codex auth bindings. */
+function normalizeCodexAppServerBindingModelProvider(params) {
+	const modelProvider = params.modelProvider?.trim();
+	if (!modelProvider) return;
+	if (isCodexAppServerNativeAuthProfile(params) && modelProvider.toLowerCase() === PUBLIC_OPENAI_MODEL_PROVIDER) return;
+	return modelProvider;
+}
+/** Restores the sole provider intentionally omitted from canonical binding rows. */
+function resolveCodexAppServerBindingModelProvider(params) {
+	return params.modelProvider?.trim() || (isCodexAppServerNativeAuthProfile(params) ? PUBLIC_OPENAI_MODEL_PROVIDER : void 0);
+}
+//#endregion
+export { reclaimCurrentCodexSessionGeneration as a, normalizeCodexAppServerBindingModelProvider as i, bindingStoreKey as n, sessionBindingIdentity as o, isCodexAppServerNativeAuthProfile as r, session_binding_exports as s, CODEX_APP_SERVER_BINDING_GUARDED_REQUEST_TIMEOUT_MS as t };

package/dist/session-binding-meta-B7aEMU7g.js

@@ -0,0 +1,6 @@
+//#region extensions/codex/src/app-server/session-binding-meta.ts
+/** Process-stable plugin-state metadata for Codex app-server bindings. */
+const CODEX_APP_SERVER_BINDING_NAMESPACE = "app-server-thread-bindings";
+const CODEX_APP_SERVER_BINDING_MAX_ENTRIES = 5e4;
+//#endregion
+export { CODEX_APP_SERVER_BINDING_NAMESPACE as n, CODEX_APP_SERVER_BINDING_MAX_ENTRIES as t };