@flowy-agent-store/client 0.1.0-beta.2 → 0.1.0-beta.3

package/dist/index.cjs

@@ -26,49 +26,74 @@ function isLoopbackUrl(raw) {
 		return false;
 	}
 }
+/** How long an unopened `connect()` waits before it fails. */
+const DEFAULT_CONNECT_TIMEOUT_MS = 1e4;
 var WebSocketTransport = class {
 	socket = null;
 	nextId = 1;
 	pending = /* @__PURE__ */ new Map();
 	listeners = /* @__PURE__ */ new Set();
-	connectResolvers = [];
-	connectRejecters = [];
+	lifecycleListeners = /* @__PURE__ */ new Set();
+	lifecycle = null;
 	closedByCaller = false;
+	/** Single in-flight connect shared by concurrent callers; null once settled. */
+	connecting = null;
 	requestTimeoutMs;
+	connectTimeoutMs;
 	url;
 	token;
 	constructor(url, options = {}) {
 		this.url = url;
 		this.token = options.token;
 		this.requestTimeoutMs = options.requestTimeoutMs ?? 3e4;
+		this.connectTimeoutMs = options.connectTimeoutMs ?? DEFAULT_CONNECT_TIMEOUT_MS;
 	}
 	get connected() {
 		return this.socket?.readyState === WebSocket.OPEN;
 	}
 	connect() {
 		if (this.connected) return Promise.resolve();
+		if (this.connecting) return this.connecting.promise;
 		this.closedByCaller = false;
 		const target = this.token ? `${this.url}${this.url.includes("?") ? "&" : "?"}token=${encodeURIComponent(this.token)}` : this.url;
 		const socket = new WebSocket(target);
 		this.socket = socket;
+		let resolveConnect;
+		let rejectConnect;
+		const promise = new Promise((resolve, reject) => {
+			resolveConnect = resolve;
+			rejectConnect = reject;
+		});
+		const timer = setTimeout(() => {
+			this.detachSocket(socket);
+			this.rejectConnect(new _flowy_agent_store_protocol.TransportError("connect", `app-server connect timed out after ${this.connectTimeoutMs}ms`, { retryable: true }));
+		}, this.connectTimeoutMs);
+		this.connecting = {
+			promise,
+			resolve: resolveConnect,
+			reject: rejectConnect,
+			timer
+		};
 		socket.onopen = () => {
-			for (const resolve of this.connectResolvers.splice(0)) resolve();
+			if (this.socket !== socket) return;
+			this.resolveConnect();
+			this.setLifecycle("open");
 		};
 		socket.onmessage = (event) => {
+			if (this.socket !== socket) return;
 			this.handleMessage(event.data);
 		};
 		socket.onclose = (event) => {
+			if (this.socket !== socket) return;
 			this.failAllPending(new _flowy_agent_store_protocol.TransportError("close", `app-server connection closed (code ${event.code})`, { retryable: !this.closedByCaller }));
 			this.socket = null;
-			for (const reject of this.connectRejecters.splice(0)) reject(new _flowy_agent_store_protocol.TransportError("connect", "app-server connection closed before opening"));
+			this.setLifecycle("closed");
+			this.rejectConnect(new _flowy_agent_store_protocol.TransportError("connect", "app-server connection closed before opening"));
 		};
 		socket.onerror = () => {
-			this.socket?.close();
+			if (this.socket === socket) socket.close();
 		};
-		return new Promise((resolve, reject) => {
-			this.connectResolvers.push(resolve);
-			this.connectRejecters.push(reject);
-		});
+		return promise;
 	}
 	request(method, params) {
 		const socket = this.requireSocket();
@@ -118,15 +143,62 @@ var WebSocketTransport = class {
 			this.listeners.delete(listener);
 		};
 	}
+	/**
+	* Observe the channel lifecycle. `closed` is only reported when an
+	* established connection is lost (a failed first dial is not a disconnect),
+	* and `open` follows it on the next successful dial — that pair is what a
+	* host should treat as a reconnect. Unlike `onNotification`, these listeners
+	* survive `close()`, since they exist to drive the reconnection itself.
+	*/
+	onLifecycle(listener) {
+		this.lifecycleListeners.add(listener);
+		return () => {
+			this.lifecycleListeners.delete(listener);
+		};
+	}
 	close() {
 		this.closedByCaller = true;
-		this.socket?.close();
-		this.socket = null;
+		this.detachSocket(this.socket);
+		this.rejectConnect(new _flowy_agent_store_protocol.TransportError("close", "app-server transport closed by caller"));
 		for (const [, pending] of this.pending) {
 			clearTimeout(pending.timer);
 			pending.reject(new _flowy_agent_store_protocol.TransportError("close", "app-server transport closed by caller"));
 		}
 		this.pending.clear();
+		this.listeners.clear();
+		this.lifecycle = null;
+	}
+	setLifecycle(state) {
+		if (state === "closed" && this.lifecycle !== "open") return;
+		if (this.lifecycle === state) return;
+		this.lifecycle = state;
+		for (const listener of [...this.lifecycleListeners]) try {
+			listener(state);
+		} catch {}
+	}
+	/** Detach the current socket (if any) and close it; its later events are ignored. */
+	detachSocket(socket) {
+		if (!socket) return;
+		if (this.socket === socket) this.socket = null;
+		try {
+			socket.close();
+		} catch {}
+	}
+	/** Settle the in-flight `connect()` successfully, when there is one. */
+	resolveConnect() {
+		const connecting = this.connecting;
+		if (!connecting) return;
+		this.connecting = null;
+		clearTimeout(connecting.timer);
+		connecting.resolve();
+	}
+	/** Fail the in-flight `connect()`, when there is one. */
+	rejectConnect(error) {
+		const connecting = this.connecting;
+		if (!connecting) return;
+		this.connecting = null;
+		clearTimeout(connecting.timer);
+		connecting.reject(error);
 	}
 	requireSocket() {
 		if (!this.socket || this.socket.readyState !== WebSocket.OPEN) throw new _flowy_agent_store_protocol.TransportError("send", "app-server transport is not connected", { retryable: true });
@@ -281,6 +353,21 @@ var ConversationSubscription = class {
 			await this.transport.request("conversation/unsubscribe", { conversation_id: this.conversationId });
 		} catch {}
 	}
+	/**
+	* Re-arm after a reconnect (docs/agent-store/16 T8): re-register the
+	* notification listener, reset the cursor and re-issue
+	* `conversation/subscribe`. This subscription has no event-replay API, so the
+	* caller must still backfill the transcript for the outage window
+	* (`conversation/messages`). Call it once the handshake completed; a no-op
+	* once closed.
+	*/
+	async rearm() {
+		if (this.closed) return;
+		this.removeListener?.();
+		this.removeListener = this.transport.onNotification((notification) => this.dispatch(notification));
+		this.lastSeenSequence = 0;
+		await this.transport.request("conversation/subscribe", { conversation_id: this.conversationId });
+	}
 	dispatch(notification) {
 		if (notification.method === "conversation/event") {
 			const event = notification.params;
@@ -520,6 +607,33 @@ var EventSubscription = class {
 			if (this.resyncInFlight === task) this.resyncInFlight = null;
 		}
 	}
+	/**
+	* Re-arm after the connection was re-established (docs/agent-store/16 T8).
+	* A new socket means the server dropped its subscriptions and the transport
+	* dropped its notification listeners, so this:
+	*
+	* 1. re-registers this subscription's notification listener,
+	* 2. resets the cursor to 0 and forgets the dedupe set, then
+	* 3. re-issues `run/subscribe` and replays **all** persisted events.
+	*
+	* The replay is deliberate (the plan's "重连后重置 lastSeenSequence"): a
+	* consumer must dedupe by `sequence`, since events seen before the outage
+	* are delivered again. Call it only once the session handshake has completed
+	* again — the transport's `open` event fires before `initialize`. A no-op
+	* once closed.
+	*/
+	async rearm() {
+		if (this.closed || !this.fetchAfter) return [];
+		this.unsubscribeNotification?.();
+		this.unsubscribeNotification = this.transport.onNotification((notification) => {
+			this.dispatch(notification);
+		});
+		this.lastSeenSequence = 0;
+		this.seenSequences.clear();
+		this.resyncInFlight = null;
+		await this.transport.request("run/subscribe", { run_id: this.runId });
+		return this.resync();
+	}
 	markSeen(sequence) {
 		this.seenSequences.add(sequence);
 		if (sequence > this.lastSeenSequence) this.lastSeenSequence = sequence;
@@ -666,6 +780,8 @@ var AppServerClient = class {
 	capabilities;
 	initializeResult = null;
 	notificationListeners = /* @__PURE__ */ new Set();
+	/** Transport → client notification bridge; re-armed after a transport close. */
+	unbridgeNotifications = null;
 	constructor(options) {
 		this.clientInfo = options.client;
 		this.capabilities = options.capabilities;
@@ -678,7 +794,16 @@ var AppServerClient = class {
 		this.agents = new AgentClient(this.transport);
 		this.teams = new TeamClient(this.transport);
 		this.models = new ModelClient(this.transport);
-		this.transport.onNotification((notification) => {
+		this.bridgeNotifications();
+	}
+	/**
+	* Subscribe the client-level fan-out on the transport exactly once.
+	* `transport.close()` drops its listeners, so this is also called on
+	* `connect()`: otherwise a reconnect would leave notifications silent.
+	*/
+	bridgeNotifications() {
+		if (this.unbridgeNotifications) return;
+		this.unbridgeNotifications = this.transport.onNotification((notification) => {
 			for (const listener of [...this.notificationListeners]) try {
 				listener(notification);
 			} catch {}
@@ -692,6 +817,7 @@ var AppServerClient = class {
 	}
 	/** Connect and perform the initialize/initialized handshake. */
 	async connect() {
+		this.bridgeNotifications();
 		await this.transport.connect();
 		const request = {
 			protocol_version: _flowy_agent_store_protocol.APP_SERVER_PROTOCOL_VERSION,
@@ -712,6 +838,8 @@ var AppServerClient = class {
 	}
 	/** Close the transport; the server revokes the connection immediately. */
 	close() {
+		this.unbridgeNotifications?.();
+		this.unbridgeNotifications = null;
 		this.transport.close();
 		this.initializeResult = null;
 		this.notificationListeners.clear();

package/dist/index.d.cts

@@ -15,15 +15,30 @@ export declare function isLoopbackUrl(raw: string): boolean;
  * so business code never knows whether it runs over WebSocket (browser),
  * stdio (Node/CLI, future) or a one-shot HTTP binding.
  */
+/**
+ * Lifecycle of the underlying channel. `open` is emitted on every successful
+ * dial (the first one included), `closed` only when an established connection
+ * is lost — so `closed` → `open` is exactly a reconnect.
+ */
+export type TransportLifecycle = "open" | "closed";
+export type TransportLifecycleListener = (state: TransportLifecycle) => void;
 export interface Transport {
   connect(): Promise<void>;
   request<T>(method: string, params: unknown): Promise<T>;
   notify(method: string, params: unknown): void;
   onNotification(listener: NotificationListener): () => void;
   close(): void;
+  /**
+   * Optional: observe the channel lifecycle so a host can show a disconnect
+   * banner and re-arm subscriptions on reconnect (docs/agent-store/16 T8/W8).
+   * Custom transports may omit it.
+   */
+  onLifecycle?(listener: TransportLifecycleListener): () => void;
 }
 export interface TransportOptions {
   requestTimeoutMs?: number;
+  /** Max time `connect()` may stay unopened before failing (default 10s). */
+  connectTimeoutMs?: number;
   token?: string;
 }
 export declare class WebSocketTransport implements Transport {
@@ -31,10 +46,13 @@ export declare class WebSocketTransport implements Transport {
   private nextId;
   private pending;
   private listeners;
-  private connectResolvers;
-  private connectRejecters;
+  private lifecycleListeners;
+  private lifecycle;
   private closedByCaller;
+  /** Single in-flight connect shared by concurrent callers; null once settled. */
+  private connecting;
   readonly requestTimeoutMs: number;
+  readonly connectTimeoutMs: number;
   readonly url: string;
   readonly token?: string;
   constructor(url: string, options?: TransportOptions);
@@ -43,7 +61,22 @@ export declare class WebSocketTransport implements Transport {
   request<T>(method: string, params: unknown): Promise<T>;
   notify(method: string, params: unknown): void;
   onNotification(listener: NotificationListener): () => void;
+  /**
+   * Observe the channel lifecycle. `closed` is only reported when an
+   * established connection is lost (a failed first dial is not a disconnect),
+   * and `open` follows it on the next successful dial — that pair is what a
+   * host should treat as a reconnect. Unlike `onNotification`, these listeners
+   * survive `close()`, since they exist to drive the reconnection itself.
+   */
+  onLifecycle(listener: TransportLifecycleListener): () => void;
   close(): void;
+  private setLifecycle;
+  /** Detach the current socket (if any) and close it; its later events are ignored. */
+  private detachSocket;
+  /** Settle the in-flight `connect()` successfully, when there is one. */
+  private resolveConnect;
+  /** Fail the in-flight `connect()`, when there is one. */
+  private rejectConnect;
   private requireSocket;
   private handleMessage;
   private failAllPending;
@@ -92,6 +125,15 @@ export declare class ConversationSubscription {
   onEvent(listener: ConversationEventListener): () => void;
   onResync(listener: ConversationResyncListener): () => void;
   close(): Promise<void>;
+  /**
+   * Re-arm after a reconnect (docs/agent-store/16 T8): re-register the
+   * notification listener, reset the cursor and re-issue
+   * `conversation/subscribe`. This subscription has no event-replay API, so the
+   * caller must still backfill the transcript for the outage window
+   * (`conversation/messages`). Call it once the handshake completed; a no-op
+   * once closed.
+   */
+  rearm(): Promise<void>;
   private dispatch;
 }
 //#endregion
@@ -184,6 +226,22 @@ export declare class EventSubscription {
    * Concurrent calls share one flight.
    */
   resync(): Promise<RunEvent[]>;
+  /**
+   * Re-arm after the connection was re-established (docs/agent-store/16 T8).
+   * A new socket means the server dropped its subscriptions and the transport
+   * dropped its notification listeners, so this:
+   *
+   * 1. re-registers this subscription's notification listener,
+   * 2. resets the cursor to 0 and forgets the dedupe set, then
+   * 3. re-issues `run/subscribe` and replays **all** persisted events.
+   *
+   * The replay is deliberate (the plan's "重连后重置 lastSeenSequence"): a
+   * consumer must dedupe by `sequence`, since events seen before the outage
+   * are delivered again. Call it only once the session handshake has completed
+   * again — the transport's `open` event fires before `initialize`. A no-op
+   * once closed.
+   */
+  rearm(): Promise<RunEvent[]>;
   private markSeen;
   private emitEvent;
   private emitError;
@@ -269,7 +327,15 @@ export declare class AppServerClient {
   readonly capabilities?: ClientCapabilities;
   private initializeResult;
   private notificationListeners;
+  /** Transport → client notification bridge; re-armed after a transport close. */
+  private unbridgeNotifications;
   constructor(options: AppServerClientOptions);
+  /**
+   * Subscribe the client-level fan-out on the transport exactly once.
+   * `transport.close()` drops its listeners, so this is also called on
+   * `connect()`: otherwise a reconnect would leave notifications silent.
+   */
+  private bridgeNotifications;
   get ready(): boolean;
   get initializeInfo(): InitializeResult | null;
   /** Connect and perform the initialize/initialized handshake. */

package/dist/index.d.mts

@@ -15,15 +15,30 @@ export declare function isLoopbackUrl(raw: string): boolean;
  * so business code never knows whether it runs over WebSocket (browser),
  * stdio (Node/CLI, future) or a one-shot HTTP binding.
  */
+/**
+ * Lifecycle of the underlying channel. `open` is emitted on every successful
+ * dial (the first one included), `closed` only when an established connection
+ * is lost — so `closed` → `open` is exactly a reconnect.
+ */
+export type TransportLifecycle = "open" | "closed";
+export type TransportLifecycleListener = (state: TransportLifecycle) => void;
 export interface Transport {
   connect(): Promise<void>;
   request<T>(method: string, params: unknown): Promise<T>;
   notify(method: string, params: unknown): void;
   onNotification(listener: NotificationListener): () => void;
   close(): void;
+  /**
+   * Optional: observe the channel lifecycle so a host can show a disconnect
+   * banner and re-arm subscriptions on reconnect (docs/agent-store/16 T8/W8).
+   * Custom transports may omit it.
+   */
+  onLifecycle?(listener: TransportLifecycleListener): () => void;
 }
 export interface TransportOptions {
   requestTimeoutMs?: number;
+  /** Max time `connect()` may stay unopened before failing (default 10s). */
+  connectTimeoutMs?: number;
   token?: string;
 }
 export declare class WebSocketTransport implements Transport {
@@ -31,10 +46,13 @@ export declare class WebSocketTransport implements Transport {
   private nextId;
   private pending;
   private listeners;
-  private connectResolvers;
-  private connectRejecters;
+  private lifecycleListeners;
+  private lifecycle;
   private closedByCaller;
+  /** Single in-flight connect shared by concurrent callers; null once settled. */
+  private connecting;
   readonly requestTimeoutMs: number;
+  readonly connectTimeoutMs: number;
   readonly url: string;
   readonly token?: string;
   constructor(url: string, options?: TransportOptions);
@@ -43,7 +61,22 @@ export declare class WebSocketTransport implements Transport {
   request<T>(method: string, params: unknown): Promise<T>;
   notify(method: string, params: unknown): void;
   onNotification(listener: NotificationListener): () => void;
+  /**
+   * Observe the channel lifecycle. `closed` is only reported when an
+   * established connection is lost (a failed first dial is not a disconnect),
+   * and `open` follows it on the next successful dial — that pair is what a
+   * host should treat as a reconnect. Unlike `onNotification`, these listeners
+   * survive `close()`, since they exist to drive the reconnection itself.
+   */
+  onLifecycle(listener: TransportLifecycleListener): () => void;
   close(): void;
+  private setLifecycle;
+  /** Detach the current socket (if any) and close it; its later events are ignored. */
+  private detachSocket;
+  /** Settle the in-flight `connect()` successfully, when there is one. */
+  private resolveConnect;
+  /** Fail the in-flight `connect()`, when there is one. */
+  private rejectConnect;
   private requireSocket;
   private handleMessage;
   private failAllPending;
@@ -92,6 +125,15 @@ export declare class ConversationSubscription {
   onEvent(listener: ConversationEventListener): () => void;
   onResync(listener: ConversationResyncListener): () => void;
   close(): Promise<void>;
+  /**
+   * Re-arm after a reconnect (docs/agent-store/16 T8): re-register the
+   * notification listener, reset the cursor and re-issue
+   * `conversation/subscribe`. This subscription has no event-replay API, so the
+   * caller must still backfill the transcript for the outage window
+   * (`conversation/messages`). Call it once the handshake completed; a no-op
+   * once closed.
+   */
+  rearm(): Promise<void>;
   private dispatch;
 }
 //#endregion
@@ -184,6 +226,22 @@ export declare class EventSubscription {
    * Concurrent calls share one flight.
    */
   resync(): Promise<RunEvent[]>;
+  /**
+   * Re-arm after the connection was re-established (docs/agent-store/16 T8).
+   * A new socket means the server dropped its subscriptions and the transport
+   * dropped its notification listeners, so this:
+   *
+   * 1. re-registers this subscription's notification listener,
+   * 2. resets the cursor to 0 and forgets the dedupe set, then
+   * 3. re-issues `run/subscribe` and replays **all** persisted events.
+   *
+   * The replay is deliberate (the plan's "重连后重置 lastSeenSequence"): a
+   * consumer must dedupe by `sequence`, since events seen before the outage
+   * are delivered again. Call it only once the session handshake has completed
+   * again — the transport's `open` event fires before `initialize`. A no-op
+   * once closed.
+   */
+  rearm(): Promise<RunEvent[]>;
   private markSeen;
   private emitEvent;
   private emitError;
@@ -269,7 +327,15 @@ export declare class AppServerClient {
   readonly capabilities?: ClientCapabilities;
   private initializeResult;
   private notificationListeners;
+  /** Transport → client notification bridge; re-armed after a transport close. */
+  private unbridgeNotifications;
   constructor(options: AppServerClientOptions);
+  /**
+   * Subscribe the client-level fan-out on the transport exactly once.
+   * `transport.close()` drops its listeners, so this is also called on
+   * `connect()`: otherwise a reconnect would leave notifications silent.
+   */
+  private bridgeNotifications;
   get ready(): boolean;
   get initializeInfo(): InitializeResult | null;
   /** Connect and perform the initialize/initialized handshake. */

package/dist/index.mjs

@@ -25,49 +25,74 @@ function isLoopbackUrl(raw) {
 		return false;
 	}
 }
+/** How long an unopened `connect()` waits before it fails. */
+const DEFAULT_CONNECT_TIMEOUT_MS = 1e4;
 var WebSocketTransport = class {
 	socket = null;
 	nextId = 1;
 	pending = /* @__PURE__ */ new Map();
 	listeners = /* @__PURE__ */ new Set();
-	connectResolvers = [];
-	connectRejecters = [];
+	lifecycleListeners = /* @__PURE__ */ new Set();
+	lifecycle = null;
 	closedByCaller = false;
+	/** Single in-flight connect shared by concurrent callers; null once settled. */
+	connecting = null;
 	requestTimeoutMs;
+	connectTimeoutMs;
 	url;
 	token;
 	constructor(url, options = {}) {
 		this.url = url;
 		this.token = options.token;
 		this.requestTimeoutMs = options.requestTimeoutMs ?? 3e4;
+		this.connectTimeoutMs = options.connectTimeoutMs ?? DEFAULT_CONNECT_TIMEOUT_MS;
 	}
 	get connected() {
 		return this.socket?.readyState === WebSocket.OPEN;
 	}
 	connect() {
 		if (this.connected) return Promise.resolve();
+		if (this.connecting) return this.connecting.promise;
 		this.closedByCaller = false;
 		const target = this.token ? `${this.url}${this.url.includes("?") ? "&" : "?"}token=${encodeURIComponent(this.token)}` : this.url;
 		const socket = new WebSocket(target);
 		this.socket = socket;
+		let resolveConnect;
+		let rejectConnect;
+		const promise = new Promise((resolve, reject) => {
+			resolveConnect = resolve;
+			rejectConnect = reject;
+		});
+		const timer = setTimeout(() => {
+			this.detachSocket(socket);
+			this.rejectConnect(new TransportError("connect", `app-server connect timed out after ${this.connectTimeoutMs}ms`, { retryable: true }));
+		}, this.connectTimeoutMs);
+		this.connecting = {
+			promise,
+			resolve: resolveConnect,
+			reject: rejectConnect,
+			timer
+		};
 		socket.onopen = () => {
-			for (const resolve of this.connectResolvers.splice(0)) resolve();
+			if (this.socket !== socket) return;
+			this.resolveConnect();
+			this.setLifecycle("open");
 		};
 		socket.onmessage = (event) => {
+			if (this.socket !== socket) return;
 			this.handleMessage(event.data);
 		};
 		socket.onclose = (event) => {
+			if (this.socket !== socket) return;
 			this.failAllPending(new TransportError("close", `app-server connection closed (code ${event.code})`, { retryable: !this.closedByCaller }));
 			this.socket = null;
-			for (const reject of this.connectRejecters.splice(0)) reject(new TransportError("connect", "app-server connection closed before opening"));
+			this.setLifecycle("closed");
+			this.rejectConnect(new TransportError("connect", "app-server connection closed before opening"));
 		};
 		socket.onerror = () => {
-			this.socket?.close();
+			if (this.socket === socket) socket.close();
 		};
-		return new Promise((resolve, reject) => {
-			this.connectResolvers.push(resolve);
-			this.connectRejecters.push(reject);
-		});
+		return promise;
 	}
 	request(method, params) {
 		const socket = this.requireSocket();
@@ -117,15 +142,62 @@ var WebSocketTransport = class {
 			this.listeners.delete(listener);
 		};
 	}
+	/**
+	* Observe the channel lifecycle. `closed` is only reported when an
+	* established connection is lost (a failed first dial is not a disconnect),
+	* and `open` follows it on the next successful dial — that pair is what a
+	* host should treat as a reconnect. Unlike `onNotification`, these listeners
+	* survive `close()`, since they exist to drive the reconnection itself.
+	*/
+	onLifecycle(listener) {
+		this.lifecycleListeners.add(listener);
+		return () => {
+			this.lifecycleListeners.delete(listener);
+		};
+	}
 	close() {
 		this.closedByCaller = true;
-		this.socket?.close();
-		this.socket = null;
+		this.detachSocket(this.socket);
+		this.rejectConnect(new TransportError("close", "app-server transport closed by caller"));
 		for (const [, pending] of this.pending) {
 			clearTimeout(pending.timer);
 			pending.reject(new TransportError("close", "app-server transport closed by caller"));
 		}
 		this.pending.clear();
+		this.listeners.clear();
+		this.lifecycle = null;
+	}
+	setLifecycle(state) {
+		if (state === "closed" && this.lifecycle !== "open") return;
+		if (this.lifecycle === state) return;
+		this.lifecycle = state;
+		for (const listener of [...this.lifecycleListeners]) try {
+			listener(state);
+		} catch {}
+	}
+	/** Detach the current socket (if any) and close it; its later events are ignored. */
+	detachSocket(socket) {
+		if (!socket) return;
+		if (this.socket === socket) this.socket = null;
+		try {
+			socket.close();
+		} catch {}
+	}
+	/** Settle the in-flight `connect()` successfully, when there is one. */
+	resolveConnect() {
+		const connecting = this.connecting;
+		if (!connecting) return;
+		this.connecting = null;
+		clearTimeout(connecting.timer);
+		connecting.resolve();
+	}
+	/** Fail the in-flight `connect()`, when there is one. */
+	rejectConnect(error) {
+		const connecting = this.connecting;
+		if (!connecting) return;
+		this.connecting = null;
+		clearTimeout(connecting.timer);
+		connecting.reject(error);
 	}
 	requireSocket() {
 		if (!this.socket || this.socket.readyState !== WebSocket.OPEN) throw new TransportError("send", "app-server transport is not connected", { retryable: true });
@@ -280,6 +352,21 @@ var ConversationSubscription = class {
 			await this.transport.request("conversation/unsubscribe", { conversation_id: this.conversationId });
 		} catch {}
 	}
+	/**
+	* Re-arm after a reconnect (docs/agent-store/16 T8): re-register the
+	* notification listener, reset the cursor and re-issue
+	* `conversation/subscribe`. This subscription has no event-replay API, so the
+	* caller must still backfill the transcript for the outage window
+	* (`conversation/messages`). Call it once the handshake completed; a no-op
+	* once closed.
+	*/
+	async rearm() {
+		if (this.closed) return;
+		this.removeListener?.();
+		this.removeListener = this.transport.onNotification((notification) => this.dispatch(notification));
+		this.lastSeenSequence = 0;
+		await this.transport.request("conversation/subscribe", { conversation_id: this.conversationId });
+	}
 	dispatch(notification) {
 		if (notification.method === "conversation/event") {
 			const event = notification.params;
@@ -519,6 +606,33 @@ var EventSubscription = class {
 			if (this.resyncInFlight === task) this.resyncInFlight = null;
 		}
 	}
+	/**
+	* Re-arm after the connection was re-established (docs/agent-store/16 T8).
+	* A new socket means the server dropped its subscriptions and the transport
+	* dropped its notification listeners, so this:
+	*
+	* 1. re-registers this subscription's notification listener,
+	* 2. resets the cursor to 0 and forgets the dedupe set, then
+	* 3. re-issues `run/subscribe` and replays **all** persisted events.
+	*
+	* The replay is deliberate (the plan's "重连后重置 lastSeenSequence"): a
+	* consumer must dedupe by `sequence`, since events seen before the outage
+	* are delivered again. Call it only once the session handshake has completed
+	* again — the transport's `open` event fires before `initialize`. A no-op
+	* once closed.
+	*/
+	async rearm() {
+		if (this.closed || !this.fetchAfter) return [];
+		this.unsubscribeNotification?.();
+		this.unsubscribeNotification = this.transport.onNotification((notification) => {
+			this.dispatch(notification);
+		});
+		this.lastSeenSequence = 0;
+		this.seenSequences.clear();
+		this.resyncInFlight = null;
+		await this.transport.request("run/subscribe", { run_id: this.runId });
+		return this.resync();
+	}
 	markSeen(sequence) {
 		this.seenSequences.add(sequence);
 		if (sequence > this.lastSeenSequence) this.lastSeenSequence = sequence;
@@ -665,6 +779,8 @@ var AppServerClient = class {
 	capabilities;
 	initializeResult = null;
 	notificationListeners = /* @__PURE__ */ new Set();
+	/** Transport → client notification bridge; re-armed after a transport close. */
+	unbridgeNotifications = null;
 	constructor(options) {
 		this.clientInfo = options.client;
 		this.capabilities = options.capabilities;
@@ -677,7 +793,16 @@ var AppServerClient = class {
 		this.agents = new AgentClient(this.transport);
 		this.teams = new TeamClient(this.transport);
 		this.models = new ModelClient(this.transport);
-		this.transport.onNotification((notification) => {
+		this.bridgeNotifications();
+	}
+	/**
+	* Subscribe the client-level fan-out on the transport exactly once.
+	* `transport.close()` drops its listeners, so this is also called on
+	* `connect()`: otherwise a reconnect would leave notifications silent.
+	*/
+	bridgeNotifications() {
+		if (this.unbridgeNotifications) return;
+		this.unbridgeNotifications = this.transport.onNotification((notification) => {
 			for (const listener of [...this.notificationListeners]) try {
 				listener(notification);
 			} catch {}
@@ -691,6 +816,7 @@ var AppServerClient = class {
 	}
 	/** Connect and perform the initialize/initialized handshake. */
 	async connect() {
+		this.bridgeNotifications();
 		await this.transport.connect();
 		const request = {
 			protocol_version: APP_SERVER_PROTOCOL_VERSION,
@@ -711,6 +837,8 @@ var AppServerClient = class {
 	}
 	/** Close the transport; the server revokes the connection immediately. */
 	close() {
+		this.unbridgeNotifications?.();
+		this.unbridgeNotifications = null;
 		this.transport.close();
 		this.initializeResult = null;
 		this.notificationListeners.clear();

package/package.json

@@ -1,32 +1,41 @@
-{
-  "name": "@flowy-agent-store/client",
-  "version": "0.1.0-beta.2",
-  "description": "Transport-agnostic App Server client (docs/agent-store/07 \u00a72.2)",
-  "type": "module",
-  "license": "Apache-2.0",
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.mts",
-      "import": "./dist/index.mjs",
-      "require": "./dist/index.cjs"
-    },
-    "./package.json": "./package.json"
-  },
-  "files": [
-    "dist"
-  ],
-  "dependencies": {
-    "@flowy-agent-store/protocol": "0.1.0-beta.2"
-  },
-  "scripts": {
-    "build": "tsdown",
-    "prepack": "tsdown"
-  },
-  "publishConfig": {
-    "access": "public",
-    "registry": "https://registry.npmjs.org/"
-  },
-  "main": "./dist/index.cjs",
-  "module": "./dist/index.mjs",
-  "types": "./dist/index.d.mts"
-}
+{
+  "name": "@flowy-agent-store/client",
+  "version": "0.1.0-beta.3",
+  "description": "Transport-agnostic App Server client (docs/agent-store/07 §2.2)",
+  "type": "module",
+  "license": "Apache-2.0",
+  "engines": {
+    "node": ">=22"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Michael-Lfx/allo.git",
+    "directory": "web/packages/client"
+  },
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@flowy-agent-store/protocol": "0.1.0-beta.3"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "prepack": "tsdown"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts"
+}