@gajae-code/coding-agent 0.12.5 → 0.12.6

package/src/sdk/bus/topic-registry.ts

@@ -94,6 +94,18 @@ export interface TopicDeleteAuthoritySnapshot {
 	record?: TopicRecord;
 }
 
+/**
+ * Proof that a definite delete was settled in memory and still owes its durable
+ * commit. Handed back only by a settlement that actually happened, so a refused
+ * settlement structurally cannot be followed by a rollback.
+ */
+export interface TopicSettledDelete {
+	sessionId: string;
+	topicId: string;
+	/** Authority epoch proven current when the record was removed. */
+	settledEpoch: number;
+}
+
 function isValidBindingString(value: unknown): value is string {
 	return typeof value === "string" && value.trim().length > 0;
 }
@@ -136,6 +148,16 @@ function isValidTopicId(value: unknown): value is string {
 	);
 }
 
+/**
+ * Monotonic epoch successor that saturates instead of leaving the safe-integer
+ * range. Past `Number.MAX_SAFE_INTEGER` two distinct generations collapse onto
+ * the same IEEE-754 double, which would let a stale settlement clear a newer
+ * fence; settlement refuses the saturated value instead of overflowing past it.
+ */
+function nextAuthorityEpoch(current: number): number {
+	return current >= Number.MAX_SAFE_INTEGER ? Number.MAX_SAFE_INTEGER : current + 1;
+}
+
 export function emptyTopicRegistryState(): TopicRegistryState {
 	return { topics: {} };
 }
@@ -161,6 +183,8 @@ export class TopicRegistry {
 	private readonly creatingBindings = new Map<string, TopicEndpointBinding>();
 	/** Monotonic authority epochs, including deletion fences for absent records. */
 	private readonly epochs = new Map<string, number>();
+	/** Phase-1 settlements awaiting their durable clear; their topic ids stay quarantined. */
+	readonly #settling = new Map<string, { topicId: string; settledEpoch: number; record: TopicRecord }>();
 
 	constructor(state: TopicRegistryState = emptyTopicRegistryState()) {
 		this.topics = new Map();
@@ -173,6 +197,7 @@ export class TopicRegistry {
 		this.byTopic.clear();
 		this.#ambiguousTopicIds.clear();
 		this.epochs.clear();
+		this.#settling.clear();
 		this.load(state);
 	}
 
@@ -259,6 +284,10 @@ export class TopicRegistry {
 	private rebuildInboundRoutes(): void {
 		this.byTopic.clear();
 		this.#ambiguousTopicIds.clear();
+		// A settled-but-not-yet-durable clear keeps its topic id quarantined: the
+		// clear is not authoritative until persisted, so no colliding survivor may
+		// become routable and no settled id may become adoptable during that write.
+		for (const settling of this.#settling.values()) this.#ambiguousTopicIds.add(settling.topicId);
 		const activeByTopic = new Map<string, string>();
 
 		for (const [sessionId, record] of this.topics) {
@@ -278,6 +307,13 @@ export class TopicRegistry {
 		}
 	}
 
+	/** Advance and publish the session authority epoch, saturating at the safe-integer bound. */
+	#advanceAuthorityEpoch(sessionId: string, base: number): number {
+		const epoch = nextAuthorityEpoch(base);
+		this.epochs.set(sessionId, epoch);
+		return epoch;
+	}
+
 	/** Resolve the owning session for a topic id (for fail-closed inbound routing). */
 	sessionForTopic(topicId: string): string | undefined {
 		return this.byTopic.get(topicId);
@@ -482,6 +518,7 @@ export class TopicRegistry {
 		const pending = this.inflight.get(sessionId);
 		if (pending) return pending;
 		const epoch = this.epochs.get(sessionId) ?? 0;
+		if (epoch >= Number.MAX_SAFE_INTEGER) throw new Error("topic authority epoch exhausted");
 		// Publish the compatible endpoint claim before invoking `create`: the callback
 		// may immediately begin a remote create and identity-less recovery must never
 		// observe a false absence during that await.
@@ -676,7 +713,9 @@ export class TopicRegistry {
 	/** Restore a failed delete fence only while its exact authority mutation remains current. */
 	restoreDeleteAuthority(snapshot: TopicDeleteAuthoritySnapshot): boolean {
 		const record = this.topics.get(snapshot.sessionId);
-		const deleteEpoch = Math.max(snapshot.fenceEpoch ?? 0, snapshot.authorityEpoch ?? 0) + 1;
+		const authorityBase = Math.max(snapshot.fenceEpoch ?? 0, snapshot.authorityEpoch ?? 0);
+		if (authorityBase >= Number.MAX_SAFE_INTEGER) return false;
+		const deleteEpoch = nextAuthorityEpoch(authorityBase);
 		if (this.epochs.get(snapshot.sessionId) !== deleteEpoch) return false;
 		if (snapshot.topicId === undefined) {
 			if (record) return false;
@@ -697,10 +736,17 @@ export class TopicRegistry {
 		return true;
 	}
 
-	/** Restore the exact delete fence after a failed compensation publication. */
+	/**
+	 * Restore the exact delete fence after a failed compensation publication.
+	 *
+	 * Settlement rebuilds derived routes, which can make a surviving colliding
+	 * record routable. Rebuild again on successful restoration so the reinstated
+	 * fence re-quarantines the topic id instead of leaving inbound routing open to
+	 * the collision partner despite the restored fence.
+	 */
 	restoreDeleteFence(snapshot: TopicDeleteAuthoritySnapshot): boolean {
 		const record = this.topics.get(snapshot.sessionId);
-		const deleteEpoch = Math.max(snapshot.fenceEpoch ?? 0, snapshot.authorityEpoch ?? 0) + 1;
+		const deleteEpoch = nextAuthorityEpoch(Math.max(snapshot.fenceEpoch ?? 0, snapshot.authorityEpoch ?? 0));
 		if (snapshot.topicId === undefined) {
 			if (record) return false;
 		} else if (!record) {
@@ -715,17 +761,19 @@ export class TopicRegistry {
 		} else {
 			record.authorityEpoch = deleteEpoch;
 			record.authorityState = "delete_pending";
-			if (this.byTopic.get(record.topicId) === snapshot.sessionId) this.byTopic.delete(record.topicId);
 		}
 		this.epochs.set(snapshot.sessionId, deleteEpoch);
+		this.rebuildInboundRoutes();
 		return true;
 	}
 
 	/** Fence new work before the remote delete starts, including an absent in-flight create. */
 	beginDelete(sessionId: string): TopicRecord | undefined {
 		const record = this.topics.get(sessionId);
-		const epoch = Math.max(this.epochs.get(sessionId) ?? 0, record?.authorityEpoch ?? 0) + 1;
-		this.epochs.set(sessionId, epoch);
+		const epoch = this.#advanceAuthorityEpoch(
+			sessionId,
+			Math.max(this.epochs.get(sessionId) ?? 0, record?.authorityEpoch ?? 0),
+		);
 		if (!record) return undefined;
 		record.authorityEpoch = epoch;
 		record.authorityState = "delete_pending";
@@ -799,11 +847,86 @@ export class TopicRegistry {
 		await this.inflight.get(sessionId)?.catch(() => undefined);
 	}
 
-	/** Remove only after a definite remote deletion; ambiguity deliberately retains its fence. */
-	settleDelete(sessionId: string, topicId: string): boolean {
+	/**
+	 * Phase 1 of settling a definite remote delete: remove the record while
+	 * deliberately RETAINING its topic-id quarantine.
+	 *
+	 * `dispatchedAuthorityEpoch` is the authority epoch the caller held when it
+	 * dispatched the remote delete. Settlement requires that epoch to still equal
+	 * both the record's own authority epoch and the registry's current epoch for
+	 * the session, so a held earlier delete can never settle a newer fence: if a
+	 * scan or close-started delete re-fenced the same session/topic after this
+	 * delete was dispatched, the stale definite result is refused and the newer
+	 * `delete_pending` record plus its topic-id quarantine stay intact.
+	 *
+	 * An epoch outside the safe-integer range cannot identify a generation, and at
+	 * `Number.MAX_SAFE_INTEGER` epoch advancement has saturated so distinct
+	 * generations are no longer distinguishable. Both fail closed: settlement can
+	 * no longer be proven fresh, so the fence is kept.
+	 *
+	 * Derived routing tables are deliberately NOT rebuilt here. Until the cleared
+	 * snapshot is durably persisted the clear is not authoritative, so publishing
+	 * routes now would make a colliding survivor routable (and the settled id
+	 * adoptable) during the held write, and a failed persist would re-quarantine
+	 * too late. Publish with {@link commitSettledDelete} once the persist
+	 * succeeds, or undo with {@link rollbackSettledDelete} when it fails.
+	 */
+	settleDelete(sessionId: string, topicId: string, dispatchedAuthorityEpoch: number): TopicSettledDelete | undefined {
+		if (!Number.isSafeInteger(dispatchedAuthorityEpoch) || dispatchedAuthorityEpoch < 0) return undefined;
+		if (this.#settling.has(sessionId)) return undefined;
 		const record = this.topics.get(sessionId);
-		if (!record || record.topicId !== topicId || record.authorityState !== "delete_pending") return false;
+		if (!record || record.topicId !== topicId || record.authorityState !== "delete_pending") return undefined;
+		if ((record.authorityEpoch ?? 0) !== dispatchedAuthorityEpoch) return undefined;
+		const currentEpoch = this.authorityEpoch(sessionId);
+		if (currentEpoch !== dispatchedAuthorityEpoch) return undefined;
+		if (currentEpoch >= Number.MAX_SAFE_INTEGER) return undefined;
 		this.topics.delete(sessionId);
+		this.#settling.set(sessionId, { topicId, settledEpoch: dispatchedAuthorityEpoch, record: { ...record } });
+		this.#ambiguousTopicIds.add(topicId);
+		if (this.byTopic.get(topicId) === sessionId) this.byTopic.delete(topicId);
+		return { sessionId, topicId, settledEpoch: dispatchedAuthorityEpoch };
+	}
+
+	/**
+	 * Phase 2: publish derived routing tables once the cleared state is durable.
+	 *
+	 * Only here does the settled topic id lose its quarantine, so a surviving
+	 * colliding record becomes routable and a settled id becomes adoptable without
+	 * waiting for a daemon restart.
+	 */
+	commitSettledDelete(settled: TopicSettledDelete): boolean {
+		const pending = this.#settling.get(settled.sessionId);
+		if (!pending || pending.topicId !== settled.topicId || pending.settledEpoch !== settled.settledEpoch)
+			return false;
+		this.#settling.delete(settled.sessionId);
+		this.rebuildInboundRoutes();
+		return true;
+	}
+
+	/**
+	 * Compare-and-swap undo for a settlement whose durable clear failed.
+	 *
+	 * Restoration applies only while the registry still holds exactly the state
+	 * that this settlement produced: the settlement is still awaiting commit, the
+	 * session still has no record, and the session epoch is still the settled
+	 * epoch. Any mismatch means a newer generation intervened, so the restore is
+	 * refused and the newer state is left untouched. A refused settlement produced
+	 * no token, so it can never reach this path.
+	 */
+	rollbackSettledDelete(settled: TopicSettledDelete): boolean {
+		const pending = this.#settling.get(settled.sessionId);
+		if (!pending || pending.topicId !== settled.topicId || pending.settledEpoch !== settled.settledEpoch)
+			return false;
+		if (this.topics.has(settled.sessionId)) return false;
+		if (this.authorityEpoch(settled.sessionId) !== settled.settledEpoch) return false;
+		this.#settling.delete(settled.sessionId);
+		this.topics.set(settled.sessionId, {
+			...pending.record,
+			authorityEpoch: settled.settledEpoch,
+			authorityState: "delete_pending",
+		});
+		this.epochs.set(settled.sessionId, settled.settledEpoch);
+		this.rebuildInboundRoutes();
 		return true;
 	}
 
@@ -811,7 +934,7 @@ export class TopicRegistry {
 	delete(sessionId: string): boolean {
 		const record = this.topics.get(sessionId);
 		if (!record) return false;
-		this.epochs.set(sessionId, Math.max(this.epochs.get(sessionId) ?? 0, record.authorityEpoch ?? 0) + 1);
+		this.#advanceAuthorityEpoch(sessionId, Math.max(this.epochs.get(sessionId) ?? 0, record.authorityEpoch ?? 0));
 		if (this.byTopic.get(record.topicId) === sessionId) this.byTopic.delete(record.topicId);
 		return this.topics.delete(sessionId);
 	}

package/src/sdk/host/host.ts

@@ -4,11 +4,21 @@ import type { BrokerIndexWriter, HostEndpointAdapters, SdkFrame } from "./types"
 
 export type SdkRequestObserver = (kind: "control" | "query", connectionId: string, frame: SdkFrame) => void;
 
+export interface ProviderLeaseIdentity {
+	leaseId: string;
+	connectionId: string;
+	connectionGeneration: number;
+	fence: string;
+}
+
+export type ProviderLeaseFence = (identity: ProviderLeaseIdentity, reason?: string) => boolean;
+
 export interface SessionSdkHostOptions extends HostEndpointAdapters {
 	control?: (connectionId: string, frame: SdkFrame) => unknown | Promise<unknown>;
 	query?: (connectionId: string, frame: SdkFrame) => unknown | Promise<unknown>;
 	/** Best-effort diagnostic observation of accepted control/query frames. */
 	onRequest?: SdkRequestObserver;
+	onFrameOverflow?: (connectionId: string) => void;
 	/** Runs before a control response is sent; identity transitions use sendTerminal. */
 	beforeControlResponse?: (
 		connectionId: string,
@@ -18,13 +28,25 @@ export interface SessionSdkHostOptions extends HostEndpointAdapters {
 	) => void | Promise<void>;
 	/** Runs only after a successful control response has been sent to the client. */
 	afterControlResponse?: (connectionId: string, request: SdkFrame, response: SdkFrame) => void | Promise<void>;
-	installProviderDefinitions?: (capability: string, definitions: unknown) => void;
+	onProviderLeaseRegistered?: (lease: ProviderLease, connectionGeneration: number) => void;
+	installProviderDefinitions?: (
+		capability: string,
+		definitions: unknown,
+		leaseId: string,
+		connectionId: string,
+		connectionGeneration: number,
+	) => void;
 	onProviderDefinitionsRemoved?: (capability: string) => void;
 	onReverseCancel?: (requestId: string, reason: "provider_disconnected" | "lease_released") => void;
 	/** Best-effort capabilities mirrored from the native transport for out-of-band consumers. */
 	connectionCapabilities?: (connectionId: string) => ReadonlySet<string> | undefined;
 }
 
+/** Bound asynchronous frame admission per transport connection. */
+const MAX_PENDING_FRAMES_PER_CONNECTION = 32;
+const MAX_QUARANTINED_PROVIDER_LEASES = 256;
+const MAX_RETAINED_CLOSED_CONNECTIONS = 256;
+
 const TOOL_ACTIVITY_CAPABILITY = "tool_activity_v2";
 const CAP_GATED_FRAME_KINDS = new Set(["tool_activity", "reasoning_summary"]);
 const EMPTY_CAPABILITIES: ReadonlySet<string> = new Set();
@@ -120,6 +142,12 @@ export class SessionSdkHost {
 	#stopPromise?: Promise<"stopped">;
 	#unsubscribe?: () => void;
 	#registration?: { writer: BrokerIndexWriter; generation: number };
+	#connectionGenerations = new Map<string, number>();
+	#openConnections = new Set<string>();
+	#pendingFrames = new Map<string, { generation: number; count: number }>();
+	#leaseRecords = new Map<string, { capability: string; connectionId: string; connectionGeneration: number }>();
+	#quarantinedLeases = new Map<string, ProviderLeaseIdentity>();
+	#closedConnectionOrder: string[] = [];
 
 	constructor(options: SessionSdkHostOptions) {
 		this.#options = options;
@@ -141,9 +169,120 @@ export class SessionSdkHost {
 	getProviderDefinitions(capability: string): unknown | undefined {
 		return this.reverse.getInstalledDefinitions(capability);
 	}
+	/** Mark a transport connection live and return its stable generation. */
+	handleConnect(connectionId: string): number {
+		if (!this.#openConnections.has(connectionId)) {
+			const generation = this.#connectionGenerations.get(connectionId) ?? 1;
+			this.#connectionGenerations.set(connectionId, generation);
+			this.#openConnections.add(connectionId);
+			this.#pendingFrames.set(connectionId, { generation, count: 0 });
+		}
+		return this.#connectionGenerations.get(connectionId) ?? 0;
+	}
+
+	/** Current generation for a transport connection, if it has been observed. */
+	connectionGeneration(connectionId: string): number {
+		return this.#connectionGenerations.get(connectionId) ?? 0;
+	}
+
+	isConnectionOpen(connectionId: string, generation?: number): boolean {
+		return (
+			this.#openConnections.has(connectionId) &&
+			(generation === undefined || this.#connectionGenerations.get(connectionId) === generation)
+		);
+	}
+
 	/** Release reverse leases after the transport reports a WebSocket disconnect. */
 	handleDisconnect(connectionId: string): void {
+		if (!this.#openConnections.delete(connectionId)) return;
+		this.#connectionGenerations.set(connectionId, (this.#connectionGenerations.get(connectionId) ?? 0) + 1);
+		this.#pendingFrames.delete(connectionId);
+		for (const [leaseId, record] of this.#leaseRecords) {
+			if (record.connectionId === connectionId) this.#leaseRecords.delete(leaseId);
+		}
 		this.reverse.disconnect(connectionId);
+		this.#closedConnectionOrder.push(connectionId);
+		while (this.#closedConnectionOrder.length > MAX_RETAINED_CLOSED_CONNECTIONS) {
+			const retired = this.#closedConnectionOrder.shift();
+			if (retired && !this.#openConnections.has(retired)) this.#connectionGenerations.delete(retired);
+		}
+	}
+
+	/**
+	 * Fences one exact provider lease after uncertain terminal cleanup. The fence
+	 * is idempotent for the same identity and never affects a newer generation.
+	 */
+	quarantineProviderLease(identity: ProviderLeaseIdentity, _reason?: string): boolean {
+		if (
+			!identity ||
+			typeof identity.leaseId !== "string" ||
+			identity.leaseId.length === 0 ||
+			typeof identity.connectionId !== "string" ||
+			identity.connectionId.length === 0 ||
+			!Number.isSafeInteger(identity.connectionGeneration) ||
+			identity.connectionGeneration < 0 ||
+			typeof identity.fence !== "string" ||
+			identity.fence.length === 0
+		)
+			return false;
+		const previous = this.#quarantinedLeases.get(identity.leaseId);
+		if (
+			previous &&
+			previous.connectionId === identity.connectionId &&
+			previous.connectionGeneration === identity.connectionGeneration &&
+			previous.fence === identity.fence
+		)
+			return true;
+		if (this.#quarantinedLeases.size >= MAX_QUARANTINED_PROVIDER_LEASES) return false;
+		if (this.#connectionGenerations.get(identity.connectionId) !== identity.connectionGeneration) return false;
+		const record = this.#leaseRecords.get(identity.leaseId);
+		if (
+			!record ||
+			record.connectionId !== identity.connectionId ||
+			record.connectionGeneration !== identity.connectionGeneration
+		)
+			return false;
+		const lease = this.reverse.getLease(record.capability);
+		if (!lease || lease.leaseId !== identity.leaseId || lease.connectionId !== identity.connectionId || !lease.active)
+			return false;
+		try {
+			this.reverse.release(identity.connectionId, identity.leaseId);
+		} catch {
+			return false;
+		}
+		this.#quarantinedLeases.set(identity.leaseId, { ...identity });
+		return true;
+	}
+
+	/** Dispatch a frame through bounded per-connection asynchronous admission. */
+	dispatchFrame(connectionId: string, frame: SdkFrame): Promise<void> {
+		const generation = this.#connectionGenerations.has(connectionId)
+			? (this.#connectionGenerations.get(connectionId) ?? 0)
+			: this.handleConnect(connectionId);
+		const pending = this.#pendingFrames.get(connectionId);
+		const pendingCount = pending?.generation === generation ? pending.count : 0;
+		if (pendingCount >= MAX_PENDING_FRAMES_PER_CONNECTION) {
+			this.#options.onFrameOverflow?.(connectionId);
+			return Promise.resolve();
+		}
+		this.#pendingFrames.set(connectionId, { generation, count: pendingCount + 1 });
+		const task = Promise.resolve().then(() => {
+			if (this.#connectionGenerations.get(connectionId) !== generation) return;
+			if (!this.#openConnections.has(connectionId)) return;
+			return this.#onFrame(connectionId, frame, generation);
+		});
+		void task.finally(() => {
+			const current = this.#pendingFrames.get(connectionId);
+			if (!current || current.generation !== generation) return;
+			this.#pendingFrames.set(connectionId, {
+				generation,
+				count: Math.max(0, current.count - 1),
+			});
+		});
+		return task.then(
+			() => {},
+			() => {},
+		);
 	}
 
 	/** Adds an event to the resumable event ring. Transport delivery is owned by bus wiring. */
@@ -156,7 +295,7 @@ export class SessionSdkHost {
 		this.events.restart();
 		this.emitEvent({ name: "session_ready", sessionId: this.#options.sessionId, generation: this.events.generation });
 		const disposer = this.#options.onFrame((connectionId, frame) => {
-			void this.#onFrame(connectionId, frame);
+			void this.dispatchFrame(connectionId, frame);
 		});
 		this.#unsubscribe = typeof disposer === "function" ? disposer : undefined;
 		this.#started = true;
@@ -221,18 +360,30 @@ export class SessionSdkHost {
 		}
 	}
 
-	async #onFrame(connectionId: string, frame: SdkFrame): Promise<void> {
+	async #onFrame(connectionId: string, frame: SdkFrame, generation: number): Promise<void> {
+		if (this.#connectionGenerations.has(connectionId) && this.#connectionGenerations.get(connectionId) !== generation)
+			return;
 		try {
 			switch (frame.type) {
 				case "control_request": {
 					this.#observeRequest("control", connectionId, frame);
 					const result = await this.#options.control?.(connectionId, frame);
+					if (
+						this.#connectionGenerations.has(connectionId) &&
+						this.#connectionGenerations.get(connectionId) !== generation
+					)
+						return;
 					if (result !== undefined) {
 						const response = { type: "control_response", ...(result as SdkFrame) };
 						let terminalSent = false;
 						const sendTerminal = async (): Promise<void> => {
 							if (terminalSent) return;
 							terminalSent = true;
+							if (
+								this.#connectionGenerations.has(connectionId) &&
+								this.#connectionGenerations.get(connectionId) !== generation
+							)
+								return;
 							await this.#send(connectionId, response);
 						};
 						await this.#options.beforeControlResponse?.(connectionId, frame, response, sendTerminal);
@@ -271,6 +422,11 @@ export class SessionSdkHost {
 				case "query_request": {
 					this.#observeRequest("query", connectionId, frame);
 					const result = await this.#options.query?.(connectionId, frame);
+					if (
+						this.#connectionGenerations.has(connectionId) &&
+						this.#connectionGenerations.get(connectionId) !== generation
+					)
+						return;
 					if (result !== undefined)
 						await this.#send(connectionId, { type: "query_response", ...(result as SdkFrame) });
 					break;
@@ -280,13 +436,30 @@ export class SessionSdkHost {
 					requireConnection(connectionId, frame);
 					const capability = requiredString(frame, "capability");
 					if (!has(frame, "definitions")) throw invalidFrame("definitions is required.");
+					const expectedLeaseId = optionalString(frame, "expectedLeaseId");
+					if (expectedLeaseId && this.#quarantinedLeases.has(expectedLeaseId))
+						throw new ReverseLeaseError("lease_unavailable");
+					const connectionGeneration = this.#connectionGenerations.get(connectionId) ?? 0;
 					const lease = this.reverse.registerProvider(
 						connectionId,
 						capability,
 						frame.definitions,
-						optionalString(frame, "expectedLeaseId"),
+						expectedLeaseId,
 						optionalString(frame, "idempotencyKey"),
+						connectionGeneration,
 					);
+					for (const [priorLeaseId, record] of this.#leaseRecords) {
+						if (record.capability === lease.capability && priorLeaseId !== lease.leaseId)
+							this.#leaseRecords.delete(priorLeaseId);
+					}
+					this.#leaseRecords.set(lease.leaseId, {
+						capability: lease.capability,
+						connectionId: lease.connectionId,
+						connectionGeneration,
+					});
+					try {
+						this.#options.onProviderLeaseRegistered?.(lease, connectionGeneration);
+					} catch {}
 					await this.#send(connectionId, {
 						id: frame.id,
 						type: "register_provider_result",
@@ -306,6 +479,7 @@ export class SessionSdkHost {
 					requireConnection(connectionId, frame);
 					const handoffTo = optionalString(frame, "handoffTo");
 					const lease = this.reverse.release(connectionId, requiredString(frame, "leaseId"), handoffTo);
+					this.#leaseRecords.delete(lease.leaseId);
 					await this.#send(connectionId, leaseState(undefined, lease));
 					break;
 				}
@@ -318,7 +492,7 @@ export class SessionSdkHost {
 					if (frame.ok) {
 						if (!has(frame, "result") || has(frame, "error"))
 							throw invalidFrame("Successful reverse responses require result and no error.");
-						this.reverse.respond(connectionId, id, leaseId, frame.result);
+						this.reverse.respond(connectionId, id, leaseId, frame.result, undefined, frame);
 					} else {
 						if (
 							has(frame, "result") ||
@@ -327,10 +501,14 @@ export class SessionSdkHost {
 							typeof responseError.message !== "string"
 						)
 							throw invalidFrame("Failed reverse responses require a structured error and no result.");
-						this.reverse.respond(connectionId, id, leaseId, undefined, {
-							code: responseError.code,
-							message: responseError.message,
-						});
+						this.reverse.respond(
+							connectionId,
+							id,
+							leaseId,
+							undefined,
+							{ code: responseError.code, message: responseError.message },
+							frame,
+						);
 					}
 					break;
 				}