@openclaw/gateway-client 2026.7.2-beta.4 → 2026.7.2-beta.6

package/dist/{reconnect-policy-CkzLe1_K.mjs → session-subscriptions-BV7MxYiL.mjs}

@@ -1,3 +1,4 @@
+import { clearGatewayConnectTimeout, 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
@@ -381,6 +382,27 @@ function createRetryRunner(runtime = {}) {
 }
 createRetryRunner();
 //#endregion
+//#region packages/gateway-client/src/event-listeners.ts
+/** Subscription identity prevents old frames and disposers from reviving callbacks. */
+var GatewayEventListeners = class {
+	constructor() {
+		this.listeners = /* @__PURE__ */ new Map();
+	}
+	add(listener) {
+		const subscription = this.listeners.get(listener) ?? {};
+		this.listeners.set(listener, subscription);
+		return () => {
+			if (this.listeners.get(listener) === subscription) this.listeners.delete(listener);
+		};
+	}
+	snapshot() {
+		return [...this.listeners];
+	}
+	isCurrent(listener, subscription) {
+		return this.listeners.get(listener) === subscription;
+	}
+};
+//#endregion
 //#region packages/gateway-client/src/protocol-client.ts
 var GatewayProtocolRequestError = class extends Error {
 	constructor(error) {
@@ -402,7 +424,7 @@ var GatewayProtocolClient = class {
 		this.opts = opts;
 		this.socket = null;
 		this.pending = /* @__PURE__ */ new Map();
-		this.listeners = /* @__PURE__ */ new Set();
+		this.listeners = new GatewayEventListeners();
 		this.stopped = true;
 		this.generation = 0;
 		this.lastSeq = null;
@@ -410,6 +432,7 @@ var GatewayProtocolClient = class {
 		this.connectSent = false;
 		this.connectRequestSent = false;
 		this.handshakeTimer = null;
+		this.reconnectSignal = null;
 		this.socketOpened = false;
 		this.helloReceived = false;
 		this.connectTiming = null;
@@ -433,6 +456,7 @@ var GatewayProtocolClient = class {
 		return [...this.pending.values()].some((pending) => pending.unbounded);
 	}
 	start() {
+		if (this.socket || this.reconnectSignal) return;
 		this.stopped = false;
 		this.reconnectSupervisor.cancel();
 		this.connect();
@@ -440,6 +464,7 @@ var GatewayProtocolClient = class {
 	stop() {
 		this.stopped = true;
 		this.clearHandshakeTimer();
+		this.reconnectSignal = null;
 		this.reconnectSupervisor.reset();
 		const socket = this.socket;
 		if (socket && this.opts.notifyStoppedClose) this.stoppedSocket = {
@@ -513,13 +538,13 @@ var GatewayProtocolClient = class {
 		});
 	}
 	addEventListener(listener) {
-		this.listeners.add(listener);
-		return () => this.listeners.delete(listener);
+		return this.listeners.add(listener);
 	}
 	closeSocket(code, reason) {
 		this.socket?.close(code, reason);
 	}
 	resetReconnectBackoff(initialMs) {
+		this.reconnectSignal = null;
 		this.reconnectSupervisor.reset(initialMs);
 	}
 	recordTiming(phase, generation, plan, detail) {
@@ -544,9 +569,9 @@ var GatewayProtocolClient = class {
 	connect() {
 		if (this.stopped) return;
 		const generation = this.generation + 1;
+		this.lastSeq = null;
 		this.connectNonce = null;
-		this.connectSent = false;
-		this.connectRequestSent = false;
+		this.connectSent = this.connectRequestSent = false;
 		this.socketOpened = false;
 		this.helloReceived = false;
 		this.connectFailure = void 0;
@@ -563,6 +588,7 @@ var GatewayProtocolClient = class {
 			this.opts.onSocketFactoryError?.(normalized);
 			this.opts.onConnectError?.(normalized);
 			if (this.opts.rethrowSocketFactoryError?.(normalized)) throw normalized;
+			if (this.opts.shouldRetrySocketFactoryError?.(normalized) && !this.stopped && !this.socket && !this.reconnectSignal) this.scheduleReconnect();
 			return;
 		}
 		this.generation = generation;
@@ -608,6 +634,9 @@ var GatewayProtocolClient = class {
 		if (!this.isActive(socket, generation) || !socket.isOpen() || this.connectSent) return;
 		this.connectSent = true;
 		this.clearHandshakeTimer();
+		this.handshakeTimer = startGatewayConnectTimeout(() => {
+			if (this.isActive(socket, generation) && !this.helloReceived) socket.close(4e3, "connect timeout");
+		});
 		let planOrPromise;
 		try {
 			planOrPromise = this.opts.buildConnectPlan({
@@ -648,6 +677,7 @@ var GatewayProtocolClient = class {
 		this.request("connect", this.opts.buildConnectParams(plan)).then((hello) => {
 			if (!this.isActive(socket, generation)) return;
 			this.helloReceived = true;
+			this.clearHandshakeTimer();
 			this.connectFailure = void 0;
 			this.reconnectSupervisor.reset();
 			this.recordTiming("hello", generation, plan);
@@ -703,11 +733,16 @@ var GatewayProtocolClient = class {
 						expected,
 						received: seq
 					}));
+					if (!this.isActive(socket, generation)) return;
 				}
 				this.lastSeq = seq;
 			}
+			const listeners = this.listeners.snapshot();
 			this.invoke("event", () => this.opts.onEvent?.(parsed));
-			for (const listener of this.listeners) this.invoke("event listener", () => listener(parsed));
+			for (const [listener, subscription] of listeners) {
+				if (!this.isActive(socket, generation)) return;
+				if (this.listeners.isCurrent(listener, subscription)) this.invoke("event listener", () => listener(parsed));
+			}
 			return;
 		}
 		if (!isGatewayResponseFrame(parsed)) return;
@@ -793,7 +828,14 @@ var GatewayProtocolClient = class {
 		if (overrideMs !== void 0) this.reconnectSupervisor.nextDelayOverrideMs = overrideMs;
 		const retry = this.reconnectSupervisor.next();
 		if (!retry) return;
-		sleepWithAbort(retry.delayMs, retry.signal).then(() => this.connect(), () => {});
+		this.reconnectSignal = retry.signal;
+		sleepWithAbort(retry.delayMs, retry.signal).then(() => {
+			if (this.reconnectSignal !== retry.signal) return;
+			this.reconnectSignal = null;
+			this.connect();
+		}, () => {
+			if (this.reconnectSignal === retry.signal) this.reconnectSignal = null;
+		});
 	}
 	closeContext() {
 		return {
@@ -811,10 +853,7 @@ var GatewayProtocolClient = class {
 		return this.opts.nowMs?.() ?? Date.now();
 	}
 	clearHandshakeTimer() {
-		if (this.handshakeTimer) {
-			clearTimeout(this.handshakeTimer);
-			this.handshakeTimer = null;
-		}
+		this.handshakeTimer = clearGatewayConnectTimeout(this.handshakeTimer);
 	}
 	invoke(label, callback) {
 		try {
@@ -847,4 +886,591 @@ 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
-export { buildGatewayConnectAuth as a, shouldRetryGatewayWithDeviceToken as c, normalizeDeviceMetadataForAuth as d, GatewayBrowserDeviceAuthLifecycle as i, buildDeviceAuthPayload as l, GatewayProtocolClient as n, resolveGatewayConnectScopes as o, GatewayProtocolRequestError as r, selectGatewayConnectAuth as s, shouldPauseGatewayReconnect as t, buildDeviceAuthPayloadV3 as u };
+//#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;
+}
+function readNonemptyString(value) {
+	return typeof value === "string" ? value.trim() || null : null;
+}
+function readPositiveSafeInteger(value) {
+	return typeof value === "number" && Number.isSafeInteger(value) && value > 0 ? value : null;
+}
+/** 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);
+}
+/** Run ownership normalizes a user-turn suffix without changing its persisted send key. */
+function normalizeSessionProjectionRunId(value) {
+	const runId = readNonemptyString(value);
+	return runId?.endsWith(":user") ? runId.slice(0, -5) || null : runId;
+}
+/** Persisted transcript facts win over envelope projections and provider-local import IDs. */
+function readSessionMessageIdentity(message, envelope) {
+	const record = readRecord(message);
+	const role = readNonemptyString(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);
+	return {
+		role,
+		id: readNonemptyString(metadata?.id) ?? readNonemptyString(envelope?.messageId),
+		sequence: readSessionMessageSequence(message, envelope),
+		idempotencyKey,
+		runId: normalizeSessionProjectionRunId(idempotencyKey) ?? normalizeSessionProjectionRunId(envelope?.runId),
+		isImported: Boolean(importedFrom || cliSessionId || externalId),
+		externalSource: importedFrom && cliSessionId && externalId ? JSON.stringify([
+			importedFrom,
+			cliSessionId,
+			externalId
+		]) : null
+	};
+}
+/** 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"]);
+	return !metadata || Object.keys(metadata).every((key) => key === "idempotencyKey");
+}
+function createEntry(message, options) {
+	const identity = readSessionMessageIdentity(message, options?.envelope);
+	const inferredPendingRunId = options?.live !== true && isLocallyOptimisticSessionMessage(message) ? identity?.runId : null;
+	const pendingRunId = normalizeSessionProjectionRunId(options?.pendingRunId ?? inferredPendingRunId);
+	return {
+		message,
+		identity,
+		live: options?.live === true,
+		pending: pendingRunId !== null,
+		pendingRunId
+	};
+}
+function createProjectionEntries(messages) {
+	let pendingUserRunId = null;
+	return messages.map((message) => {
+		const entry = createEntry(message);
+		if (entry.identity?.role === "user") {
+			pendingUserRunId = entry.pending ? entry.pendingRunId : null;
+			return entry;
+		}
+		if (pendingUserRunId && entry.identity?.role === "assistant" && !entry.pending && isLocallyOptimisticSessionMessage(message)) return createEntry(message, { pendingRunId: pendingUserRunId });
+		if (!isLocallyOptimisticSessionMessage(message)) pendingUserRunId = null;
+		return entry;
+	});
+}
+function createSessionProjection(scope = {}, messages = []) {
+	const entries = createProjectionEntries(messages);
+	return {
+		scope: { ...scope },
+		entries,
+		messages: entries.map((entry) => entry.message),
+		runs: {},
+		hasTransportGap: false
+	};
+}
+function scopesMatch(left, right) {
+	return SESSION_PROJECTION_SCOPE_KEYS.every((key) => left[key] === void 0 || right[key] === void 0 || left[key] === right[key]);
+}
+function readEventScope(event) {
+	const scope = { ...event.scope };
+	for (const key of SESSION_PROJECTION_SCOPE_KEYS) if (event[key] !== void 0) Object.assign(scope, { [key]: event[key] });
+	return scope;
+}
+function sameTranscriptIdentity(left, right) {
+	if (!left || !right || left.role !== right.role) return false;
+	if (left.isImported || right.isImported) {
+		if (!left.isImported || !right.isImported) return false;
+		if (left.externalSource || right.externalSource) return Boolean(left.externalSource && left.externalSource === right.externalSource);
+		return left.sequence !== null && right.sequence !== null && left.sequence === right.sequence;
+	}
+	if (left.id || right.id) return Boolean(left.id && right.id && left.id === right.id);
+	return left.sequence !== null && right.sequence !== null && left.sequence === right.sequence;
+}
+function entryMatches(left, right, allowSnapshotPromotion = false) {
+	if (sameTranscriptIdentity(left.identity, right.identity)) 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);
+}
+function withEntries(state, entries) {
+	return {
+		...state,
+		entries,
+		messages: entries.map((entry) => entry.message)
+	};
+}
+function insertEntry(entries, incoming, runs) {
+	const sequence = incoming.identity?.sequence;
+	let nextIndex = sequence === void 0 || sequence === null ? -1 : entries.findIndex((entry) => {
+		const candidate = entry.identity?.sequence;
+		return candidate !== void 0 && candidate !== null && candidate > sequence;
+	});
+	if (nextIndex < 0 && incoming.identity?.role === "user" && incoming.identity.runId) {
+		const runId = incoming.identity.runId;
+		const terminalMessage = runs?.[runId]?.message;
+		nextIndex = entries.findIndex((entry) => entry.identity?.role === "assistant" && (entry.identity.runId === runId || entry.message === terminalMessage));
+	}
+	return nextIndex < 0 ? [...entries, incoming] : [
+		...entries.slice(0, nextIndex),
+		incoming,
+		...entries.slice(nextIndex)
+	];
+}
+function projectLiveSessionMessage(state, message, envelope, scope = {}) {
+	if (!scopesMatch(state.scope, scope)) return state;
+	const incoming = createEntry(message, {
+		envelope,
+		live: true
+	});
+	if (!incoming.identity) return state;
+	const existingIndex = state.entries.findIndex((entry) => entryMatches(entry, incoming));
+	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?.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));
+	}
+	return withEntries(state, [
+		...state.entries.slice(0, existingIndex),
+		incoming,
+		...state.entries.slice(existingIndex + 1)
+	]);
+}
+/** Only observed live events and this client's pending turns may survive an older snapshot. */
+function reconcileSessionProjectionSnapshot(state, messages, scope = {}, options = {}) {
+	const visibleMessages = options.shouldIncludeMessage ? messages.filter(options.shouldIncludeMessage) : messages;
+	if (!scopesMatch(state.scope, scope)) return createSessionProjection(scope, visibleMessages);
+	let entries = createProjectionEntries(visibleMessages);
+	for (const current of state.entries) {
+		if (!current.live && !current.pending || options.shouldIncludeMessage?.(current.message) === false || entries.filter((entry) => entryMatches(entry, current, true)).length === 1) continue;
+		entries = insertEntry(entries, current, state.runs);
+	}
+	return {
+		...withEntries(state, entries),
+		scope: {
+			...state.scope,
+			...scope
+		},
+		hasTransportGap: false
+	};
+}
+function hasDisplayableSessionMessage(message) {
+	if (typeof message === "string") return message.trim().length > 0;
+	const record = readRecord(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 media = readRecord(record["__openclaw"])?.media;
+	return Boolean(typeof record.content === "string" && record.content.trim() || displayableBlocks || Array.isArray(media) && media.length > 0);
+}
+function readSessionProjectionFinalMessageIdentity(message) {
+	if (!hasDisplayableSessionMessage(message)) return null;
+	const identity = readSessionMessageIdentity(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"]);
+	try {
+		return `content:${JSON.stringify([
+			identity?.role ?? "assistant",
+			typeof message === "string" ? message : record?.content ?? null,
+			metadata?.media ?? null,
+			identity?.isImported ? [
+				metadata?.importedFrom ?? null,
+				metadata?.cliSessionId ?? null,
+				metadata?.externalId ?? null
+			] : null
+		])}`;
+	} catch {
+		return null;
+	}
+}
+/** Replayed finals are recognized against this run's bounded canonical terminal history. */
+function hasSessionProjectionAcceptedFinal(run, message) {
+	const identity = readSessionProjectionFinalMessageIdentity(message);
+	return Boolean(identity && run && (run.acceptedFinalMessageIdentities?.includes(identity) || readSessionProjectionFinalMessageIdentity(run.message) === identity));
+}
+function retainSessionProjectionRuns(runs) {
+	const entries = Object.entries(runs);
+	if (entries.length <= MAX_TRACKED_SESSION_RUNS) return runs;
+	const active = entries.filter(([, run]) => run.status === "streaming");
+	const terminal = entries.filter(([, run]) => run.status !== "streaming");
+	const terminalLimit = Math.max(0, RETAINED_SESSION_RUNS - active.length);
+	const retainedTerminal = terminalLimit > 0 ? terminal.slice(-terminalLimit) : [];
+	return Object.fromEntries([...active, ...retainedTerminal]);
+}
+function updateRun(state, incoming) {
+	const incomingErrorMessage = readNonemptyString(incoming.errorMessage);
+	const normalizedIncoming = { ...incoming };
+	if (incomingErrorMessage) normalizedIncoming.errorMessage = incomingErrorMessage;
+	else delete normalizedIncoming.errorMessage;
+	const current = state.runs[incoming.runId];
+	if (current && current.status !== "streaming") {
+		const incomingFinalIdentity = readSessionProjectionFinalMessageIdentity(incoming.message);
+		const incomingIsFinal = incoming.status === "completed" || incoming.status === "yielded";
+		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;
+		if (!acceptFinal && !recoverError) return state;
+		const firstFinalIdentity = readSessionProjectionFinalMessageIdentity(current.message);
+		const previousFinalIdentities = current.acceptedFinalMessageIdentities ?? (firstFinalIdentity ? [firstFinalIdentity] : []);
+		return {
+			...state,
+			runs: {
+				...state.runs,
+				[incoming.runId]: {
+					...current,
+					...recoverMessage ? { message: incoming.message } : {},
+					...acceptFinal && incomingFinalIdentity ? { acceptedFinalMessageIdentities: [...previousFinalIdentities, incomingFinalIdentity].slice(-32) } : {},
+					...recoverError && incomingErrorMessage ? {
+						errorMessage: incomingErrorMessage,
+						...incoming.errorKind ? { errorKind: incoming.errorKind } : {}
+					} : {}
+				}
+			}
+		};
+	}
+	const previousRuns = current && current.status === "streaming" && incoming.status !== "streaming" ? Object.fromEntries(Object.entries(state.runs).filter(([runId]) => runId !== incoming.runId)) : state.runs;
+	const acceptedFinalIdentity = incoming.status === "completed" || incoming.status === "yielded" ? readSessionProjectionFinalMessageIdentity(incoming.message) : null;
+	return {
+		...state,
+		runs: retainSessionProjectionRuns({
+			...previousRuns,
+			[incoming.runId]: {
+				...current,
+				...normalizedIncoming,
+				...acceptedFinalIdentity ? { acceptedFinalMessageIdentities: [acceptedFinalIdentity] } : {},
+				...incoming.message === void 0 && current?.message !== void 0 ? { message: current.message } : {}
+			}
+		})
+	};
+}
+/** Reduces durable events, snapshots, and transport lifecycle without client-specific policy. */
+function reduceSessionProjection(state, event) {
+	const scope = readEventScope(event);
+	if (event.type === "snapshotLoaded") return scopesMatch(state.scope, scope) ? reconcileSessionProjectionSnapshot(state, event.messages, scope, event.options) : state;
+	if (event.type === "sessionReset") {
+		const { sessionKey, sessionId, agentId } = state.scope;
+		return scopesMatch({
+			sessionKey,
+			sessionId,
+			agentId
+		}, scope) ? createSessionProjection({
+			...state.scope,
+			...scope
+		}) : state;
+	}
+	if (!scopesMatch(state.scope, scope)) return state;
+	switch (event.type) {
+		case "messagePersisted": return projectLiveSessionMessage(state, event.message, event.envelope ?? event, scope);
+		case "sendPending": {
+			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;
+		}
+		case "sendAcknowledged": {
+			const runId = normalizeSessionProjectionRunId(event.idempotencyKey ?? event.runId);
+			const previousRunId = normalizeSessionProjectionRunId(event.previousRunId);
+			if (!runId || !previousRunId || previousRunId === runId) return state;
+			let changed = false;
+			const entries = state.entries.flatMap((entry) => {
+				if (!entry.pending || entry.pendingRunId !== previousRunId) return [entry];
+				changed = true;
+				const rekeyed = {
+					...entry,
+					pendingRunId: runId
+				};
+				return state.entries.some((candidate) => !candidate.pending && entryMatches(rekeyed, candidate)) ? [] : [rekeyed];
+			});
+			return changed ? withEntries(state, entries) : state;
+		}
+		case "sendFailed": {
+			const runId = normalizeSessionProjectionRunId(event.runId);
+			const entries = state.entries.filter((entry) => !entry.pending || entry.pendingRunId !== runId);
+			return entries.length === state.entries.length ? state : withEntries(state, entries);
+		}
+		case "runDelta": return updateRun(state, {
+			runId: event.runId,
+			status: "streaming",
+			...event.message === void 0 ? {} : { message: event.message }
+		});
+		case "runTerminal": return updateRun(state, {
+			runId: event.runId,
+			status: event.status,
+			...event.message === void 0 ? {} : { message: event.message },
+			...event.stopReason === void 0 ? {} : { stopReason: event.stopReason },
+			...event.errorKind === void 0 ? {} : { errorKind: event.errorKind },
+			...event.errorMessage === void 0 ? {} : { errorMessage: event.errorMessage }
+		});
+		case "transportGap": return state.hasTransportGap ? state : {
+			...state,
+			hasTransportGap: true
+		};
+		case "reconnected": return state;
+		default: return state;
+	}
+}
+/** 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]
+	};
+}
+//#endregion
+//#region packages/gateway-client/src/session-subscriptions.ts
+function sessionSubscriptionParams(key, agentId) {
+	return {
+		key: key.trim(),
+		...agentId ? { agentId } : {}
+	};
+}
+/**
+* One Gateway connection owns one targeted observer per canonical session.
+* Approval delivery is an upgrade of that observer, never a second observer.
+*/
+var GatewaySessionMessageSubscriptionCoordinator = class {
+	#client;
+	#keysEquivalent;
+	#entries = /* @__PURE__ */ new Set();
+	#retired = false;
+	constructor(client, options = {}) {
+		this.#client = client;
+		this.#keysEquivalent = options.keysEquivalent;
+	}
+	configure(options = {}) {
+		const matcher = options.keysEquivalent;
+		if (!matcher || matcher === this.#keysEquivalent) return this;
+		if (this.#keysEquivalent || this.#entries.size > 0) throw new Error("Session message key equivalence cannot change for an active connection");
+		this.#keysEquivalent = matcher;
+		return this;
+	}
+	async acquire(key, options = {}) {
+		const normalizedKey = key.trim();
+		if (!normalizedKey) throw new Error("Session message subscription requires a session key");
+		const agentId = options.agentId?.trim() || null;
+		let entry;
+		while (true) {
+			if (this.#retired) throw new Error("Session message subscription belongs to a replaced Gateway connection");
+			const existing = [...this.#entries].find((candidate) => candidate.agentId === agentId && (this.#areKeysEquivalent(candidate.key, normalizedKey) || [...candidate.requestedKeys].some((requestedKey) => this.#areKeysEquivalent(requestedKey, normalizedKey))));
+			if (!existing) {
+				const provisional = [...this.#entries].find((candidate) => candidate.agentId === agentId && !candidate.canonicalSettled);
+				if (provisional) {
+					await (provisional.plainFallback ?? provisional.ready).catch(() => void 0);
+					continue;
+				}
+				entry = this.#createEntry(normalizedKey, agentId, options.includeApprovals === true);
+				break;
+			}
+			if (!existing.release) {
+				entry = existing;
+				entry.requestedKeys.add(normalizedKey);
+				break;
+			}
+			await existing.release.catch(() => void 0);
+		}
+		entry.pendingOwners += 1;
+		try {
+			const result = await this.#acquireCapability(entry, options.includeApprovals === true);
+			if (this.#retired) throw new Error("Session message subscription completed on a replaced Gateway connection");
+			const subscription = {
+				key: result.key,
+				agentId,
+				...options.includeApprovals === true ? {
+					includeApprovals: true,
+					...result.approvalReplay !== void 0 ? { approvalReplay: result.approvalReplay } : {}
+				} : {}
+			};
+			entry.handles.add(subscription);
+			sessionMessageSubscriptionOwners.set(subscription, {
+				coordinator: this,
+				entry
+			});
+			return subscription;
+		} finally {
+			entry.pendingOwners -= 1;
+			if (entry.pendingOwners === 0 && entry.handles.size === 0 && !entry.release) this.#entries.delete(entry);
+		}
+	}
+	release(subscription) {
+		const owner = sessionMessageSubscriptionOwners.get(subscription);
+		if (!owner || owner.coordinator !== this) return Promise.resolve();
+		const { entry } = owner;
+		if (this.#retired || entry.handles.size > 1) {
+			this.#finishRelease(subscription, owner);
+			return Promise.resolve();
+		}
+		if (entry.release) return entry.release;
+		if (entry.pendingOwners > 0) {
+			const pending = [entry.ready, ...entry.approvalRequest ? [entry.approvalRequest] : []];
+			const tracked = Promise.allSettled(pending).then(() => {
+				if (entry.release === tracked) entry.release = null;
+				return this.release(subscription);
+			});
+			entry.release = tracked;
+			return tracked;
+		}
+		const tracked = this.#client.request("sessions.messages.unsubscribe", sessionSubscriptionParams(entry.key, entry.agentId)).then(() => {
+			this.#finishRelease(subscription, owner, true);
+		}).finally(() => {
+			if (entry.release === tracked) entry.release = null;
+		});
+		entry.release = tracked;
+		return tracked;
+	}
+	/** A reconnect retires leases without touching the next connection's observers. */
+	reset() {
+		this.#retired = true;
+		for (const entry of this.#entries) for (const subscription of entry.handles) {
+			const owner = sessionMessageSubscriptionOwners.get(subscription);
+			if (owner?.coordinator === this) this.#finishRelease(subscription, owner);
+		}
+		this.#entries.clear();
+	}
+	#createEntry(key, agentId, includeApprovals) {
+		const entry = {
+			key,
+			requestedKeys: /* @__PURE__ */ new Set([key]),
+			agentId,
+			ready: Promise.resolve({ key }),
+			approvalRequest: null,
+			approvalResponse: null,
+			plainFallback: null,
+			canonicalSettled: false,
+			handles: /* @__PURE__ */ new Set(),
+			pendingOwners: 0,
+			release: null
+		};
+		entry.ready = this.#requestSubscribe(entry, includeApprovals).then((result) => {
+			entry.key = result.key;
+			entry.canonicalSettled = true;
+			if (includeApprovals) entry.approvalResponse = result;
+			return result;
+		});
+		if (includeApprovals) entry.approvalRequest = entry.ready;
+		entry.ready.catch(() => void 0);
+		this.#entries.add(entry);
+		return entry;
+	}
+	#acquireCapability(entry, includeApprovals) {
+		if (!includeApprovals) {
+			if (entry.approvalRequest === entry.ready && !entry.approvalResponse) {
+				if (!entry.plainFallback) {
+					const approvalRequest = entry.ready;
+					entry.plainFallback = approvalRequest.catch(async (error) => {
+						if (this.#retired) throw error;
+						const result = await this.#requestSubscribe(entry, false);
+						entry.key = result.key;
+						entry.canonicalSettled = true;
+						entry.ready = Promise.resolve(result);
+						if (entry.approvalRequest === approvalRequest) entry.approvalRequest = null;
+						return result;
+					});
+				}
+				return entry.plainFallback;
+			}
+			return entry.ready;
+		}
+		if (entry.approvalResponse) return Promise.resolve(entry.approvalResponse);
+		if (entry.approvalRequest) return entry.approvalRequest;
+		const upgrade = entry.ready.then(() => this.#requestSubscribe(entry, true)).then((result) => {
+			entry.key = result.key;
+			entry.approvalResponse = result;
+			return result;
+		});
+		entry.approvalRequest = upgrade;
+		upgrade.catch(() => {
+			if (entry.approvalRequest === upgrade) entry.approvalRequest = null;
+		});
+		return upgrade;
+	}
+	async #requestSubscribe(entry, includeApprovals) {
+		const result = await this.#client.request("sessions.messages.subscribe", {
+			...sessionSubscriptionParams(entry.key, entry.agentId),
+			...includeApprovals ? { includeApprovals: true } : {}
+		});
+		const response = result && typeof result === "object" ? result : null;
+		const responseKey = response && "key" in response ? response.key : void 0;
+		return {
+			key: typeof responseKey === "string" && responseKey.trim() ? responseKey.trim() : entry.key,
+			...response && "approvalReplay" in response ? { approvalReplay: response.approvalReplay } : {}
+		};
+	}
+	#finishRelease(subscription, owner, removeEntry = false) {
+		if (sessionMessageSubscriptionOwners.get(subscription) !== owner) return;
+		sessionMessageSubscriptionOwners.delete(subscription);
+		owner.entry.handles.delete(subscription);
+		if (removeEntry) this.#entries.delete(owner.entry);
+	}
+	#areKeysEquivalent(left, right) {
+		return left === right || this.#keysEquivalent?.(left, right) === true;
+	}
+};
+const sessionMessageSubscriptionOwners = /* @__PURE__ */ new WeakMap();
+const sessionMessageSubscriptionCoordinators = /* @__PURE__ */ new WeakMap();
+function getGatewaySessionMessageSubscriptionCoordinator(client, options = {}) {
+	const existing = sessionMessageSubscriptionCoordinators.get(client);
+	if (existing) return existing.configure(options);
+	const coordinator = new GatewaySessionMessageSubscriptionCoordinator(client, options);
+	sessionMessageSubscriptionCoordinators.set(client, coordinator);
+	return coordinator;
+}
+function resetGatewaySessionMessageSubscriptionCoordinator(client) {
+	sessionMessageSubscriptionCoordinators.get(client)?.reset();
+	sessionMessageSubscriptionCoordinators.delete(client);
+}
+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 };