@openclaw/gateway-client 2026.8.1-beta.1 → 2026.8.1-beta.3

package/dist/{session-subscriptions-D4Xv60cN.mjs → session-subscriptions-OJnDJHPL.mjs}

@@ -1,4 +1,4 @@
-import { clearGatewayConnectTimeout, startGatewayConnectTimeout } from "./timeouts.mjs";
+import { DEFAULT_GATEWAY_REQUEST_TIMEOUT_MS, clearGatewayConnectTimeout, resolveSafeTimeoutDelayMs, startGatewayConnectTimeout } from "./timeouts.mjs";
 import { ConnectErrorDetailCodes, readConnectErrorDetailCode, readConnectErrorRecoveryAdvice, readPairingConnectErrorDetails } from "@openclaw/gateway-protocol/connect-error-details";
 import { isGatewayEventFrame, isGatewayResponseFrame } from "@openclaw/gateway-protocol/frame-guards";
 //#region packages/gateway-client/src/device-auth.ts
@@ -59,7 +59,7 @@ function selectGatewayConnectAuth(params) {
 	};
 	if (params.preferBootstrapToken && bootstrapToken) return {
 		authBootstrapToken: bootstrapToken,
-		authPassword,
+		signatureToken: bootstrapToken,
 		...stored
 	};
 	const useRetryToken = params.pendingDeviceTokenRetry === true && !explicitDeviceToken && Boolean(authToken && storedToken && params.trustedDeviceTokenRetry);
@@ -177,12 +177,18 @@ var GatewayBrowserDeviceAuthLifecycle = class {
 	async acceptHello(hello, plan) {
 		const token = hello.auth?.deviceToken?.trim();
 		if (!token || !plan.identity) return;
+		const role = hello.auth?.role ?? plan.role;
+		const stored = await this.deps.tokenStore.load({
+			clientId: plan.clientId,
+			deviceId: plan.identity.deviceId,
+			role
+		});
 		await this.deps.tokenStore.store({
 			clientId: plan.clientId,
 			deviceId: plan.identity.deviceId,
-			role: hello.auth?.role ?? plan.role,
+			role,
 			token,
-			scopes: hello.auth?.scopes ?? []
+			scopes: stored?.token === token ? stored.scopes : hello.auth?.scopes ?? []
 		});
 	}
 	async clearStoredToken(plan) {
@@ -195,6 +201,29 @@ var GatewayBrowserDeviceAuthLifecycle = class {
 	}
 };
 //#endregion
+//#region packages/gateway-client/src/gateway-origin-scope.ts
+function normalizeGatewayScope(gatewayUrl, includeSearch) {
+	const trimmed = gatewayUrl.trim();
+	if (!trimmed) return "default";
+	try {
+		const browserLocation = globalThis.location;
+		const base = browserLocation ? `${browserLocation.protocol}//${browserLocation.host}${browserLocation.pathname || "/"}` : void 0;
+		const parsed = base ? new URL(trimmed, base) : new URL(trimmed);
+		const pathname = parsed.pathname === "/" ? "" : parsed.pathname.replace(/\/+$/, "") || parsed.pathname;
+		return `${parsed.protocol}//${parsed.host}${pathname}${includeSearch ? parsed.search : ""}`;
+	} catch {
+		return trimmed;
+	}
+}
+/** Normalizes the gateway URL scope used for origin-bound device tokens. */
+function gatewayOriginScope(gatewayUrl) {
+	return normalizeGatewayScope(gatewayUrl, false);
+}
+/** Normalizes the gateway URL scope used for browser credential records. */
+function gatewayCredentialScope(gatewayUrl) {
+	return normalizeGatewayScope(gatewayUrl, true);
+}
+//#endregion
 //#region packages/retry/src/index.ts
 const MAX_TIMER_TIMEOUT_MS = 2147e6;
 function computeBackoff(policy, attempt) {
@@ -215,7 +244,9 @@ async function sleepWithAbort(ms, abortSignal, options = {}) {
 			if (timer) clearTimeout(timer);
 			timer = null;
 			cleanup();
-			reject(new Error("aborted", { cause: abortSignal?.reason ?? /* @__PURE__ */ new Error("aborted") }));
+			const error = new Error("aborted", { cause: abortSignal?.reason ?? /* @__PURE__ */ new Error("aborted") });
+			error.name = "AbortError";
+			reject(error);
 		};
 		abortSignal?.addEventListener("abort", onAbort, { once: true });
 		if (abortSignal?.aborted) {
@@ -277,24 +308,21 @@ const DEFAULT_RETRY_CONFIG = {
 const defaultSleep = (ms) => new Promise((resolve) => {
 	setTimeout(resolve, ms);
 });
-function asFiniteNumber(value) {
-	return typeof value === "number" && Number.isFinite(value) ? value : void 0;
-}
 function clampNumber(value, fallback, min, max) {
-	const next = asFiniteNumber(value);
+	const next = Number.isFinite(value) ? value : void 0;
 	if (next === void 0) return fallback;
 	return Math.min(Math.max(next, min ?? Number.NEGATIVE_INFINITY), max ?? Number.POSITIVE_INFINITY);
 }
 function resolveAttemptCount(value, fallback) {
-	return Math.max(1, Math.round(asFiniteNumber(value) ?? fallback));
+	return Math.max(1, Math.round(Number.isFinite(value) ? value : fallback));
 }
 function resolveRetryDelayMs(value) {
-	const finite = value === Number.POSITIVE_INFINITY ? MAX_TIMER_TIMEOUT_MS : asFiniteNumber(value) ?? 0;
+	const finite = value === Number.POSITIVE_INFINITY ? MAX_TIMER_TIMEOUT_MS : Number.isFinite(value) ? value : 0;
 	return Math.min(Math.max(Math.round(finite), 0), MAX_TIMER_TIMEOUT_MS);
 }
 function resolveJitterConfig(value, fallback) {
 	if (value === "full") return "full";
-	const fraction = asFiniteNumber(value);
+	const fraction = Number.isFinite(value) ? value : void 0;
 	return fraction === void 0 ? fallback : Math.min(Math.max(fraction, 0), 1);
 }
 function resolveRetryConfig(defaults = DEFAULT_RETRY_CONFIG, overrides) {
@@ -416,6 +444,162 @@ var GatewayProtocolRequestError = class extends Error {
 		this.retryAfterMs = error.retryAfterMs;
 	}
 };
+/** A local transport deadline, distinct from a Gateway's authoritative rejection. */
+var GatewayProtocolRequestTimeoutError = class extends Error {
+	constructor(params, message = `gateway request timed out after ${params.timeoutMs}ms: ${params.method}`) {
+		super(message);
+		this.code = "CLIENT_TIMEOUT";
+		this.name = "GatewayProtocolRequestTimeoutError";
+		this.method = params.method;
+		this.timeoutMs = params.timeoutMs;
+		this.requestSent = params.requestSent;
+	}
+};
+//#endregion
+//#region packages/gateway-client/src/pending-request.ts
+/** Owns request deadlines, correlation, settlement, and generation-scoped IDs. */
+var GatewayPendingRequests = class {
+	constructor(opts) {
+		this.opts = opts;
+		this.pending = /* @__PURE__ */ new Map();
+		this.requestSequence = 0;
+	}
+	get hasPending() {
+		return this.pending.size > 0;
+	}
+	get hasUnboundedPending() {
+		return [...this.pending.values()].some((pending) => pending.unbounded);
+	}
+	request(sender, method, params, options) {
+		let id;
+		try {
+			id = this.allocateRequestId();
+		} catch (error) {
+			return Promise.reject(error instanceof Error ? error : new Error(String(error)));
+		}
+		const requestedTimeoutMs = options?.timeoutMs === null ? void 0 : options?.timeoutMs ?? this.opts.requestTimeoutMs;
+		const timeoutMs = typeof requestedTimeoutMs === "number" && Number.isFinite(requestedTimeoutMs) ? resolveSafeTimeoutDelayMs(requestedTimeoutMs, { minMs: 0 }) : void 0;
+		return new Promise((resolve, reject) => {
+			let timeout;
+			let requestSent = false;
+			const pending = {
+				resolve: (value) => resolve(value),
+				reject,
+				expectFinal: options?.expectFinal === true,
+				acceptedNotified: false,
+				onAccepted: options?.onAccepted,
+				unbounded: timeoutMs === void 0,
+				method,
+				startedAtMs: this.opts.nowMs()
+			};
+			const cleanup = () => {
+				if (timeout !== void 0) clearTimeout(timeout);
+				options?.signal?.removeEventListener("abort", onAbort);
+			};
+			const retire = (errorCode) => {
+				if (this.pending.get(id) !== pending) return false;
+				this.pending.delete(id);
+				cleanup();
+				this.finishTiming(id, pending, false, errorCode);
+				return true;
+			};
+			const onAbort = () => {
+				if (!retire("CLIENT_ABORTED")) return;
+				reject(this.opts.createRequestAbortError?.(method) ?? /* @__PURE__ */ new Error(`gateway request aborted for ${method}`));
+			};
+			if (options?.signal?.aborted) {
+				reject(this.opts.createRequestAbortError?.(method) ?? /* @__PURE__ */ new Error(`gateway request aborted for ${method}`));
+				return;
+			}
+			pending.cleanup = cleanup;
+			if (timeoutMs !== void 0) {
+				timeout = setTimeout(() => {
+					if (!retire("CLIENT_TIMEOUT")) return;
+					reject(this.opts.createRequestTimeoutError?.(method, timeoutMs, requestSent) ?? new GatewayProtocolRequestTimeoutError({
+						method,
+						timeoutMs,
+						requestSent
+					}));
+				}, timeoutMs);
+				timeout.unref?.();
+			}
+			options?.signal?.addEventListener("abort", onAbort, { once: true });
+			this.pending.set(id, pending);
+			try {
+				sender.send(JSON.stringify({
+					type: "req",
+					id,
+					method,
+					params
+				}));
+				if (this.pending.get(id) !== pending) return;
+				requestSent = true;
+				this.invoke("sent", () => options?.onSent?.());
+			} catch (error) {
+				if (retire("CLIENT_SEND_ERROR")) reject(error instanceof Error ? error : new Error(String(error)));
+			}
+		});
+	}
+	handleResponse(frame) {
+		const pending = this.pending.get(frame.id);
+		if (!pending) return;
+		const status = frame.payload?.status;
+		if (pending.expectFinal && status === "accepted") {
+			if (!pending.acceptedNotified) {
+				pending.acceptedNotified = true;
+				this.invoke("accepted", () => pending.onAccepted?.(frame.payload));
+			}
+			return;
+		}
+		this.pending.delete(frame.id);
+		pending.cleanup?.();
+		if (frame.ok) {
+			this.finishTiming(frame.id, pending, true);
+			pending.resolve(frame.payload);
+			return;
+		}
+		this.finishTiming(frame.id, pending, false, frame.error?.code);
+		pending.reject(this.opts.createRequestError?.(frame.error ?? {}) ?? new GatewayProtocolRequestError(frame.error ?? {}));
+	}
+	flush(error) {
+		for (const [id, pending] of this.pending) {
+			this.finishTiming(id, pending, false, "CLIENT_CLOSED");
+			pending.cleanup?.();
+			pending.reject(error);
+		}
+		this.pending.clear();
+		this.requestSequence = 0;
+	}
+	allocateRequestId() {
+		this.requestSequence += 1;
+		return `${this.requestSequence}:${this.opts.createRequestId()}`;
+	}
+	finishTiming(id, pending, ok, errorCode) {
+		const endedAtMs = this.opts.nowMs();
+		try {
+			const onTiming = this.opts.onTiming;
+			if (onTiming === void 0 || onTiming === null) return;
+			Reflect.apply(onTiming, this.opts, [{
+				id,
+				method: pending.method,
+				ok,
+				durationMs: Math.max(0, endedAtMs - pending.startedAtMs),
+				startedAtMs: pending.startedAtMs,
+				endedAtMs,
+				errorCode
+			}]);
+		} catch (error) {
+			this.opts.onCallbackError?.("request timing", error);
+		}
+	}
+	invoke(label, callback) {
+		try {
+			callback();
+		} catch (error) {
+			this.opts.onCallbackError?.(label, error);
+		}
+	}
+};
 //#endregion
 //#region packages/gateway-client/src/protocol-client.ts
 /**
@@ -426,7 +610,6 @@ var GatewayProtocolClient = class {
 	constructor(opts) {
 		this.opts = opts;
 		this.socket = null;
-		this.pending = /* @__PURE__ */ new Map();
 		this.listeners = new GatewayEventListeners();
 		this.stopped = true;
 		this.generation = 0;
@@ -445,18 +628,28 @@ var GatewayProtocolClient = class {
 			factor: opts.reconnect.multiplier,
 			jitter: 0
 		});
+		this.requests = new GatewayPendingRequests({
+			createRequestId: opts.createRequestId,
+			createRequestError: opts.createRequestError,
+			createRequestTimeoutError: opts.createRequestTimeoutError,
+			createRequestAbortError: opts.createRequestAbortError,
+			requestTimeoutMs: opts.requestTimeoutMs,
+			nowMs: () => this.nowMs(),
+			onTiming: opts.onRequestTiming,
+			onCallbackError: opts.onCallbackError
+		});
 	}
 	get connected() {
 		return this.socket?.isOpen() ?? false;
 	}
 	get hasPendingRequests() {
-		return this.pending.size > 0;
+		return this.requests.hasPending;
 	}
 	get connecting() {
 		return this.connectSent && !this.helloReceived;
 	}
 	get hasUnboundedPendingRequests() {
-		return [...this.pending.values()].some((pending) => pending.unbounded);
+		return this.requests.hasUnboundedPending;
 	}
 	start() {
 		if (this.socket || this.reconnectSignal) return;
@@ -477,71 +670,14 @@ var GatewayProtocolClient = class {
 		this.socket = null;
 		this.connectFailure = void 0;
 		this.connectTiming = null;
-		this.flushRequests(/* @__PURE__ */ new Error("gateway client stopped"));
+		this.requests.flush(/* @__PURE__ */ new Error("gateway client stopped"));
 		socket?.close();
 	}
 	request(method, params, options) {
 		const socket = this.socket;
 		if (!socket?.isOpen()) return Promise.reject(/* @__PURE__ */ new Error("gateway not connected"));
 		if (typeof method !== "string" || method.length === 0) return Promise.reject(/* @__PURE__ */ new Error("invalid request frame: method must be a non-empty string"));
-		const id = this.opts.createRequestId();
-		const timeoutMs = options?.timeoutMs === null ? void 0 : options?.timeoutMs ?? this.opts.requestTimeoutMs;
-		return new Promise((resolve, reject) => {
-			let timeout;
-			let requestSent = false;
-			const pending = {
-				resolve: (value) => resolve(value),
-				reject,
-				expectFinal: options?.expectFinal === true,
-				acceptedNotified: false,
-				onAccepted: options?.onAccepted,
-				unbounded: timeoutMs === void 0,
-				method,
-				startedAtMs: this.nowMs()
-			};
-			const onAbort = () => {
-				this.pending.delete(id);
-				pending.cleanup?.();
-				this.finishRequestTiming(id, pending, false, "CLIENT_ABORTED");
-				reject(this.opts.createRequestAbortError?.(method) ?? /* @__PURE__ */ new Error(`gateway request aborted for ${method}`));
-			};
-			const cleanup = () => {
-				if (timeout) clearTimeout(timeout);
-				options?.signal?.removeEventListener("abort", onAbort);
-			};
-			if (options?.signal?.aborted) {
-				reject(this.opts.createRequestAbortError?.(method) ?? /* @__PURE__ */ new Error(`gateway request aborted for ${method}`));
-				return;
-			}
-			pending.cleanup = cleanup;
-			if (timeoutMs !== void 0 && timeoutMs >= 0) {
-				timeout = setTimeout(() => {
-					if (this.pending.get(id) !== pending) return;
-					this.pending.delete(id);
-					options?.signal?.removeEventListener("abort", onAbort);
-					this.finishRequestTiming(id, pending, false, "CLIENT_TIMEOUT");
-					reject(this.opts.createRequestTimeoutError?.(method, timeoutMs, requestSent) ?? /* @__PURE__ */ new Error(`gateway request timed out after ${timeoutMs}ms: ${method}`));
-				}, timeoutMs);
-				timeout.unref?.();
-			}
-			options?.signal?.addEventListener("abort", onAbort, { once: true });
-			this.pending.set(id, pending);
-			try {
-				socket.send(JSON.stringify({
-					type: "req",
-					id,
-					method,
-					params
-				}));
-				requestSent = true;
-				this.invoke("sent", () => options?.onSent?.());
-			} catch (error) {
-				this.pending.delete(id);
-				cleanup();
-				this.finishRequestTiming(id, pending, false, "CLIENT_SEND_ERROR");
-				reject(error instanceof Error ? error : new Error(String(error)));
-			}
-		});
+		return this.requests.request(socket, method, params, options);
 	}
 	addEventListener(listener) {
 		return this.listeners.add(listener);
@@ -758,28 +894,7 @@ var GatewayProtocolClient = class {
 		}
 		if (!isGatewayResponseFrame(parsed)) return;
 		this.opts.onActivity?.();
-		this.handleResponse(parsed);
-	}
-	handleResponse(frame) {
-		const pending = this.pending.get(frame.id);
-		if (!pending) return;
-		const status = frame.payload?.status;
-		if (pending.expectFinal && status === "accepted") {
-			if (!pending.acceptedNotified) {
-				pending.acceptedNotified = true;
-				this.invoke("accepted", () => pending.onAccepted?.(frame.payload));
-			}
-			return;
-		}
-		this.pending.delete(frame.id);
-		pending.cleanup?.();
-		if (frame.ok) {
-			this.finishRequestTiming(frame.id, pending, true);
-			pending.resolve(frame.payload);
-			return;
-		}
-		this.finishRequestTiming(frame.id, pending, false, frame.error?.code);
-		pending.reject(this.opts.createRequestError?.(frame.error ?? {}) ?? new GatewayProtocolRequestError(frame.error ?? {}));
+		this.requests.handleResponse(parsed);
 	}
 	handleClose(socket, generation, code, reason) {
 		if (this.socket !== socket) {
@@ -807,34 +922,15 @@ var GatewayProtocolClient = class {
 		};
 		this.connectFailure = void 0;
 		const decision = this.opts.resolveClose(context);
-		this.flushRequests(decision.pendingError ?? context.connectFailure?.error ?? /* @__PURE__ */ new Error(`gateway closed (${code}): ${reason}`));
+		this.requests.flush(decision.pendingError ?? context.connectFailure?.error ?? /* @__PURE__ */ new Error(`gateway closed (${code}): ${reason}`));
 		this.invoke("close", () => this.opts.onClose?.(context, decision));
 		if (decision.retry && !this.stopped) this.scheduleReconnect(decision.reconnectDelayMs ?? context.connectFailure?.reconnectDelayMs);
 	}
 	handleSocketError(socket, generation, error) {
 		if (!this.isActive(socket, generation) || this.connectSent) return;
+		this.connectFailure = { error };
 		this.opts.onConnectError?.(error);
 	}
-	flushRequests(error) {
-		for (const [id, pending] of this.pending) {
-			this.finishRequestTiming(id, pending, false, "CLIENT_CLOSED");
-			pending.cleanup?.();
-			pending.reject(error);
-		}
-		this.pending.clear();
-	}
-	finishRequestTiming(id, pending, ok, errorCode) {
-		const endedAtMs = this.nowMs();
-		this.invoke("request timing", () => this.opts.onRequestTiming?.({
-			id,
-			method: pending.method,
-			ok,
-			durationMs: Math.max(0, endedAtMs - pending.startedAtMs),
-			startedAtMs: pending.startedAtMs,
-			endedAtMs,
-			errorCode
-		}));
-	}
 	scheduleReconnect(overrideMs) {
 		if (overrideMs !== void 0) this.reconnectSupervisor.nextDelayOverrideMs = overrideMs;
 		const retry = this.reconnectSupervisor.next();
@@ -884,6 +980,8 @@ const NON_RECOVERABLE_AUTH_ERRORS = /* @__PURE__ */ new Set([
 	ConnectErrorDetailCodes.AUTH_RATE_LIMITED,
 	ConnectErrorDetailCodes.AUTH_DEVICE_TOKEN_MISMATCH,
 	ConnectErrorDetailCodes.AUTH_SCOPE_MISMATCH,
+	ConnectErrorDetailCodes.AUTH_IDENTITY_HEADER_REQUIRED,
+	ConnectErrorDetailCodes.CONTROL_UI_BUILD_MISMATCH,
 	ConnectErrorDetailCodes.PAIRING_REQUIRED,
 	ConnectErrorDetailCodes.CONTROL_UI_DEVICE_IDENTITY_REQUIRED,
 	ConnectErrorDetailCodes.DEVICE_IDENTITY_REQUIRED
@@ -894,23 +992,22 @@ function shouldPauseGatewayReconnect(params) {
 	const pairing = readPairingConnectErrorDetails(params.details);
 	if (code === ConnectErrorDetailCodes.PAIRING_REQUIRED && (pairing?.pauseReconnect === false || pairing?.recommendedNextStep === "wait_then_retry")) return false;
 	if (code === ConnectErrorDetailCodes.AUTH_TOKEN_MISMATCH) return params.tokenMismatchIsTerminal === true && !params.deviceTokenRetryPending;
+	if (code === ConnectErrorDetailCodes.AUTH_IDENTITY_HEADER_REQUIRED) return !params.deviceTokenRetryPending;
 	return NON_RECOVERABLE_AUTH_ERRORS.has(code) || params.protocolMismatchIsTerminal === true && code === ConnectErrorDetailCodes.PROTOCOL_MISMATCH || params.clientVersionMismatchIsTerminal === true && code === ConnectErrorDetailCodes.CLIENT_VERSION_MISMATCH;
 }
 //#endregion
-//#region packages/gateway-client/src/session-projection.ts
-const MAX_TRACKED_SESSION_RUNS = 200;
-const RETAINED_SESSION_RUNS = 150;
-const SESSION_PROJECTION_SCOPE_KEYS = [
-	"sessionKey",
-	"sessionId",
-	"agentId",
-	"lifecycleRevision",
-	"activeLeafEntryId"
-];
-function readRecord(value) {
-	return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+//#region packages/normalization-core/src/record-coerce.ts
+/** Type guard for non-array object records at browser-safe boundaries. */
+function isRecord(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
 }
-function readNonemptyString(value) {
+/** Returns a non-array record or null. */
+function asNullableRecord(value) {
+	return isRecord(value) ? value : null;
+}
+//#endregion
+//#region packages/gateway-client/src/session-projection-message-identity.ts
+function readSessionProjectionString(value) {
 	return typeof value === "string" ? value.trim() || null : null;
 }
 function readPositiveSafeInteger(value) {
@@ -918,29 +1015,36 @@ function readPositiveSafeInteger(value) {
 }
 /** History and status markers carry transcript order even when they have no chat role. */
 function readSessionMessageSequence(message, envelope) {
-	return readPositiveSafeInteger(readRecord(readRecord(message)?.["__openclaw"])?.seq) ?? readPositiveSafeInteger(envelope?.messageSeq);
+	return readPositiveSafeInteger(asNullableRecord(asNullableRecord(message)?.["__openclaw"])?.seq) ?? readPositiveSafeInteger(envelope?.messageSeq);
 }
 /** Run ownership normalizes a user-turn suffix without changing its persisted send key. */
 function normalizeSessionProjectionRunId(value) {
-	const runId = readNonemptyString(value);
+	const runId = readSessionProjectionString(value);
 	return runId?.endsWith(":user") ? runId.slice(0, -5) || null : runId;
 }
-/** Persisted transcript facts win over envelope projections and provider-local import IDs. */
+/** Persisted row facts win; assistant run ownership comes from its authoritative producer. */
 function readSessionMessageIdentity(message, envelope) {
-	const record = readRecord(message);
-	const role = readNonemptyString(record?.role)?.toLowerCase();
+	const record = asNullableRecord(message);
+	const role = readSessionProjectionString(record?.role)?.toLowerCase();
 	if (!record || !role) return null;
-	const metadata = readRecord(record["__openclaw"]);
-	const importedFrom = readNonemptyString(metadata?.importedFrom);
-	const cliSessionId = readNonemptyString(metadata?.cliSessionId);
-	const externalId = readNonemptyString(metadata?.externalId);
-	const idempotencyKey = readNonemptyString(metadata?.idempotencyKey) ?? readNonemptyString(record.idempotencyKey) ?? readNonemptyString(envelope?.idempotencyKey) ?? readNonemptyString(envelope?.clientRunId);
+	const metadata = asNullableRecord(record["__openclaw"]);
+	const importedFrom = readSessionProjectionString(metadata?.importedFrom);
+	const cliSessionId = readSessionProjectionString(metadata?.cliSessionId);
+	const externalId = readSessionProjectionString(metadata?.externalId);
+	const idempotencyKey = readSessionProjectionString(metadata?.idempotencyKey) ?? readSessionProjectionString(record.idempotencyKey) ?? readSessionProjectionString(envelope?.idempotencyKey) ?? readSessionProjectionString(envelope?.clientRunId);
+	const persistedRunId = normalizeSessionProjectionRunId(idempotencyKey);
+	const envelopeRunId = normalizeSessionProjectionRunId(envelope?.runId);
+	const metadataRunId = normalizeSessionProjectionRunId(metadata?.runId);
+	const mirroredMessage = readSessionProjectionString(metadata?.mirrorOrigin) !== null;
+	const isCliAssistant = role === "assistant" && readSessionProjectionString(record.api)?.toLowerCase() === "cli";
+	const canonicalPersistedRunId = isCliAssistant && persistedRunId?.startsWith("cli-assistant:") ? readSessionProjectionString(persistedRunId.slice(14)) : persistedRunId;
+	const optimisticRunId = metadata && Object.keys(metadata).every((key) => key === "idempotencyKey") ? canonicalPersistedRunId : null;
 	return {
 		role,
-		id: readNonemptyString(metadata?.id) ?? readNonemptyString(envelope?.messageId),
+		id: readSessionProjectionString(metadata?.id) ?? readSessionProjectionString(envelope?.messageId),
 		sequence: readSessionMessageSequence(message, envelope),
 		idempotencyKey,
-		runId: normalizeSessionProjectionRunId(idempotencyKey) ?? normalizeSessionProjectionRunId(envelope?.runId),
+		runId: role === "assistant" ? metadataRunId ?? envelopeRunId ?? (isCliAssistant || !mirroredMessage ? canonicalPersistedRunId : null) ?? optimisticRunId : metadataRunId ?? canonicalPersistedRunId ?? envelopeRunId,
 		isImported: Boolean(importedFrom || cliSessionId || externalId),
 		externalSource: importedFrom && cliSessionId && externalId ? JSON.stringify([
 			importedFrom,
@@ -949,11 +1053,62 @@ function readSessionMessageIdentity(message, envelope) {
 		]) : null
 	};
 }
+//#endregion
+//#region packages/gateway-client/src/session-projection-run-event.ts
+function readNonemptyString(value) {
+	return typeof value === "string" ? value.trim() || null : null;
+}
+function reduceSessionProjectionRunEventImpl(projection, event, scope = {}) {
+	const runId = readNonemptyString(event.runId);
+	if (!runId || typeof event.state !== "string" || ![
+		"delta",
+		"final",
+		"error",
+		"aborted"
+	].includes(event.state)) return null;
+	const message = event.message;
+	const messageStopReason = isRecord(message) ? readNonemptyString(message.stopReason) : null;
+	const stopReason = readNonemptyString(event.stopReason) ?? messageStopReason;
+	const errorKind = readNonemptyString(event.errorKind);
+	const base = {
+		runId,
+		...message === void 0 ? {} : { message },
+		scope
+	};
+	const next = reduceSessionProjection(projection, event.state === "delta" ? {
+		type: "runDelta",
+		...base
+	} : {
+		type: "runTerminal",
+		...base,
+		status: event.state === "aborted" ? "aborted" : event.state === "error" ? errorKind === "timeout" ? "timeout" : "error" : event.yielded === true && stopReason === "end_turn" ? "yielded" : stopReason === "error" ? "error" : "completed",
+		...stopReason === null ? {} : { stopReason },
+		...errorKind === null ? {} : { errorKind },
+		...typeof event.errorMessage === "string" ? { errorMessage: event.errorMessage } : {}
+	});
+	return {
+		projection: next,
+		previousRun: projection.runs[runId],
+		currentRun: next.runs[runId]
+	};
+}
+//#endregion
+//#region packages/gateway-client/src/session-projection.ts
+/** Browser-safe identity and replay rules shared by Gateway conversation clients. */
+const MAX_TRACKED_SESSION_RUNS = 200;
+const RETAINED_SESSION_RUNS = 150;
+const SESSION_PROJECTION_SCOPE_KEYS = [
+	"sessionKey",
+	"sessionId",
+	"agentId",
+	"lifecycleRevision",
+	"activeLeafEntryId"
+];
 /** Local turns have no durable transcript metadata beyond their own optional send key. */
 function isLocallyOptimisticSessionMessage(message) {
 	const identity = readSessionMessageIdentity(message);
 	if (!identity || identity.role !== "user" && identity.role !== "assistant") return false;
-	const metadata = readRecord(readRecord(message)?.["__openclaw"]);
+	const metadata = asNullableRecord(asNullableRecord(message)?.["__openclaw"]);
 	return !metadata || Object.keys(metadata).every((key) => key === "idempotencyKey");
 }
 function createEntry(message, options) {
@@ -1011,13 +1166,18 @@ function sameTranscriptIdentity(left, right) {
 }
 function entryMatches(left, right, allowSnapshotPromotion = false) {
 	if (sameTranscriptIdentity(left.identity, right.identity)) return true;
+	const durableEntry = left.identity?.id ? left : right.identity?.id ? right : null;
+	const provisionalEntry = durableEntry === left ? right : durableEntry === right ? left : null;
+	const durableMetadata = asNullableRecord(asNullableRecord(durableEntry?.message)?.["__openclaw"]);
+	if (durableEntry?.live && provisionalEntry?.live && durableEntry.identity?.role === "assistant" && provisionalEntry.identity?.role === "assistant" && !durableEntry.identity.isImported && !provisionalEntry.identity.isImported && !provisionalEntry.identity.id && durableEntry.identity.runId && durableEntry.identity.runId === provisionalEntry.identity.runId && (readSessionProjectionString(durableMetadata?.mirrorOrigin) === null || durableMetadata?.runTerminal === true)) return true;
 	const persisted = left.identity;
 	const observed = right.identity;
-	if (allowSnapshotPromotion && right.live && persisted && observed && persisted.role === observed.role && !persisted.isImported && !observed.isImported && persisted.id && !observed.id && (persisted.sequence !== null && persisted.sequence === observed.sequence || persisted.role === "assistant" && observed.sequence === null && persisted.runId !== null && persisted.runId === observed.runId)) return true;
+	const persistedMetadata = asNullableRecord(asNullableRecord(left.message)?.["__openclaw"]);
+	if (allowSnapshotPromotion && right.live && persisted && observed && persisted.role === observed.role && !persisted.isImported && !observed.isImported && persisted.id && !observed.id && (persisted.sequence !== null && persisted.sequence === observed.sequence || persisted.role === "assistant" && observed.sequence === null && persisted.runId !== null && persisted.runId === observed.runId && (readSessionProjectionString(persistedMetadata?.mirrorOrigin) === null || persistedMetadata?.runTerminal === true))) return true;
 	if (left.pending && right.pending) return Boolean(left.identity?.role === right.identity?.role && left.pendingRunId && left.pendingRunId === right.pendingRunId);
 	const pending = left.pending ? left : right.pending ? right : null;
 	const authoritative = pending === left ? right : pending === right ? left : null;
-	return Boolean(pending && authoritative && pending.identity?.role === authoritative.identity?.role && !pending.identity?.isImported && !authoritative.identity?.isImported && pending.pendingRunId && pending.pendingRunId === authoritative.identity?.runId);
+	return Boolean(pending && authoritative && pending.identity && authoritative.identity && pending.identity.role === authoritative.identity.role && !pending.identity.isImported && !authoritative.identity.isImported && pending.pendingRunId && pending.pendingRunId === authoritative.identity.runId && (pending.identity.sequence === null || authoritative.identity.sequence === null || pending.identity.sequence === authoritative.identity.sequence));
 }
 function withEntries(state, entries) {
 	return {
@@ -1054,6 +1214,7 @@ function projectLiveSessionMessage(state, message, envelope, scope = {}) {
 	if (existingIndex < 0) return withEntries(state, insertEntry(state.entries, incoming, state.runs));
 	const existing = state.entries[existingIndex];
 	if (existing && existing.message === message && existing.live && !existing.pending) return state;
+	if (existing && !existing.pending && existing.identity?.id && !incoming.identity.id) return state;
 	if (existing?.pending && incoming.identity.sequence !== null) {
 		const sequence = incoming.identity.sequence;
 		return withEntries(state, state.entries.some(({ identity }, index) => identity?.sequence != null && (index < existingIndex ? identity.sequence > sequence : identity.sequence < sequence)) ? insertEntry(state.entries.filter((_, index) => index !== existingIndex), incoming, state.runs) : state.entries.toSpliced(existingIndex, 1, incoming));
@@ -1084,13 +1245,13 @@ function reconcileSessionProjectionSnapshot(state, messages, scope = {}, options
 }
 function hasDisplayableSessionMessage(message) {
 	if (typeof message === "string") return message.trim().length > 0;
-	const record = readRecord(message);
+	const record = asNullableRecord(message);
 	if (!record) return false;
 	const displayableBlocks = Array.isArray(record.content) && record.content.some((block) => {
-		const entry = readRecord(block);
-		return entry ? entry.type !== "text" || readNonemptyString(entry.text) !== null : typeof block === "string" && block.trim().length > 0;
+		const entry = asNullableRecord(block);
+		return entry ? entry.type !== "text" || readSessionProjectionString(entry.text) !== null : typeof block === "string" && block.trim().length > 0;
 	});
-	const media = readRecord(record["__openclaw"])?.media;
+	const media = asNullableRecord(record["__openclaw"])?.media;
 	return Boolean(typeof record.content === "string" && record.content.trim() || displayableBlocks || Array.isArray(media) && media.length > 0);
 }
 function readSessionProjectionFinalMessageIdentity(message) {
@@ -1099,8 +1260,8 @@ function readSessionProjectionFinalMessageIdentity(message) {
 	if (identity?.externalSource) return `import:${identity.role}:${identity.externalSource}`;
 	if (identity?.id && !identity.isImported) return `id:${identity.role}:${identity.id}`;
 	if (identity?.sequence !== null && identity?.sequence !== void 0) return `seq:${identity.role}:${identity.sequence}`;
-	const record = readRecord(message);
-	const metadata = readRecord(record?.["__openclaw"]);
+	const record = asNullableRecord(message);
+	const metadata = asNullableRecord(record?.["__openclaw"]);
 	try {
 		return `content:${JSON.stringify([
 			identity?.role ?? "assistant",
@@ -1131,7 +1292,7 @@ function retainSessionProjectionRuns(runs) {
 	return Object.fromEntries([...active, ...retainedTerminal]);
 }
 function updateRun(state, incoming) {
-	const incomingErrorMessage = readNonemptyString(incoming.errorMessage);
+	const incomingErrorMessage = readSessionProjectionString(incoming.errorMessage);
 	const normalizedIncoming = { ...incoming };
 	if (incomingErrorMessage) normalizedIncoming.errorMessage = incomingErrorMessage;
 	else delete normalizedIncoming.errorMessage;
@@ -1142,7 +1303,7 @@ function updateRun(state, incoming) {
 		const canRecoverFinal = !hasDisplayableSessionMessage(current.message) || (current.acceptedFinalMessageIdentities?.length ?? 0) > 0;
 		const acceptFinal = incomingIsFinal && (current.status === incoming.status || canRecoverFinal) && incomingFinalIdentity !== null && !hasSessionProjectionAcceptedFinal(current, incoming.message);
 		const recoverMessage = acceptFinal && !hasDisplayableSessionMessage(current.message);
-		const recoverError = readNonemptyString(current.errorMessage) === null && incomingErrorMessage !== null;
+		const recoverError = readSessionProjectionString(current.errorMessage) === null && incomingErrorMessage !== null;
 		if (!acceptFinal && !recoverError) return state;
 		const firstFinalIdentity = readSessionProjectionFinalMessageIdentity(current.message);
 		const previousFinalIdentities = current.acceptedFinalMessageIdentities ?? (firstFinalIdentity ? [firstFinalIdentity] : []);
@@ -1199,7 +1360,13 @@ function reduceSessionProjection(state, event) {
 			const pendingRunId = normalizeSessionProjectionRunId(event.idempotencyKey ?? event.runId);
 			const incoming = createEntry(event.message, { pendingRunId });
 			if (!pendingRunId || !incoming.identity) return state;
-			return state.entries.findIndex((entry) => entryMatches(entry, incoming)) < 0 ? withEntries(state, insertEntry(state.entries, incoming, state.runs)) : state;
+			const seed = state.entries.find((entry) => entry.message === event.message);
+			if (seed && !seed.pending && incoming.identity.id === null && !incoming.identity.isImported && incoming.identity.runId === pendingRunId) return withEntries(state, state.entries.map((entry) => entry === seed ? {
+				...seed,
+				pending: true,
+				pendingRunId
+			} : entry));
+			return seed || state.entries.some((entry) => entryMatches(entry, incoming)) ? state : withEntries(state, insertEntry(state.entries, incoming, state.runs));
 		}
 		case "sendAcknowledged": {
 			const runId = normalizeSessionProjectionRunId(event.idempotencyKey ?? event.runId);
@@ -1245,38 +1412,7 @@ function reduceSessionProjection(state, event) {
 }
 /** Normalizes Gateway run envelopes once for every browser and terminal adapter. */
 function reduceSessionProjectionRunEvent(projection, event, scope = {}) {
-	const runId = readNonemptyString(event.runId);
-	const eventState = event.state;
-	if (!runId || typeof eventState !== "string" || ![
-		"delta",
-		"final",
-		"error",
-		"aborted"
-	].includes(eventState)) return null;
-	const message = event.message;
-	const stopReason = readNonemptyString(event.stopReason) ?? readNonemptyString(readRecord(message)?.stopReason);
-	const errorKind = readNonemptyString(event.errorKind);
-	const base = {
-		runId,
-		...message === void 0 ? {} : { message },
-		scope
-	};
-	const next = reduceSessionProjection(projection, eventState === "delta" ? {
-		type: "runDelta",
-		...base
-	} : {
-		type: "runTerminal",
-		...base,
-		status: eventState === "aborted" ? "aborted" : eventState === "error" ? errorKind === "timeout" ? "timeout" : "error" : event.yielded === true && stopReason === "end_turn" ? "yielded" : stopReason === "error" ? "error" : "completed",
-		...stopReason === null ? {} : { stopReason },
-		...errorKind === null ? {} : { errorKind },
-		...typeof event.errorMessage === "string" ? { errorMessage: event.errorMessage } : {}
-	});
-	return {
-		projection: next,
-		previousRun: projection.runs[runId],
-		currentRun: next.runs[runId]
-	};
+	return reduceSessionProjectionRunEventImpl(projection, event, scope);
 }
 //#endregion
 //#region packages/gateway-client/src/session-subscriptions.ts
@@ -1371,7 +1507,7 @@ var GatewaySessionMessageSubscriptionCoordinator = class {
 			entry.release = tracked;
 			return tracked;
 		}
-		const tracked = this.#client.request("sessions.messages.unsubscribe", sessionSubscriptionParams(entry.key, entry.agentId)).then(() => {
+		const tracked = this.#client.request("sessions.messages.unsubscribe", sessionSubscriptionParams(entry.key, entry.agentId), { timeoutMs: DEFAULT_GATEWAY_REQUEST_TIMEOUT_MS }).then(() => {
 			this.#finishRelease(subscription, owner, true);
 		}).finally(() => {
 			if (entry.release === tracked) entry.release = null;
@@ -1446,9 +1582,18 @@ var GatewaySessionMessageSubscriptionCoordinator = class {
 		return upgrade;
 	}
 	async #requestSubscribe(entry, includeApprovals) {
-		const result = await this.#client.request("sessions.messages.subscribe", {
-			...sessionSubscriptionParams(entry.key, entry.agentId),
-			...includeApprovals ? { includeApprovals: true } : {}
+		const params = sessionSubscriptionParams(entry.key, entry.agentId);
+		const result = await this.#client.request("sessions.messages.subscribe", includeApprovals ? {
+			...params,
+			includeApprovals: true
+		} : params, { timeoutMs: DEFAULT_GATEWAY_REQUEST_TIMEOUT_MS }).catch(async (error) => {
+			if (!(error instanceof GatewayProtocolRequestTimeoutError) || !error.requestSent || this.#retired) throw error;
+			try {
+				await this.#client.request(entry.handles.size > 0 ? "sessions.messages.subscribe" : "sessions.messages.unsubscribe", params, { timeoutMs: DEFAULT_GATEWAY_REQUEST_TIMEOUT_MS });
+			} catch (recoveryError) {
+				if (!this.#retired) throw new AggregateError([error, recoveryError], "session message subscription recovery failed", { cause: recoveryError });
+			}
+			throw error;
 		});
 		const response = result && typeof result === "object" ? result : null;
 		const responseKey = response && "key" in response ? response.key : void 0;
@@ -1484,4 +1629,4 @@ function releaseGatewaySessionMessageSubscription(subscription) {
 	return sessionMessageSubscriptionOwners.get(subscription)?.coordinator.release(subscription) ?? Promise.resolve();
 }
 //#endregion
-export { buildDeviceAuthPayload as C, shouldRetryGatewayWithDeviceToken as S, normalizeDeviceMetadataForAuth as T, GatewayProtocolRequestError as _, createSessionProjection as a, resolveGatewayConnectScopes as b, normalizeSessionProjectionRunId as c, readSessionMessageSequence as d, reconcileSessionProjectionSnapshot as f, GatewayProtocolClient as g, shouldPauseGatewayReconnect as h, resetGatewaySessionMessageSubscriptionCoordinator as i, projectLiveSessionMessage as l, reduceSessionProjectionRunEvent as m, getGatewaySessionMessageSubscriptionCoordinator as n, hasSessionProjectionAcceptedFinal as o, reduceSessionProjection as p, releaseGatewaySessionMessageSubscription as r, isLocallyOptimisticSessionMessage as s, GatewaySessionMessageSubscriptionCoordinator as t, readSessionMessageIdentity as u, GatewayBrowserDeviceAuthLifecycle as v, buildDeviceAuthPayloadV3 as w, selectGatewayConnectAuth as x, buildGatewayConnectAuth as y };
+export { resolveGatewayConnectScopes as C, buildDeviceAuthPayloadV3 as D, buildDeviceAuthPayload as E, normalizeDeviceMetadataForAuth as O, buildGatewayConnectAuth as S, shouldRetryGatewayWithDeviceToken as T, GatewayProtocolRequestError as _, createSessionProjection as a, gatewayOriginScope as b, projectLiveSessionMessage as c, reduceSessionProjectionRunEvent as d, normalizeSessionProjectionRunId as f, GatewayProtocolClient as g, shouldPauseGatewayReconnect as h, resetGatewaySessionMessageSubscriptionCoordinator as i, reconcileSessionProjectionSnapshot as l, readSessionMessageSequence as m, getGatewaySessionMessageSubscriptionCoordinator as n, hasSessionProjectionAcceptedFinal as o, readSessionMessageIdentity as p, releaseGatewaySessionMessageSubscription as r, isLocallyOptimisticSessionMessage as s, GatewaySessionMessageSubscriptionCoordinator as t, reduceSessionProjection as u, GatewayProtocolRequestTimeoutError as v, selectGatewayConnectAuth as w, GatewayBrowserDeviceAuthLifecycle as x, gatewayCredentialScope as y };