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

package/dist/{notification-correlation-Bj_Ak_jI.js → notification-correlation-CU6_AnOb.js}

@@ -1,6 +1,6 @@
-import { V as isJsonObject } from "./shared-client-BVKE40c-.js";
-import { T as readCodexPluginConfig, g as resolveCodexSupervisionAppServerRuntimeOptions, p as resolveCodexAppServerRuntimeOptions } from "./session-binding-DlVQ-Pxs.js";
-import { t as buildCodexAppServerConnectionFingerprint } from "./plugin-app-cache-key-DSXX-rXO.js";
+import { W as isJsonObject } from "./shared-client-DTbvH-XV.js";
+import { O as readCodexPluginConfig, g as resolveCodexAppServerRuntimeOptions, y as resolveCodexSupervisionAppServerRuntimeOptions } from "./session-binding-BXpo9ymA.js";
+import { t as buildCodexAppServerConnectionFingerprint } from "./plugin-app-cache-key-DztPafOA.js";
 //#region extensions/codex/src/app-server/binding-connection.ts
 /** Requires the native model pair after a supervised pending branch has materialized. */
 function requireCodexSupervisionModelSelection(binding) {

package/dist/{plugin-app-cache-key-DSXX-rXO.js → plugin-app-cache-key-DztPafOA.js}

@@ -1,5 +1,5 @@
-import { U as resolveCodexAppServerHomeDir } from "./shared-client-BVKE40c-.js";
-import { x as resolveCodexAppServerUserHomeDir } from "./session-binding-DlVQ-Pxs.js";
+import { K as resolveCodexAppServerHomeDir } from "./shared-client-DTbvH-XV.js";
+import { w as resolveCodexAppServerUserHomeDir } from "./session-binding-BXpo9ymA.js";
 import { createRequire } from "node:module";
 import { isFutureDateTimestampMs, resolveDateTimestampMs, resolveExpiresAtMsFromDurationMs } from "openclaw/plugin-sdk/number-runtime";
 import { OPENCLAW_VERSION, embeddedAgentLog } from "openclaw/plugin-sdk/agent-harness-runtime";
@@ -14,7 +14,7 @@ import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
 */
 /** Default app inventory cache freshness window. */
 const CODEX_APP_INVENTORY_CACHE_TTL_MS = 3600 * 1e3;
-const CODEX_TARGETED_APP_INVENTORY_LIMIT = 1e3;
+const CODEX_APP_READ_BATCH_LIMIT = 100;
 const MAX_SERIALIZED_ERROR_MESSAGE_LENGTH = 500;
 /** In-memory app inventory cache with coalesced refreshes per key. */
 var CodexAppInventoryCache = class {
@@ -55,15 +55,25 @@ var CodexAppInventoryCache = class {
 	refreshNow(params) {
 		return this.refresh(params);
 	}
-	/** Marks a key stale and records the reason as a diagnostic. */
-	invalidate(key, reason, nowMs = Date.now()) {
+	/**
+	* Marks a key stale and records the reason as a diagnostic. A scope names
+	* the app ids the invalidation concerns so a covering targeted refresh can
+	* clear it; without one, only a complete refresh revalidates the entry.
+	*/
+	invalidate(key, reason, nowMs = Date.now(), invalidatedAppIds) {
 		this.revision += 1;
+		this.refreshTokens.set(key, (this.refreshTokens.get(key) ?? 0) + 1);
+		this.inFlight.delete(key);
 		const diagnostic = {
 			message: reason,
 			atMs: nowMs
 		};
 		const entry = this.entries.get(key);
 		if (entry) {
+			const scope = invalidatedAppIds?.filter(Boolean) ?? [];
+			if (!entry.invalidated) entry.invalidatedAppIds = scope.length ? [...scope].toSorted() : void 0;
+			else if (entry.invalidatedAppIds && scope.length) entry.invalidatedAppIds = Array.from(/* @__PURE__ */ new Set([...entry.invalidatedAppIds, ...scope])).toSorted();
+			else entry.invalidatedAppIds = void 0;
 			entry.invalidated = true;
 			entry.lastError = diagnostic;
 			entry.revision = this.revision;
@@ -83,42 +93,60 @@ var CodexAppInventoryCache = class {
 		return this.revision;
 	}
 	scheduleRefresh(params) {
-		if (this.inFlight.has(params.key) && !params.forceRefetch) return true;
-		const promise = this.refresh(params);
-		this.inFlight.set(params.key, promise);
-		promise.catch(() => void 0);
+		const existing = this.inFlight.get(params.key);
+		if (existing && !params.forceRefetch && doesInFlightRefreshCover(existing, params)) return true;
+		this.refresh(params).catch(() => void 0);
 		return true;
 	}
 	async refresh(params) {
 		const existing = this.inFlight.get(params.key);
-		if (existing && !params.forceRefetch) return existing;
+		if (existing && !params.forceRefetch && doesInFlightRefreshCover(existing, params)) return existing.promise;
 		const refreshToken = (this.refreshTokens.get(params.key) ?? 0) + 1;
 		this.refreshTokens.set(params.key, refreshToken);
-		const promise = this.refreshUncoalesced(params, refreshToken);
-		this.inFlight.set(params.key, promise);
+		const previousRefresh = params.forceRefetch ? void 0 : existing?.promise;
+		const promise = this.refreshUncoalesced(params, refreshToken, previousRefresh);
+		const currentRefresh = {
+			promise,
+			targetAppIds: new Set(params.targetAppIds?.filter(Boolean) ?? [])
+		};
+		this.inFlight.set(params.key, currentRefresh);
 		try {
 			return await promise;
 		} finally {
-			if (this.inFlight.get(params.key) === promise) this.inFlight.delete(params.key);
+			if (this.inFlight.get(params.key) === currentRefresh) this.inFlight.delete(params.key);
 		}
 	}
-	async refreshUncoalesced(params, refreshToken) {
+	async refreshUncoalesced(params, refreshToken, previousRefresh) {
 		const nowMs = resolveDateTimestampMs(params.nowMs);
 		try {
-			const apps = await listAllApps(params.request, params.forceRefetch ?? false, params.targetAppIds);
+			let previousRefreshSucceeded = false;
+			if (previousRefresh) try {
+				await previousRefresh;
+				previousRefreshSucceeded = true;
+			} catch {}
+			const inventory = await readInstalledApps(params.request, {
+				forceRefresh: params.forceRefetch === true || !this.entries.has(params.key) && !previousRefreshSucceeded,
+				targetAppIds: params.targetAppIds
+			});
 			this.revision += 1;
 			const expiresAtMs = resolveExpiresAtMsFromDurationMs(this.ttlMs, { nowMs }) ?? 0;
 			const snapshot = {
 				key: params.key,
-				apps,
+				apps: inventory.apps,
+				installedApps: inventory.installedApps,
+				...params.targetAppIds?.some(Boolean) ? { targetAppIds: Array.from(new Set(params.targetAppIds.filter(Boolean))).toSorted() } : {},
 				fetchedAtMs: nowMs,
 				expiresAtMs,
 				revision: this.revision
 			};
 			if (this.refreshTokens.get(params.key) === refreshToken) {
+				const existingEntry = this.entries.get(params.key);
+				const published = resolvePublishedInventorySnapshot(existingEntry, snapshot, nowMs);
+				const remaining = resolveRemainingInvalidationScope(existingEntry, snapshot);
 				this.entries.set(params.key, {
-					...snapshot,
-					invalidated: false
+					...published,
+					...remaining,
+					...remaining.invalidated && existingEntry?.lastError ? { lastError: existingEntry.lastError } : {}
 				});
 				this.diagnostics.delete(params.key);
 			}
@@ -140,6 +168,59 @@ var CodexAppInventoryCache = class {
 		}
 	}
 };
+/**
+* Publish policy for refreshed snapshots. A complete refresh replaces the
+* entry, but a targeted refresh only rewrites its own target rows in place —
+* replacing the whole entry with a narrow snapshot makes agents that share
+* the runtime identity see each other's plugin apps vanish and force a hosted
+* connector refresh per turn. The refreshed snapshot stays authoritative for
+* its target set, so target rows it no longer returns are deleted.
+*/
+function resolvePublishedInventorySnapshot(existing, snapshot, nowMs) {
+	if (!snapshot.targetAppIds?.length || !existing) return snapshot;
+	if (!isFutureDateTimestampMs(existing.expiresAtMs, { nowMs })) return snapshot;
+	const refreshedTargetIds = new Set(snapshot.targetAppIds);
+	const { targetAppIds: snapshotTargetAppIds, ...snapshotBase } = snapshot;
+	return {
+		...snapshotBase,
+		fetchedAtMs: existing.fetchedAtMs,
+		expiresAtMs: existing.expiresAtMs,
+		apps: mergeRefreshedRows(existing.apps, snapshot.apps, refreshedTargetIds),
+		installedApps: mergeRefreshedRows(existing.installedApps, snapshot.installedApps, refreshedTargetIds),
+		...existing.targetAppIds?.length ? { targetAppIds: Array.from(/* @__PURE__ */ new Set([...existing.targetAppIds, ...snapshotTargetAppIds])).toSorted() } : {}
+	};
+}
+/** Replaces refreshed target rows in place, deletes vanished ones, appends new ones. */
+function mergeRefreshedRows(existingRows, refreshedRows, refreshedTargetIds) {
+	const refreshedById = new Map(refreshedRows.map((row) => [row.id, row]));
+	const existingIds = new Set(existingRows.map((row) => row.id));
+	return [...existingRows.flatMap((row) => {
+		if (!refreshedTargetIds.has(row.id)) return [row];
+		const refreshed = refreshedById.get(row.id);
+		return refreshed ? [refreshed] : [];
+	}), ...refreshedRows.filter((row) => !existingIds.has(row.id))];
+}
+/**
+* A refresh retires exactly the invalidation scope it re-read: a complete
+* refresh clears everything; a targeted one subtracts its target ids so
+* separate covering refreshes accumulate until no scope remains. Unscoped
+* invalidations require a complete refresh.
+*/
+function resolveRemainingInvalidationScope(existing, snapshot) {
+	if (!existing?.invalidated || !snapshot.targetAppIds?.length) return { invalidated: false };
+	if (!existing.invalidatedAppIds) return { invalidated: true };
+	const refreshedTargetIds = new Set(snapshot.targetAppIds);
+	const remaining = existing.invalidatedAppIds.filter((appId) => !refreshedTargetIds.has(appId));
+	return remaining.length > 0 ? {
+		invalidated: true,
+		invalidatedAppIds: remaining
+	} : { invalidated: false };
+}
+function doesInFlightRefreshCover(existing, params) {
+	if (existing.targetAppIds.size === 0) return true;
+	const requestedAppIds = new Set(params.targetAppIds?.filter(Boolean) ?? []);
+	return requestedAppIds.size > 0 && Array.from(requestedAppIds).every((appId) => existing.targetAppIds.has(appId));
+}
 /** Serializes a refresh failure without leaking large or sensitive error data. */
 function serializeCodexAppInventoryError(error) {
 	const record = isRecord(error) ? error : void 0;
@@ -175,29 +256,41 @@ function normalizeRuntimeIdentityForCacheKey(value) {
 	}).toSorted(([left], [right]) => left.localeCompare(right));
 	return entries.length > 0 ? Object.fromEntries(entries) : null;
 }
-async function listAllApps(request, forceRefetch, targetAppIds = []) {
-	const apps = [];
-	const targetIds = new Set(targetAppIds.filter(Boolean));
-	const remainingTargetIds = new Set(targetIds);
-	const seenCursors = /* @__PURE__ */ new Set();
-	let cursor;
-	do {
-		const response = await request("app/list", {
-			cursor,
-			limit: targetIds.size > 0 ? CODEX_TARGETED_APP_INVENTORY_LIMIT : 100,
-			forceRefetch
-		});
-		apps.push(...response.data);
-		for (const app of response.data) remainingTargetIds.delete(app.id);
-		if (targetIds.size > 0 && remainingTargetIds.size === 0) break;
-		cursor = response.nextCursor;
-		if (cursor && seenCursors.has(cursor)) throw new Error(`app/list returned repeated cursor ${cursor}`);
-		if (cursor) seenCursors.add(cursor);
-	} while (cursor);
-	return apps;
+async function readInstalledApps(request, options) {
+	const installed = await request("app/installed", { forceRefresh: options.forceRefresh });
+	const targetIds = new Set((options.targetAppIds ?? []).filter(Boolean));
+	const apps = targetIds.size === 0 ? installed.apps : installed.apps.filter((app) => targetIds.has(app.id));
+	if (apps.length === 0) return {
+		apps: [],
+		installedApps: []
+	};
+	const metadataResponses = await Promise.all(Array.from({ length: Math.ceil(apps.length / CODEX_APP_READ_BATCH_LIMIT) }, (_, index) => request("app/read", { appIds: apps.slice(index * CODEX_APP_READ_BATCH_LIMIT, (index + 1) * CODEX_APP_READ_BATCH_LIMIT).map((app) => app.id) })));
+	const metadataById = new Map(metadataResponses.flatMap((response) => response.apps).map((metadata) => [metadata.id, metadata]));
+	return {
+		apps: apps.flatMap((installedApp) => {
+			const metadata = metadataById.get(installedApp.id);
+			if (!metadata) return [];
+			return [{
+				id: installedApp.id,
+				name: metadata.name,
+				description: metadata.description ?? null,
+				logoUrl: metadata.iconUrl ?? null,
+				logoUrlDark: metadata.iconUrlDark ?? null,
+				distributionChannel: metadata.distributionChannel ?? null,
+				branding: null,
+				appMetadata: null,
+				labels: null,
+				installUrl: metadata.installUrl ?? null,
+				isAccessible: true,
+				isEnabled: installedApp.enabled,
+				pluginDisplayNames: metadata.pluginDisplayNames
+			}];
+		}),
+		installedApps: apps
+	};
 }
 function stripEntryState(entry) {
-	const { invalidated: _invalidated, ...snapshot } = entry;
+	const { invalidated: _invalidated, invalidatedAppIds: _invalidatedAppIds, ...snapshot } = entry;
 	return snapshot;
 }
 function fingerprintInventoryCacheKey(key) {

package/dist/{rate-limits-S_PXs0ul.js → rate-limits-CU-gVCCS.js}

@@ -1,4 +1,4 @@
-import { V as isJsonObject } from "./shared-client-BVKE40c-.js";
+import { W as isJsonObject } from "./shared-client-DTbvH-XV.js";
 import { MAX_DATE_TIMESTAMP_MS, resolveExpiresAtMsFromEpochSeconds } from "openclaw/plugin-sdk/number-runtime";
 import { asFiniteNumber, parseStrictFiniteNumber } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { expectDefined } from "openclaw/plugin-sdk/expect-runtime";

package/dist/{request-CXpPennK.js → request-qKh331yu.js}

@@ -1,5 +1,5 @@
-import { a as getLeasedSharedCodexAppServerClient, f as retireSharedCodexAppServerClientIfCurrent, h as withTimeout, i as createIsolatedCodexAppServerClient, l as releaseLeasedSharedCodexAppServerClient, s as isCodexAppServerStartSelectionChangedError } from "./shared-client-BVKE40c-.js";
-import { t as resolveCodexAppServerDirectSandboxBypassBlock } from "./sandbox-guard-D1Wky__S.js";
+import { a as getLeasedSharedCodexAppServerClient, g as withTimeout, i as createIsolatedCodexAppServerClient, l as releaseLeasedSharedCodexAppServerClient, p as retireSharedCodexAppServerClientIfCurrent, s as isCodexAppServerStartSelectionChangedError } from "./shared-client-DTbvH-XV.js";
+import { t as resolveCodexAppServerDirectSandboxBypassBlock } from "./sandbox-guard-NuhpXmPB.js";
 //#region extensions/codex/src/app-server/request.ts
 /** Sends one guarded request over a client lease owned by the caller. */
 async function requestCodexAppServerClientJson(params) {
@@ -154,4 +154,4 @@ async function withCodexAppServerJsonClient(params, run) {
 	}
 }
 //#endregion
-export { requestCodexAppServerClientJson as n, requestCodexAppServerJson as r, readCodexAppServerUsage as t };
+export { withCodexAppServerJsonClient as i, requestCodexAppServerClientJson as n, requestCodexAppServerJson as r, readCodexAppServerUsage as t };