@openclaw/gateway-client 2026.7.2-beta.7 → 2026.8.1-beta.2

package/dist/{session-subscriptions-BV7MxYiL.mjs → session-subscriptions-uKmTyc3P.mjs}

@@ -1,4 +1,4 @@
-import { clearGatewayConnectTimeout, startGatewayConnectTimeout } from "./timeouts.mjs";
+import { 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);
@@ -139,7 +139,8 @@ var GatewayBrowserDeviceAuthLifecycle = class {
 			scopes,
 			auth: buildGatewayConnectAuth(selectedAuth)
 		};
-		const signedAtMs = this.deps.nowMs?.() ?? Date.now();
+		const signedAtMs = params.challengeTs === void 0 ? this.deps.nowMs?.() ?? Date.now() : params.challengeTs;
+		if (typeof signedAtMs !== "number" || !Number.isSafeInteger(signedAtMs) || signedAtMs < 0) throw new Error("gateway connect challenge timestamp invalid");
 		const nonce = params.nonce ?? "";
 		const { authBootstrapToken: primary, signatureToken: signed } = selectedAuth;
 		let token = null;
@@ -176,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) {
@@ -194,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) {
@@ -214,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) {
@@ -276,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) {
@@ -403,7 +432,7 @@ var GatewayEventListeners = class {
 	}
 };
 //#endregion
-//#region packages/gateway-client/src/protocol-client.ts
+//#region packages/gateway-client/src/protocol-request.ts
 var GatewayProtocolRequestError = class extends Error {
 	constructor(error) {
 		super(error.message ?? "request failed");
@@ -415,6 +444,167 @@ 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.retiredIds = /* @__PURE__ */ new Set();
+		this.collisionSuffix = 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);
+				this.retiredIds.add(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.retiredIds.clear();
+		this.collisionSuffix = 0;
+	}
+	allocateRequestId() {
+		const id = this.opts.createRequestId();
+		if (!this.pending.has(id) && !this.retiredIds.has(id)) return id;
+		let uniqueId;
+		do {
+			this.collisionSuffix += 1;
+			uniqueId = `${id}:${this.collisionSuffix}`;
+		} while (this.pending.has(uniqueId) || this.retiredIds.has(uniqueId));
+		return uniqueId;
+	}
+	finishTiming(id, pending, ok, errorCode) {
+		const endedAtMs = this.opts.nowMs();
+		this.invoke("request timing", () => this.opts.onTiming?.({
+			id,
+			method: pending.method,
+			ok,
+			durationMs: Math.max(0, endedAtMs - pending.startedAtMs),
+			startedAtMs: pending.startedAtMs,
+			endedAtMs,
+			errorCode
+		}));
+	}
+	invoke(label, callback) {
+		try {
+			callback();
+		} catch (error) {
+			this.opts.onCallbackError?.(label, error);
+		}
+	}
+};
+//#endregion
+//#region packages/gateway-client/src/protocol-client.ts
 /**
 * Browser-safe gateway wire client. Environment adapters own transport and auth
 * policy; this class owns the single socket/handshake/reconnect/frame state machine.
@@ -423,7 +613,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;
@@ -442,18 +631,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;
@@ -474,68 +673,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;
-			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);
-				if (timeout) clearTimeout(timeout);
-				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(() => {
-					this.pending.delete(id);
-					options?.signal?.removeEventListener("abort", onAbort);
-					this.finishRequestTiming(id, pending, false, "CLIENT_TIMEOUT");
-					reject(this.opts.createRequestTimeoutError?.(method, timeoutMs) ?? /* @__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
-				}));
-				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);
@@ -571,6 +716,7 @@ var GatewayProtocolClient = class {
 		const generation = this.generation + 1;
 		this.lastSeq = null;
 		this.connectNonce = null;
+		this.connectChallengeTs = void 0;
 		this.connectSent = this.connectRequestSent = false;
 		this.socketOpened = false;
 		this.helloReceived = false;
@@ -641,6 +787,7 @@ var GatewayProtocolClient = class {
 		try {
 			planOrPromise = this.opts.buildConnectPlan({
 				nonce: this.connectNonce,
+				challengeTs: this.connectChallengeTs,
 				generation
 			});
 		} catch (error) {
@@ -669,6 +816,7 @@ var GatewayProtocolClient = class {
 		const context = {
 			generation,
 			nonce: this.connectNonce,
+			challengeTs: this.connectChallengeTs,
 			plan
 		};
 		this.recordTiming("connect-plan-ready", generation, plan);
@@ -721,6 +869,8 @@ var GatewayProtocolClient = class {
 					return;
 				}
 				this.connectNonce = nonce;
+				const challengeTs = payload?.ts;
+				this.connectChallengeTs = typeof challengeTs === "number" && Number.isSafeInteger(challengeTs) && challengeTs >= 0 ? challengeTs : null;
 				this.recordTiming("challenge", generation);
 				this.sendConnect(socket, generation);
 				return;
@@ -747,28 +897,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) {
@@ -796,34 +925,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();
@@ -873,6 +983,7 @@ const NON_RECOVERABLE_AUTH_ERRORS = /* @__PURE__ */ new Set([
 	ConnectErrorDetailCodes.AUTH_RATE_LIMITED,
 	ConnectErrorDetailCodes.AUTH_DEVICE_TOKEN_MISMATCH,
 	ConnectErrorDetailCodes.AUTH_SCOPE_MISMATCH,
+	ConnectErrorDetailCodes.CONTROL_UI_BUILD_MISMATCH,
 	ConnectErrorDetailCodes.PAIRING_REQUIRED,
 	ConnectErrorDetailCodes.CONTROL_UI_DEVICE_IDENTITY_REQUIRED,
 	ConnectErrorDetailCodes.DEVICE_IDENTITY_REQUIRED
@@ -886,7 +997,47 @@ function shouldPauseGatewayReconnect(params) {
 	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-run-event.ts
+function readNonemptyString$1(value) {
+	return typeof value === "string" ? value.trim() || null : null;
+}
+function reduceSessionProjectionRunEventImpl(projection, event, scope = {}) {
+	const runId = readNonemptyString$1(event.runId);
+	if (!runId || typeof event.state !== "string" || ![
+		"delta",
+		"final",
+		"error",
+		"aborted"
+	].includes(event.state)) return null;
+	const message = event.message;
+	const messageStopReason = message !== null && typeof message === "object" && !Array.isArray(message) ? readNonemptyString$1(message.stopReason) : null;
+	const stopReason = readNonemptyString$1(event.stopReason) ?? messageStopReason;
+	const errorKind = readNonemptyString$1(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 = [
@@ -1000,13 +1151,16 @@ 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;
+	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) 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;
 	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 {
@@ -1188,7 +1342,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);
@@ -1234,38 +1394,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
@@ -1473,4 +1602,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, 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, GatewayProtocolRequestTimeoutError as v, selectGatewayConnectAuth as w, GatewayBrowserDeviceAuthLifecycle as x, gatewayCredentialScope as y };

package/dist/timeouts.mjs

@@ -1,5 +1,5 @@
 //#region packages/gateway-client/src/timeouts.ts
-function parseStrictPositiveInteger(value) {
+function parsePositiveTimeoutSetting(value) {
 	const trimmed = value.trim();
 	if (!/^\+?\d+$/u.test(trimmed)) return;
 	const parsed = Number(trimmed);
@@ -53,7 +53,7 @@ function clampConnectChallengeTimeoutMs(timeoutMs, maxTimeoutMs = MAX_CONNECT_CH
 function getConnectChallengeTimeoutMsFromEnv(env = process.env) {
 	const raw = env.OPENCLAW_CONNECT_CHALLENGE_TIMEOUT_MS;
 	if (raw) {
-		const parsed = parseStrictPositiveInteger(raw);
+		const parsed = parsePositiveTimeoutSetting(raw);
 		if (parsed !== void 0) return resolveSafeTimeoutDelayMs(parsed);
 	}
 }
@@ -77,7 +77,7 @@ function resolvePreauthHandshakeTimeoutMs(params) {
 	const env = params?.env ?? process.env;
 	const configuredTimeout = env.OPENCLAW_HANDSHAKE_TIMEOUT_MS || (isTestRuntimeEnv(env) ? env.OPENCLAW_TEST_HANDSHAKE_TIMEOUT_MS : void 0);
 	if (configuredTimeout) {
-		const parsed = parseStrictPositiveInteger(configuredTimeout);
+		const parsed = parsePositiveTimeoutSetting(configuredTimeout);
 		if (parsed !== void 0) return resolveSafeTimeoutDelayMs(parsed);
 	}
 	const configured = normalizePositiveTimeoutMs(params?.configuredTimeoutMs);

package/dist/websocket-data.d.mts

@@ -0,0 +1,6 @@
+import { RawData } from "ws";
+
+//#region packages/gateway-client/src/websocket-data.d.ts
+declare function rawDataToString(data: RawData, encoding?: BufferEncoding): string;
+//#endregion
+export { rawDataToString };

package/dist/websocket-data.mjs

@@ -0,0 +1,8 @@
+import { Buffer } from "node:buffer";
+//#region packages/gateway-client/src/websocket-data.ts
+function rawDataToString(data, encoding = "utf8") {
+	if (Array.isArray(data)) return Buffer.concat(data).toString(encoding);
+	return data instanceof ArrayBuffer ? Buffer.from(data).toString(encoding) : data.toString(encoding);
+}
+//#endregion
+export { rawDataToString };