@openclaw/codex 2026.8.1-beta.3 → 2026.8.2

package/dist/{protocol-validators-VAVyEnDp.js → protocol-validators-Bg5rpNxk.js}

@@ -89,6 +89,10 @@ var definitions = {
 		"required": ["id"],
 		"type": "object"
 	},
+	"AgentMessageDelivery": {
+		"enum": ["async"],
+		"type": "string"
+	},
 	"AgentPath": { "type": "string" },
 	"ApprovalsReviewer": {
 		"description": "Configures who approval requests are routed to for review. Examples include sandbox escapes, blocked network access, MCP approval prompts, and ARC escalations. Defaults to `user`. `auto_review` uses a carefully prompted subagent to gather relevant context and apply a risk-based decision framework before approving or denying the request. The legacy value `guardian_subagent` is accepted for compatibility.",
@@ -228,6 +232,7 @@ var definitions = {
 					"contextWindowExceeded",
 					"sessionBudgetExceeded",
 					"usageLimitExceeded",
+					"rateLimitExceeded",
 					"serverOverloaded",
 					"cyberPolicy",
 					"misalignmentPolicyViolation",
@@ -268,7 +273,11 @@ var definitions = {
 			"sendInput",
 			"resumeAgent",
 			"wait",
-			"closeAgent"
+			"closeAgent",
+			"sendMessage",
+			"followupTask",
+			"interruptAgent",
+			"listAgents"
 		],
 		"type": "string"
 	},
@@ -276,7 +285,8 @@ var definitions = {
 		"enum": [
 			"inProgress",
 			"completed",
-			"failed"
+			"failed",
+			"interrupted"
 		],
 		"type": "string"
 	},
@@ -424,6 +434,68 @@ var definitions = {
 		],
 		"type": "object"
 	},
+	"FunctionCallOutputBody": { "anyOf": [{
+		"items": { "$ref": "#/definitions/FunctionCallOutputContentItem" },
+		"type": "array"
+	}, { "type": "string" }] },
+	"FunctionCallOutputContentItem": {
+		"description": "Responses API compatible content items that can be returned by a tool call. This is a subset of ContentItem with the types we support as function call outputs.",
+		"oneOf": [
+			{
+				"properties": {
+					"text": { "type": "string" },
+					"type": {
+						"enum": ["input_text"],
+						"title": "InputTextFunctionCallOutputContentItemType",
+						"type": "string"
+					}
+				},
+				"required": ["text", "type"],
+				"title": "InputTextFunctionCallOutputContentItem",
+				"type": "object"
+			},
+			{
+				"properties": {
+					"detail": { "anyOf": [{ "$ref": "#/definitions/ImageDetail" }, { "type": "null" }] },
+					"image_url": { "type": "string" },
+					"type": {
+						"enum": ["input_image"],
+						"title": "InputImageFunctionCallOutputContentItemType",
+						"type": "string"
+					}
+				},
+				"required": ["image_url", "type"],
+				"title": "InputImageFunctionCallOutputContentItem",
+				"type": "object"
+			},
+			{
+				"properties": {
+					"audio_url": { "type": "string" },
+					"type": {
+						"enum": ["input_audio"],
+						"title": "InputAudioFunctionCallOutputContentItemType",
+						"type": "string"
+					}
+				},
+				"required": ["audio_url", "type"],
+				"title": "InputAudioFunctionCallOutputContentItem",
+				"type": "object"
+			},
+			{
+				"properties": {
+					"encrypted_content": { "type": "string" },
+					"type": {
+						"enum": ["encrypted_content"],
+						"title": "EncryptedContentFunctionCallOutputContentItemType",
+						"type": "string"
+					}
+				},
+				"required": ["encrypted_content", "type"],
+				"title": "EncryptedContentFunctionCallOutputContentItem",
+				"type": "object"
+			}
+		]
+	},
 	"GitInfo": {
 		"properties": {
 			"branch": { "type": ["string", "null"] },
@@ -572,6 +644,28 @@ var definitions = {
 			"type": "string"
 		}]
 	},
+	"MisalignmentErrorDetails": {
+		"properties": {
+			"detailedExplanation": {
+				"description": "A substantive localized explanation is required before offering continuation.",
+				"type": ["string", "null"]
+			},
+			"errorType": {
+				"description": "Open-ended classification; clients must accept categories added by Responses.",
+				"type": ["string", "null"]
+			},
+			"steer": {
+				"anyOf": [{ "$ref": "#/definitions/MisalignmentSteer" }, { "type": "null" }],
+				"description": "Instruction to submit as the next turn's user input if continuation is confirmed."
+			}
+		},
+		"type": "object"
+	},
+	"MisalignmentSteer": {
+		"properties": { "message": { "type": "string" } },
+		"required": ["message"],
+		"type": "object"
+	},
 	"Model": {
 		"properties": {
 			"additionalSpeedTiers": {
@@ -757,6 +851,8 @@ var definitions = {
 			"enterprise_cbp_usage_based",
 			"enterprise",
 			"edu",
+			"edu_plus",
+			"edu_pro",
 			"unknown"
 		],
 		"type": "string"
@@ -877,7 +973,8 @@ var definitions = {
 		"enum": [
 			"started",
 			"interacted",
-			"interrupted"
+			"interrupted",
+			"completed"
 		],
 		"type": "string"
 	},
@@ -1013,6 +1110,10 @@ var definitions = {
 				"description": "Usually the first user message in the thread, if available.",
 				"type": "string"
 			},
+			"projectId": {
+				"description": "Canonical project assignment owned by app-server, if any.",
+				"type": ["string", "null"]
+			},
 			"recencyAt": {
 				"description": "Unix timestamp (in seconds) used for thread recency ordering.",
 				"format": "int64",
@@ -1064,6 +1165,7 @@ var definitions = {
 			"id",
 			"modelProvider",
 			"preview",
+			"projectId",
 			"sessionId",
 			"source",
 			"status",
@@ -1131,6 +1233,10 @@ var definitions = {
 		},
 		{
 			"properties": {
+				"delivery": {
+					"anyOf": [{ "$ref": "#/definitions/AgentMessageDelivery" }, { "type": "null" }],
+					"default": null
+				},
 				"id": { "type": "string" },
 				"memoryCitation": {
 					"anyOf": [{ "$ref": "#/definitions/MemoryCitation" }, { "type": "null" }],
@@ -1155,6 +1261,27 @@ var definitions = {
 			"title": "AgentMessageThreadItem",
 			"type": "object"
 		},
+		{
+			"properties": {
+				"id": { "type": "string" },
+				"name": { "type": "string" },
+				"namespace": { "type": ["string", "null"] },
+				"output": { "$ref": "#/definitions/FunctionCallOutputBody" },
+				"type": {
+					"enum": ["functionCallOutput"],
+					"title": "FunctionCallOutputThreadItemType",
+					"type": "string"
+				}
+			},
+			"required": [
+				"id",
+				"name",
+				"output",
+				"type"
+			],
+			"title": "FunctionCallOutputThreadItem",
+			"type": "object"
+		},
 		{
 			"description": "EXPERIMENTAL - proposed plan item content. The completed plan item is authoritative and may not match the concatenation of `PlanDelta` text.",
 			"properties": {
@@ -1711,7 +1838,12 @@ var definitions = {
 				"type": ["string", "null"]
 			},
 			"codexErrorInfo": { "anyOf": [{ "$ref": "#/definitions/CodexErrorInfo" }, { "type": "null" }] },
-			"message": { "type": "string" }
+			"message": { "type": "string" },
+			"misalignment": {
+				"anyOf": [{ "$ref": "#/definitions/MisalignmentErrorDetails" }, { "type": "null" }],
+				"default": null,
+				"description": "Optional public explanation and continuation instruction for a misalignment block."
+			}
 		},
 		"required": ["message"],
 		"type": "object"
@@ -2301,6 +2433,16 @@ function assertCodexThreadResumeResponse(value) {
 	const normalized = normalizeWithDefaults(threadResumeResponseSchema, value);
 	return assertCodexShape(validateThreadResumeResponse, normalized, "thread/resume response");
 }
+var CodexThreadDirectInputError = class extends Error {
+	constructor(threadId) {
+		super(`Codex thread ${threadId} is controlled by its parent and cannot accept direct input. Continue its parent thread, or use /new for a separate OpenClaw session.`);
+		this.name = "CodexThreadDirectInputError";
+	}
+};
+/** Native V2 children allow observation, but only their parent may supply turn input. */
+function assertCodexThreadAcceptsDirectInput(thread) {
+	if (thread.canAcceptDirectInput === false) throw new CodexThreadDirectInputError(thread.id);
+}
 /** Asserts and normalizes a Codex turn/start response. */
 function assertCodexTurnStartResponse(value) {
 	const normalized = normalizeWithDefaults(turnStartResponseSchema, normalizeTurnStartResponse(value));
@@ -2349,6 +2491,7 @@ function normalizeThreadItem(value) {
 	switch (value.type) {
 		case "agentMessage": return {
 			phase: null,
+			delivery: null,
 			memoryCitation: null,
 			...value
 		};
@@ -2396,4 +2539,4 @@ function formatValidationErrors(validate, value) {
 	}).join("; ");
 }
 //#endregion
-export { assertCodexThreadStartResponse as a, readCodexErrorNotification as c, assertCodexThreadResumeResponse as i, readCodexTurn as l, assertCodexThreadForkParams as n, assertCodexTurnStartResponse as o, assertCodexThreadForkResponse as r, readCodexDynamicToolCallParams as s, assertCodexModelListResponse as t, readCodexTurnCompletedNotification as u };
+export { assertCodexThreadForkResponse as a, assertCodexTurnStartResponse as c, readCodexTurn as d, readCodexTurnCompletedNotification as f, assertCodexThreadForkParams as i, readCodexDynamicToolCallParams as l, assertCodexModelListResponse as n, assertCodexThreadResumeResponse as o, assertCodexThreadAcceptsDirectInput as r, assertCodexThreadStartResponse as s, CodexThreadDirectInputError as t, readCodexErrorNotification as u };

package/dist/{rate-limits-BI1dMHDG.js → rate-limits-BqHEHXQJ.js}

@@ -1,4 +1,4 @@
-import { ut as isJsonObject } from "./shared-client-Dw-rzii0.js";
+import { Ht as isJsonObject } from "./shared-client-B1tT5U6r.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";
@@ -186,8 +186,9 @@ function isRateLimitSnapshot(value) {
 function readRateLimitWindow(snapshot, key) {
 	const window = snapshot[key];
 	if (!isJsonObject(window)) return;
+	const resetsAt = asFiniteNumber(window.resetsAt) ?? asFiniteNumber(window.resets_at);
 	return {
-		resetsAtMs: resolveExpiresAtMsFromEpochSeconds(asFiniteNumber(window.resetsAt) ?? asFiniteNumber(window.resets_at), { maxMs: MAX_DATE_TIMESTAMP_MS }) ?? 0,
+		resetsAtMs: resolveExpiresAtMsFromEpochSeconds(resetsAt, { maxMs: MAX_DATE_TIMESTAMP_MS }) ?? 0,
 		...readOptionalNumberField(window, "usedPercent", "used_percent"),
 		...readOptionalNumberField(window, "windowDurationMins", "window_duration_mins", "windowMinutes", "window_minutes")
 	};

package/dist/{sandbox-guard-C1qEeZ5C.js → request-BWxweEdK.js}

@@ -1,4 +1,6 @@
-import { p as isCodexRemoteExecPlacementSandbox } from "./config-CpNeo5AE.js";
+import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
+import { C as isCodexRemoteExecPlacementSandbox } from "./config-CcYL77O6.js";
+import { Et as withTimeout, c as getLeasedSharedCodexAppServerClient, h as releaseLeasedSharedCodexAppServerClient, s as createIsolatedCodexAppServerClient, u as isCodexAppServerStartSelectionChangedError, y as retireSharedCodexAppServerClientIfCurrent } from "./shared-client-B1tT5U6r.js";
 import { resolveAgentConfig, tryResolveDefaultAgentId } from "openclaw/plugin-sdk/agent-scope-runtime";
 import { getSessionEntry } from "openclaw/plugin-sdk/session-store-runtime";
 import { normalizeAgentId, parseAgentSessionKey } from "openclaw/plugin-sdk/routing";
@@ -279,4 +281,183 @@ function resolveCodexNativeNodeExecBlock(params) {
 	});
 }
 //#endregion
-export { resolveCodexNodeExecToolOverrides as a, resolveCodexNativeExecutionPolicy as i, resolveCodexNativeExecutionBlock as n, resolveCodexNativeSandboxBlock as r, resolveCodexAppServerDirectSandboxBypassBlock as t };
+//#region extensions/codex/src/app-server/request.ts
+var request_exports = /* @__PURE__ */ __exportAll({
+	CodexAppServerScopedRequestRejectedError: () => CodexAppServerScopedRequestRejectedError,
+	readCodexAppServerUsage: () => readCodexAppServerUsage,
+	requestCodexAppServerClientJson: () => requestCodexAppServerClientJson,
+	requestCodexAppServerJson: () => requestCodexAppServerJson,
+	withCodexAppServerJsonClient: () => withCodexAppServerJsonClient
+});
+/** Sends one guarded request over a client lease owned by the caller. */
+async function requestCodexAppServerClientJson(params) {
+	const sandboxBlock = resolveCodexAppServerDirectSandboxBypassBlock({
+		method: params.method,
+		requestParams: params.requestParams,
+		config: params.config,
+		sessionKey: params.sessionKey,
+		sessionId: params.sessionId
+	});
+	if (sandboxBlock) throw new Error(sandboxBlock);
+	const timeoutMs = params.timeoutMs ?? 6e4;
+	return await withTimeout(params.client.request(params.method, params.requestParams, { timeoutMs }), timeoutMs, `codex app-server ${params.method} timed out`);
+}
+async function requestCodexAppServerJson(params) {
+	const sandboxBlock = resolveCodexAppServerDirectSandboxBypassBlock({
+		method: params.method,
+		requestParams: params.requestParams,
+		config: params.config,
+		sessionKey: params.sessionKey,
+		sessionId: params.sessionId
+	});
+	if (sandboxBlock) throw new Error(sandboxBlock);
+	return await withCodexAppServerJsonClient({
+		...params,
+		timeoutMessage: `codex app-server ${params.method} timed out`
+	}, async (request) => await request({
+		method: params.method,
+		requestParams: params.requestParams
+	}));
+}
+/** A scoped guard rejected the request before it reached the physical client. */
+var CodexAppServerScopedRequestRejectedError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "CodexAppServerScopedRequestRejectedError";
+	}
+};
+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;
+/** Reads rate limits and best-effort account identity from one isolated app-server session. */
+async function readCodexAppServerUsage(options) {
+	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 } : {}
+		};
+	});
+}
+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 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);
+	}
+}
+/**
+* Runs several guarded requests over one acquired client (shared lease or
+* isolated child) so related reads see the same app-server session. The whole
+* callback re-runs once when the client's start selection changed underneath it.
+*/
+async function withCodexAppServerJsonClient(params, run) {
+	const timeoutMs = params.timeoutMs ?? 6e4;
+	const timeoutMessage = params.timeoutMessage ?? "codex app-server request timed out";
+	const timeoutController = new AbortController();
+	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 || isPastDeadline()) throw new CodexAppServerScopedRequestRejectedError(timeoutMessage);
+	};
+	const remainingTimeoutMs = () => {
+		throwIfAbandoned();
+		return deadline === void 0 ? timeoutMs : Math.max(1, deadline - Date.now());
+	};
+	try {
+		return await withTimeout((async () => {
+			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 = () => {
+					throwIfAbandoned();
+					if (!scopeActive) throw new CodexAppServerScopedRequestRejectedError("Codex app-server request scope is closed");
+				};
+				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);
+						assertCurrent();
+						return await client.request(request.method, request.requestParams, {
+							timeoutMs: remainingTimeoutMs(),
+							signal: timeoutController.signal,
+							assertCurrent
+						});
+					};
+					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);
+				}
+			}
+			throw new Error("Codex app-server selection retry loop exited unexpectedly");
+		})(), timeoutMs, timeoutMessage);
+	} catch (error) {
+		if (isPastDeadline()) throw new Error(timeoutMessage, { cause: error });
+		throw error;
+	} finally {
+		timeoutController.abort();
+	}
+}
+//#endregion
+export { request_exports as a, resolveCodexNativeSandboxBlock as c, requestCodexAppServerJson as i, resolveCodexNativeExecutionPolicy as l, readCodexAppServerUsage as n, withCodexAppServerJsonClient as o, requestCodexAppServerClientJson as r, resolveCodexNativeExecutionBlock as s, CodexAppServerScopedRequestRejectedError as t, resolveCodexNodeExecToolOverrides as u };