@openclaw/codex 2026.7.2-beta.4 → 2026.7.2-beta.7

package/dist/effective-mcp-catalog-Bbd98Inw.js

@@ -0,0 +1,114 @@
+import { d as retainSharedCodexAppServerClientByInstanceId } from "./shared-client-DTbvH-XV.js";
+import { d as sessionBindingIdentity } from "./session-binding-BXpo9ymA.js";
+import { assignMcpCatalogSafeServerNames } from "openclaw/plugin-sdk/agent-harness-runtime";
+//#region extensions/codex/src/app-server/effective-mcp-catalog.ts
+const MCP_STATUS_PAGE_SIZE = 100;
+const MCP_STATUS_MAX_PAGES = 100;
+function asRecord(value) {
+	return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function readString(value) {
+	return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function catalogTool(params) {
+	const raw = asRecord(params.raw);
+	const description = readString(raw?.description);
+	return {
+		serverName: params.serverName,
+		safeServerName: params.safeServerName,
+		toolName: params.toolName,
+		...readString(raw?.title) ? { title: readString(raw?.title) } : {},
+		...description ? { description } : {},
+		inputSchema: asRecord(raw?.inputSchema) ?? { type: "object" },
+		fallbackDescription: description ?? params.toolName,
+		...params.deniedBySession ? { deniedBySession: true } : {}
+	};
+}
+/** Converts Codex's thread-scoped status response into OpenClaw's MCP catalog shape. */
+function buildCodexEffectiveMcpCatalog(statuses, toolOverrides) {
+	const orderedStatuses = [...new Map(statuses.map((status) => [status.name, status])).values()].toSorted((left, right) => left.name.localeCompare(right.name));
+	const safeNames = assignMcpCatalogSafeServerNames(orderedStatuses.map((status) => status.name));
+	const serverEntries = [];
+	const tools = [];
+	const sessionDeniedTools = [];
+	for (const status of orderedStatuses) {
+		const safeServerName = safeNames.get(status.name) ?? status.name;
+		const denialMap = toolOverrides?.mcpToolsDeny;
+		const deniedNames = new Set(denialMap && Object.hasOwn(denialMap, status.name) ? denialMap[status.name] : []);
+		const observedNames = /* @__PURE__ */ new Set();
+		for (const [toolName, raw] of Object.entries(status.tools).toSorted(([left], [right]) => left.localeCompare(right))) {
+			observedNames.add(toolName);
+			const deniedBySession = deniedNames.has(toolName) ? true : void 0;
+			const tool = catalogTool({
+				serverName: status.name,
+				safeServerName,
+				toolName,
+				raw,
+				...deniedBySession ? { deniedBySession } : {}
+			});
+			if (deniedBySession) sessionDeniedTools.push(tool);
+			else tools.push(tool);
+		}
+		for (const toolName of [...deniedNames].toSorted()) {
+			if (observedNames.has(toolName)) continue;
+			sessionDeniedTools.push(catalogTool({
+				serverName: status.name,
+				safeServerName,
+				toolName,
+				deniedBySession: true
+			}));
+		}
+		serverEntries.push([status.name, {
+			serverName: status.name,
+			safeServerName,
+			launchSummary: "Codex native MCP connection",
+			toolCount: observedNames.size + [...deniedNames].filter((name) => !observedNames.has(name)).length
+		}]);
+	}
+	return {
+		version: 1,
+		generatedAt: Date.now(),
+		servers: Object.fromEntries(serverEntries),
+		tools,
+		...sessionDeniedTools.length > 0 ? { sessionDeniedTools } : {}
+	};
+}
+async function listCodexMcpServerStatuses(client, threadId) {
+	const statuses = [];
+	const seenCursors = /* @__PURE__ */ new Set();
+	let cursor;
+	for (let page = 0; page < MCP_STATUS_MAX_PAGES; page += 1) {
+		const response = await client.request("mcpServerStatus/list", {
+			threadId,
+			detail: "toolsAndAuthOnly",
+			limit: MCP_STATUS_PAGE_SIZE,
+			...cursor ? { cursor } : {}
+		});
+		statuses.push(...response.data);
+		cursor = response.nextCursor;
+		if (!cursor) return statuses;
+		if (seenCursors.has(cursor)) throw new Error("Codex mcpServerStatus/list repeated its pagination cursor");
+		seenCursors.add(cursor);
+	}
+	throw new Error("Codex mcpServerStatus/list exceeded the bounded page limit");
+}
+/** Loads MCP inventory only from the already-bound Codex process and thread. */
+async function loadCodexEffectiveMcpCatalog(params, options) {
+	const binding = await options.bindingStore.read(sessionBindingIdentity({
+		agentId: params.agentId,
+		sessionId: params.sessionId,
+		sessionKey: params.sessionKey,
+		config: params.config
+	}));
+	if (!binding?.clientId) return;
+	const retained = retainSharedCodexAppServerClientByInstanceId(binding.clientId);
+	if (!retained) return;
+	try {
+		const allowedServerNames = new Set(params.mcpServerNames);
+		return buildCodexEffectiveMcpCatalog((await listCodexMcpServerStatuses(retained.client, binding.threadId)).filter((status) => allowedServerNames.has(status.name)), params.toolOverrides);
+	} finally {
+		retained.release();
+	}
+}
+//#endregion
+export { loadCodexEffectiveMcpCatalog };

package/dist/{event-projector-usage-D6tE7_qD.js → event-projector-usage-Xp4AlR2k.js}

@@ -1,5 +1,5 @@
-import { Q as isJsonObject } from "./shared-client-wmgNFNYp.js";
-import { dt as readNonNegativeInteger, pt as readNumber } from "./thread-lifecycle-cqrOlJkq.js";
+import { W as isJsonObject } from "./shared-client-DTbvH-XV.js";
+import { at as readNonNegativeInteger, ct as readString, st as readNumber } from "./thread-lifecycle-DF53ogiA.js";
 import { normalizeUsage } from "openclaw/plugin-sdk/agent-harness-runtime";
 //#region extensions/codex/src/app-server/event-projector-usage.ts
 function readTokenCount(record, key) {
@@ -65,5 +65,22 @@ function normalizeCodexResponseTokenUsage(record) {
 		}
 	};
 }
+var CodexResponseCompletionProjection = class {
+	constructor() {
+		this.responseIds = /* @__PURE__ */ new Set();
+	}
+	get modelIterations() {
+		return this.responseIds.size;
+	}
+	clear() {
+		this.usage = void 0;
+	}
+	record(params) {
+		const responseId = readString(params, "responseId");
+		if (responseId) this.responseIds.add(responseId);
+		const usage = isJsonObject(params.usage) ? params.usage : void 0;
+		this.usage = usage ? normalizeCodexResponseTokenUsage(usage) : void 0;
+	}
+};
 //#endregion
-export { projectCodexThreadUsageUpdate as n, normalizeCodexResponseTokenUsage as t };
+export { normalizeCodexResponseTokenUsage as n, projectCodexThreadUsageUpdate as r, CodexResponseCompletionProjection as t };

package/dist/harness.js

@@ -35,7 +35,7 @@ function createCodexAppServerAgentHarness(options) {
 		...sessionCatalogControl && sessionRuntime ? { sessionFork: {
 			upstreamKinds: ["codex-app-server"],
 			fork: async (params) => {
-				const { forkCodexUpstreamSession } = await import("./upstream-session-fork-vPjwkT1i.js");
+				const { forkCodexUpstreamSession } = await import("./upstream-session-fork-Dy4Xvuoj.js");
 				return await forkCodexUpstreamSession(params, {
 					bindingStore: options.bindingStore,
 					control: sessionCatalogControl,
@@ -46,17 +46,21 @@ function createCodexAppServerAgentHarness(options) {
 			}
 		} } : {},
 		authBinding: { fingerprint: async (params) => {
-			const { fingerprintCodexAppServerAuthBinding } = await import("./auth-binding-C1czuHPA.js").then((n) => n.t);
+			const { fingerprintCodexAppServerAuthBinding } = await import("./auth-binding-B4FfbcCg.js").then((n) => n.t);
 			return fingerprintCodexAppServerAuthBinding(params);
 		} },
 		runtimeArtifact: { validate: async (binding) => {
-			const { validateCodexAppServerRuntimeArtifact } = await import("./runtime-artifact-C2ITXdhM.js");
+			const { validateCodexAppServerRuntimeArtifact } = await import("./runtime-artifact-CmtG_t1L.js");
 			return validateCodexAppServerRuntimeArtifact(binding);
 		} },
 		fetchUsageSnapshot: async (ctx) => {
-			const { fetchCodexAppServerUsageSnapshot } = await import("./usage-DM_I3mPT.js");
+			const { fetchCodexAppServerUsageSnapshot } = await import("./usage-CQ6GhD5-.js");
 			return await fetchCodexAppServerUsageSnapshot(ctx, { pluginConfig: options?.resolvePluginConfig?.() ?? options?.pluginConfig });
 		},
+		loadMcpToolCatalog: async (params) => {
+			const { loadCodexEffectiveMcpCatalog } = await import("./effective-mcp-catalog-Bbd98Inw.js");
+			return await loadCodexEffectiveMcpCatalog(params, { bindingStore: options.bindingStore });
+		},
 		supports: (ctx) => {
 			const provider = ctx.provider.trim().toLowerCase();
 			if (!providerIds.has(provider)) return {
@@ -95,7 +99,7 @@ function createCodexAppServerAgentHarness(options) {
 			};
 		},
 		runAttempt: async (params) => {
-			const { runCodexAppServerAttempt } = await import("./run-attempt--858NXDl.js");
+			const { runCodexAppServerAttempt } = await import("./run-attempt-CY9WlDLc.js");
 			return runCodexAppServerAttempt(params, {
 				bindingStore: options.bindingStore,
 				pluginConfig: options?.resolvePluginConfig?.() ?? options?.pluginConfig,
@@ -103,11 +107,11 @@ function createCodexAppServerAgentHarness(options) {
 			});
 		},
 		finalizeSettledTurn: async (params) => {
-			const { runCodexSettledTurnFinalization } = await import("./settled-turn-finalizer-DHltNgtF.js");
+			const { runCodexSettledTurnFinalization } = await import("./settled-turn-finalizer-CXY2Z9dT.js");
 			return runCodexSettledTurnFinalization(params, { pluginConfig: options?.resolvePluginConfig?.() ?? options?.pluginConfig });
 		},
 		runSideQuestion: async (params) => {
-			const { runCodexAppServerSideQuestion } = await import("./side-question-BfFZCsJ-.js");
+			const { runCodexAppServerSideQuestion } = await import("./side-question-_ulBk1AL.js");
 			return runCodexAppServerSideQuestion(params, {
 				bindingStore: options.bindingStore,
 				pluginConfig: options?.resolvePluginConfig?.() ?? options?.pluginConfig,
@@ -115,14 +119,14 @@ function createCodexAppServerAgentHarness(options) {
 			});
 		},
 		compact: async (params) => {
-			const { maybeCompactCodexAppServerSession } = await import("./compact-CC5KhBzX.js");
+			const { maybeCompactCodexAppServerSession } = await import("./compact-D_uvHurS.js");
 			return maybeCompactCodexAppServerSession(params, {
 				bindingStore: options.bindingStore,
 				pluginConfig: options?.resolvePluginConfig?.() ?? options?.pluginConfig
 			});
 		},
 		compactAfterContextEngine: async (params) => {
-			const { maybeCompactCodexAppServerSession } = await import("./compact-CC5KhBzX.js");
+			const { maybeCompactCodexAppServerSession } = await import("./compact-D_uvHurS.js");
 			return maybeCompactCodexAppServerSession(params, {
 				bindingStore: options.bindingStore,
 				pluginConfig: options?.resolvePluginConfig?.() ?? options?.pluginConfig,
@@ -131,21 +135,22 @@ function createCodexAppServerAgentHarness(options) {
 		},
 		reset: async (params) => {
 			if (params.sessionId) {
-				const { reclaimCurrentCodexSessionGeneration, sessionBindingIdentity } = await import("./session-binding-ZSMX1omP.js").then((n) => n.u);
+				const { reclaimCurrentCodexSessionGeneration, sessionBindingIdentity } = await import("./session-binding-BXpo9ymA.js").then((n) => n.f);
 				const identity = sessionBindingIdentity({
 					agentId: params.agentId,
 					sessionId: params.sessionId,
 					sessionKey: params.sessionKey
 				});
-				let retired = await options.bindingStore.retireSessionGeneration(identity);
-				if (retired === "conflict") {
+				const resetGeneration = params.reason === "deleted" ? options.bindingStore.retireSessionGeneration.bind(options.bindingStore) : options.bindingStore.resetSessionGeneration.bind(options.bindingStore);
+				let reset = await resetGeneration(identity);
+				if (reset === "conflict") {
 					if (await reclaimCurrentCodexSessionGeneration({
 						bindingStore: options.bindingStore,
 						identity,
 						config: options.resolveConfig?.()
-					})) retired = await options.bindingStore.retireSessionGeneration(identity);
+					})) reset = await resetGeneration(identity);
 				}
-				if (retired === "conflict") throw new Error(`Codex binding generation changed before session ${params.sessionId} could reset`);
+				if (reset === "conflict") throw new Error(`Codex binding generation changed before session ${params.sessionId} could reset`);
 			}
 		},
 		dispose: disposeSharedCodexAppServerClients