@openclaw/codex 2026.9.4 → 2026.9.6

package/dist/{conversation-control-CtUu1b3m.js → .setup/conversation-control-uK9Jomlc.mjs}

@@ -1,12 +1,11 @@
-import { n as isCodexFastServiceTier } from "./config-utils-DujwEnhg.js";
-import { r as bindingStoreKey } from "./session-binding-record-Bcvslnhf.js";
-import { o as formatCodexDisplayText } from "./command-formatters-lxlkNZgU.js";
-import "./config-oIORaQ5T.js";
-import { i as resolveCodexBindingAppServerConnection } from "./binding-connection-D3udKbIE.js";
-import { n as normalizeCodexAppServerBindingModelProvider, t as isCodexAppServerNativeAuthProfile } from "./auth-profile-CwzO4_RG.js";
-import { c as getLeasedSharedCodexAppServerClient, h as releaseLeasedSharedCodexAppServerClient } from "./shared-client-CscigXXL.js";
-import { D as resolveCodexAppServerRequestModelSelection, k as resolveCodexBindingModelProviderFallback } from "./thread-lifecycle-DXl1-I6b.js";
-import "./session-binding-CI8UuilT.js";
+import { n as isCodexFastServiceTier } from "./config-utils-DujwEnhg.mjs";
+import { r as bindingStoreKey } from "./session-binding-record-BGoz8wOK.mjs";
+import { o as formatCodexDisplayText } from "./command-formatters-Bmqvr9tO.mjs";
+import "./config-BoTP_mrL.mjs";
+import { n as normalizeCodexAppServerBindingModelProvider, t as isCodexAppServerNativeAuthProfile } from "./auth-profile-WqZtZfXN.mjs";
+import { _ as resolveCodexAppServerRequestModelSelection, y as resolveCodexBindingModelProviderFallback } from "./thread-requests-BLvGkP2R.mjs";
+import "./thread-lifecycle-B3mfz1TG.mjs";
+import "./session-binding-Cm0apEbd.mjs";
 import { resolveAgentDir } from "openclaw/plugin-sdk/agent-runtime";
 import { getSessionEntry, patchSessionEntry, resolveStorePath } from "openclaw/plugin-sdk/session-store-runtime";
 import { ModelSelectionLockedError, applyModelOverrideWithAuthProfileCompatibility } from "openclaw/plugin-sdk/model-session-runtime";
@@ -34,35 +33,17 @@ async function stopCodexConversationTurn(params) {
 		stopped: false,
 		message: "No active Codex run to stop."
 	};
-	const lookup = buildBindingLookup(params);
-	const binding = params.binding;
-	if (binding?.threadId !== active.threadId) return {
+	if (params.binding?.threadId !== active.threadId) return {
 		stopped: false,
 		message: "The active Codex run no longer matches this session binding."
 	};
-	const connection = resolveCodexBindingAppServerConnection({
-		binding,
-		authProfileId: binding?.authProfileId,
-		pluginConfig: params.pluginConfig
-	});
-	const runtime = connection.appServer;
-	const client = active.client ?? await getLeasedSharedCodexAppServerClient({
-		startOptions: runtime.start,
-		timeoutMs: runtime.requestTimeoutMs,
-		authProfileId: connection.clientAuthProfileId,
-		...lookup
+	await active.client.request("turn/interrupt", {
+		threadId: active.threadId,
+		turnId: active.turnId
+	}, {
+		timeoutMs: active.requestTimeoutMs,
+		assertCurrent: params.assertCurrent
 	});
-	try {
-		await client.request("turn/interrupt", {
-			threadId: active.threadId,
-			turnId: active.turnId
-		}, {
-			timeoutMs: runtime.requestTimeoutMs,
-			assertCurrent: params.assertCurrent
-		});
-	} finally {
-		if (!active.client) releaseLeasedSharedCodexAppServerClient(client);
-	}
 	return {
 		stopped: true,
 		message: "Codex stop requested."
@@ -79,50 +60,34 @@ async function steerCodexConversationTurn(params) {
 		steered: false,
 		message: "No active Codex run to steer."
 	};
-	const lookup = buildBindingLookup(params);
-	const binding = params.binding;
-	if (binding?.threadId !== active.threadId) return {
+	if (params.binding?.threadId !== active.threadId) return {
 		steered: false,
 		message: "The active Codex run no longer matches this session binding."
 	};
-	const connection = resolveCodexBindingAppServerConnection({
-		binding,
-		authProfileId: binding?.authProfileId,
-		pluginConfig: params.pluginConfig
-	});
-	const runtime = connection.appServer;
-	const client = active.client ?? await getLeasedSharedCodexAppServerClient({
-		startOptions: runtime.start,
-		timeoutMs: runtime.requestTimeoutMs,
-		authProfileId: connection.clientAuthProfileId,
-		...lookup
+	await active.client.request("turn/steer", {
+		threadId: active.threadId,
+		expectedTurnId: active.turnId,
+		input: [{
+			type: "text",
+			text,
+			text_elements: []
+		}]
+	}, {
+		timeoutMs: active.requestTimeoutMs,
+		assertCurrent: params.assertCurrent
 	});
-	try {
-		await client.request("turn/steer", {
-			threadId: active.threadId,
-			expectedTurnId: active.turnId,
-			input: [{
-				type: "text",
-				text,
-				text_elements: []
-			}]
-		}, {
-			timeoutMs: runtime.requestTimeoutMs,
-			assertCurrent: params.assertCurrent
-		});
-	} finally {
-		if (!active.client) releaseLeasedSharedCodexAppServerClient(client);
-	}
 	return {
 		steered: true,
 		message: "Sent steer message to Codex."
 	};
 }
-async function setCodexConversationModel(params) {
+async function setCodexConversationModel(input) {
+	const params = { ...input };
 	const model = params.model.trim();
 	if (!model) return "Usage: /codex model <model>";
 	const lookup = buildBindingLookup(params);
 	params.assertCurrent();
+	const assertCommitAllowed = params.assertCommitAllowed ?? params.assertCurrent;
 	const binding = requirePreparedThreadBinding(params.binding);
 	if (binding.connectionScope === "supervision") throw new ModelSelectionLockedError();
 	const modelProvider = resolveConversationControlModelProvider({
@@ -157,7 +122,7 @@ async function setCodexConversationModel(params) {
 			sessionKey: identity.sessionKey,
 			requireWriteSuccess: true,
 			replaceEntry: true,
-			assertCommitAllowed: params.assertCurrent,
+			assertCommitAllowed,
 			update: (entry) => {
 				if (entry.sessionId !== identity.sessionId) throw new Error("Codex session changed while applying the model selection.");
 				applyModelOverrideWithAuthProfileCompatibility({
@@ -179,7 +144,7 @@ async function setCodexConversationModel(params) {
 		model: nextModel,
 		modelProvider: nextModelProvider,
 		...projectionPatch
-	}, params.assertCurrent);
+	}, assertCommitAllowed);
 	return `Codex model set to ${formatCodexDisplayText(nextModel)}.`;
 }
 async function setCodexConversationFastMode(params) {

package/dist/.setup/cyber-failover-DYwbmf1o.mjs

@@ -0,0 +1,123 @@
+import { d as readCodexPluginConfig } from "./config-parsing-CcB9iPoq.mjs";
+import { t as attemptTerminal } from "./attempt-terminal-gZrxQ35N.mjs";
+//#region extensions/codex/src/app-server/cyber-failover.ts
+/**
+* Automatic Daybreak escalation for OpenAI cyber-policy refusals.
+*
+* OpenAI refuses some defensive-cyber work on its general models and directs
+* approved workspaces to a Daybreak model instead. When a turn is refused, the
+* harness retries it once on the configured Daybreak model so the refused work
+* reaches the tier allowed to answer it. Only a refused turn is ever routed
+* there, and the retry never changes the session's stored model selection.
+*
+* Authorization stays server-owned. `model/list` advertises Daybreak to every
+* client, but an unentitled workspace still gets 401/403 on use, and each such
+* attempt costs the transport's full five-try reconnect ladder. Entitlement is
+* therefore only ever observed from an actual attempt, and a failure is
+* remembered per workspace so siblings do not each pay for it.
+*/
+const DEFAULT_CYBER_FAILOVER = {
+	mode: "auto",
+	model: "gpt-daybreak-blue-latest",
+	cooloffMs: 6e5
+};
+function resolveCodexCyberFailoverConfig(pluginConfig) {
+	const configured = readCodexPluginConfig(pluginConfig).appServer?.cyberFailover;
+	if (!configured) return DEFAULT_CYBER_FAILOVER;
+	return {
+		mode: configured.mode ?? DEFAULT_CYBER_FAILOVER.mode,
+		model: configured.model ?? DEFAULT_CYBER_FAILOVER.model,
+		cooloffMs: configured.cooloffMs ?? DEFAULT_CYBER_FAILOVER.cooloffMs
+	};
+}
+const unavailableTargets = /* @__PURE__ */ new Map();
+const MAX_UNAVAILABLE_TARGETS = 256;
+const inFlightProbes = /* @__PURE__ */ new Set();
+function targetKey(model, workspace) {
+	const normalized = model.trim().toLowerCase();
+	const slashIndex = normalized.lastIndexOf("/");
+	return [
+		workspace?.agentId?.trim().toLowerCase() ?? "",
+		workspace?.authProfileId?.trim().toLowerCase() ?? "",
+		slashIndex >= 0 ? normalized.slice(slashIndex + 1) : normalized
+	].join("\0");
+}
+/** Marks a workspace/target probe in flight; the returned handle releases it. */
+function reserveCodexCyberProbe(params) {
+	const key = targetKey(params.model, params.workspace);
+	inFlightProbes.add(key);
+	return () => {
+		inFlightProbes.delete(key);
+	};
+}
+/** Remembers that this workspace cannot use the target for `cooloffMs`. */
+function recordCodexCyberTargetUnavailable(params) {
+	if (params.cooloffMs <= 0) return;
+	const now = params.now ?? Date.now();
+	for (const [key, expiresAt] of unavailableTargets) if (expiresAt <= now) unavailableTargets.delete(key);
+	while (unavailableTargets.size >= MAX_UNAVAILABLE_TARGETS) {
+		const oldest = unavailableTargets.keys().next();
+		if (oldest.done) break;
+		unavailableTargets.delete(oldest.value);
+	}
+	unavailableTargets.set(targetKey(params.model, params.workspace), now + params.cooloffMs);
+}
+/** Decides whether a refused turn may be retried on Daybreak. */
+function planCodexCyberEscalation(params) {
+	const { config } = params;
+	if (config.mode !== "auto") return {
+		kind: "skip",
+		reason: "disabled"
+	};
+	if (!params.replaySafe) return {
+		kind: "skip",
+		reason: "not_replay_safe"
+	};
+	if (!config.model.trim()) return {
+		kind: "skip",
+		reason: "no_target"
+	};
+	const key = targetKey(config.model, params.workspace);
+	if (params.currentModel && targetKey(params.currentModel, params.workspace) === key) return {
+		kind: "skip",
+		reason: "already_daybreak"
+	};
+	const now = params.now ?? Date.now();
+	const expiresAt = unavailableTargets.get(key);
+	if (expiresAt !== void 0 && expiresAt <= now) unavailableTargets.delete(key);
+	else if (expiresAt !== void 0) return {
+		kind: "skip",
+		reason: "target_unavailable"
+	};
+	if (inFlightProbes.has(key)) return {
+		kind: "skip",
+		reason: "probe_in_flight"
+	};
+	return {
+		kind: "escalate",
+		model: config.model
+	};
+}
+const AUTHORIZATION_FAILURE_RE = /\b(401|403)\b|unauthorized|not authorized|forbidden/i;
+/** Everything the escalation decision needs from one attempt outcome. */
+function readCodexCyberAttemptVerdict(result) {
+	const message = result?.currentAttemptAssistant;
+	const refusals = message?.role === "assistant" ? message.diagnostics ?? [] : [];
+	const cyberRefused = result?.terminal.kind === "ok" && refusals.some((d) => d.type === "provider_refusal" && d.details?.category === "cyber" && d.details?.provider === "openai");
+	const promptError = result ? attemptTerminal.project(result.terminal).promptError : void 0;
+	const answered = !(promptError !== void 0 && promptError !== null) && message?.role === "assistant" && !refusals.some((d) => d.type === "provider_refusal") && message.stopReason !== "error" && message.stopReason !== "aborted";
+	const errorTexts = [
+		typeof promptError === "string" ? promptError : void 0,
+		promptError instanceof Error ? promptError.message : void 0,
+		result?.lastAssistant?.errorMessage,
+		message?.errorMessage
+	];
+	return {
+		cyberRefused,
+		replaySafe: result?.replayMetadata?.replaySafe === true && result.runtimeContinuationStarted !== true,
+		answered,
+		unavailable: errorTexts.some((t) => t !== void 0 && AUTHORIZATION_FAILURE_RE.test(t))
+	};
+}
+//#endregion
+export { planCodexCyberEscalation, readCodexCyberAttemptVerdict, recordCodexCyberTargetUnavailable, reserveCodexCyberProbe, resolveCodexCyberFailoverConfig };

package/dist/.setup/cyber-failover-notice-e9G3J9-e.mjs

@@ -0,0 +1,17 @@
+import { t as emitCodexAppServerEvent } from "./run-attempt-lifecycle-B7JbY4-F.mjs";
+//#region extensions/codex/src/app-server/cyber-failover-notice.ts
+async function emitCodexCyberNotice(params, notice) {
+	await emitCodexAppServerEvent(params, {
+		stream: "notice",
+		data: {
+			phase: "provider_policy",
+			category: "cyber",
+			state: notice.state,
+			provider: "openai",
+			...notice.model ? { model: notice.model } : {},
+			fallbackModel: notice.fallbackModel
+		}
+	});
+}
+//#endregion
+export { emitCodexCyberNotice };