@flowy-agent-store/client 0.1.0-beta.10

package/dist/index.cjs

@@ -0,0 +1,2750 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let _flowy_agent_store_protocol = require("@flowy-agent-store/protocol");
+//#region src/transport.ts
+/**
+* JSON-RPC 2.0 transport over WebSocket for the App Server protocol.
+*
+* Works in browsers and in Node 22+/Bun (global `WebSocket`). The browser
+* WebSocket API cannot set custom headers, so an optional bearer token is
+* appended as a query parameter (`?token=...`) when provided; HTTP calls in
+* the SDK use the `Authorization` header instead.
+*/
+/**
+* True for loopback-only URLs (`127.0.0.0/8`, `::1`, `localhost`).
+* SDK spawn contract (docs/agent-store/12-sdk-packaging.md P0-4): an SDK
+* must only speak the local-trusted mode over loopback; anything else is
+* rejected before connecting.
+*/
+function isLoopbackUrl(raw) {
+	try {
+		const host = new URL(raw).hostname.toLowerCase();
+		if (host === "localhost" || host === "::1") return true;
+		if (host.startsWith("[") && host.endsWith("]")) return host === "[::1]";
+		const parts = host.split(".").map(Number);
+		return parts.length === 4 && parts[0] === 127 && parts.every((n) => Number.isInteger(n) && n >= 0 && n <= 255);
+	} catch {
+		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();
+	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 = () => {
+			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;
+			this.setLifecycle("closed");
+			this.rejectConnect(new _flowy_agent_store_protocol.TransportError("connect", "app-server connection closed before opening"));
+		};
+		socket.onerror = () => {
+			if (this.socket === socket) socket.close();
+		};
+		return promise;
+	}
+	request(method, params) {
+		const socket = this.requireSocket();
+		const id = this.nextId++;
+		const payload = {
+			jsonrpc: "2.0",
+			id,
+			method,
+			params
+		};
+		return new Promise((resolve, reject) => {
+			const timer = setTimeout(() => {
+				this.pending.delete(id);
+				reject(new _flowy_agent_store_protocol.RequestTimeoutError(method, this.requestTimeoutMs));
+			}, this.requestTimeoutMs);
+			this.pending.set(id, {
+				resolve,
+				reject,
+				timer,
+				method
+			});
+			try {
+				socket.send(JSON.stringify(payload));
+			} catch (error) {
+				clearTimeout(timer);
+				this.pending.delete(id);
+				reject(new _flowy_agent_store_protocol.TransportError("send", `failed to send ${method}`, { cause: error }));
+			}
+		});
+	}
+	notify(method, params) {
+		const socket = this.requireSocket();
+		const payload = {
+			jsonrpc: "2.0",
+			method,
+			params
+		};
+		try {
+			socket.send(JSON.stringify(payload));
+		} catch (error) {
+			throw new _flowy_agent_store_protocol.TransportError("send", `failed to send notification ${method}`, { cause: error });
+		}
+	}
+	onNotification(listener) {
+		this.listeners.add(listener);
+		return () => {
+			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.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 });
+		return this.socket;
+	}
+	handleMessage(raw) {
+		let message;
+		try {
+			message = JSON.parse(String(raw));
+		} catch {
+			return;
+		}
+		if ("id" in message && message.id !== void 0) {
+			const response = message;
+			const pending = response.id === null ? void 0 : this.pending.get(Number(response.id));
+			if (!pending) return;
+			clearTimeout(pending.timer);
+			this.pending.delete(Number(response.id));
+			if (response.error) pending.reject(new _flowy_agent_store_protocol.AppServerError(response.error));
+			else pending.resolve(response.result);
+			return;
+		}
+		if ("method" in message) {
+			const notification = message;
+			for (const listener of [...this.listeners]) try {
+				listener(notification);
+			} catch {}
+			return;
+		}
+	}
+	failAllPending(error) {
+		for (const [, pending] of this.pending) {
+			clearTimeout(pending.timer);
+			pending.reject(error);
+		}
+		this.pending.clear();
+	}
+};
+//#endregion
+//#region src/http-transport.ts
+/**
+* HTTP transport binding (doc `16` R2 / `05` §2.1.1).
+*
+* ## What this is
+*
+* The App Server exposes one method semantics over two bindings. This class is
+* the **request/response** binding: it maps a protocol method name onto the
+* server's hand-written REST route and returns the same result body the
+* WebSocket binding would.
+*
+* ## What this is not
+*
+* - **No server push.** HTTP has no notification channel, so `onNotification`
+*   hands back a no-op unsubscribe and `notify` throws. Live conversation / run
+*   events and subscription methods (`conversation/subscribe`, `run/subscribe`)
+*   exist **only** over `WebSocketTransport`; an `HttpTransport` is not a
+*   drop-in replacement for it. Consumers that need events must connect over
+*   WS (or run both).
+* - **One-shot handshake per call.** `05` §2.1.1: *each* HTTP call performs its
+*   own `POST /initialize` → `POST /initialized` → business call, after which
+*   the connection id expires. `connect()` therefore has nothing to hold open
+*   and is a no-op; it does not warm anything up.
+* - **Host file services stay out.** `/api/fs/*` (browse / list / read /
+*   metadata) is a host file service on the server *root*, explicitly not a
+*   protocol method (`05` §2.1.1), so it is not reachable through this class.
+*
+* ## The route table
+*
+* Every entry was read out of the handler bodies in
+* `crates/backend/nomifun-app-server/src/lib.rs` — the `source` field records
+* which handler (and, where one exists, which shared `*_impl`) proves the two
+* bindings run the same operation. Methods with no entry throw
+* `TransportError("send", …)` instead of silently degrading.
+*/
+/** Header the server mints the per-call connection id under. */
+const CONNECTION_HEADER = "x-app-server-connection-id";
+/** Protocol version this binding announces on the one-shot handshake. */
+const PROTOCOL_VERSION = "fp-14";
+/**
+* Protocol method → REST route. Verified from handler bodies, not from the
+* route list (a route existing does not prove which method it mirrors).
+*/
+const HTTP_ROUTES = {
+	ping: {
+		verb: "POST",
+		path: "/ping",
+		source: "ping() -> registry.require_ready"
+	},
+	"workspace/list": {
+		verb: "GET",
+		path: "/workspaces",
+		source: "workspace_list() -> owner-scoped active rows"
+	},
+	"workspace/revoke": {
+		verb: "DELETE",
+		path: "/workspaces/:workspace_id",
+		source: "workspace_delete() -> workspace_revoke_impl (shared with the WS arm)"
+	},
+	"conversation/create": {
+		verb: "POST",
+		path: "/conversations",
+		source: "conversation_create() -> create_conversation_for_user (shared)"
+	},
+	"conversation/list": {
+		verb: "GET",
+		path: "/conversations",
+		query: ["limit"],
+		source: "conversation_list() -> list_app_server_chats (shared); Query<limit>"
+	},
+	"conversation/get": {
+		verb: "GET",
+		path: "/conversations/:conversation_id",
+		source: "conversation_get() -> project_conversation_view (shared)"
+	},
+	"conversation/delete": {
+		verb: "DELETE",
+		path: "/conversations/:conversation_id",
+		source: "conversation_delete() -> conversation/delete arm semantics"
+	},
+	"conversation/messages": {
+		verb: "GET",
+		path: "/conversations/:conversation_id/messages",
+		query: [
+			"page",
+			"page_size",
+			"cursor"
+		],
+		source: "conversation_messages() -> list_conversation_messages_for_user (shared)"
+	},
+	"conversation/send": {
+		verb: "POST",
+		path: "/conversations/:conversation_id/messages",
+		body: [
+			"content",
+			"idempotency_key",
+			"attachments",
+			"mentions",
+			"model",
+			"reasoning_effort"
+		],
+		source: "conversation_send() -> send_conversation_message_for_user (shared with the WS arm)"
+	},
+	"conversation/cancel": {
+		verb: "POST",
+		path: "/conversations/:conversation_id/cancel",
+		source: "conversation_cancel() -> cancel arm semantics"
+	},
+	"agent/run": {
+		verb: "POST",
+		path: "/agent/run",
+		source: "agent_run() -> same request/receipt as the `agent/run` arm"
+	},
+	"team/run": {
+		verb: "POST",
+		path: "/team/run",
+		source: "team_run() -> execute_team_run() (same as the WS arm); Leader Conversation + planned delegation, `TeamRunReceipt`"
+	},
+	"run/get": {
+		verb: "GET",
+		path: "/run/:run_id",
+		source: "run_get()"
+	},
+	"run/result": {
+		verb: "GET",
+		path: "/run/:run_id/result",
+		source: "run_result()"
+	},
+	"run/plan": {
+		verb: "GET",
+		path: "/run/:run_id/plan",
+		source: "run_plan() -> get_run_plan_for_user() (same as the WS arm)"
+	},
+	"run/events": {
+		verb: "GET",
+		path: "/run/:run_id/events",
+		query: ["after_sequence", "limit"],
+		source: "run_events() -> runtime.list_events(after_sequence, limit) (same as the WS arm)"
+	},
+	"run/cancel": {
+		verb: "POST",
+		path: "/run/:run_id/cancel",
+		body: [
+			"expected_version",
+			"reason",
+			"idempotency_key"
+		],
+		source: "run_cancel() -> same CancelRunRequest as the WS arm"
+	},
+	"run/steer": {
+		verb: "POST",
+		path: "/run/:run_id/steer",
+		body: [
+			"text",
+			"expected_version",
+			"command_id",
+			"idempotency_key"
+		],
+		source: "run_steer() -> execute_steer_run (shared with the WS arm)"
+	},
+	"run/answer-decision": {
+		verb: "POST",
+		path: "/run/:run_id/answer-decision",
+		body: [
+			"step_id",
+			"attempt_id",
+			"answer",
+			"expected_execution_version",
+			"expected_step_version",
+			"expected_attempt_version"
+		],
+		source: "run_answer_decision() -> execute_answer_decision (shared with the WS arm; engine answer gate, no always_allow)"
+	},
+	"skill/list": {
+		verb: "GET",
+		path: "/skills",
+		source: "list_skills_route() -> list_skills_impl"
+	},
+	"skill/get": {
+		verb: "GET",
+		path: "/skills/:skill_id",
+		source: "get_skill_route() -> get_skill_impl"
+	},
+	"skill/files": {
+		verb: "GET",
+		path: "/skills/:skill_id/files",
+		source: "list_skill_files_route() -> list_skill_files_impl"
+	},
+	"connector/list": {
+		verb: "GET",
+		path: "/connectors",
+		source: "list_connectors_route() -> list_connectors_impl"
+	},
+	"models/list": {
+		verb: "GET",
+		path: "/models",
+		source: "list_models_route() -> list_models_impl"
+	},
+	"connector/get": {
+		verb: "GET",
+		path: "/connectors/:connector_id",
+		source: "get_connector_route() -> get_connector_impl"
+	},
+	"connector/status": {
+		verb: "GET",
+		path: "/connectors/:connector_id/status",
+		source: "connector_status_route() -> connector_status_impl"
+	},
+	"connector/test": {
+		verb: "POST",
+		path: "/connectors/:connector_id/test",
+		source: "connector_test_route() -> connector_test_impl"
+	},
+	"connector/call": {
+		verb: "POST",
+		path: "/connectors/:connector_id/call",
+		source: "connector_call_route() -> connector_call_impl"
+	},
+	"connector/auth/start": {
+		verb: "POST",
+		path: "/connectors/:connector_id/auth-start",
+		source: "connector_auth_start_route() -> connector_auth_start_impl (WS name uses slashes)"
+	},
+	"connector/auth/status": {
+		verb: "GET",
+		path: "/connectors/:connector_id/auth-status",
+		source: "connector_auth_status_route() -> connector_auth_status_impl"
+	},
+	"connector/auth/logout": {
+		verb: "POST",
+		path: "/connectors/:connector_id/auth-logout",
+		source: "connector_auth_logout_route() -> connector_auth_logout_impl"
+	},
+	"connector/credential/get": {
+		verb: "GET",
+		path: "/connectors/:connector_id/credential",
+		source: "connector_credential_get_route() -> connector_credential_get_impl"
+	},
+	"connector/credential/set": {
+		verb: "POST",
+		path: "/connectors/:connector_id/credential",
+		source: "connector_credential_set_route() -> connector_credential_set_impl"
+	},
+	"connector/credential/clear": {
+		verb: "POST",
+		path: "/connectors/:connector_id/credential/clear",
+		source: "connector_credential_clear_route() -> connector_credential_clear_impl"
+	},
+	"connector/register": {
+		verb: "POST",
+		path: "/connectors",
+		source: "register_connector_route() -> register_connector_impl"
+	},
+	"import/run": {
+		verb: "POST",
+		path: "/imports",
+		source: "run_import_route() -> run_import_impl"
+	},
+	"import/list": {
+		verb: "GET",
+		path: "/imports",
+		source: "list_imports_route() -> list_imports_impl"
+	},
+	"import/get": {
+		verb: "GET",
+		path: "/imports/:snapshot_id",
+		source: "get_import_route() -> get_import_impl"
+	},
+	"install/run": {
+		verb: "POST",
+		path: "/installs",
+		source: "run_install_route() -> install_impl"
+	},
+	"install/status": {
+		verb: "GET",
+		path: "/installs/:snapshot_id",
+		source: "install_status_route() -> install_status_impl"
+	},
+	"install/disable": {
+		verb: "POST",
+		path: "/installs/:snapshot_id/disable",
+		body: ["component_ids"],
+		source: "install_disable_route() -> install_disable_impl; body `component_ids`"
+	},
+	"install/enable": {
+		verb: "POST",
+		path: "/installs/:snapshot_id/enable",
+		body: ["component_ids"],
+		source: "install_enable_route() -> install_enable_impl; body `component_ids`"
+	},
+	"install/uninstall": {
+		verb: "POST",
+		path: "/installs/:snapshot_id/uninstall",
+		body: ["component_ids"],
+		source: "install_uninstall_route() -> install_uninstall_impl; body `component_ids`"
+	},
+	"market/add": {
+		verb: "POST",
+		path: "/markets",
+		source: "market_add_route() -> market_add_impl"
+	},
+	"market/list": {
+		verb: "GET",
+		path: "/markets",
+		source: "market_list_route() -> market_list_impl"
+	},
+	"market/get": {
+		verb: "GET",
+		path: "/markets/:marketplace_id",
+		source: "market_get_route() -> market_get_impl"
+	},
+	"market/remove": {
+		verb: "POST",
+		path: "/markets/:marketplace_id/remove",
+		body: ["cascade"],
+		source: "market_remove_route() -> market_remove_impl; body `cascade` defaults to true"
+	},
+	"market/auto-update": {
+		verb: "POST",
+		path: "/markets/:marketplace_id/auto-update",
+		body: ["enabled"],
+		source: "market_auto_update_route() -> market_auto_update_impl; body `enabled` defaults to true"
+	},
+	"market/refresh": {
+		verb: "POST",
+		path: "/markets/:marketplace_id/refresh",
+		source: "market_refresh_route() -> market_refresh_impl"
+	},
+	"market/entry-import": {
+		verb: "POST",
+		path: "/markets/:marketplace_id/entries/:entry_name/import",
+		source: "market_entry_import_route() -> market_entry_import_impl"
+	},
+	"market/settings": {
+		verb: "GET",
+		path: "/market-settings",
+		source: "market_settings_route() -> market_settings_impl"
+	},
+	"market/settings-set": {
+		verb: "POST",
+		path: "/market-settings",
+		body: ["auto_update_interval_hours", "entry_auto_update_kinds"],
+		source: "market_settings_set_route() -> market_settings_set_impl"
+	},
+	"store/list": {
+		verb: "GET",
+		path: "/store",
+		source: "store_list_route() -> store_list_impl"
+	},
+	"store/install-entry": {
+		verb: "POST",
+		path: "/store/:marketplace_id/entries/:entry_name/install",
+		source: "store_install_entry_route() -> store_install_entry_impl"
+	},
+	"store/update-entry": {
+		verb: "POST",
+		path: "/store/:marketplace_id/entries/:entry_name/update",
+		source: "store_update_entry_route() -> store_update_entry_impl"
+	}
+};
+/** Methods that are WebSocket-only by design — named so the error explains itself. */
+const WS_ONLY_METHODS = /* @__PURE__ */ new Set([
+	"initialize",
+	"initialized",
+	"conversation/subscribe",
+	"conversation/unsubscribe",
+	"run/subscribe",
+	"run/unsubscribe"
+]);
+var HttpTransport = class {
+	routes;
+	options;
+	closed = false;
+	constructor(options, routes = HTTP_ROUTES) {
+		this.options = options;
+		this.routes = routes;
+	}
+	/**
+	* No-op: the HTTP binding handshakes per call (`05` §2.1.1), so there is no
+	* connection to open. Kept for `Transport` compatibility.
+	*/
+	async connect() {
+		this.closed = false;
+	}
+	/**
+	* Perform one business call over its own handshake.
+	*
+	* Throws `TransportError("send", …)` for a method with no HTTP binding —
+	* never a silent fallback to another binding.
+	*/
+	async request(method, params) {
+		if (this.closed) throw new _flowy_agent_store_protocol.TransportError("connect", "http transport is closed");
+		const route = this.routes[method];
+		if (!route) {
+			const reason = WS_ONLY_METHODS.has(method) ? `"${method}" is WebSocket-only (doc 05 §2.1.1); use WebSocketTransport for subscriptions and live events` : `"${method}" has no HTTP binding in this SDK (doc 16 R2 route table)`;
+			throw new _flowy_agent_store_protocol.TransportError("send", reason);
+		}
+		const { path, query, body } = this.splitParams(route, params);
+		const connectionId = await this.openConnection();
+		const response = await this.fetchWithTimeout(route.verb, path, {
+			query,
+			body,
+			connectionId
+		});
+		return await this.readResult(response, method);
+	}
+	/**
+	* Not supported: HTTP carries no server-push. Throws instead of pretending.
+	*/
+	notify(method, _params) {
+		throw new _flowy_agent_store_protocol.TransportError("send", `HTTP binding cannot notify ("${method}"): notifications are WebSocket-only (doc 05 §2.1.1)`);
+	}
+	/**
+	* Returns a no-op unsubscribe: this binding receives **no** notifications.
+	*
+	* Not equivalent to the WebSocket binding — callers that need live events
+	* must use `WebSocketTransport` (or run both).
+	*/
+	onNotification(_listener) {
+		return () => void 0;
+	}
+	/** No-op: every call is independent, so nothing is held open. */
+	close() {
+		this.closed = true;
+	}
+	/**
+	* One-shot handshake: `POST /initialize` (connection id header) →
+	* `POST /initialized`. Returns the connection id.
+	*
+	* Public because host-side services that sit *outside* the protocol surface
+	* (`/api/fs/*`, the HTTP-only `POST /workspaces` register route) still need a
+	* ready connection id; they are not protocol methods, so they cannot go
+	* through `request()`.
+	*/
+	async openConnection() {
+		const connectionId = (await this.fetchWithTimeout("POST", "/initialize", { body: {
+			protocol_version: PROTOCOL_VERSION,
+			client: this.options.client ?? {
+				name: "flowy-agent-store-client",
+				version: "0.1.0"
+			},
+			...this.options.capabilities === void 0 ? {} : { capabilities: this.options.capabilities }
+		} })).headers.get(CONNECTION_HEADER);
+		if (!connectionId) throw new _flowy_agent_store_protocol.TransportError("connect", `handshake response is missing the ${CONNECTION_HEADER} header`, { retryable: true });
+		await this.fetchWithTimeout("POST", "/initialized", { connectionId });
+		return connectionId;
+	}
+	splitParams(route, params) {
+		const source = isRecord(params) ? params : {};
+		const pathParams = [...route.path.matchAll(/:([A-Za-z0-9_]+)/g)].map((match) => match[1]);
+		const path = route.path.replace(/:([A-Za-z0-9_]+)/g, (_full, name) => {
+			const value = source[name];
+			if (value === void 0 || value === null) throw new _flowy_agent_store_protocol.TransportError("send", `missing required path param "${name}" for ${route.verb} ${route.path}`);
+			return encodeURIComponent(String(value));
+		});
+		const query = {};
+		for (const key of route.query ?? []) {
+			const value = source[key];
+			if (value !== void 0 && value !== null) query[key] = String(value);
+		}
+		if (route.verb === "GET" || route.verb === "DELETE") return {
+			path,
+			query,
+			body: void 0
+		};
+		const carried = route.body ?? [];
+		const body = {};
+		for (const key of Object.keys(source)) {
+			if (pathParams.includes(key) || (route.query ?? []).includes(key)) continue;
+			if (carried.length > 0 && !carried.includes(key)) continue;
+			body[key] = source[key];
+		}
+		return {
+			path,
+			query,
+			body
+		};
+	}
+	async fetchWithTimeout(verb, path, request) {
+		const url = new URL(`${this.baseUrl()}${path}`);
+		for (const [key, value] of Object.entries(request.query ?? {})) url.searchParams.set(key, value);
+		const headers = { accept: "application/json" };
+		if (request.body !== void 0) headers["content-type"] = "application/json";
+		if (request.connectionId) headers[CONNECTION_HEADER] = request.connectionId;
+		if (this.options.token) headers.authorization = `Bearer ${this.options.token}`;
+		const controller = new AbortController();
+		const timeoutMs = this.options.requestTimeoutMs ?? 3e4;
+		const timer = setTimeout(() => controller.abort(), timeoutMs);
+		try {
+			const fetchImpl = this.options.fetch ?? globalThis.fetch;
+			if (!fetchImpl) throw new _flowy_agent_store_protocol.TransportError("connect", "no fetch implementation available");
+			return await fetchImpl(url.toString(), {
+				method: verb,
+				headers,
+				body: request.body === void 0 ? void 0 : JSON.stringify(request.body),
+				signal: controller.signal
+			});
+		} catch (error) {
+			if (error instanceof _flowy_agent_store_protocol.TransportError) throw error;
+			const aborted = error?.name === "AbortError";
+			throw new _flowy_agent_store_protocol.TransportError("send", aborted ? `${verb} ${path} timed out after ${timeoutMs}ms` : `${verb} ${path} failed: ${String(error)}`, {
+				retryable: true,
+				cause: error
+			});
+		} finally {
+			clearTimeout(timer);
+		}
+	}
+	/** 2xx → result body; otherwise the server's wire error becomes an `AppServerError`. */
+	async readResult(response, method) {
+		let payload = void 0;
+		const text = await response.text();
+		if (text.length > 0) try {
+			payload = JSON.parse(text);
+		} catch {
+			if (response.ok) throw new _flowy_agent_store_protocol.TransportError("receive", `${method}: response is not JSON`, { retryable: true });
+		}
+		if (response.ok) return payload;
+		throw appServerErrorFromWire(payload, response.status, method);
+	}
+	baseUrl() {
+		return this.options.baseUrl.replace(/\/+$/, "").replace(/\/ws$/, "");
+	}
+};
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+* Turn an HTTP failure body into the SDK error model.
+*
+* Shared by this transport and by host-side helpers (webui `lib/client.ts`) so
+* a second spelling of the wire-error mapping cannot drift. Two wire contracts
+* reach this function, both of them `AppError` on the server:
+*
+* - the App Server emits `{code, message, retryable, details, request_id}`
+*   (`into_wire_error`), which is exactly the `AppServerError` shape;
+* - the standalone host file service (`/api/fs/*`) emits the `ErrorResponse`
+*   envelope `{success: false, error, code, details?}` — same error, another
+*   spelling: `error` carries the human message, and there is no retry hint, so
+*   a 5xx status stays the retry signal.
+*
+* Anything else becomes a retryable-on-5xx `TransportError`.
+*/
+function appServerErrorFromWire(payload, status, context = "request") {
+	if (isRecord(payload) && typeof payload.code === "string" && typeof payload.message === "string") return new _flowy_agent_store_protocol.AppServerError({
+		code: payload.code,
+		message: payload.message,
+		retryable: payload.retryable === true,
+		request_id: payload.request_id ?? null,
+		details: isRecord(payload.details) ? payload.details : {}
+	});
+	if (isRecord(payload) && payload.success === false && typeof payload.code === "string" && typeof payload.error === "string") return new _flowy_agent_store_protocol.AppServerError({
+		code: payload.code,
+		message: payload.error,
+		retryable: status >= 500,
+		request_id: null,
+		details: isRecord(payload.details) ? payload.details : {}
+	});
+	return new _flowy_agent_store_protocol.TransportError("receive", `${context}: HTTP ${status} without a wire error body`, { retryable: status >= 500 });
+}
+/** Exposed for tests and docs (R5): the verified method → route table. */
+function httpRouteTable() {
+	return HTTP_ROUTES;
+}
+//#endregion
+//#region src/agents.ts
+var AgentClient = class {
+	transport;
+	constructor(transport) {
+		this.transport = transport;
+	}
+	/** List Agent Store AgentDefinitions (public summaries only). */
+	list() {
+		return this.transport.request("agent/list", {});
+	}
+	/** Fetch one AgentDefinition; raw prompts never cross the wire. */
+	get(agentId) {
+		return this.transport.request("agent/get", { agent_id: agentId });
+	}
+	/**
+	* Export one AgentDefinition as a portable {@link ExpertPack}.
+	*
+	* Requires WebSocket: like the rest of this family, `agent/export` has no HTTP
+	* route. The expert must be installed and enabled, or the host answers
+	* `agent_not_installed` / `agent_disabled`; a host whose `[expert_export]`
+	* table refuses the id answers `policy_denied`. Check
+	* `capabilities.expert_export` for the *seam* — it does not promise this id is
+	* exportable.
+	*/
+	export(agentId) {
+		return this.transport.request("agent/export", { agent_id: agentId });
+	}
+};
+//#endregion
+//#region src/skills.ts
+var SkillClient = class {
+	transport;
+	constructor(transport) {
+		this.transport = transport;
+	}
+	/** List the Agent Store Skill catalog (public summaries only). */
+	list() {
+		return this.transport.request("skill/list", {});
+	}
+	/** Fetch one Skill detail; instructions are a bounded public summary. */
+	get(skillId) {
+		return this.transport.request("skill/get", { skill_id: skillId });
+	}
+	/**
+	* Every readable file inside a Skill's directory, with a tree digest.
+	*
+	* This is the only way to learn what a Skill actually ships: `get()` returns
+	* a bounded summary of `SKILL.md` and says nothing about the `references/`,
+	* `scripts/`, `templates/` and `assets/` beside it. Check
+	* `capabilities.skill_files` first — a host may wire the catalog without
+	* this face, in which case it answers `unsupported_operation`.
+	*/
+	files(skillId) {
+		return this.transport.request("skill/files", { skill_id: skillId });
+	}
+	/**
+	* One skill file's bytes, over the WebSocket binding.
+	*
+	* The wire carries base64 because JSON has no byte string, so this decodes
+	* back to `Uint8Array` for you. The HTTP route
+	* (`GET /api/app-server/skills/{id}/files/{path}`) returns the raw body
+	* instead, but that is deliberately not on the typed client's JSON
+	* transport — use this method, or `fetch` the route directly if you are on a
+	* host token.
+	*/
+	async readFile(skillId, path) {
+		return decodeBase64((await this.transport.request("skill/file", {
+			skill_id: skillId,
+			path
+		})).content);
+	}
+	/** Same as {@link readFile}, but also returns the server's content type. */
+	readFileWithType(skillId, path) {
+		return this.transport.request("skill/file", {
+			skill_id: skillId,
+			path
+		});
+	}
+};
+/**
+* Decode base64 to bytes (shared with the snapshot asset face, doc 38).
+*
+* `atob` is used when present (browsers, Bun, Node 16+) and a manual decode
+* otherwise, so the package keeps working on a bare Node without a DOM lib.
+*/
+function decodeBase64(content) {
+	if (typeof atob === "function") {
+		const binary = atob(content);
+		const bytes = new Uint8Array(binary.length);
+		for (let index = 0; index < binary.length; index += 1) bytes[index] = binary.charCodeAt(index);
+		return bytes;
+	}
+	const bufferCtor = globalThis.Buffer;
+	if (bufferCtor) return bufferCtor.from(content, "base64");
+	throw new Error("no base64 decoder available in this environment");
+}
+//#endregion
+//#region src/conversations.ts
+var ConversationClient = class {
+	transport;
+	constructor(transport) {
+		this.transport = transport;
+	}
+	create(input) {
+		const model = input.model ? {
+			provider_id: input.model.provider_id,
+			model: input.model.model
+		} : void 0;
+		return this.transport.request("conversation/create", {
+			name: input.name,
+			model,
+			workspace: input.workspaceId ? { id: input.workspaceId } : void 0,
+			reasoning_effort: input.reasoningEffort || void 0,
+			agent_id: input.agentId || void 0,
+			team_id: input.teamId || void 0
+		});
+	}
+	update(conversationId, input) {
+		return this.transport.request("conversation/update", {
+			conversation_id: conversationId,
+			name: input.name,
+			model: input.model ? {
+				provider_id: input.model.provider_id,
+				model: input.model.model
+			} : void 0,
+			reasoning_effort: input.reasoningEffort || void 0
+		});
+	}
+	modelOptions() {
+		return this.transport.request("conversation/model-options", {});
+	}
+	list(limit = 100) {
+		return this.transport.request("conversation/list", { limit });
+	}
+	get(conversationId) {
+		return this.transport.request("conversation/get", { conversation_id: conversationId });
+	}
+	messages(query) {
+		return this.transport.request("conversation/messages", {
+			conversation_id: query.conversationId,
+			page: query.page,
+			page_size: query.pageSize,
+			cursor: query.cursor
+		});
+	}
+	/**
+	* R15（W10）：`attachments` 是**会话工作区内的绝对路径**（图片附件）。
+	* doc `27` §4.1：`mentions` 是**本轮挂载的技能**（`kind: "skill"`）——技能的正文与
+	* 不可变快照都随这一轮走；`agent` / `connector` 在 send 上没有载体，服务端会以
+	* `invalid_request` **明确拒绝**（不是静默不挂）。
+	*
+	* 两者缺省都不上 wire，保持老调用方的形状逐字不变；服务端只接受会话工作区内的真实
+	* 文件（越界 / 相对路径 / 不存在一律拒），准入见 `nomifun-app-server` 的
+	* `resolve_conversation_attachments` 与 `send_mention_skills`。
+	*
+	* 第 4 个参数同时接受旧的 `string[]`（附件）与选项对象——再堆一个位置参数会让调用点
+	* 变成一串没有名字的布尔/数组。
+	*/
+	send(conversationId, content, idempotencyKey, options = {}) {
+		const attachments = Array.isArray(options) ? options : options.attachments ?? [];
+		const mentions = Array.isArray(options) ? [] : options.mentions ?? [];
+		const model = Array.isArray(options) ? void 0 : options.model;
+		const reasoningEffort = Array.isArray(options) ? void 0 : options.reasoningEffort;
+		return this.transport.request("conversation/send", {
+			conversation_id: conversationId,
+			content,
+			idempotency_key: idempotencyKey,
+			...attachments.length > 0 ? { attachments } : {},
+			...mentions.length > 0 ? { mentions } : {},
+			...model ? { model: {
+				provider_id: model.provider_id,
+				model: model.model
+			} } : {},
+			...reasoningEffort ? { reasoning_effort: reasoningEffort } : {}
+		});
+	}
+	cancel(conversationId) {
+		return this.transport.request("conversation/cancel", { conversation_id: conversationId });
+	}
+	delete(conversationId) {
+		return this.transport.request("conversation/delete", { conversation_id: conversationId });
+	}
+	/**
+	* Subscribe to one conversation's realtime stream (doc `16` R1).
+	*
+	* `options.fetchMessages` is what makes auto catch-up possible: a detected
+	* sequence gap or a `conversation/resync-required` triggers one transcript
+	* fetch whose result is handed to `onBackfill`. Conversations have no event
+	* replay API (`05` §「V1 不提供 after_cursor 事件追平」), so the transcript is
+	* the recovery medium — unlike Runs, where `run/events` replays the events
+	* themselves.
+	*/
+	async follow(conversationId, options = {}) {
+		await this.transport.request("conversation/subscribe", { conversation_id: conversationId });
+		return new ConversationSubscription(this.transport, conversationId, {
+			fetchMessages: (id) => this.messages({
+				conversationId: id,
+				pageSize: 50
+			}),
+			...options
+		});
+	}
+};
+/** Events held before the first listener attaches (see `pendingLimit`). */
+const DEFAULT_PENDING_LIMIT = 256;
+var ConversationSubscription = class {
+	transport;
+	conversationId;
+	options;
+	events = /* @__PURE__ */ new Set();
+	resyncs = /* @__PURE__ */ new Set();
+	errors = /* @__PURE__ */ new Set();
+	backfills = /* @__PURE__ */ new Set();
+	closed = false;
+	lastSeenSequence = 0;
+	removeListener;
+	/**
+	* `follow()` resolves as soon as the server acknowledged the subscription,
+	* but the caller attaches listeners one tick later. Events landing in that
+	* window used to be dropped silently; they are held here (oldest first) and
+	* flushed to the first `onEvent` listener.
+	*/
+	pending = [];
+	pendingDropped = 0;
+	backfillInFlight = null;
+	constructor(transport, conversationId, options = {}) {
+		this.transport = transport;
+		this.conversationId = conversationId;
+		this.options = options;
+		this.removeListener = transport.onNotification((notification) => this.dispatch(notification));
+	}
+	get lastSequence() {
+		return this.lastSeenSequence;
+	}
+	/** Events dropped because nobody was listening and the buffer was full. */
+	get droppedPendingCount() {
+		return this.pendingDropped;
+	}
+	onEvent(listener) {
+		this.events.add(listener);
+		if (this.events.size === 1 && this.pending.length > 0) {
+			const queued = this.pending;
+			this.pending = [];
+			for (const event of queued) this.deliver(event);
+		}
+		return () => this.events.delete(listener);
+	}
+	onResync(listener) {
+		this.resyncs.add(listener);
+		return () => this.resyncs.delete(listener);
+	}
+	/**
+	* Auto catch-up result (R1). Fires only when `autoResync` is on and the
+	* transcript fetch succeeded; the listener owns replacing the transcript.
+	*/
+	onBackfill(listener) {
+		this.backfills.add(listener);
+		return () => this.backfills.delete(listener);
+	}
+	/**
+	* Failures that used to be swallowed: the catch-up fetch, and a failed
+	* re-subscribe during `rearm()`. Listener isolation keeps one bad listener
+	* from hiding the error from the others.
+	*/
+	onError(listener) {
+		this.errors.add(listener);
+		return () => this.errors.delete(listener);
+	}
+	async close() {
+		if (this.closed) return;
+		this.closed = true;
+		this.removeListener?.();
+		this.removeListener = null;
+		this.events.clear();
+		this.resyncs.clear();
+		this.errors.clear();
+		this.backfills.clear();
+		this.pending = [];
+		try {
+			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`. The server restarts a conversation's sequence at
+	* 1 for a fresh subscription, which is exactly why the cursor resets. On a
+	* failed re-subscribe the error reaches `onError` and the caller can still
+	* backfill the outage window via `conversation/messages`.
+	*/
+	async rearm() {
+		if (this.closed) return;
+		this.removeListener?.();
+		this.removeListener = this.transport.onNotification((notification) => this.dispatch(notification));
+		this.lastSeenSequence = 0;
+		try {
+			await this.transport.request("conversation/subscribe", { conversation_id: this.conversationId });
+		} catch (error) {
+			this.emitError(error);
+			throw error;
+		}
+	}
+	dispatch(notification) {
+		if (notification.method === "conversation/event") {
+			const event = notification.params;
+			if (event.conversation_id !== this.conversationId) return;
+			if (!Number.isFinite(event.sequence)) return;
+			if (event.sequence <= this.lastSeenSequence) return;
+			const gap = this.lastSeenSequence > 0 && event.sequence > this.lastSeenSequence + 1;
+			this.lastSeenSequence = event.sequence;
+			if (this.events.size === 0) this.buffer(event);
+			else this.deliver(event);
+			if (gap) {
+				this.emitResync("gap");
+				this.requestBackfill("gap");
+			}
+			return;
+		}
+		if (notification.method === "conversation/resync-required") {
+			if (!notification.params.conversation_ids.includes(this.conversationId)) return;
+			this.emitResync(notification.params.reason);
+			this.requestBackfill(notification.params.reason);
+		}
+	}
+	buffer(event) {
+		const limit = this.options.pendingLimit ?? DEFAULT_PENDING_LIMIT;
+		this.pending.push(event);
+		while (this.pending.length > limit) {
+			this.pending.shift();
+			this.pendingDropped += 1;
+		}
+	}
+	deliver(event) {
+		for (const listener of [...this.events]) try {
+			listener(event);
+		} catch {}
+	}
+	emitResync(reason) {
+		for (const listener of [...this.resyncs]) try {
+			listener(reason);
+		} catch {}
+	}
+	emitError(error) {
+		for (const listener of [...this.errors]) try {
+			listener(error);
+		} catch {}
+	}
+	/**
+	* One in-flight catch-up at a time: a burst of resync signals collapses into
+	* a single transcript fetch (the fetch itself returns the newest page, so the
+	* result supersedes every signal that arrived before it).
+	*/
+	requestBackfill(reason) {
+		if (this.closed || this.options.autoResync === false) return;
+		const fetchMessages = this.options.fetchMessages;
+		if (!fetchMessages || this.backfillInFlight) return;
+		const task = (async () => {
+			try {
+				const page = await fetchMessages(this.conversationId);
+				if (this.closed) return;
+				const backfill = {
+					conversationId: this.conversationId,
+					reason,
+					messages: page?.items ?? [],
+					hasMore: page?.has_more === true
+				};
+				for (const listener of [...this.backfills]) try {
+					listener(backfill);
+				} catch {}
+			} catch (error) {
+				this.emitError(error);
+			}
+		})();
+		this.backfillInFlight = task;
+		task.finally(() => {
+			if (this.backfillInFlight === task) this.backfillInFlight = null;
+		});
+	}
+};
+//#endregion
+//#region src/connectors.ts
+/**
+* How long {@link ConnectorClient.waitForAuth} waits by default: the host's own
+* callback window is 120s, so a shorter client budget would give up on flows the
+* host is still willing to finish.
+*/
+const DEFAULT_AUTH_TIMEOUT_MS = 12e4;
+const DEFAULT_AUTH_POLL_MS = 500;
+var ConnectorClient = class {
+	transport;
+	constructor(transport) {
+		this.transport = transport;
+	}
+	/** List the Agent Store Connector catalog (public summaries only). */
+	list() {
+		return this.transport.request("connector/list", {});
+	}
+	/** Fetch one Connector detail: namespaced tools + auth state. */
+	get(connectorId) {
+		return this.transport.request("connector/get", { connector_id: connectorId });
+	}
+	/** Combined auth × probe status. `connected` only when auth is ready AND the last probe succeeded. */
+	status(connectorId) {
+		return this.transport.request("connector/status", { connector_id: connectorId });
+	}
+	/**
+	* Run a connection probe and report what the connector currently offers —
+	* including each tool's `input_schema`.
+	*
+	* It really connects: a stdio connector gets its child process spawned, an
+	* HTTP/SSE one gets `initialize` + `tools/list`. The result is **persisted**,
+	* so this is also what refreshes the tool list `get()` reads back.
+	*
+	* Named `test` and not `probe` on purpose: this repo's split is `test` for the
+	* action (wire `connector/test`, `test_connection`) and `probe` for its
+	* artifact (`ConnectorProbeResult`, `probe_status`), and every method here is
+	* the last segment of its wire method.
+	*/
+	test(connectorId) {
+		return this.transport.request("connector/test", { connector_id: connectorId });
+	}
+	/**
+	* Check the current OAuth state for a connector.
+	*
+	* Read `error` too: a flow that failed after the browser step is reported as
+	* `state: "not_authenticated"` **plus** `error`, because the wire has no
+	* failing state to flip to. {@link waitForAuth} is the loop that does this.
+	*/
+	authStatus(connectorId) {
+		return this.transport.request("connector/auth/status", { connector_id: connectorId });
+	}
+	/**
+	* The credential form a connector needs filled in, as **this caller** sees it
+	* (doc `34` §6.1).
+	*
+	* `mode` says which kind of authentication applies (`none` / `oauth` / `token`),
+	* `status` whether anything is still missing, and `missing` names the keys.
+	* `fields` is everything needed to render the form — labels, placeholders,
+	* descriptions and the marketplace's "where do I get a key" link, in both
+	* languages. No secret ever comes back: only `plain` fields carry a `value`.
+	*/
+	credentials(connectorId) {
+		return this.transport.request("connector/credential/get", { connector_id: connectorId });
+	}
+	/**
+	* Store what the user typed and get the new state back.
+	*
+	* Only keys the connector's own declaration names are accepted — the form is
+	* the whole write surface. `secret` fields go to the host's credential store
+	* under the caller's own namespace, `plain` fields into the connector's
+	* configuration, so a shared host never resolves one user's token for another.
+	*/
+	setCredentials(connectorId, values) {
+		return this.transport.request("connector/credential/set", {
+			connector_id: connectorId,
+			values
+		});
+	}
+	/**
+	* Forget stored credentials. `keys` omitted = every secret field of this
+	* connector. Idempotent: clearing what is not there succeeds.
+	*/
+	clearCredentials(connectorId, keys) {
+		return this.transport.request("connector/credential/clear", {
+			connector_id: connectorId,
+			...keys ? { keys } : {}
+		});
+	}
+	/**
+	* Register a connector this host never imported — your own MCP server, handed
+	* over together with the template that says what it needs (doc `34` §6.5).
+	*
+	* The **template is the whole declaration**: whatever `${secret:NAME}` the URL,
+	* headers or env name becomes that connector's credential form, so there is no
+	* `token-schema.json` to ship and nothing to install from a marketplace. The
+	* connector's own non-secret settings travel in `values`.
+	*
+	* Secrets do **not** travel here: hand them over with {@link setCredentials},
+	* which keeps exactly one write surface for values. The returned detail already
+	* carries the credential block, so `missing` tells you which keys are still
+	* needed.
+	*
+	* Re-registering the same name updates it; a builtin server's name is refused.
+	* The row is created **disabled** — enabling it still requires a probe that
+	* passes — and this method is on the installation-owner-only surface, because
+	* choosing where the host reaches is the owner's call.
+	*/
+	register(registration) {
+		return this.transport.request("connector/register", registration);
+	}
+	/**
+	* Kick off the OAuth browser flow on the trusted host. Returns the start
+	* acknowledgement immediately; follow it with {@link waitForAuth}.
+	*
+	* `state: "error"` here is a failure that happened **before** the browser was
+	* opened (endpoint discovery, client identity, binding the callback, launching
+	* the browser): nothing was shown to the user, so `error` is the whole story
+	* and there is nothing to wait for.
+	*/
+	authStart(connectorId) {
+		return this.transport.request("connector/auth/start", { connector_id: connectorId });
+	}
+	/**
+	* Wait for an authorization that was started (in the browser, or by a
+	* previous `authStart`) to finish — and **report why** when it does not.
+	*
+	* A hand-rolled `while (state !== "authenticated") poll()` loop ends in "it
+	* never became authenticated", with the reason sitting unread in the status it
+	* already fetched: a token exchange the authorization server refused (a
+	* throttling gateway answers `slow_down`), a callback timeout, a CSRF/path
+	* mismatch. Those land in `authStatus().error` *only*, and the state stays
+	* `not_authenticated` — there is no failing state on the wire.
+	*
+	* Resolves for every domain outcome (`authenticated` / `error` / `timeout`);
+	* rejects only when the status read itself fails (transport or protocol), the
+	* same rule as `connector/call`. The wait is bounded by `timeoutMs`; a caller
+	* that needs to stop earlier can race the returned promise.
+	*/
+	async waitForAuth(connectorId, options = {}) {
+		const deadline = Date.now() + (options.timeoutMs ?? DEFAULT_AUTH_TIMEOUT_MS);
+		const pollMs = options.pollMs ?? DEFAULT_AUTH_POLL_MS;
+		for (;;) {
+			const status = await this.authStatus(connectorId);
+			if (status.state === "authenticated") return { state: "authenticated" };
+			if (status.error) return {
+				state: "error",
+				error: status.error
+			};
+			if (Date.now() >= deadline) return { state: "timeout" };
+			await new Promise((resolve) => setTimeout(resolve, pollMs));
+		}
+	}
+	/** Revoke the OAuth token for a connector. */
+	logout(connectorId) {
+		return this.transport.request("connector/auth/logout", { connector_id: connectorId }).then(() => void 0);
+	}
+	/**
+	* Run one tool on a registered connector, through the host's own connection.
+	*
+	* The host holds the transport, its headers and its OAuth token; this sends a
+	* tool name and an argument object and nothing else — you cannot name a URL,
+	* a command or a header. Whether the pair is callable at all is the host's
+	* `[connector_proxy]` policy: once its operator turns the proxy on, the
+	* enabled connectors are callable, and `allow` / `deny` are that operator's
+	* optional narrowing and subtraction. So `policy_denied` means either that
+	* the host never turned the proxy on, or that this pair was narrowed out or
+	* explicitly denied — not that a tool name was misspelled in a list you were
+	* supposed to maintain.
+	*
+	* Arguments are passed through verbatim (there is no client-side schema
+	* check); `get()` / `test()` return each tool's `input_schema` so you can see
+	* what it takes, and a parameter the server rejects comes back as
+	* `is_error: true`, not as a rejected promise.
+	*
+	* Resolves even when the tool itself failed — check `is_error`. It rejects
+	* only when the call never reached the tool: `connector_call_timeout`,
+	* `connector_call_failed`, `response_too_large`, `connector_unavailable`,
+	* `policy_denied`, `not_found`.
+	*/
+	call(connectorId, tool, args = {}) {
+		return this.transport.request("connector/call", {
+			connector_id: connectorId,
+			tool,
+			arguments: args
+		});
+	}
+};
+//#endregion
+//#region src/runs.ts
+/**
+* Run client: agent/run, run/get, run/result, run/events, run/cancel plus the
+* realtime `follow` subscription over the WebSocket transport.
+*/
+var RunClient = class {
+	transport;
+	constructor(transport) {
+		this.transport = transport;
+	}
+	/** Start an Agent run and return its asynchronous receipt. */
+	agent(input) {
+		return this.transport.request("agent/run", toWire(input));
+	}
+	/**
+	* Start a Team run (`16` §7 决策 3): the server creates the Leader
+	* Conversation, materializes/binds the Team's execution template and returns
+	* the public run id of the execution the Leader started.
+	*
+	* The receipt is `TeamRunReceipt`, not `RunReceipt` — a Team Run has no lead
+	* preset revision/digest to report. Member pool and concurrency limits are not
+	* inputs; sending `planning` is rejected as `invalid_request`.
+	*/
+	team(input) {
+		return this.transport.request("team/run", toTeamWire(input));
+	}
+	/** Read the authoritative run state. */
+	get(runId) {
+		return this.transport.request("run/get", { run_id: runId });
+	}
+	/** Read the terminal result (fails until the run reaches a terminal state). */
+	result(runId) {
+		return this.transport.request("run/result", { run_id: runId });
+	}
+	/**
+	* Read the authoritative plan / step snapshot (W4 / W6, resolves D-W6-1):
+	* titles, statuses, retries with their reason, errors and timings — none of
+	* which the append-only event log carries.
+	*/
+	plan(runId) {
+		return this.transport.request("run/plan", { run_id: runId });
+	}
+	/** Replay persisted events after a cursor. */
+	events(query) {
+		return this.transport.request("run/events", {
+			run_id: query.runId,
+			after_sequence: query.afterSequence,
+			limit: query.limit
+		});
+	}
+	/** Request cancellation; the terminal state is confirmed by events/run/get. */
+	cancel(input) {
+		return this.transport.request("run/cancel", {
+			run_id: input.runId,
+			expected_version: input.expectedVersion,
+			command_id: input.commandId,
+			idempotency_key: input.idempotencyKey
+		});
+	}
+	/**
+	* Inject steering text into the currently active step of a running Agent
+	* (runtime durable conversation effect; server resolves the opaque step).
+	*/
+	steer(input) {
+		return this.transport.request("run/steer", {
+			run_id: input.runId,
+			text: input.text,
+			expected_version: input.expectedVersion,
+			command_id: input.commandId,
+			idempotency_key: input.idempotencyKey
+		});
+	}
+	/**
+	* Answer the pending decision of a `waiting_input` attempt.
+	*
+	* The three `expected*Version` tokens are mandatory CAS inputs, normally the
+	* ones projected on the pending `approval.requested` event. The server passes
+	* them straight to the engine's single answer gate, so a stale token is a
+	* `conflict`, never a silent overwrite. There is no `always_allow` here: the
+	* desktop confirmation route's approve-all flag is not part of this protocol.
+	*/
+	answerDecision(input) {
+		return this.transport.request("run/answer-decision", {
+			run_id: input.runId,
+			step_id: input.stepId,
+			attempt_id: input.attemptId,
+			answer: input.answer,
+			expected_execution_version: input.expectedExecutionVersion,
+			expected_step_version: input.expectedStepVersion,
+			expected_attempt_version: input.expectedAttemptVersion
+		});
+	}
+	/** Subscribe to best-effort realtime events for one run. */
+	async follow(runId, options) {
+		const params = { run_id: runId };
+		await this.transport.request("run/subscribe", params);
+		const subscription = new EventSubscription(this.transport, runId, (afterSequence) => this.events({
+			runId,
+			afterSequence
+		}), options);
+		if (options?.catchUp !== false) await subscription.catchUp().catch(() => void 0);
+		return subscription;
+	}
+};
+/** Upper bound for the silent catch-up page (cursor baseline, not delivery). */
+const CATCH_UP_LIMIT = 500;
+/** Prune the dedup set past this size (sequences are per-run monotonic). */
+const SEEN_SET_PRUNE_AT = 2e3;
+const SEEN_SET_KEEP_BELOW_MAX = 500;
+var EventSubscription = class {
+	transport;
+	runId;
+	fetchAfter;
+	eventListeners = /* @__PURE__ */ new Set();
+	resyncListeners = /* @__PURE__ */ new Set();
+	errorListeners = /* @__PURE__ */ new Set();
+	closed = false;
+	unsubscribeNotification = null;
+	lastSeenSequence = 0;
+	seenSequences = /* @__PURE__ */ new Set();
+	resyncInFlight = null;
+	autoResync;
+	constructor(transport, runId, fetchAfter, options) {
+		this.transport = transport;
+		this.runId = runId;
+		this.fetchAfter = fetchAfter;
+		this.autoResync = options?.autoResync !== false;
+		this.unsubscribeNotification = transport.onNotification((notification) => {
+			this.dispatch(notification);
+		});
+	}
+	onEvent(listener) {
+		this.eventListeners.add(listener);
+		return () => {
+			this.eventListeners.delete(listener);
+		};
+	}
+	onResync(listener) {
+		this.resyncListeners.add(listener);
+		return () => {
+			this.resyncListeners.delete(listener);
+		};
+	}
+	onError(listener) {
+		this.errorListeners.add(listener);
+		return () => {
+			this.errorListeners.delete(listener);
+		};
+	}
+	get lastSequence() {
+		return this.lastSeenSequence;
+	}
+	async close() {
+		if (this.closed) return;
+		this.closed = true;
+		this.unsubscribeNotification?.();
+		this.eventListeners.clear();
+		this.resyncListeners.clear();
+		this.errorListeners.clear();
+		try {
+			await this.transport.request("run/unsubscribe", { run_id: this.runId });
+		} catch {}
+	}
+	dispatch(notification) {
+		if (this.closed) return;
+		if (notification.method === "event") {
+			const event = notification.params;
+			if (event.run_id !== this.runId) return;
+			if (!Number.isFinite(event.sequence) || this.seenSequences.has(event.sequence)) return;
+			this.markSeen(event.sequence);
+			this.emitEvent(event);
+			return;
+		}
+		if (notification.method === "run/resync-required") {
+			const params = notification.params;
+			if (params.run_ids.length > 0 && !params.run_ids.includes(this.runId)) return;
+			for (const listener of [...this.resyncListeners]) try {
+				listener(params);
+			} catch {}
+			if (this.autoResync && this.fetchAfter) this.resync().catch((error) => this.emitError(error));
+			return;
+		}
+	}
+	/**
+	* Silent cursor baseline: mark already-persisted events seen WITHOUT
+	* dispatching, so the first resync never replays history as "new".
+	* For explicit history use `RunClient.events({ afterSequence: 0 })`.
+	*/
+	async catchUp() {
+		if (this.closed || !this.fetchAfter) return;
+		const history = await this.fetchAfter(0);
+		const page = Array.isArray(history) ? history.slice(0, CATCH_UP_LIMIT) : [];
+		for (const event of page) if (event.run_id === this.runId && Number.isFinite(event.sequence)) this.markSeen(event.sequence);
+	}
+	/**
+	*追平 missed events via `run/events` after the cursor. Returned (and
+	* dispatched) in sequence order, deduplicated against live delivery.
+	* Concurrent calls share one flight.
+	*/
+	async resync() {
+		if (this.closed) return [];
+		if (this.resyncInFlight) return this.resyncInFlight;
+		if (!this.fetchAfter) return [];
+		const fetchAfter = this.fetchAfter;
+		const task = (async () => {
+			const missed = await fetchAfter(this.lastSeenSequence);
+			const fresh = (Array.isArray(missed) ? [...missed] : []).filter((event) => event.run_id === this.runId && Number.isFinite(event.sequence)).sort((left, right) => left.sequence - right.sequence).filter((event) => {
+				if (this.seenSequences.has(event.sequence)) return false;
+				this.markSeen(event.sequence);
+				return true;
+			});
+			for (const event of fresh) this.emitEvent(event);
+			return fresh;
+		})();
+		this.resyncInFlight = task;
+		try {
+			return await task;
+		} finally {
+			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;
+		if (this.seenSequences.size > SEEN_SET_PRUNE_AT) {
+			const floor = this.lastSeenSequence - SEEN_SET_KEEP_BELOW_MAX;
+			for (const seen of this.seenSequences) if (seen < floor) this.seenSequences.delete(seen);
+		}
+	}
+	emitEvent(event) {
+		for (const listener of [...this.eventListeners]) try {
+			listener(event);
+		} catch {}
+	}
+	emitError(error) {
+		for (const listener of [...this.errorListeners]) try {
+			listener(error);
+		} catch {}
+	}
+	/** Forward transport-level errors into subscription error listeners. */
+	deliverError(error) {
+		if (error instanceof _flowy_agent_store_protocol.TransportError) for (const listener of [...this.errorListeners]) try {
+			listener(error);
+		} catch {}
+	}
+};
+function toWire(input) {
+	return {
+		agent_id: input.agentId,
+		agent_version: input.agentVersion,
+		goal: input.goal,
+		input: input.input,
+		workspace: input.workspaceId ? { id: input.workspaceId } : void 0,
+		steps: input.steps,
+		command_id: input.commandId,
+		idempotency_key: input.idempotencyKey,
+		mentions: input.mentions,
+		model: input.model ? {
+			provider_id: input.model.provider_id,
+			model: input.model.model
+		} : void 0,
+		reasoning_effort: input.reasoningEffort || void 0
+	};
+}
+function toTeamWire(input) {
+	return {
+		team_id: input.teamId,
+		team_version: input.teamVersion,
+		goal: input.goal,
+		input: input.input,
+		workspace: input.workspaceId ? { id: input.workspaceId } : void 0,
+		command_id: input.commandId,
+		idempotency_key: input.idempotencyKey
+	};
+}
+//#endregion
+//#region src/store.ts
+var StoreError = class extends Error {
+	code;
+	constructor(code, message) {
+		super(message);
+		this.code = code;
+		this.name = "StoreError";
+	}
+};
+const DEFAULT_READY_TIMEOUT_MS = 3e4;
+const DEFAULT_READY_POLL_MS = 400;
+const DEFAULT_READY_POLL_MAX_MS = 4e3;
+const DEFAULT_READY_PROBE_MS = 5e3;
+/** Every string a `LocalizedText` carries, for haystack building. */
+function localizedValues(text) {
+	if (typeof text === "string") return [text];
+	if (!text || typeof text !== "object") return [];
+	return Object.values(text).filter((value) => typeof value === "string");
+}
+function haystack(item) {
+	return [
+		item.entry_name,
+		item.name,
+		item.id,
+		item.description ?? "",
+		item.version,
+		...localizedValues(item.display_name),
+		...localizedValues(item.display_description),
+		...localizedValues(item.profession),
+		...(item.tags ?? []).flatMap(localizedValues)
+	].join("\n").toLowerCase();
+}
+function abortableDelay(ms, signal) {
+	return new Promise((resolve, reject) => {
+		if (signal?.aborted) {
+			reject(new StoreError("aborted", "the operation was aborted"));
+			return;
+		}
+		const timer = setTimeout(() => {
+			signal?.removeEventListener("abort", onAbort);
+			resolve();
+		}, ms);
+		const onAbort = () => {
+			clearTimeout(timer);
+			reject(new StoreError("aborted", "the operation was aborted"));
+		};
+		signal?.addEventListener("abort", onAbort, { once: true });
+	});
+}
+var StoreClient = class {
+	host;
+	readyTimeoutMs;
+	readyPollMs;
+	readyPollMaxMs;
+	readyProbeMs;
+	constructor(host, options = {}) {
+		this.host = host;
+		this.readyTimeoutMs = options.readyTimeoutMs ?? DEFAULT_READY_TIMEOUT_MS;
+		this.readyPollMs = options.readyPollMs ?? DEFAULT_READY_POLL_MS;
+		this.readyPollMaxMs = options.readyPollMaxMs ?? DEFAULT_READY_POLL_MAX_MS;
+		this.readyProbeMs = options.readyProbeMs ?? DEFAULT_READY_PROBE_MS;
+	}
+	/** Every item across enabled marketplaces, with install state. */
+	async list() {
+		return (await this.host.listStore()).items;
+	}
+	/** Case-insensitive substring search over the fields a user can see. */
+	async search(query, filter = {}) {
+		const needle = query.trim().toLowerCase();
+		return (await this.list()).filter((item) => {
+			if (filter.kind && item.kind !== filter.kind) return false;
+			if (!needle) return true;
+			return haystack(item).includes(needle);
+		});
+	}
+	/** Items currently installed on this host. */
+	async installed() {
+		return (await this.list()).filter((item) => item.installed);
+	}
+	/**
+	* The installed item that owns a given connector, or `null` when none does.
+	*
+	* A store item carries no field for the connector it installed — its
+	* `entry_name` is the *market's* name (real example: the entry
+	* `fenbi-baokao-decision` installs a server called `fenbi_mcp`), so a caller
+	* holding an id from `connectors.list()` cannot reach the `StoreItem` that
+	* `setEnabled()` / `uninstall()` require. `search()` cannot bridge that
+	* either: it is a substring scan over catalogue text, and the runtime name is
+	* not in it. This is the link, walked through the snapshot each installed item
+	* already points at.
+	*
+	* Both identifiers a caller may hold are accepted: the connector's own `id`
+	* (`connector/get`) and its `name` (`fenbi_mcp` — the MCP row's name and the
+	* tool namespace's middle segment). Matching is exact; call `list()`/`search()`
+	* when the question is "which catalogue entries mention X".
+	*/
+	async findByConnector(connectorId) {
+		const needle = connectorId.trim();
+		if (!needle) return null;
+		for (const item of await this.installed()) {
+			const snapshotId = item.snapshot_id;
+			if (!snapshotId) continue;
+			if ((await this.host.getInstallStatus(snapshotId)).components.some((component) => component.kind === "connector" && (component.name === needle || component.id === needle))) return item;
+		}
+		return null;
+	}
+	/**
+	* Installed items whose marketplace offers a different version.
+	*
+	* Both conditions matter: `update_available` is computed from the imported
+	* snapshot even when nothing is installed, so filtering on it alone would
+	* report an "update" for an entry the user has never installed.
+	*/
+	async checkUpdates() {
+		return (await this.list()).filter((item) => item.installed && item.update_available);
+	}
+	/**
+	* What a caller can offer for an item's pending update.
+	*
+	* `"none"` means there is nothing to do; `"update"` means the entry is
+	* installed at a different version and `update()` is the action that lands it
+	* (`store/update-entry`, `36` D3); `"unknown"` is returned rather than
+	* guessing when the item carries no snapshot to replace.
+	*/
+	updateHint(item) {
+		if (!item.installed || !item.update_available) return "none";
+		return item.snapshot_id ? "update" : "unknown";
+	}
+	/**
+	* Upgrade an installed item to the version its marketplace advertises.
+	*
+	* The host does the ordering: new version installed first, previous one
+	* released only when that succeeded. So a failure resolves `ok: false` with
+	* the previous installation still in place (`releasedCount === 0`) — the
+	* caller never has to reason about a half-upgraded item.
+	*
+	* Refuses before the round trip when there is nothing to replace: an item that
+	* is not installed (`not_installed`) or is already current is not a failure of
+	* *this* call, and `updateHint()` is the way to ask first.
+	*/
+	async update(item, options = {}) {
+		this.assertUsable(item, options.signal);
+		this.requireSnapshot(item);
+		const result = await this.host.updateStoreEntry(item.marketplace_id, item.entry_name);
+		const components = result.outcomes ?? [];
+		const outcome = {
+			snapshotId: result.snapshot_id,
+			reused: result.reused,
+			components,
+			ok: result.errors.length === 0 && components.every((component) => component.ok),
+			errors: result.errors,
+			warnings: result.warnings,
+			installedCount: result.installed_count,
+			fromVersion: result.previous_version ?? void 0,
+			toVersion: result.version,
+			releasedCount: result.released_count ?? 0
+		};
+		if (options.waitForReady === false) return outcome;
+		return this.awaitReady(outcome, options);
+	}
+	/**
+	* Import (when needed) and install one store item, then wait until it is
+	* usable.
+	*/
+	async install(item, options = {}) {
+		this.assertUsable(item, options.signal);
+		const result = await this.host.installStoreEntry(item.marketplace_id, item.entry_name);
+		const components = result.outcomes ?? [];
+		const outcome = {
+			snapshotId: result.snapshot_id,
+			reused: result.reused,
+			components,
+			ok: result.errors.length === 0 && components.every((component) => component.ok),
+			errors: result.errors,
+			warnings: result.warnings,
+			installedCount: result.installed_count
+		};
+		if (options.waitForReady === false) return outcome;
+		return this.awaitReady(outcome, options);
+	}
+	/**
+	* Release an item's runtime artifacts and clear its install record.
+	*
+	* The server only clears the record for components it actually released, so a
+	* partial failure leaves `ok: false` with the failing component named — and
+	* the item stays installed, which is what makes a retry meaningful.
+	*/
+	async uninstall(item, options = {}) {
+		const snapshotId = this.requireSnapshot(item);
+		const componentIds = options.componentIds ?? await this.installedComponentIds(snapshotId);
+		if (componentIds.length === 0) return {
+			snapshotId,
+			reused: true,
+			components: [],
+			ok: true,
+			errors: [],
+			warnings: []
+		};
+		const status = await this.host.uninstallInstall(snapshotId, componentIds);
+		return this.outcomeFromStatus(snapshotId, status, false);
+	}
+	/**
+	* Switch an item's components on or off.
+	*
+	* Idempotent: the server sets the state it is asked for instead of toggling.
+	* A skill reports `skill_disable_flag_only` because the skill corpus has no
+	* enable state — that code is passed through, not swallowed, so a caller can
+	* tell "switched off" from "marked in the catalogue".
+	*/
+	async setEnabled(item, enabled, options = {}) {
+		const snapshotId = this.requireSnapshot(item);
+		const componentIds = options.componentIds ?? await this.installedComponentIds(snapshotId);
+		if (componentIds.length === 0) return {
+			snapshotId,
+			reused: true,
+			components: [],
+			ok: true,
+			errors: [],
+			warnings: []
+		};
+		const status = enabled ? await this.host.enableInstall(snapshotId, componentIds) : await this.host.disableInstall(snapshotId, componentIds);
+		return this.outcomeFromStatus(snapshotId, status, false);
+	}
+	assertUsable(item, signal) {
+		if (signal?.aborted) throw new StoreError("aborted", "the operation was aborted before it started");
+		if (item.blocked_reason) throw new StoreError("item_blocked", item.blocked_reason);
+	}
+	requireSnapshot(item) {
+		const snapshotId = item.snapshot_id;
+		if (!snapshotId) throw new StoreError("not_installed", `store item ${item.id} has no imported snapshot to act on`);
+		return snapshotId;
+	}
+	async installedComponentIds(snapshotId) {
+		return (await this.host.getInstallStatus(snapshotId)).components.filter((component) => component.state !== "not-installed").map((component) => component.id);
+	}
+	outcomeFromStatus(snapshotId, status, reused) {
+		const components = status.outcomes ?? [];
+		const errors = status.errors ?? [];
+		return {
+			snapshotId,
+			reused,
+			components,
+			ok: errors.length === 0 && components.every((component) => component.ok),
+			errors,
+			warnings: []
+		};
+	}
+	/**
+	* Poll until every component of the snapshot is usable.
+	*
+	* A timeout does **not** discard the install: the caller gets the successful
+	* install plus `ready: false` and `readyIssue: "ready_timeout"`, so a slow
+	* connector never turns into "the install failed".
+	*/
+	async awaitReady(outcome, options) {
+		const snapshotId = outcome.snapshotId;
+		if (!snapshotId) return outcome;
+		const status = await this.host.getInstallStatus(snapshotId);
+		const connectors = status.components.filter((component) => component.kind === "connector" && component.state !== "not-installed");
+		if (connectors.length > 0) await this.host.enableInstall(snapshotId, connectors.map((component) => component.id));
+		const deadline = Date.now() + (options.timeoutMs ?? this.readyTimeoutMs);
+		let interval = this.readyPollMs;
+		let nextProbeAt = 0;
+		let last = status.components;
+		for (;;) {
+			const now = Date.now();
+			const allowProbe = now >= nextProbeAt;
+			if (allowProbe) nextProbeAt = now + this.readyProbeMs;
+			const blocked = (await Promise.all(last.filter((component) => component.state !== "not-installed").map(async (component) => ({
+				component,
+				verdict: await this.readiness(component, allowProbe)
+			})))).find((entry) => !entry.verdict.ready);
+			if (!blocked) return {
+				...outcome,
+				ready: true
+			};
+			if (!blocked.verdict.ready && blocked.verdict.terminal) return {
+				...outcome,
+				ready: false,
+				readyIssue: blocked.verdict.terminal,
+				readyComponentId: blocked.component.id
+			};
+			if (Date.now() >= deadline) return {
+				...outcome,
+				ready: false,
+				readyIssue: "ready_timeout",
+				readyComponentId: blocked.component.id
+			};
+			await abortableDelay(interval, options.signal);
+			interval = Math.min(interval * 2, this.readyPollMaxMs);
+			last = (await this.host.getInstallStatus(snapshotId)).components;
+		}
+	}
+	/**
+	* Is this one component usable yet?
+	*
+	* Each kind answers with the narrowest read the protocol already offers. An
+	* unknown kind is reported ready rather than blocking: this layer cannot judge
+	* a component it does not understand, and a false timeout on a future kind
+	* would be worse than passing it through.
+	*
+	* `allowProbe` gates the one kind whose readiness needs a real connection (a
+	* connector); the other kinds answer from local reads, so the cadence does not
+	* apply to them.
+	*/
+	async readiness(component, allowProbe) {
+		try {
+			switch (component.kind) {
+				case "skill": return (await this.host.skills.list()).some((skill) => skill.name === component.name) ? { ready: true } : { ready: false };
+				case "agent": return (await this.host.agents.get(component.id)).preset_id ? { ready: true } : { ready: false };
+				case "team":
+					await this.host.teams.get(component.id);
+					return { ready: true };
+				case "connector": {
+					if (allowProbe && (await this.host.connectors.test(component.id)).success) return { ready: true };
+					const status = await this.host.connectors.status(component.id);
+					if (status.status === "connected") return { ready: true };
+					if (status.status === "authorization_required" || status.status === "reauthorization_required") return {
+						ready: false,
+						terminal: "authorization_required"
+					};
+					return { ready: false };
+				}
+				default: return { ready: true };
+			}
+		} catch {
+			return { ready: false };
+		}
+	}
+};
+//#endregion
+//#region src/teams.ts
+var TeamClient = class {
+	transport;
+	constructor(transport) {
+		this.transport = transport;
+	}
+	/** List AgentTeamDefinitions (fixed-member rosters). */
+	list() {
+		return this.transport.request("team/list", {});
+	}
+	/** Fetch one TeamDefinition; planning-context bodies are never returned. */
+	get(teamId) {
+		return this.transport.request("team/get", { team_id: teamId });
+	}
+	/**
+	* Export one TeamDefinition as a portable {@link ExpertPack}, with every member
+	* expanded and the **leader first**.
+	*
+	* All-or-nothing: if any member is uninstalled, disabled, or refused by the
+	* host's `[expert_export]` table, the whole call fails rather than returning a
+	* partial roster — the same posture `team/run` takes before it creates
+	* anything. `teamVersion` is an optional pin; a mismatch is `version_mismatch`.
+	*/
+	export(teamId, teamVersion) {
+		return this.transport.request("team/export", {
+			team_id: teamId,
+			team_version: teamVersion
+		});
+	}
+};
+//#endregion
+//#region src/models.ts
+var ModelClient = class {
+	transport;
+	constructor(transport) {
+		this.transport = transport;
+	}
+	/** Enabled providers' models; `is_default` marks the `agent/run` fallback. */
+	async list() {
+		return (await this.transport.request("models/list", {})).items;
+	}
+};
+//#endregion
+//#region src/workspaces.ts
+var WorkspaceClient = class {
+	transport;
+	constructor(transport) {
+		this.transport = transport;
+	}
+	list() {
+		return this.transport.request("workspace/list", {});
+	}
+	/**
+	* Validate + register (idempotently per canonical root) an absolute local
+	* directory chosen by the owner. The server canonicalizes the path and
+	* rejects links/reparse points; the returned view only carries the
+	* canonical path back to this same authenticated connection.
+	*/
+	create(path) {
+		return this.transport.request("workspace/create", { path });
+	}
+	/**
+	* Revoke (soft-delete) an owner's active workspace. Its conversations are
+	* kept and their `workspace_id` reference is preserved, so re-registering
+	* the same path re-activates the same workspace and those conversations
+	* become visible again.
+	*/
+	revoke(workspaceId) {
+		return this.transport.request("workspace/revoke", { workspace_id: workspaceId });
+	}
+};
+//#endregion
+//#region src/client.ts
+/**
+* Typed App Server client (`@flowy-agent-store/client`).
+*
+* Transport-agnostic: all business methods go through the injected
+* `Transport` (07 §2.3). Web-only helpers (asset URLs, `/api/fs/browse`,
+* one-shot HTTP registration) live in the host app, not here.
+*
+* Connection lifecycle: transport connect → `initialize` → protocol version
+* check → `initialized` notification → ready. Business methods require a
+* ready client; the server rejects them with `not_initialized` otherwise.
+*/
+var AppServerClient = class {
+	transport;
+	/** Legacy preset/execution workflow client. */
+	runs;
+	/** Persistent presetless Nomi chat client. */
+	conversations;
+	/** Owner-scoped workspace registry client (user-chosen paths). */
+	workspaces;
+	/** Agent Store Skill catalog client (`skill/list`, `skill/get`). */
+	skills;
+	/** Agent Store Connector catalog/status/probe/OAuth client. */
+	connectors;
+	/** Agent Store AgentDefinition catalog client (`agent/list`, `agent/get`). */
+	agents;
+	/** Agent Store Team catalog client (`team/list`, `team/get`). */
+	teams;
+	/** Public model directory (`models/list`, REQ-PAR-05b). */
+	models;
+	/**
+	* Agent Store lifecycle as one state machine: search → install (wait until
+	* usable) → enable/disable → uninstall. Composes the flat methods below; it
+	* adds no wire surface.
+	*/
+	store;
+	clientInfo;
+	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;
+		this.transport = options.transport;
+		this.runs = new RunClient(this.transport);
+		this.conversations = new ConversationClient(this.transport);
+		this.workspaces = new WorkspaceClient(this.transport);
+		this.skills = new SkillClient(this.transport);
+		this.connectors = new ConnectorClient(this.transport);
+		this.agents = new AgentClient(this.transport);
+		this.teams = new TeamClient(this.transport);
+		this.models = new ModelClient(this.transport);
+		this.store = new StoreClient(this, options.store);
+		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 {}
+		});
+	}
+	get ready() {
+		return this.initializeResult !== null;
+	}
+	get initializeInfo() {
+		return this.initializeResult;
+	}
+	/** 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,
+			client: this.clientInfo,
+			capabilities: this.capabilities
+		};
+		const result = await this.transport.request("initialize", request);
+		if (result.protocol_version !== _flowy_agent_store_protocol.APP_SERVER_PROTOCOL_VERSION) throw new _flowy_agent_store_protocol.ProtocolError("version_mismatch", `server protocol version ${result.protocol_version} is not supported (client ${_flowy_agent_store_protocol.APP_SERVER_PROTOCOL_VERSION})`);
+		this.transport.notify("initialized", {});
+		this.initializeResult = result;
+		return result;
+	}
+	onNotification(listener) {
+		this.notificationListeners.add(listener);
+		return () => {
+			this.notificationListeners.delete(listener);
+		};
+	}
+	/** Close the transport; the server revokes the connection immediately. */
+	close() {
+		this.unbridgeNotifications?.();
+		this.unbridgeNotifications = null;
+		this.transport.close();
+		this.initializeResult = null;
+		this.notificationListeners.clear();
+	}
+	/** Import a local CodeBuddy/WorkBuddy source directory (roadmap Phase 1). */
+	async runImport(input) {
+		return this.transport.request("import/run", input);
+	}
+	async listImports() {
+		return this.transport.request("import/list", {});
+	}
+	/** One immutable snapshot with its standardized components. */
+	async getImport(snapshotId) {
+		return this.transport.request("import/get", { snapshot_id: snapshotId });
+	}
+	/**
+	* The plugin-level asset inventory of one snapshot (`import/assets`, doc 38):
+	* the `avatars/`, `bin/` and `scripts/` files beside the skills, sorted by
+	* path with a sha256 each. This is the same address space `readImportAsset`
+	* accepts and an `ExpertPack.assets` names — one provider, one whitelist.
+	* Check `capabilities.snapshot_assets` first.
+	*/
+	async listImportAssets(snapshotId) {
+		return this.transport.request("import/assets", { snapshot_id: snapshotId });
+	}
+	/**
+	* One plugin-level asset's bytes, over the WebSocket binding (`import/asset`,
+	* doc 38). Base64 on the wire, decoded to `Uint8Array` here — the same
+	* envelope `skills.readFile()` decodes. Persona text and skill bodies are
+	* deliberately not reachable through this face.
+	*/
+	async readImportAsset(snapshotId, path) {
+		return decodeBase64((await this.transport.request("import/asset", {
+			snapshot_id: snapshotId,
+			path
+		})).content);
+	}
+	/** Install a snapshot into the runtime (roadmap Phase 2). */
+	async runInstall(input) {
+		return this.transport.request("install/run", input);
+	}
+	/** Per-component installation state of a snapshot. */
+	async getInstallStatus(snapshotId) {
+		return this.transport.request("install/status", { snapshot_id: snapshotId });
+	}
+	/**
+	* Disable installed components.
+	*
+	* The runtime state moves with the flag — a connector's MCP server is switched
+	* off, an expert's Preset is disabled — while the artifacts stay on disk. A
+	* skill is the documented exception: the corpus has no enable state, so it
+	* reports `skill_disable_flag_only` and the flag stays a catalogue marker.
+	*/
+	async disableInstall(snapshotId, componentIds) {
+		return this.transport.request("install/disable", {
+			snapshot_id: snapshotId,
+			component_ids: componentIds
+		});
+	}
+	/** Re-enable previously disabled components. */
+	async enableInstall(snapshotId, componentIds) {
+		return this.transport.request("install/enable", {
+			snapshot_id: snapshotId,
+			component_ids: componentIds
+		});
+	}
+	/** Uninstall: remove runtime artifacts and clear the state (snapshot kept). */
+	async uninstallInstall(snapshotId, componentIds) {
+		return this.transport.request("install/uninstall", {
+			snapshot_id: snapshotId,
+			component_ids: componentIds
+		});
+	}
+	/** Register a marketplace source on the trusted host. */
+	async addMarketplace(input) {
+		return this.transport.request("market/add", input);
+	}
+	/** All active marketplaces. */
+	async listMarketplaces() {
+		return this.transport.request("market/list", {});
+	}
+	/** One marketplace with its discovered entries. */
+	async getMarketplace(marketplaceId) {
+		return this.transport.request("market/get", { marketplace_id: marketplaceId });
+	}
+	/** Remove a marketplace (`cascade` uninstalls snapshots installed from it). */
+	async removeMarketplace(marketplaceId, cascade) {
+		return this.transport.request("market/remove", {
+			marketplace_id: marketplaceId,
+			cascade
+		});
+	}
+	/** Toggle auto-update for a marketplace. */
+	async setMarketplaceAutoUpdate(marketplaceId, enabled) {
+		return this.transport.request("market/auto-update", {
+			marketplace_id: marketplaceId,
+			enabled
+		});
+	}
+	/** Re-fetch a marketplace source and rebuild entries when the revision changed. */
+	async refreshMarketplace(marketplaceId) {
+		return this.transport.request("market/refresh", { marketplace_id: marketplaceId });
+	}
+	/** Import one discovered marketplace entry (provenance linked). */
+	async importMarketplaceEntry(marketplaceId, entryName) {
+		return this.transport.request("market/entry-import", {
+			marketplace_id: marketplaceId,
+			entry_name: entryName
+		});
+	}
+	/**
+	* The host's market policy: sweep cadence, auto-upgrade kind whitelist and the
+	* last sweep's reading (doc `37` §3.2).
+	*
+	* Host-level rather than per-market: it answers "when does the sweep run and
+	* what may it touch", while {@link setMarketplaceAutoUpdate} answers "which
+	* market participates".
+	*/
+	async getMarketSettings() {
+		return this.transport.request("market/settings", {});
+	}
+	/**
+	* Update the host's market policy. An absent field is left alone; the host
+	* writes the value into its `config.toml` and answers with the file re-read,
+	* so a caller can never see an optimistic echo.
+	*/
+	async setMarketSettings(patch) {
+		return this.transport.request("market/settings-set", patch);
+	}
+	/** All store items across enabled marketplaces (display + install state). */
+	async listStore() {
+		return this.transport.request("store/list", {});
+	}
+	/** One-click install: import (when missing) + register in one call. */
+	async installStoreEntry(marketplaceId, entryName) {
+		return this.transport.request("store/install-entry", {
+			marketplace_id: marketplaceId,
+			entry_name: entryName
+		});
+	}
+	/**
+	* Upgrade an installed entry to the version its marketplace advertises.
+	*
+	* The host installs the new version before releasing the old one, so a failure
+	* leaves the previous installation usable (`released_count: 0` is the machine
+	* readable form of that). Refused for an entry that is not installed — this is
+	* never a second way to install something.
+	*/
+	async updateStoreEntry(marketplaceId, entryName) {
+		return this.transport.request("store/update-entry", {
+			marketplace_id: marketplaceId,
+			entry_name: entryName
+		});
+	}
+};
+//#endregion
+//#region src/conversation-handle.ts
+/** How long `send` waits for a terminal event before returning a still-open turn. */
+const TURN_TIMEOUT_MS = 6e5;
+function stringValue(value) {
+	return typeof value === "string" ? value : void 0;
+}
+/** Aggregate assistant text from `message.delta` events (fallback path). */
+function aggregateAssistantText(events) {
+	const byId = /* @__PURE__ */ new Map();
+	for (const event of events) {
+		if (event.event_type !== "message.delta") continue;
+		if (typeof event.payload["content"] !== "string") continue;
+		const id = stringValue(event.payload["message_id"]) ?? "";
+		if (!id) continue;
+		byId.set(id, (byId.get(id) ?? "") + event.payload["content"]);
+	}
+	let last = null;
+	for (const value of byId.values()) if (value) last = value;
+	return last;
+}
+function lastUsage(events) {
+	for (let index = events.length - 1; index >= 0; index -= 1) if (events[index].event_type === "context.usage") {
+		const value = events[index].payload["context_usage"];
+		return value && typeof value === "object" ? value : null;
+	}
+}
+var ConversationHandle = class ConversationHandle {
+	conversationId;
+	conversations;
+	subscription;
+	constructor(conversations, conversationId, subscription) {
+		this.conversations = conversations;
+		this.conversationId = conversationId;
+		this.subscription = subscription;
+	}
+	/** Create a new conversation and subscribe to its live event stream. */
+	static async open(conversations, input) {
+		const view = await conversations.create(input ?? {});
+		const subscription = await conversations.follow(view.conversation_id);
+		return new ConversationHandle(conversations, view.conversation_id, subscription);
+	}
+	/** Attach to an existing conversation (by id) and subscribe. */
+	static async attach(conversations, conversationId) {
+		const subscription = await conversations.follow(conversationId);
+		return new ConversationHandle(conversations, conversationId, subscription);
+	}
+	/** Register a listener for every conversation event (returns an unsubscribe). */
+	onEvent(listener) {
+		return this.subscription.onEvent(listener);
+	}
+	/**
+	* Send a message (a "turn") and await its terminal state. The event collector
+	* is installed before the send so streaming deltas / usage are captured even
+	* when they arrive before the send acknowledgment is parsed.
+	*/
+	async send(content, options = {}) {
+		const collected = [];
+		let terminalResolve;
+		let terminal = false;
+		const terminalPromise = new Promise((resolve) => {
+			terminalResolve = resolve;
+		});
+		const markTerminal = () => {
+			if (terminal) return;
+			terminal = true;
+			terminalResolve();
+		};
+		const off = this.subscription.onEvent((event) => {
+			collected.push(event);
+			if (event.event_type === "turn.status" && stringValue(event.payload["status"]) === "completed") markTerminal();
+			else if (event.event_type === "message.error") markTerminal();
+		});
+		let receipt;
+		try {
+			receipt = await this.conversations.send(this.conversationId, content, options.idempotencyKey ?? crypto.randomUUID());
+			if (!receipt.completed && !terminal) await Promise.race([terminalPromise, new Promise((resolve) => setTimeout(resolve, TURN_TIMEOUT_MS))]);
+		} finally {
+			off();
+		}
+		return {
+			conversation_id: this.conversationId,
+			content,
+			message_id: receipt.message_id,
+			turn_id: receipt.turn_id,
+			accepted: receipt.accepted,
+			completed: receipt.completed || terminal,
+			events: collected,
+			assistant_text: receipt.result_text ?? aggregateAssistantText(collected),
+			isError: Boolean(receipt.result_error) || collected.some((event) => event.event_type === "message.error"),
+			result_error: receipt.result_error ?? null,
+			result_error_code: receipt.result_error_code ?? null,
+			usage: lastUsage(collected)
+		};
+	}
+	/** Cancel the in-flight turn (idempotent; erases the current transcript row). */
+	cancel() {
+		return this.conversations.cancel(this.conversationId).then(() => void 0);
+	}
+	/** Fetch the transcript (paginated). */
+	messages(query) {
+		return this.conversations.messages({
+			conversationId: this.conversationId,
+			...query
+		});
+	}
+	/** Unsubscribe and release the handle. */
+	close() {
+		return this.subscription.close();
+	}
+};
+/** Convenience: simple transcript snapshot (all roles, newest last). */
+function conversationMessages(page) {
+	return page.items;
+}
+//#endregion
+//#region src/turn-result.ts
+const KIND_BY_EVENT = {
+	"run.plan_changed": "plan",
+	"task.updated": "task",
+	"attempt.updated": "attempt",
+	"run.status_changed": "status",
+	"approval.requested": "approval",
+	"approval.responded": "approval"
+};
+function asRecord(payload) {
+	return payload && typeof payload === "object" ? payload : {};
+}
+function pickString(source, key) {
+	const value = source[key];
+	return typeof value === "string" ? value : void 0;
+}
+function toItem(event) {
+	const payload = asRecord(event.payload);
+	return {
+		sequence: event.sequence,
+		event_type: event.event_type,
+		kind: KIND_BY_EVENT[event.event_type] ?? "other",
+		ref_id: pickString(payload, "attempt_id") ?? pickString(payload, "step_id"),
+		status: pickString(payload, "status"),
+		reason: pickString(payload, "reason") ?? pickString(payload, "change")
+	};
+}
+function extractUsage(events) {
+	for (const event of events) {
+		const payload = asRecord(event.payload);
+		const candidate = asRecord(payload["usage"] ?? payload["context_usage"]);
+		const input = candidate["input_tokens"] ?? candidate["inputTokens"];
+		const output = candidate["output_tokens"] ?? candidate["outputTokens"];
+		const total = candidate["total_tokens"] ?? candidate["totalTokens"];
+		if (typeof input === "number" || typeof output === "number" || typeof total === "number") return {
+			...typeof input === "number" ? { input_tokens: input } : {},
+			...typeof output === "number" ? { output_tokens: output } : {},
+			...typeof total === "number" ? { total_tokens: total } : {}
+		};
+	}
+}
+/** Build the terminal turn result from the authoritative view + event stream. */
+function aggregateTurnResult(view, events) {
+	const ordered = [...events].sort((left, right) => left.sequence - right.sequence);
+	const usage = extractUsage(ordered);
+	return {
+		run_id: view.run_id,
+		status: view.status,
+		version: view.version,
+		final_response: view.summary ?? null,
+		output_files: view.output_files ?? [],
+		preset_revision: view.preset_revision ?? null,
+		content_digest: view.content_digest ?? null,
+		events: ordered,
+		items: ordered.map(toItem),
+		...usage ? { usage } : {}
+	};
+}
+//#endregion
+//#region src/run-handle.ts
+/** Poll cadence while waiting for a terminal state (authoritative backstop). */
+const POLL_INTERVAL_MS = 3e3;
+/** Absolute cap so a wedged run cannot hang `finished` forever. */
+const FINISHED_TIMEOUT_MS = 18e5;
+/** Live events kept for the terminal aggregation (bounded). */
+const MAX_BUFFERED_EVENTS = 2e3;
+const TERMINAL = [
+	"completed",
+	"failed",
+	"cancelled"
+];
+/**
+* A launched Agent run. Async-iterable over live events; await `.finished`
+* for the blocking Codex `thread.run()` shape.
+*/
+var AgentRunHandle = class {
+	runId;
+	receipt;
+	runClient;
+	poll;
+	subscription;
+	terminalView = null;
+	terminalResult = null;
+	finishWaiters = [];
+	iteratorQueue = [];
+	iteratorWaiters = [];
+	iteratorClosed = false;
+	bufferedEvents = [];
+	bufferedSequences = /* @__PURE__ */ new Set();
+	constructor(runClient, receipt, subscription, poll) {
+		this.runId = receipt.run_id;
+		this.receipt = receipt;
+		this.runClient = runClient;
+		this.subscription = subscription;
+		this.poll = poll;
+		subscription?.onEvent((event) => this.pushEvent(event));
+		subscription?.onError(() => void 0);
+	}
+	/**
+	* Resolves with the aggregated terminal turn result (≈ `thread.run()`):
+	* authoritative status/version plus `final_response`, output files, the
+	* persisted event stream and derived items.
+	*/
+	get finished() {
+		if (this.terminalResult) return Promise.resolve(this.terminalResult);
+		return new Promise((resolve, reject) => {
+			this.finishWaiters.push((error, result) => {
+				if (error) {
+					reject(error);
+					return;
+				}
+				resolve(result);
+			});
+			this.ensureTerminalWatch();
+		});
+	}
+	/** Latest live cursor (proxied from the subscription when attached). */
+	get lastSequence() {
+		return this.subscription?.lastSequence ?? 0;
+	}
+	/** Ask the server to cancel; terminal confirmation still arrives via events/get. */
+	async cancel() {
+		await this.runClient.cancel({
+			runId: this.runId,
+			expectedVersion: this.receipt.version
+		});
+	}
+	/**
+	* Inject steering text into the currently active step (≈ Codex turn steer).
+	* Throws `conflict` when the run already changed or has no active step —
+	* refresh `receipt`-level state via `runClient.get()` and retry.
+	*/
+	async steer(text) {
+		return this.runClient.steer({
+			runId: this.runId,
+			text,
+			expectedVersion: this.receipt.version
+		});
+	}
+	/** Detach the live subscription (events may still be polled via run/events). */
+	async close() {
+		this.iteratorClosed = true;
+		const waiters = this.iteratorWaiters;
+		this.iteratorWaiters = [];
+		for (const waiter of waiters) waiter({
+			value: void 0,
+			done: true
+		});
+		const subscription = this.subscription;
+		this.subscription = null;
+		await subscription?.close();
+	}
+	/** Async iterator over live events (≈ `thread.runStreamed()`). */
+	[Symbol.asyncIterator]() {
+		return { next: () => {
+			if (this.iteratorQueue.length > 0) {
+				const event = this.iteratorQueue.shift();
+				return Promise.resolve({
+					value: event,
+					done: false
+				});
+			}
+			if (this.iteratorClosed) return Promise.resolve({
+				value: void 0,
+				done: true
+			});
+			return new Promise((resolve) => {
+				this.iteratorWaiters.push(resolve);
+			});
+		} };
+	}
+	pushEvent(event) {
+		if (!this.bufferedSequences.has(event.sequence)) {
+			this.bufferedSequences.add(event.sequence);
+			this.bufferedEvents.push(event);
+			if (this.bufferedEvents.length > MAX_BUFFERED_EVENTS) {
+				const dropped = this.bufferedEvents.shift();
+				if (dropped) this.bufferedSequences.delete(dropped.sequence);
+			}
+		}
+		const waiter = this.iteratorWaiters.shift();
+		if (waiter) {
+			waiter({
+				value: event,
+				done: false
+			});
+			return;
+		}
+		this.iteratorQueue.push(event);
+	}
+	/**
+	* Authoritative backfill for `finished`: `run/result` (terminal summary)
+	* plus the persisted `run/events` stream, falling back to the live buffer
+	* when the query fails.
+	*/
+	async aggregate(view) {
+		const result = await this.runClient.result(this.runId).catch(() => null);
+		const events = await this.runClient.events({
+			runId: this.runId,
+			afterSequence: 0,
+			limit: MAX_BUFFERED_EVENTS
+		}).catch(() => this.bufferedEvents);
+		const source = events.length > 0 ? events : this.bufferedEvents;
+		return aggregateTurnResult(result ?? view, source);
+	}
+	/** Poll run/get until terminal, then resolve all `finished` waiters once. */
+	ensureTerminalWatch() {
+		(async () => {
+			const deadline = Date.now() + FINISHED_TIMEOUT_MS;
+			try {
+				while (!this.terminalView && Date.now() < deadline) {
+					const view = await this.poll(this.runId);
+					if (TERMINAL.includes(view.status)) this.terminalView = view;
+					else await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
+				}
+				const waiters = this.finishWaiters;
+				this.finishWaiters = [];
+				if (!this.terminalView) {
+					const timeout = /* @__PURE__ */ new Error(`run ${this.runId} did not reach a terminal state in time`);
+					for (const waiter of waiters) waiter(timeout);
+					return;
+				}
+				this.terminalResult = await this.aggregate(this.terminalView);
+				for (const waiter of waiters) waiter(void 0, this.terminalResult);
+			} catch (error) {
+				const waiters = this.finishWaiters;
+				this.finishWaiters = [];
+				for (const waiter of waiters) waiter(error);
+			}
+		})();
+	}
+};
+/** Codex-parity launch: start the run and return a live handle immediately. */
+async function launchRun(runClient, input, options = {}) {
+	const receipt = await runClient.agent(input);
+	return new AgentRunHandle(runClient, receipt, options.follow === false ? null : await runClient.follow(receipt.run_id), (runId) => runClient.get(runId));
+}
+//#endregion
+//#region src/retry.ts
+/**
+* Retry helper (REQ-PAR-05e, ≈ Codex `retry_on_overload`): exponential backoff
+* with jitter, driven by the protocol's stable `retryable` hint.
+*
+* Only errors the server/transport marks retryable are retried; protocol
+* errors that carry `retryable: false` (validation, not_found, ...) surface
+* immediately. `command_id` / `idempotency_key` callers stay safe because the
+* App Server deduplicates replayed mutations.
+*/
+/** Run `operation`, retrying retryable failures with exponential backoff. */
+async function withRetry(operation, options = {}) {
+	const maxAttempts = Math.max(1, options.maxAttempts ?? 3);
+	const baseDelayMs = Math.max(0, options.baseDelayMs ?? 500);
+	const maxDelayMs = Math.max(baseDelayMs, options.maxDelayMs ?? 8e3);
+	const jitter = Math.min(1, Math.max(0, options.jitter ?? .25));
+	const sleep = options.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+	const shouldRetry = options.shouldRetry ?? ((error) => (0, _flowy_agent_store_protocol.isRetryableError)(error));
+	let lastError;
+	for (let attempt = 1; attempt <= maxAttempts; attempt += 1) try {
+		return await operation();
+	} catch (error) {
+		lastError = error;
+		if (attempt >= maxAttempts || !shouldRetry(error, attempt)) throw error;
+		const ceiling = Math.min(maxDelayMs, baseDelayMs * 2 ** (attempt - 1));
+		const delayMs = Math.round(ceiling * (1 - jitter) + Math.random() * ceiling * jitter);
+		options.onRetry?.({
+			attempt,
+			delayMs,
+			error
+		});
+		await sleep(delayMs);
+	}
+	throw lastError;
+}
+//#endregion
+exports.AgentClient = AgentClient;
+exports.AgentRunHandle = AgentRunHandle;
+exports.AppServerClient = AppServerClient;
+exports.ConnectorClient = ConnectorClient;
+exports.ConversationClient = ConversationClient;
+exports.ConversationHandle = ConversationHandle;
+exports.ConversationSubscription = ConversationSubscription;
+exports.EventSubscription = EventSubscription;
+exports.HttpTransport = HttpTransport;
+exports.ModelClient = ModelClient;
+exports.RunClient = RunClient;
+exports.SkillClient = SkillClient;
+exports.StoreClient = StoreClient;
+exports.StoreError = StoreError;
+exports.TeamClient = TeamClient;
+exports.WebSocketTransport = WebSocketTransport;
+exports.WorkspaceClient = WorkspaceClient;
+exports.aggregateTurnResult = aggregateTurnResult;
+exports.appServerErrorFromWire = appServerErrorFromWire;
+exports.conversationMessages = conversationMessages;
+exports.decodeBase64 = decodeBase64;
+exports.httpRouteTable = httpRouteTable;
+exports.isLoopbackUrl = isLoopbackUrl;
+exports.launchRun = launchRun;
+exports.withRetry = withRetry;