@openclaw/gateway-client 2026.9.3 → 2026.9.5

package/dist/{session-subscriptions-DwU8T0CH.mjs → session-subscriptions-DrOaOXNR.mjs}

@@ -225,6 +225,19 @@ function gatewayCredentialScope(gatewayUrl) {
 	return normalizeGatewayScope(gatewayUrl, true);
 }
 //#endregion
+//#region packages/gateway-client/src/model-catalog-connect.ts
+const MODEL_CATALOG_SNAPSHOT = "model-catalog-snapshot";
+/** A requested snapshot opts in only after the server advertises its connect field. */
+function resolveModelCatalogConnect(params) {
+	const modelCatalog = params.serverCapabilities.includes(MODEL_CATALOG_SNAPSHOT) ? params.modelCatalog : void 0;
+	const caps = params.caps?.filter((cap) => cap !== MODEL_CATALOG_SNAPSHOT);
+	if (modelCatalog === void 0) return { caps };
+	return {
+		modelCatalog,
+		caps: [...caps ?? [], MODEL_CATALOG_SNAPSHOT]
+	};
+}
+//#endregion
 //#region packages/retry/src/index.ts
 const MAX_TIMER_TIMEOUT_MS = 2147e6;
 function computeBackoff(policy, attempt) {
@@ -306,9 +319,16 @@ const DEFAULT_RETRY_CONFIG = {
 	maxDelayMs: 3e4,
 	jitter: 0
 };
-const defaultSleep = (ms) => new Promise((resolve) => {
-	setTimeout(resolve, ms);
-});
+const defaultSleep = async (ms) => {
+	let remainingMs = ms;
+	do {
+		const delayMs = Math.min(remainingMs, MAX_TIMER_TIMEOUT_MS);
+		await new Promise((resolve) => {
+			setTimeout(resolve, delayMs);
+		});
+		remainingMs -= delayMs;
+	} while (remainingMs > 0);
+};
 function clampNumber(value, fallback, min, max) {
 	const next = Number.isFinite(value) ? value : void 0;
 	if (next === void 0) return fallback;
@@ -630,8 +650,10 @@ var GatewayProtocolClient = class {
 		this.listeners = new GatewayEventListeners();
 		this.stopped = true;
 		this.generation = 0;
+		this.connectionAbort = null;
 		this.lastSeq = null;
 		this.connectNonce = null;
+		this.serverCapabilities = [];
 		this.connectSent = false;
 		this.connectRequestSent = false;
 		this.handshakeTimer = null;
@@ -676,6 +698,7 @@ var GatewayProtocolClient = class {
 	}
 	stop() {
 		this.stopped = true;
+		this.connectionAbort?.abort();
 		this.clearHandshakeTimer();
 		this.reconnectSignal = null;
 		this.reconnectSupervisor.reset();
@@ -700,6 +723,7 @@ var GatewayProtocolClient = class {
 		return this.listeners.add(listener);
 	}
 	closeSocket(code, reason) {
+		this.connectionAbort?.abort();
 		this.socket?.close(code, reason);
 	}
 	resetReconnectBackoff(initialMs) {
@@ -731,6 +755,7 @@ var GatewayProtocolClient = class {
 		this.lastSeq = null;
 		this.connectNonce = null;
 		this.connectChallengeTs = void 0;
+		this.serverCapabilities = [];
 		this.connectSent = this.connectRequestSent = false;
 		this.socketOpened = false;
 		this.helloReceived = false;
@@ -756,6 +781,7 @@ var GatewayProtocolClient = class {
 			return;
 		}
 		this.generation = generation;
+		this.connectionAbort = new AbortController();
 		this.socket = socket;
 		const now = this.nowMs();
 		this.connectTiming = {
@@ -806,7 +832,9 @@ var GatewayProtocolClient = class {
 			planOrPromise = this.opts.buildConnectPlan({
 				nonce: this.connectNonce,
 				challengeTs: this.connectChallengeTs,
-				generation
+				serverCapabilities: this.serverCapabilities,
+				generation,
+				...this.connectAuthority(socket, generation)
 			});
 		} catch (error) {
 			this.handleConnectPlanError(socket, generation, error);
@@ -819,7 +847,7 @@ var GatewayProtocolClient = class {
 		this.sendConnectPlan(socket, generation, planOrPromise);
 	}
 	handleConnectPlanError(socket, generation, error) {
-		if (!this.isActive(socket, generation)) return;
+		if (!this.isConnectCurrent(socket, generation)) return;
 		const normalized = error instanceof Error ? error : new Error(String(error));
 		const outcome = this.opts.onConnectPlanError?.(normalized) ?? {
 			closeCode: 1008,
@@ -830,8 +858,9 @@ var GatewayProtocolClient = class {
 		socket.close(outcome.closeCode, outcome.closeReason);
 	}
 	sendConnectPlan(socket, generation, plan) {
-		if (!this.isActive(socket, generation) || !socket.isOpen()) return;
+		if (!this.isConnectCurrent(socket, generation)) return;
 		const context = {
+			...this.connectAuthority(socket, generation),
 			generation,
 			nonce: this.connectNonce,
 			challengeTs: this.connectChallengeTs,
@@ -841,27 +870,43 @@ var GatewayProtocolClient = class {
 		this.recordTiming("request-sent", generation, plan);
 		this.connectRequestSent = true;
 		this.request("connect", this.opts.buildConnectParams(plan)).then((hello) => {
-			if (!this.isActive(socket, generation) || !socket.isOpen()) return;
+			if (!this.isConnectCurrent(socket, generation)) return;
 			this.helloReceived = true;
 			this.clearHandshakeTimer();
 			this.connectFailure = void 0;
 			this.reconnectSupervisor.reset();
 			this.recordTiming("hello", generation, plan);
-			this.opts.onConnectHello?.(hello, context);
-			this.invoke("hello", () => this.opts.onHello?.(hello));
+			const publishHello = () => {
+				if (!this.isConnectCurrent(socket, generation)) return;
+				this.invoke("hello", () => this.opts.onHello?.(hello));
+			};
+			const accepted = this.opts.onConnectHello?.(hello, context);
+			if (accepted instanceof Promise) return accepted.then(publishHello);
+			return publishHello();
 		}).catch((error) => {
 			if (!this.isActive(socket, generation)) return;
 			const requestError = error instanceof GatewayProtocolRequestError ? error : new GatewayProtocolRequestError({ message: String(error) });
+			this.connectFailure = { error: requestError };
 			const outcome = this.opts.onConnectFailure?.(requestError, context) ?? {
 				closeCode: 1008,
 				closeReason: "connect failed"
 			};
-			this.connectFailure = {
-				error: requestError,
-				reconnectDelayMs: outcome.reconnectDelayMs
+			const applyFailure = (decision) => {
+				if (!this.isActive(socket, generation)) return;
+				this.connectFailure = {
+					error: requestError,
+					reconnectDelayMs: decision.reconnectDelayMs
+				};
+				if (decision.stop) this.stopped = true;
+				this.connectionAbort?.abort();
+				socket.close(decision.closeCode, decision.closeReason);
 			};
-			if (outcome.stop) this.stopped = true;
-			socket.close(outcome.closeCode, outcome.closeReason);
+			if (outcome instanceof Promise) return outcome.then(applyFailure);
+			return applyFailure(outcome);
+		}).catch((error) => {
+			if (!this.isConnectCurrent(socket, generation)) return;
+			this.opts.onConnectError?.(error instanceof Error ? error : new Error(String(error)));
+			this.closeSocket(1008, "connect failed");
 		});
 	}
 	handleMessage(socket, generation, raw) {
@@ -887,6 +932,7 @@ var GatewayProtocolClient = class {
 					return;
 				}
 				this.connectNonce = nonce;
+				this.serverCapabilities = Array.isArray(payload?.capabilities) ? payload.capabilities.filter((value) => typeof value === "string") : [];
 				const challengeTs = payload?.ts;
 				this.connectChallengeTs = typeof challengeTs === "number" && Number.isSafeInteger(challengeTs) && challengeTs >= 0 ? challengeTs : null;
 				this.recordTiming("challenge", generation);
@@ -934,6 +980,7 @@ var GatewayProtocolClient = class {
 			return;
 		}
 		this.socket = null;
+		this.connectionAbort?.abort();
 		this.clearHandshakeTimer();
 		const context = {
 			...this.closeContext(),
@@ -978,6 +1025,20 @@ var GatewayProtocolClient = class {
 			connectFailure: this.connectFailure
 		};
 	}
+	isConnectCurrent(socket, generation) {
+		return this.isActive(socket, generation) && socket.isOpen() && !this.connectionAbort?.signal.aborted;
+	}
+	connectAuthority(socket, generation) {
+		const signal = this.connectionAbort?.signal;
+		if (!signal) throw new Error("gateway connection authority is unavailable");
+		return {
+			signal,
+			assertCurrent: () => {
+				signal.throwIfAborted();
+				if (!this.isConnectCurrent(socket, generation)) throw new Error("gateway connection retired");
+			}
+		};
+	}
 	isActive(socket, generation) {
 		return !this.stopped && this.socket === socket && this.generation === generation;
 	}
@@ -1032,6 +1093,67 @@ function asNullableRecord(value) {
 	return isRecord(value) ? value : null;
 }
 //#endregion
+//#region packages/normalization-core/src/stable-stringify.ts
+const preserveString = (value) => value;
+/** Deterministically stringifies values, optionally normalizing strings before key ordering. */
+function stableStringify(value, normalizeString = preserveString) {
+	return stringifyStableValue(value, /* @__PURE__ */ new WeakSet(), normalizeString);
+}
+function stringifyStableValue(value, stack, normalizeString) {
+	if (value === null || value === void 0) return String(value);
+	if (typeof value === "number" && !Number.isFinite(value)) return JSON.stringify(String(value));
+	if (typeof value === "bigint") return JSON.stringify(value.toString());
+	if (typeof value === "string") return JSON.stringify(normalizeString(value));
+	if (typeof value !== "object") return JSON.stringify(value) ?? "null";
+	if (stack.has(value)) return JSON.stringify("[Circular]");
+	stack.add(value);
+	try {
+		return stringifyObjectValue(value, stack, normalizeString);
+	} finally {
+		stack.delete(value);
+	}
+}
+function stringifyObjectValue(value, stack, normalizeString) {
+	if (value instanceof Error) return stringifyStableValue({
+		name: value.name,
+		message: value.message,
+		stack: value.stack
+	}, stack, normalizeString);
+	if (value instanceof Uint8Array) return stringifyStableValue({
+		type: "Uint8Array",
+		data: encodeBase64(value)
+	}, stack, normalizeString);
+	if (Array.isArray(value)) {
+		const serializedEntries = [];
+		for (const entry of value) serializedEntries.push(stringifyStableValue(entry, stack, normalizeString));
+		return `[${serializedEntries.join(",")}]`;
+	}
+	const record = value;
+	if (normalizeString === preserveString) {
+		const fields = Object.keys(record).sort();
+		let fieldIndex = 0;
+		for (const key of fields) fields[fieldIndex++] = `${JSON.stringify(key)}:${stringifyStableValue(record[key], stack, normalizeString)}`;
+		return `{${fields.join(",")}}`;
+	}
+	const entries = Object.keys(record).map((key) => ({
+		key,
+		normalizedKey: normalizeString(key)
+	})).sort((left, right) => {
+		return compareStableStrings(left.normalizedKey, right.normalizedKey) || compareStableStrings(left.key, right.key);
+	});
+	const serializedFields = [];
+	for (const { key, normalizedKey } of entries) serializedFields.push(`${JSON.stringify(normalizedKey)}:${stringifyStableValue(record[key], stack, normalizeString)}`);
+	return `{${serializedFields.join(",")}}`;
+}
+function encodeBase64(value) {
+	let binary = "";
+	for (const byte of value) binary += String.fromCharCode(byte);
+	return btoa(binary);
+}
+function compareStableStrings(left, right) {
+	return left < right ? -1 : left > right ? 1 : 0;
+}
+//#endregion
 //#region packages/gateway-client/src/session-projection-message-identity.ts
 function readSessionProjectionString(value) {
 	return typeof value === "string" ? value.trim() || null : null;
@@ -1057,15 +1179,18 @@ function readSessionMessageIdentity(message, envelope) {
 	const importedFrom = readSessionProjectionString(metadata?.importedFrom);
 	const cliSessionId = readSessionProjectionString(metadata?.cliSessionId);
 	const externalId = readSessionProjectionString(metadata?.externalId);
+	const position = asNullableRecord(metadata?.transcriptPosition);
+	const positionSource = readSessionProjectionString(position?.source);
+	const isImported = !(positionSource !== null && positionSource.length <= 128 && typeof position?.rawSeq === "number" && Number.isSafeInteger(position.rawSeq) && position.rawSeq >= 0) && Boolean(importedFrom || cliSessionId || 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 fallbackRunId = normalizeSessionProjectionRunId(asNullableRecord(record.openclawStreamFallback)?.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;
-	const runId = role === "assistant" ? metadataRunId ?? envelopeRunId ?? (isCliAssistant || !mirroredMessage ? canonicalPersistedRunId : null) ?? optimisticRunId : metadataRunId ?? canonicalPersistedRunId ?? envelopeRunId;
+	const runId = role === "assistant" ? metadataRunId ?? envelopeRunId ?? fallbackRunId ?? (isCliAssistant || !mirroredMessage ? canonicalPersistedRunId : null) : metadataRunId ?? canonicalPersistedRunId ?? envelopeRunId;
 	return {
 		role,
 		id: readSessionProjectionString(metadata?.id) ?? readSessionProjectionString(envelope?.messageId),
@@ -1073,8 +1198,8 @@ function readSessionMessageIdentity(message, envelope) {
 		idempotencyKey,
 		sendId: role === "user" ? persistedRunId ?? runId : null,
 		runId,
-		isImported: Boolean(importedFrom || cliSessionId || externalId),
-		externalSource: importedFrom && cliSessionId && externalId ? JSON.stringify([
+		isImported,
+		externalSource: isImported && importedFrom && cliSessionId && externalId ? JSON.stringify([
 			importedFrom,
 			cliSessionId,
 			externalId
@@ -1087,11 +1212,51 @@ function readAssistantStreamSegmentIdentity(message) {
 	if (readSessionProjectionString(record?.role)?.toLowerCase() !== "assistant") return;
 	const fallback = asNullableRecord(record?.openclawStreamFallback);
 	const itemId = readSessionProjectionString(fallback?.itemId);
+	if (!itemId) return;
 	const runId = readSessionMessageIdentity(message)?.runId ?? readSessionProjectionString(record?.runId) ?? readSessionProjectionString(fallback?.runId);
-	return itemId ? {
+	return {
 		itemId,
 		...runId ? { runId } : {}
-	} : void 0;
+	};
+}
+/** A saved occurrence can enrich its live projection, never another durable row. */
+function sameAssistantPersistenceReceipt(left, right) {
+	return Boolean(left?.role === "assistant" && right?.role === "assistant" && !left.isImported && !right.isImported && left.idempotencyKey && left.idempotencyKey === right.idempotencyKey && (!left.id && left.sequence === null || !right.id && right.sequence === null));
+}
+/** Local turns have no durable transcript metadata beyond their own optional send key. */
+function isLocallyOptimisticSessionMessage(message) {
+	const record = asNullableRecord(message);
+	const role = readSessionProjectionString(record?.role)?.toLowerCase();
+	if (role !== "user" && role !== "assistant") return false;
+	if (asNullableRecord(record?.openclawStreamFallback)) return false;
+	const metadata = asNullableRecord(record?.["__openclaw"]);
+	return !metadata || Object.keys(metadata).every((key) => key === "idempotencyKey");
+}
+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;
+}
+/** Normalize a message into its live, durable, or pending projection entry. */
+function createSessionProjectionEntry(message, options) {
+	const identity = readSessionMessageIdentity(message, options?.envelope);
+	const fallback = asNullableRecord(asNullableRecord(message)?.openclawStreamFallback);
+	const provisionalFallback = Boolean(fallback && identity?.role === "assistant" && !identity.id && identity.sequence === null);
+	const inferredPendingRunId = options?.live !== true && isLocallyOptimisticSessionMessage(message) ? identity?.runId : null;
+	const pendingRunId = normalizeSessionProjectionRunId(options?.pendingRunId ?? inferredPendingRunId);
+	return {
+		message,
+		identity,
+		afterSequence: options?.envelope?.afterSequence !== void 0 ? options.envelope.afterSequence : provisionalFallback && typeof fallback?.afterSequence === "number" ? fallback.afterSequence : void 0,
+		live: options?.live === true || provisionalFallback,
+		pending: pendingRunId !== null,
+		pendingRunId
+	};
 }
 //#endregion
 //#region packages/gateway-client/src/session-projection-message-content.ts
@@ -1117,6 +1282,11 @@ function readSessionMessageDisplayContent(message) {
 		usesFallbackText: fallback !== null
 	};
 }
+/** Check whether a projected message has text or another displayable block. */
+function hasDisplayableSessionMessage(message) {
+	const { text, hasNonText } = readSessionMessageDisplayContent(message);
+	return Boolean(text) || hasNonText;
+}
 function normalizeChatErrorComparisonText(text) {
 	return text.trim().replace(/^⚠️\s*/u, "").replace(/^Error:\s*/iu, "").replace(/\s+/gu, " ").trim();
 }
@@ -1129,6 +1299,153 @@ function isSessionProjectionErrorMessage(message, errorMessage) {
 	return !hasNonText && (!normalizedText || normalizedText === "[assistant turn failed before producing content]" || normalizedText === GATEWAY_ASSISTANT_ERROR_FALLBACK_TEXT || normalizedText === normalizeChatErrorComparisonText(errorMessage ?? ""));
 }
 //#endregion
+//#region packages/gateway-client/src/session-projection-final-identity.ts
+/** Terminal identity rules used to reconcile live and durable assistant projections. */
+/**
+* The class of rows the #148297 relaxation newly admits as finals: persisted
+* with the run's terminal tool stop reason while carrying no tool-call
+* content. Both adoption directions and every position rule scope to this
+* predicate, so pre-existing match semantics stay untouched.
+*/
+function isToolUsePersistedFinalRow(message) {
+	return asNullableRecord(message)?.["stopReason"] === "toolUse" && !isSessionProjectionToolContinuation(message);
+}
+/** Tool-bearing assistant rows are continuations even without a tool stop reason. */
+function isSessionProjectionToolContinuation(message) {
+	const record = asNullableRecord(message);
+	if (Array.isArray(record?.content) && record.content.some((block) => {
+		const type = asNullableRecord(block)?.type;
+		return type === "toolCall" || type === "toolUse" || type === "functionCall";
+	})) return true;
+	return record?.stopReason === "toolUse" && !hasDisplayableSessionMessage(message);
+}
+function readPersistedFinalIdentity(message) {
+	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}`;
+	if (identity?.role === "assistant" && !identity.isImported && identity.idempotencyKey) return `key:assistant:${identity.idempotencyKey}`;
+	return null;
+}
+function hasCompatiblePersistedFinalIdentity(currentMessage, incomingMessage) {
+	const current = readSessionMessageIdentity(currentMessage);
+	const incoming = readSessionMessageIdentity(incomingMessage);
+	if (!current || !incoming || current.role !== incoming.role) return false;
+	if (current.isImported || incoming.isImported) {
+		if (!current.isImported || !incoming.isImported) return false;
+		if (current.externalSource && incoming.externalSource) return current.externalSource === incoming.externalSource;
+		return current.sequence !== null && incoming.sequence !== null && current.sequence === incoming.sequence;
+	}
+	if (sameAssistantPersistenceReceipt(current, incoming)) return true;
+	if (current.id && incoming.id) return current.id === incoming.id;
+	return current.sequence !== null && incoming.sequence !== null && current.sequence === incoming.sequence;
+}
+function readFinalContentIdentity(message) {
+	const display = readSessionMessageDisplayContent(message);
+	if (!display.text && !display.hasNonText) return null;
+	const identity = readSessionMessageIdentity(message);
+	const record = asNullableRecord(message);
+	const metadata = asNullableRecord(record?.["__openclaw"]);
+	try {
+		return `content:${stableStringify([
+			identity?.role ?? "assistant",
+			display.text,
+			display.hasNonText ? record?.content ?? null : null,
+			metadata?.media ?? null,
+			identity?.isImported ? [
+				metadata?.importedFrom ?? null,
+				metadata?.cliSessionId ?? null,
+				metadata?.externalId ?? null
+			] : null
+		])}`;
+	} catch {
+		return null;
+	}
+}
+function hasTerminalStopReason(message) {
+	const stopReason = asNullableRecord(message)?.stopReason;
+	return stopReason === "stop" || stopReason === "length" || stopReason === "error" || stopReason === "aborted" || stopReason === "end_turn";
+}
+/** Read stable persisted identity first, falling back to canonical display content. */
+function readSessionProjectionFinalMessageIdentity(message) {
+	if (!hasDisplayableSessionMessage(message)) return null;
+	return readPersistedFinalIdentity(message) ?? readFinalContentIdentity(message);
+}
+/** Check whether a displayable terminal may recover a prior empty terminal. */
+function canRecoverSessionProjectionFinal(currentMessage, incomingMessage) {
+	if (hasDisplayableSessionMessage(currentMessage)) return false;
+	return readPersistedFinalIdentity(currentMessage) === null || hasCompatiblePersistedFinalIdentity(currentMessage, incomingMessage);
+}
+/** Check whether a run has already accepted the same terminal reply. */
+function hasSessionProjectionAcceptedFinal(run, message) {
+	const identity = readSessionProjectionFinalMessageIdentity(message);
+	return Boolean(identity && run && (run.acceptedFinalMessageIdentities?.includes(identity) || readSessionProjectionFinalMessageIdentity(run.message) === identity));
+}
+/** Match an unsequenced live terminal to exactly one durable same-run terminal row. */
+function findUniqueSnapshotTerminalMatch(current, matches, run, snapshot) {
+	if (!current.live || current.identity?.role !== "assistant" || current.identity.id || current.identity.sequence !== null || !run || run.status === "streaming" || matches.length === 0) return null;
+	const terminalContent = readFinalContentIdentity(current.message);
+	if (!terminalContent || readFinalContentIdentity(run.message) !== terminalContent) return null;
+	let snapshotIndexes;
+	let firstUserIndex = -1;
+	let lastAssistantIndex = -1;
+	const ensureRunIndexes = () => {
+		if (snapshotIndexes) return;
+		const runId = current.identity?.runId;
+		const indexes = /* @__PURE__ */ new Map();
+		if (runId) snapshot.forEach((candidate, index) => {
+			if (candidate.identity?.runId === runId) {
+				if (!indexes.has(candidate)) indexes.set(candidate, index);
+				if (candidate.identity.role === "user" && firstUserIndex < 0) firstUserIndex = index;
+				else if (candidate.identity.role === "assistant") lastAssistantIndex = index;
+			}
+		});
+		snapshotIndexes = indexes;
+	};
+	const hasCompletedRunSnapshotContext = (entry) => {
+		const runId = current.identity?.runId;
+		if (!runId || entry.identity?.runId !== runId) return false;
+		ensureRunIndexes();
+		const entryIndex = snapshotIndexes?.get(entry);
+		return entryIndex !== void 0 && firstUserIndex >= 0 && firstUserIndex < entryIndex && lastAssistantIndex <= entryIndex;
+	};
+	const isLastSameRunAssistantRow = (entry) => {
+		const runId = current.identity?.runId;
+		if (!runId || entry.identity?.runId !== runId) return false;
+		ensureRunIndexes();
+		const entryIndex = snapshotIndexes?.get(entry);
+		return entryIndex !== void 0 && lastAssistantIndex >= 0 && entryIndex >= lastAssistantIndex;
+	};
+	const durableTerminalMatches = matches.filter((entry) => {
+		return (asNullableRecord(asNullableRecord(entry.message)?.["__openclaw"])?.runTerminal === true || entry.identity?.runId === current.identity?.runId && (hasTerminalStopReason(entry.message) || asNullableRecord(entry.message)?.["stopReason"] === "toolUse" && !isSessionProjectionToolContinuation(entry.message) && isLastSameRunAssistantRow(entry)) || hasCompletedRunSnapshotContext(entry)) && readFinalContentIdentity(entry.message) === terminalContent;
+	});
+	const entry = durableTerminalMatches.length === 1 ? durableTerminalMatches[0] : void 0;
+	if (!entry) return null;
+	return {
+		entry,
+		inferred: asNullableRecord(asNullableRecord(entry.message)?.["__openclaw"])?.runTerminal !== true && !hasTerminalStopReason(entry.message)
+	};
+}
+/** Check whether ordinary single-match promotion needs terminal-content verification. */
+function isUnsequencedLiveTerminal(current, run) {
+	return Boolean(current.live && current.identity?.role === "assistant" && !current.identity.id && current.identity.sequence === null && run && run.status !== "streaming" && readFinalContentIdentity(current.message) === readFinalContentIdentity(run.message));
+}
+//#endregion
+//#region packages/gateway-client/src/session-projection-run-retention.ts
+/** Bounded retention for completed and active session projection runs. */
+const MAX_TRACKED_SESSION_RUNS = 200;
+const RETAINED_SESSION_RUNS = 150;
+/** Retain every active run and the newest completed runs within the projection bound. */
+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]);
+}
+//#endregion
 //#region packages/gateway-client/src/session-projection-run-event.ts
 function readNonemptyString(value) {
 	return typeof value === "string" ? value.trim() || null : null;
@@ -1172,8 +1489,6 @@ function reduceSessionProjectionRunEvent(projection, event, scope = {}) {
 //#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",
@@ -1181,35 +1496,15 @@ const SESSION_PROJECTION_SCOPE_KEYS = [
 	"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 = asNullableRecord(asNullableRecord(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,
-		afterSequence: options?.envelope?.afterSequence,
-		live: options?.live === true,
-		pending: pendingRunId !== null,
-		pendingRunId
-	};
-}
 function createProjectionEntries(messages) {
 	let pendingUserRunId = null;
 	return messages.map((message) => {
-		const entry = createEntry(message);
+		const entry = createSessionProjectionEntry(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 (pendingUserRunId && entry.identity?.role === "assistant" && !entry.pending && isLocallyOptimisticSessionMessage(message)) return createSessionProjectionEntry(message, { pendingRunId: pendingUserRunId });
 		if (!isLocallyOptimisticSessionMessage(message)) pendingUserRunId = null;
 		return entry;
 	});
@@ -1232,26 +1527,21 @@ function readEventScope(event) {
 	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) {
+	const leftSegment = readAssistantStreamSegmentIdentity(left.message);
+	const rightSegment = readAssistantStreamSegmentIdentity(right.message);
+	if (leftSegment?.itemId !== rightSegment?.itemId) return false;
 	if (sameTranscriptIdentity(left.identity, right.identity)) return true;
+	if (sameAssistantPersistenceReceipt(left.identity, right.identity)) return true;
+	if (left.identity?.role === "assistant" && right.identity?.role === "assistant" && left.identity.idempotencyKey && right.identity.idempotencyKey && left.identity.idempotencyKey !== right.identity.idempotencyKey) return false;
 	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?.identity?.role === "assistant" && provisionalEntry?.identity?.role === "assistant" && !durableEntry.identity.isImported && !provisionalEntry.identity.isImported && !provisionalEntry.identity.id) {
-		const durableSegment = readAssistantStreamSegmentIdentity(durableEntry.message);
-		const provisionalSegment = readAssistantStreamSegmentIdentity(provisionalEntry.message);
+		const durableSegment = durableEntry === left ? leftSegment : rightSegment;
+		const provisionalSegment = durableEntry === left ? rightSegment : leftSegment;
 		if (provisionalEntry.identity.sequence === null && durableSegment?.runId && durableSegment.runId === provisionalSegment?.runId && durableSegment.itemId === provisionalSegment.itemId) return true;
-		if (provisionalEntry.live && provisionalEntry.identity.sequence === null && (provisionalEntry.afterSequence === void 0 || provisionalEntry.afterSequence !== null && durableEntry.identity.sequence !== null && durableEntry.identity.sequence > provisionalEntry.afterSequence) && durableEntry.identity.runId && durableEntry.identity.runId === provisionalEntry.identity.runId && (readSessionProjectionString(durableMetadata?.mirrorOrigin) === null || durableMetadata?.runTerminal === true)) return true;
+		if (provisionalEntry.live && !durableSegment && !isSessionProjectionToolContinuation(durableEntry.message) && (!isToolUsePersistedFinalRow(durableEntry.message) || readFinalContentIdentity(durableEntry.message) === readFinalContentIdentity(provisionalEntry.message)) && provisionalEntry.identity.sequence === null && (provisionalEntry.afterSequence === void 0 || provisionalEntry.afterSequence !== null && durableEntry.identity.sequence !== null && durableEntry.identity.sequence > provisionalEntry.afterSequence) && 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;
@@ -1299,40 +1589,94 @@ function insertEntry(entries, incoming, runs) {
 		...entries.slice(nextIndex)
 	];
 }
-function projectLiveSessionMessage(state, message, envelope, scope = {}) {
+function projectLiveSessionMessage(initialState, message, envelope, scope = {}) {
+	let state = initialState;
 	if (!scopesMatch(state.scope, scope)) return state;
-	const incoming = createEntry(message, {
+	const incoming = createSessionProjectionEntry(message, {
 		envelope,
 		live: true
 	});
 	if (!incoming.identity) return state;
 	const matches = state.entries.filter((entry) => entryMatches(entry, incoming));
 	const existing = matches.find((entry) => sameTranscriptIdentity(entry.identity, incoming.identity)) ?? (matches.length === 1 ? matches[0] : void 0);
+	if (existing && !sameTranscriptIdentity(existing.identity, incoming.identity) && !sameAssistantPersistenceReceipt(existing.identity, incoming.identity)) {
+		const durable = existing.identity?.id ? existing : incoming.identity.id ? incoming : null;
+		const provisional = durable === existing ? incoming : existing;
+		if (durable && isToolUsePersistedFinalRow(durable.message)) {
+			const history = state.entries.filter((entry) => entry !== provisional);
+			const snapshot = durable === incoming ? insertEntry(history, durable) : history;
+			const runId = provisional.identity?.runId;
+			const run = runId ? state.runs[runId] : void 0;
+			const terminalMatch = findUniqueSnapshotTerminalMatch(provisional, [durable], run, snapshot);
+			if (!terminalMatch) return withEntries(state, insertEntry(state.entries, incoming, state.runs));
+			if (terminalMatch.inferred && durable.identity && runId && run) {
+				const inferredSnapshotTerminal = {
+					entry: provisional,
+					matchedIdentity: durable.identity
+				};
+				state = {
+					...state,
+					runs: {
+						...state.runs,
+						[runId]: {
+							...run,
+							inferredSnapshotTerminal
+						}
+					}
+				};
+			}
+		}
+	}
 	if (!existing) return withEntries(state, insertEntry(state.entries, incoming, state.runs));
 	const existingIndex = state.entries.indexOf(existing);
 	if (existing.message === message && existing.live && !existing.pending) return state;
 	if (!existing.pending && existing.identity?.id && !incoming.identity.id) return state;
 	if (incoming.identity.sequence !== null && (existing.pending || existing.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));
+		const violatesOrder = state.entries.some(({ identity }, index) => identity?.sequence != null && (index < existingIndex ? identity.sequence > sequence : identity.sequence < sequence));
+		return withEntries(state, violatesOrder ? 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)
-	]);
+	return withEntries(state, state.entries.toSpliced(existingIndex, 1, incoming));
 }
 /** 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);
+	const runs = { ...state.runs };
 	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);
+		if (!current.live && !current.pending || options.shouldIncludeMessage?.(current.message) === false) continue;
+		const matches = entries.filter((entry) => entryMatches(entry, current, true));
+		const uniqueMatch = matches.length === 1 ? matches[0] : void 0;
+		const run = current.identity?.runId ? runs[current.identity.runId] : void 0;
+		const terminalMatch = findUniqueSnapshotTerminalMatch(current, matches, run, entries);
+		if (uniqueMatch && (sameAssistantPersistenceReceipt(uniqueMatch.identity, current.identity) || !isUnsequencedLiveTerminal(current, run)) || terminalMatch) {
+			if (terminalMatch?.inferred && terminalMatch.entry.identity && current.identity?.runId && run) runs[current.identity.runId] = {
+				...run,
+				inferredSnapshotTerminal: {
+					entry: current,
+					matchedIdentity: terminalMatch.entry.identity
+				}
+			};
+			continue;
+		}
+		entries = insertEntry(entries, current, runs);
+	}
+	for (const [runId, run] of Object.entries(runs)) {
+		const inferred = run.inferredSnapshotTerminal;
+		if (!inferred) continue;
+		const candidateRemains = entries.some((entry) => sameTranscriptIdentity(entry.identity, inferred.matchedIdentity));
+		const visible = options.shouldIncludeMessage?.(inferred.entry.message) !== false;
+		const matches = entries.filter((entry) => entryMatches(entry, inferred.entry, true));
+		const terminalMatch = findUniqueSnapshotTerminalMatch(inferred.entry, matches, run, entries);
+		if (candidateRemains && visible && terminalMatch?.inferred) continue;
+		if (candidateRemains && visible && !terminalMatch) entries = insertEntry(entries, inferred.entry, runs);
+		const { inferredSnapshotTerminal: _inferred, ...settledRun } = run;
+		runs[runId] = settledRun;
 	}
 	return {
 		...withEntries(state, entries),
+		runs,
 		scope: {
 			...state.scope,
 			...scope
@@ -1340,49 +1684,6 @@ function reconcileSessionProjectionSnapshot(state, messages, scope = {}, options
 		hasTransportGap: false
 	};
 }
-function hasDisplayableSessionMessage(message) {
-	const { text, hasNonText } = readSessionMessageDisplayContent(message);
-	return Boolean(text) || hasNonText;
-}
-function readSessionProjectionFinalMessageIdentity(message) {
-	const display = readSessionMessageDisplayContent(message);
-	if (!display.text && !display.hasNonText) 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 = asNullableRecord(message);
-	const metadata = asNullableRecord(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,
-			...display.usesFallbackText ? [record?.text] : []
-		])}`;
-	} 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 = readSessionProjectionString(incoming.errorMessage);
 	const incomingSeq = typeof incoming.seq === "number" && Number.isSafeInteger(incoming.seq) && incoming.seq >= 0 ? incoming.seq : void 0;
@@ -1397,9 +1698,10 @@ function updateRun(state, incoming) {
 	if (current && current.status !== "streaming" && !resumesErrorProjection) {
 		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 currentHasDisplayableMessage = hasDisplayableSessionMessage(current.message);
+		const canAcceptFinal = currentHasDisplayableMessage ? current.status === incoming.status || (current.acceptedFinalMessageIdentities?.length ?? 0) > 0 : canRecoverSessionProjectionFinal(current.message, incoming.message);
+		const acceptFinal = incomingIsFinal && canAcceptFinal && incomingFinalIdentity !== null && !hasSessionProjectionAcceptedFinal(current, incoming.message);
+		const recoverMessage = acceptFinal && !currentHasDisplayableMessage;
 		const recoverError = readSessionProjectionString(current.errorMessage) === null && incomingErrorMessage !== null;
 		const updateTerminalSequence = incoming.status !== "streaming" && (incomingSeq === void 0 ? current.seq !== void 0 : current.seq === void 0 || incomingSeq > current.seq);
 		if (!acceptFinal && !recoverError && !updateTerminalSequence) return state;
@@ -1458,7 +1760,7 @@ function reduceSessionProjection(state, event) {
 		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 });
+			const incoming = createSessionProjectionEntry(event.message, { pendingRunId });
 			if (!pendingRunId || !incoming.identity) return 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 ? {
@@ -1727,4 +2029,4 @@ function releaseGatewaySessionMessageSubscription(subscription) {
 	return sessionMessageSubscriptionOwners.get(subscription)?.coordinator.release(subscription) ?? Promise.resolve();
 }
 //#endregion
-export { shouldRetryGatewayWithDeviceToken as A, isGatewayProtocolResponseError as C, buildGatewayConnectAuth as D, GatewayBrowserDeviceAuthLifecycle as E, buildDeviceAuthPayloadV3 as M, normalizeDeviceMetadataForAuth as N, resolveGatewayConnectScopes as O, GatewayProtocolRequestTimeoutError as S, gatewayOriginScope as T, readSessionMessageSequence as _, createSessionProjection as a, GatewayProtocolClient as b, projectLiveSessionMessage as c, reduceSessionProjection as d, reduceSessionProjectionRunEvent as f, readSessionMessageIdentity as g, readAssistantStreamSegmentIdentity as h, resetGatewaySessionMessageSubscriptionCoordinator as i, buildDeviceAuthPayload as j, selectGatewayConnectAuth as k, readSessionProjectionFinalMessageIdentity as l, normalizeSessionProjectionRunId as m, getGatewaySessionMessageSubscriptionCoordinator as n, hasSessionProjectionAcceptedFinal as o, isSessionProjectionErrorMessage as p, releaseGatewaySessionMessageSubscription as r, isLocallyOptimisticSessionMessage as s, GatewaySessionMessageSubscriptionCoordinator as t, reconcileSessionProjectionSnapshot as u, isRecord as v, gatewayCredentialScope as w, GatewayProtocolRequestError as x, shouldPauseGatewayReconnect as y };
+export { selectGatewayConnectAuth as A, isGatewayProtocolResponseError as C, GatewayBrowserDeviceAuthLifecycle as D, gatewayOriginScope as E, buildDeviceAuthPayload as M, buildDeviceAuthPayloadV3 as N, buildGatewayConnectAuth as O, normalizeDeviceMetadataForAuth as P, GatewayProtocolRequestTimeoutError as S, gatewayCredentialScope as T, readSessionMessageSequence as _, createSessionProjection as a, GatewayProtocolClient as b, reduceSessionProjection as c, readSessionProjectionFinalMessageIdentity as d, isSessionProjectionErrorMessage as f, readSessionMessageIdentity as g, readAssistantStreamSegmentIdentity as h, resetGatewaySessionMessageSubscriptionCoordinator as i, shouldRetryGatewayWithDeviceToken as j, resolveGatewayConnectScopes as k, reduceSessionProjectionRunEvent as l, normalizeSessionProjectionRunId as m, getGatewaySessionMessageSubscriptionCoordinator as n, projectLiveSessionMessage as o, isLocallyOptimisticSessionMessage as p, releaseGatewaySessionMessageSubscription as r, reconcileSessionProjectionSnapshot as s, GatewaySessionMessageSubscriptionCoordinator as t, hasSessionProjectionAcceptedFinal as u, isRecord as v, resolveModelCatalogConnect as w, GatewayProtocolRequestError as x, shouldPauseGatewayReconnect as y };