agents 0.22.0 → 0.24.0

package/dist/client-C9DAjZIY.js

@@ -0,0 +1,518 @@
+import { camelCaseToKebabCase, isInternalJsStubProp } from "./utils.js";
+import "./types.js";
+import { i as capnWebTransportUrl, n as CAPNWEB_TRANSPORT_SEND } from "./transport-protocol-BxyngQ_R.js";
+import { i as _classPrivateFieldInitSpec, n as _classPrivateFieldSet2, t as _classPrivateFieldGet2 } from "./classPrivateFieldGet2-DZBYAB34.js";
+import { PartySocket } from "partysocket";
+import { RpcTarget, newWebSocketRpcSession } from "capnweb";
+//#region src/websockets/capnweb-socket.ts
+/** Local root the host calls to deliver frames. */
+var Inbox = class extends RpcTarget {
+	constructor(socket) {
+		super();
+		this.socket = socket;
+	}
+	message(value) {
+		this.socket.dispatchEvent(new MessageEvent("message", { data: value }));
+	}
+};
+var _socket = /* @__PURE__ */ new WeakMap();
+var _root = /* @__PURE__ */ new WeakMap();
+/**
+* A WebSocket-shaped client for the Cap'n Web connection transport.
+*
+* It has the constructor, `readyState`, `send()`, `close()`, and events of
+* a `WebSocket`, so PartySocket (and therefore `useAgent` and
+* `AgentClient`) can drive it as a drop-in socket implementation and keep
+* owning reconnection, buffering, and backoff. Frames sent here travel
+* through the host's pipe method; frames from the host arrive as
+* `message` events.
+*
+* @experimental The transport is experimental.
+*/
+var CapnWebSocket = class CapnWebSocket extends EventTarget {
+	constructor(url, protocols) {
+		super();
+		this.CONNECTING = 0;
+		this.OPEN = 1;
+		this.CLOSING = 2;
+		this.CLOSED = 3;
+		this.readyState = CapnWebSocket.CONNECTING;
+		this.binaryType = "arraybuffer";
+		this.bufferedAmount = 0;
+		this.extensions = "";
+		this.protocol = "";
+		this.onopen = null;
+		this.onmessage = null;
+		this.onclose = null;
+		this.onerror = null;
+		_classPrivateFieldInitSpec(this, _socket, void 0);
+		_classPrivateFieldInitSpec(this, _root, void 0);
+		this.url = capnWebTransportUrl(url);
+		_classPrivateFieldSet2(_socket, this, protocols ? new WebSocket(this.url, protocols) : new WebSocket(this.url));
+		_classPrivateFieldSet2(_root, this, newWebSocketRpcSession(_classPrivateFieldGet2(_socket, this), new Inbox(this)));
+		_classPrivateFieldGet2(_socket, this).addEventListener("open", () => {
+			this.readyState = CapnWebSocket.OPEN;
+			this.protocol = _classPrivateFieldGet2(_socket, this).protocol;
+			this.dispatchEvent(new Event("open"));
+		});
+		_classPrivateFieldGet2(_socket, this).addEventListener("close", (event) => {
+			this.readyState = CapnWebSocket.CLOSED;
+			this.dispatchEvent(new CloseEvent("close", {
+				code: event.code,
+				reason: event.reason,
+				wasClean: event.wasClean
+			}));
+		});
+		_classPrivateFieldGet2(_socket, this).addEventListener("error", () => {
+			this.dispatchEvent(new Event("error"));
+		});
+	}
+	dispatchEvent(event) {
+		const handler = Reflect.get(this, `on${event.type}`);
+		if (typeof handler === "function") Reflect.apply(handler, this, [event]);
+		return super.dispatchEvent(event);
+	}
+	/**
+	* Invoke one of the host's native callables on the session root. The
+	* result keeps Cap'n Web semantics: an `RpcTarget` arrives as a live
+	* stub, a `ReadableStream` streams, and chained calls pipeline.
+	*/
+	invoke(method, args) {
+		if (this.readyState !== CapnWebSocket.OPEN) return Promise.reject(/* @__PURE__ */ new Error("Connection closed"));
+		const root = _classPrivateFieldGet2(_root, this);
+		return Promise.resolve(root[method](...args));
+	}
+	send(data) {
+		if (this.readyState !== CapnWebSocket.OPEN) throw new DOMException("WebSocket is not open", "InvalidStateError");
+		_classPrivateFieldGet2(_root, this)[CAPNWEB_TRANSPORT_SEND](data).catch(() => {
+			this.dispatchEvent(new Event("error"));
+		});
+	}
+	close(code, reason) {
+		if (this.readyState >= CapnWebSocket.CLOSING) return;
+		this.readyState = CapnWebSocket.CLOSING;
+		try {
+			_classPrivateFieldGet2(_root, this)[Symbol.dispose]();
+		} catch {}
+		_classPrivateFieldGet2(_socket, this).close(code, reason);
+	}
+};
+CapnWebSocket.CONNECTING = 0;
+CapnWebSocket.OPEN = 1;
+CapnWebSocket.CLOSING = 2;
+CapnWebSocket.CLOSED = 3;
+/**
+* A `CapnWebSocket` subclass that reports each instance it constructs.
+* PartySocket instantiates the class it is given; this is how a client
+* gets hold of the live socket to call `invoke()` without reaching into
+* PartySocket internals.
+*/
+function boundCapnWebSocket(onCreate) {
+	return class BoundCapnWebSocket extends CapnWebSocket {
+		constructor(url, protocols) {
+			super(url, protocols);
+			onCreate(this);
+		}
+	};
+}
+//#endregion
+//#region src/client.ts
+var AgentConnectionError = class extends Error {
+	constructor(event) {
+		const reason = event.reason || `WebSocket closed with code ${event.code}`;
+		super(`Agent connection closed: ${reason}`);
+		this.name = "AgentConnectionError";
+		this.code = event.code;
+		this.reason = event.reason;
+		this.wasClean = event.wasClean;
+	}
+};
+function isTerminalCloseEvent(event) {
+	return event.code === 1008 || event.code >= 4e3 && event.code <= 4999;
+}
+/**
+* Default timeout (in milliseconds) applied to non-streaming RPC calls
+* that don't pass an explicit `timeout`. Acts as a backstop so calls
+* whose response is lost (e.g. the connection drops mid-flight) reject
+* instead of hanging forever. Override per client via
+* `defaultCallTimeout`, or per call via `timeout` (0 disables).
+*/
+const DEFAULT_CALL_TIMEOUT_MS = 3e4;
+/**
+* Normalize `call()` options. The legacy shape is the stream callbacks
+* themselves (`{ onChunk, onDone, onError }`); the current shape nests
+* them under `stream` beside `timeout`.
+*/
+function splitCallOptions(options) {
+	return options !== void 0 && ("onChunk" in options || "onDone" in options || "onError" in options) ? {
+		stream: options,
+		timeout: void 0
+	} : {
+		stream: options?.stream,
+		timeout: options?.timeout
+	};
+}
+/**
+* One native call on the Cap'n Web transport, with the timeout and
+* stream-callback contract `call()` has on the JSON wire. The timeout
+* covers the whole call, draining included: on expiry the stream reader is
+* cancelled and the promise rejects once. A `ReadableStream` result is
+* drained into the stream callbacks when they are given; any other value,
+* live stubs included, passes straight through.
+*/
+async function nativeCall(socket, method, args, options, defaultTimeout) {
+	const { stream, timeout } = splitCallOptions(options);
+	const effectiveTimeout = timeout !== void 0 ? timeout : stream ? void 0 : defaultTimeout;
+	let reader;
+	let timer;
+	const work = (async () => {
+		const result = await socket.invoke(method, args);
+		if (stream && result instanceof ReadableStream) {
+			reader = result.getReader();
+			for (;;) {
+				const { done, value } = await reader.read();
+				if (done) break;
+				stream.onChunk?.(value);
+			}
+			stream.onDone?.(void 0);
+			return;
+		}
+		return result;
+	})();
+	const expiry = effectiveTimeout ? new Promise((_, reject) => {
+		timer = setTimeout(() => {
+			reader?.cancel().catch(() => {});
+			reject(/* @__PURE__ */ new Error(`RPC call to ${method} timed out after ${effectiveTimeout}ms`));
+		}, effectiveTimeout);
+	}) : void 0;
+	try {
+		return await (expiry ? Promise.race([work, expiry]) : work);
+	} catch (error) {
+		work.catch(() => {});
+		stream?.onError?.(error instanceof Error ? error.message : String(error));
+		throw error;
+	} finally {
+		if (timer) clearTimeout(timer);
+	}
+}
+var _pending = /* @__PURE__ */ new WeakMap();
+/**
+* Native calls issued while the Cap'n Web socket is still connecting or
+* between reconnects. They must not fall back to JSON frames — that would
+* change which methods are reachable and lose return-by-reference — so
+* they wait here and run on the next open socket, or reject when the
+* connection ends for good. Their timeout starts when they are issued.
+*/
+var NativeCallQueue = class {
+	constructor() {
+		_classPrivateFieldInitSpec(this, _pending, []);
+	}
+	enqueue(method, args, options, defaultTimeout) {
+		return new Promise((resolve, reject) => {
+			const { stream, timeout } = splitCallOptions(options);
+			const effectiveTimeout = timeout !== void 0 ? timeout : stream ? void 0 : defaultTimeout;
+			const startedAt = Date.now();
+			const entry = {
+				run: (socket) => {
+					const remaining = effectiveTimeout === void 0 ? void 0 : Math.max(1, effectiveTimeout - (Date.now() - startedAt));
+					nativeCall(socket, method, args, remaining === void 0 ? options : {
+						stream,
+						timeout: remaining
+					}, defaultTimeout).then(resolve, reject);
+				},
+				reject: (error) => {
+					stream?.onError?.(error.message);
+					reject(error);
+				}
+			};
+			_classPrivateFieldGet2(_pending, this).push(entry);
+			if (effectiveTimeout) setTimeout(() => {
+				const index = _classPrivateFieldGet2(_pending, this).indexOf(entry);
+				if (index === -1) return;
+				_classPrivateFieldGet2(_pending, this).splice(index, 1);
+				entry.reject(/* @__PURE__ */ new Error(`RPC call to ${method} timed out after ${effectiveTimeout}ms`));
+			}, effectiveTimeout);
+		});
+	}
+	/** Run everything queued on a socket that just opened. */
+	flush(socket) {
+		const pending = _classPrivateFieldGet2(_pending, this);
+		_classPrivateFieldSet2(_pending, this, []);
+		for (const entry of pending) entry.run(socket);
+	}
+	/** Reject everything queued; the connection will not come back. */
+	rejectAll(reason) {
+		const pending = _classPrivateFieldGet2(_pending, this);
+		_classPrivateFieldSet2(_pending, this, []);
+		const error = new Error(reason);
+		for (const entry of pending) entry.reject(error);
+	}
+};
+/**
+* Creates a proxy that wraps RPC method calls.
+* Internal JS methods (toJSON, then, etc.) return undefined to avoid
+* triggering RPC calls during serialization (e.g., console.log)
+*/
+function createStubProxy(call) {
+	return new Proxy({}, { get: (_target, method) => {
+		if (isInternalJsStubProp(method)) return;
+		return (...args) => call(method, args);
+	} });
+}
+var _capnWeb = /* @__PURE__ */ new WeakMap();
+var _nativeQueue = /* @__PURE__ */ new WeakMap();
+/**
+* WebSocket client for connecting to an Agent
+*/
+var AgentClient = class extends PartySocket {
+	/**
+	* @deprecated Use agentFetch instead
+	*/
+	static fetch(_opts) {
+		throw new Error("AgentClient.fetch is not implemented, use agentFetch instead");
+	}
+	/**
+	* Promise that resolves when identity has been received from the server.
+	* Useful for waiting before making calls that depend on knowing the instance.
+	* Resets on connection close so it can be awaited again after reconnect.
+	*/
+	get ready() {
+		return this._readyPromise;
+	}
+	_resetReady() {
+		this._readyPromise = new Promise((resolve) => {
+			this._resolveReady = resolve;
+		});
+	}
+	constructor(options) {
+		const capnWeb = { current: null };
+		const socketClass = options.transport === "capnweb" ? { WebSocket: boundCapnWebSocket((socket) => {
+			capnWeb.current = socket;
+		}) } : {};
+		const agentNamespace = camelCaseToKebabCase(options.agent);
+		const shouldReconnectOnClose = options.shouldReconnectOnClose;
+		const classifyReconnect = (event) => (shouldReconnectOnClose?.(event) ?? true) && !isTerminalCloseEvent(event);
+		const socketOptions = options.basePath ? {
+			basePath: options.basePath,
+			path: options.path,
+			...options,
+			...socketClass,
+			shouldReconnectOnClose: classifyReconnect
+		} : {
+			party: agentNamespace,
+			prefix: "agents",
+			room: options.name || "default",
+			path: options.path,
+			...options,
+			...socketClass,
+			shouldReconnectOnClose: classifyReconnect
+		};
+		super(socketOptions);
+		this.state = void 0;
+		this.identified = false;
+		this.connectionError = null;
+		this._pendingCalls = /* @__PURE__ */ new Map();
+		this._previousName = null;
+		this._previousAgent = null;
+		_classPrivateFieldInitSpec(this, _capnWeb, void 0);
+		_classPrivateFieldInitSpec(this, _nativeQueue, new NativeCallQueue());
+		_classPrivateFieldSet2(_capnWeb, this, capnWeb);
+		this.agent = agentNamespace;
+		this.name = options.name || "default";
+		this.options = options;
+		this._resetReady();
+		this.addEventListener("message", (event) => {
+			if (typeof event.data === "string") {
+				let parsedMessage;
+				try {
+					parsedMessage = JSON.parse(event.data);
+				} catch (_error) {
+					return;
+				}
+				if (parsedMessage.type === "cf_agent_identity") {
+					const oldName = this._previousName;
+					const oldAgent = this._previousAgent;
+					const newName = parsedMessage.name;
+					const newAgent = parsedMessage.agent;
+					this.identified = true;
+					this._resolveReady();
+					if (oldName !== null && oldAgent !== null && (oldName !== newName || oldAgent !== newAgent)) if (this.options.onIdentityChange) this.options.onIdentityChange(oldName, newName, oldAgent, newAgent);
+					else {
+						const agentChanged = oldAgent !== newAgent;
+						const nameChanged = oldName !== newName;
+						let changeDescription = "";
+						if (agentChanged && nameChanged) changeDescription = `agent "${oldAgent}" → "${newAgent}", instance "${oldName}" → "${newName}"`;
+						else if (agentChanged) changeDescription = `agent "${oldAgent}" → "${newAgent}"`;
+						else changeDescription = `instance "${oldName}" → "${newName}"`;
+						console.warn(`[agents] Identity changed on reconnect: ${changeDescription}. This can happen with server-side routing (e.g., basePath with getAgentByName) where the instance is determined by auth/session. Provide onIdentityChange callback to handle this explicitly, or ignore if this is expected for your routing pattern.`);
+					}
+					this._previousName = newName;
+					this._previousAgent = newAgent;
+					this.name = newName;
+					this.agent = newAgent;
+					this.options.onIdentity?.(newName, newAgent);
+					return;
+				}
+				if (parsedMessage.type === "cf_agent_state") {
+					this.state = parsedMessage.state;
+					this.options.onStateUpdate?.(parsedMessage.state, "server");
+					return;
+				}
+				if (parsedMessage.type === "cf_agent_state_error") {
+					this.options.onStateUpdateError?.(parsedMessage.error);
+					return;
+				}
+				if (parsedMessage.type === "rpc") {
+					const response = parsedMessage;
+					const pending = this._pendingCalls.get(response.id);
+					if (!pending) {
+						console.warn(`[AgentClient] Discarded an RPC response with no matching pending call (id "${response.id}"). The call likely timed out or was rejected when its connection closed before the response arrived.`);
+						return;
+					}
+					if (!response.success) {
+						pending.reject(new Error(response.error));
+						this._pendingCalls.delete(response.id);
+						pending.stream?.onError?.(response.error);
+						return;
+					}
+					if ("done" in response) if (response.done) {
+						pending.resolve(response.result);
+						this._pendingCalls.delete(response.id);
+						pending.stream?.onDone?.(response.result);
+					} else pending.stream?.onChunk?.(response.result);
+					else {
+						pending.resolve(response.result);
+						this._pendingCalls.delete(response.id);
+					}
+				}
+			}
+		});
+		this.addEventListener("open", () => {
+			this.connectionError = null;
+			for (const pending of this._pendingCalls.values()) pending.transmitted = true;
+			const native = _classPrivateFieldGet2(_capnWeb, this).current;
+			if (native) _classPrivateFieldGet2(_nativeQueue, this).flush(native);
+		});
+		this.addEventListener("close", (event) => {
+			const terminalClose = isTerminalCloseEvent(event);
+			this.identified = false;
+			this._resetReady();
+			if (this.shouldReconnect) this._rejectPendingCalls("Connection closed", { onlyTransmitted: true });
+			else {
+				this._rejectPendingCalls("Connection closed");
+				_classPrivateFieldGet2(_nativeQueue, this).rejectAll("Connection closed");
+				if (terminalClose) {
+					const error = new AgentConnectionError(event);
+					this.connectionError = error;
+					this.options.onConnectionError?.(error);
+				}
+			}
+		});
+		this.call = this._callImpl.bind(this);
+		this.stub = createStubProxy((method, args) => this._callImpl(method, args));
+	}
+	/**
+	* Reject pending RPC calls with the given reason.
+	* With `onlyTransmitted`, calls still sitting in the send buffer are
+	* kept pending (they'll be flushed on reconnect).
+	*/
+	_rejectPendingCalls(reason, { onlyTransmitted = false } = {}) {
+		const error = new Error(reason);
+		for (const [id, pending] of this._pendingCalls) {
+			if (onlyTransmitted && !pending.transmitted) continue;
+			this._pendingCalls.delete(id);
+			pending.reject(error);
+			pending.stream?.onError?.(reason);
+		}
+	}
+	setState(state) {
+		this.send(JSON.stringify({
+			state,
+			type: "cf_agent_state"
+		}));
+		this.state = state;
+		this.options.onStateUpdate?.(state, "client");
+	}
+	/**
+	* Close the connection and immediately reject all pending RPC calls.
+	* This provides immediate feedback on intentional close rather than
+	* waiting for the WebSocket close handshake to complete.
+	*
+	* Note: Any calls made after `close()` will be rejected when the
+	* underlying WebSocket close event fires.
+	*/
+	close(code, reason) {
+		this._rejectPendingCalls("Connection closed");
+		super.close(code, reason);
+	}
+	/**
+	* Call a method on the Agent.
+	* When AgentT is provided, method names are inferred from the agent's methods.
+	* Falls back to untyped string-based calls when AgentT is not provided.
+	*/
+	async _callImpl(method, args = [], options) {
+		if (this.options.transport === "capnweb") {
+			const timeout = this.options.defaultCallTimeout ?? 3e4;
+			const native = _classPrivateFieldGet2(_capnWeb, this).current;
+			if (native && this.readyState === this.OPEN) return nativeCall(native, method, args, options, timeout);
+			if (this.connectionError && this.readyState === this.CLOSED) throw new Error("Connection closed");
+			return _classPrivateFieldGet2(_nativeQueue, this).enqueue(method, args, options, timeout);
+		}
+		if (this.connectionError && this.readyState === this.CLOSED) throw new Error("Connection closed");
+		return new Promise((resolve, reject) => {
+			const id = crypto.randomUUID();
+			let timeoutId;
+			const { stream: streamOptions, timeout } = splitCallOptions(options);
+			const effectiveTimeout = timeout !== void 0 ? timeout : streamOptions ? void 0 : this.options.defaultCallTimeout ?? 3e4;
+			if (effectiveTimeout) timeoutId = setTimeout(() => {
+				const pending = this._pendingCalls.get(id);
+				this._pendingCalls.delete(id);
+				const errorMessage = `RPC call to ${method} timed out after ${effectiveTimeout}ms`;
+				pending?.stream?.onError?.(errorMessage);
+				reject(new Error(errorMessage));
+			}, effectiveTimeout);
+			this._pendingCalls.set(id, {
+				reject: (e) => {
+					if (timeoutId) clearTimeout(timeoutId);
+					reject(e);
+				},
+				resolve: (value) => {
+					if (timeoutId) clearTimeout(timeoutId);
+					resolve(value);
+				},
+				stream: streamOptions,
+				transmitted: this.readyState === this.OPEN
+			});
+			const request = {
+				args,
+				id,
+				method,
+				type: "rpc"
+			};
+			this.send(JSON.stringify(request));
+		});
+	}
+};
+/**
+* Make an HTTP request to an Agent
+* @param opts Connection options
+* @param init Request initialization options
+* @returns Promise resolving to a Response
+*/
+function agentFetch(opts, init) {
+	const agentNamespace = camelCaseToKebabCase(opts.agent);
+	if (opts.basePath) return PartySocket.fetch({
+		basePath: opts.basePath,
+		...opts
+	}, init);
+	return PartySocket.fetch({
+		party: agentNamespace,
+		prefix: "agents",
+		room: opts.name || "default",
+		...opts
+	}, init);
+}
+//#endregion
+export { agentFetch as a, nativeCall as c, NativeCallQueue as i, splitCallOptions as l, AgentConnectionError as n, createStubProxy as o, DEFAULT_CALL_TIMEOUT_MS as r, isTerminalCloseEvent as s, AgentClient as t, boundCapnWebSocket as u };
+
+//# sourceMappingURL=client-C9DAjZIY.js.map

package/dist/client-C9DAjZIY.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"client-C9DAjZIY.js","names":[],"sources":["../src/websockets/capnweb-socket.ts","../src/client.ts"],"sourcesContent":["import { newWebSocketRpcSession, RpcTarget, type RpcStub } from \"capnweb\";\nimport {\n  CAPNWEB_TRANSPORT_SEND,\n  capnWebTransportUrl,\n  type TransportClientEvents,\n  type TransportHostPipe,\n  type TransportMessage\n} from \"./transport-protocol\";\n\n/** Local root the host calls to deliver frames. */\nclass Inbox extends RpcTarget implements TransportClientEvents {\n  constructor(private readonly socket: CapnWebSocket) {\n    super();\n  }\n\n  message(value: TransportMessage): void {\n    this.socket.dispatchEvent(new MessageEvent(\"message\", { data: value }));\n  }\n}\n\n/**\n * A WebSocket-shaped client for the Cap'n Web connection transport.\n *\n * It has the constructor, `readyState`, `send()`, `close()`, and events of\n * a `WebSocket`, so PartySocket (and therefore `useAgent` and\n * `AgentClient`) can drive it as a drop-in socket implementation and keep\n * owning reconnection, buffering, and backoff. Frames sent here travel\n * through the host's pipe method; frames from the host arrive as\n * `message` events.\n *\n * @experimental The transport is experimental.\n */\nexport class CapnWebSocket extends EventTarget {\n  static readonly CONNECTING = 0;\n  static readonly OPEN = 1;\n  static readonly CLOSING = 2;\n  static readonly CLOSED = 3;\n  readonly CONNECTING = 0;\n  readonly OPEN = 1;\n  readonly CLOSING = 2;\n  readonly CLOSED = 3;\n\n  readonly url: string;\n  readyState = CapnWebSocket.CONNECTING;\n  binaryType: BinaryType = \"arraybuffer\";\n  bufferedAmount = 0;\n  extensions = \"\";\n  protocol = \"\";\n  onopen: ((event: Event) => void) | null = null;\n  onmessage: ((event: MessageEvent) => void) | null = null;\n  onclose: ((event: CloseEvent) => void) | null = null;\n  onerror: ((event: Event) => void) | null = null;\n\n  readonly #socket: WebSocket;\n  readonly #root: RpcStub<TransportHostPipe>;\n\n  constructor(url: string | URL, protocols?: string | string[]) {\n    super();\n    this.url = capnWebTransportUrl(url);\n    this.#socket = protocols\n      ? new WebSocket(this.url, protocols)\n      : new WebSocket(this.url);\n    this.#root = newWebSocketRpcSession<TransportHostPipe>(\n      this.#socket,\n      new Inbox(this)\n    );\n    this.#socket.addEventListener(\"open\", () => {\n      this.readyState = CapnWebSocket.OPEN;\n      this.protocol = this.#socket.protocol;\n      this.dispatchEvent(new Event(\"open\"));\n    });\n    this.#socket.addEventListener(\"close\", (event) => {\n      this.readyState = CapnWebSocket.CLOSED;\n      this.dispatchEvent(\n        new CloseEvent(\"close\", {\n          code: event.code,\n          reason: event.reason,\n          wasClean: event.wasClean\n        })\n      );\n    });\n    this.#socket.addEventListener(\"error\", () => {\n      this.dispatchEvent(new Event(\"error\"));\n    });\n  }\n\n  override dispatchEvent(event: Event): boolean {\n    const handler = Reflect.get(this, `on${event.type}`) as unknown;\n    if (typeof handler === \"function\") Reflect.apply(handler, this, [event]);\n    return super.dispatchEvent(event);\n  }\n\n  /**\n   * Invoke one of the host's native callables on the session root. The\n   * result keeps Cap'n Web semantics: an `RpcTarget` arrives as a live\n   * stub, a `ReadableStream` streams, and chained calls pipeline.\n   */\n  invoke(method: string, args: unknown[]): Promise<unknown> {\n    if (this.readyState !== CapnWebSocket.OPEN) {\n      return Promise.reject(new Error(\"Connection closed\"));\n    }\n    // The root stub answers every property with a callable, so an unknown\n    // method is only detected by the host, which rejects the call. The\n    // result is an RpcPromise; resolve through a plain Promise so callers\n    // hold nothing exotic.\n    const root = this.#root as unknown as Record<\n      string,\n      (...a: unknown[]) => unknown\n    >;\n    return Promise.resolve(root[method](...args));\n  }\n\n  send(data: TransportMessage): void {\n    if (this.readyState !== CapnWebSocket.OPEN) {\n      throw new DOMException(\"WebSocket is not open\", \"InvalidStateError\");\n    }\n    void this.#root[CAPNWEB_TRANSPORT_SEND](data).catch(() => {\n      this.dispatchEvent(new Event(\"error\"));\n    });\n  }\n\n  close(code?: number, reason?: string): void {\n    if (this.readyState >= CapnWebSocket.CLOSING) return;\n    this.readyState = CapnWebSocket.CLOSING;\n    try {\n      this.#root[Symbol.dispose]();\n    } catch {\n      // The session is already gone; closing the socket is enough.\n    }\n    this.#socket.close(code, reason);\n  }\n}\n\n/**\n * A `CapnWebSocket` subclass that reports each instance it constructs.\n * PartySocket instantiates the class it is given; this is how a client\n * gets hold of the live socket to call `invoke()` without reaching into\n * PartySocket internals.\n */\nexport function boundCapnWebSocket(\n  onCreate: (socket: CapnWebSocket) => void\n): typeof CapnWebSocket {\n  return class BoundCapnWebSocket extends CapnWebSocket {\n    constructor(url: string | URL, protocols?: string | string[]) {\n      super(url, protocols);\n      onCreate(this);\n    }\n  };\n}\n","import {\n  type PartyFetchOptions,\n  PartySocket,\n  type PartySocketOptions\n} from \"partysocket\";\nimport type { Agent, RPCRequest, RPCResponse } from \"./\";\nimport type {\n  ClientParameters,\n  Method,\n  RPCMethod,\n  SerializableReturnValue,\n  SerializableValue\n} from \"./serializable\";\nimport { MessageType } from \"./types\";\nimport { camelCaseToKebabCase, isInternalJsStubProp } from \"./utils\";\nimport {\n  boundCapnWebSocket,\n  type CapnWebSocket\n} from \"./websockets/capnweb-socket\";\nimport type { AgentTransport } from \"./websockets/transport-protocol\";\n\nexport type { AgentTransport } from \"./websockets/transport-protocol\";\n\nexport class AgentConnectionError extends Error {\n  code: number;\n  reason: string;\n  wasClean: boolean;\n\n  constructor(event: CloseEvent) {\n    const reason = event.reason || `WebSocket closed with code ${event.code}`;\n    super(`Agent connection closed: ${reason}`);\n    this.name = \"AgentConnectionError\";\n    this.code = event.code;\n    this.reason = event.reason;\n    this.wasClean = event.wasClean;\n  }\n}\n\nexport function isTerminalCloseEvent(event: CloseEvent): boolean {\n  return event.code === 1008 || (event.code >= 4000 && event.code <= 4999);\n}\n\ntype TerminalReconnectOptions = {\n  shouldReconnectOnClose?: (event: CloseEvent) => boolean;\n};\n\n/**\n * Options for creating an AgentClient\n */\nexport type AgentClientOptions<State = unknown> = Omit<\n  PartySocketOptions,\n  \"party\" | \"room\"\n> &\n  TerminalReconnectOptions & {\n    /**\n     * Wire the connection travels on. `\"cf-websocket\"` (default) is a\n     * hibernating WebSocket where `call()` sends JSON `rpc` frames.\n     * `\"capnweb\"` carries protocol frames over a Cap'n Web session whose\n     * root also serves the host's `callables` natively, so `call()` and\n     * `stub` invoke them directly and an `RpcTarget` result is a live stub.\n     * The Durable Object stays in memory while a capnweb connection is open.\n     * @experimental The `\"capnweb\"` transport is experimental.\n     */\n    transport?: AgentTransport;\n    /** Name of the agent to connect to (ignored if basePath is set) */\n    agent: string;\n    /** Name of the specific Agent instance (ignored if basePath is set) */\n    name?: string;\n    /**\n     * Full URL path - bypasses agent/name URL construction.\n     * When set, the client connects to this path directly.\n     * Server must handle routing manually (e.g., with getAgentByName + fetch).\n     * @example\n     * // Client connects to /user, server routes based on session\n     * useAgent({ agent: \"UserAgent\", basePath: \"user\" })\n     */\n    basePath?: string;\n    /** Called when the Agent's state is updated */\n    onStateUpdate?: (state: State, source: \"server\" | \"client\") => void;\n    /** Called when a state update fails (e.g., connection is readonly) */\n    onStateUpdateError?: (error: string) => void;\n    /**\n     * Called when the server sends the agent's identity on connect.\n     * Useful when using basePath, as the actual instance name is determined server-side.\n     * @param name The actual agent instance name\n     * @param agent The agent class name (kebab-case)\n     */\n    onIdentity?: (name: string, agent: string) => void;\n    /**\n     * Called when identity changes on reconnect (different instance than before).\n     * If not provided and identity changes, a warning will be logged.\n     * @param oldName Previous instance name\n     * @param newName New instance name\n     * @param oldAgent Previous agent class name\n     * @param newAgent New agent class name\n     */\n    onIdentityChange?: (\n      oldName: string,\n      newName: string,\n      oldAgent: string,\n      newAgent: string\n    ) => void;\n    /**\n     * Additional path to append to the URL.\n     * Works with both standard routing and basePath.\n     * @example\n     * // With basePath: /user/settings\n     * { basePath: \"user\", path: \"settings\" }\n     * // Standard: /agents/my-agent/room/settings\n     * { agent: \"MyAgent\", name: \"room\", path: \"settings\" }\n     */\n    path?: string;\n    /**\n     * Default timeout (in milliseconds) applied to non-streaming `call()`s\n     * that don't pass an explicit `timeout`. Defaults to 30 000 ms.\n     * Set to `0` to disable. Streaming calls never get a default timeout.\n     */\n    defaultCallTimeout?: number;\n    /** Called when the connection closes with a terminal code and will not reconnect. */\n    onConnectionError?: (error: AgentConnectionError) => void;\n  };\n\n/**\n * Default timeout (in milliseconds) applied to non-streaming RPC calls\n * that don't pass an explicit `timeout`. Acts as a backstop so calls\n * whose response is lost (e.g. the connection drops mid-flight) reject\n * instead of hanging forever. Override per client via\n * `defaultCallTimeout`, or per call via `timeout` (0 disables).\n */\nexport const DEFAULT_CALL_TIMEOUT_MS = 30_000;\n\n/**\n * Options for streaming RPC calls\n */\nexport type StreamOptions = {\n  /** Called when a chunk of data is received */\n  onChunk?: (chunk: unknown) => void;\n  /** Called when the stream ends */\n  onDone?: (finalChunk: unknown) => void;\n  /** Called when an error occurs */\n  onError?: (error: string) => void;\n};\n\n/**\n * Options for RPC calls\n */\nexport type CallOptions = {\n  /** Timeout in milliseconds. If the call doesn't complete within this time, it will be rejected. */\n  timeout?: number;\n  /** Streaming options for handling streaming responses */\n  stream?: StreamOptions;\n};\n\n/**\n * Normalize `call()` options. The legacy shape is the stream callbacks\n * themselves (`{ onChunk, onDone, onError }`); the current shape nests\n * them under `stream` beside `timeout`.\n */\nexport function splitCallOptions(\n  options: CallOptions | StreamOptions | undefined\n): {\n  stream: StreamOptions | undefined;\n  timeout: number | undefined;\n} {\n  const legacy =\n    options !== undefined &&\n    (\"onChunk\" in options || \"onDone\" in options || \"onError\" in options);\n  return legacy\n    ? { stream: options as StreamOptions, timeout: undefined }\n    : {\n        stream: (options as CallOptions | undefined)?.stream,\n        timeout: (options as CallOptions | undefined)?.timeout\n      };\n}\n\n/**\n * One native call on the Cap'n Web transport, with the timeout and\n * stream-callback contract `call()` has on the JSON wire. The timeout\n * covers the whole call, draining included: on expiry the stream reader is\n * cancelled and the promise rejects once. A `ReadableStream` result is\n * drained into the stream callbacks when they are given; any other value,\n * live stubs included, passes straight through.\n */\nexport async function nativeCall<T>(\n  socket: CapnWebSocket,\n  method: string,\n  args: unknown[],\n  options: CallOptions | StreamOptions | undefined,\n  defaultTimeout: number\n): Promise<T> {\n  const { stream, timeout } = splitCallOptions(options);\n  const effectiveTimeout =\n    timeout !== undefined ? timeout : stream ? undefined : defaultTimeout;\n  let reader: ReadableStreamDefaultReader<unknown> | undefined;\n  let timer: ReturnType<typeof setTimeout> | undefined;\n\n  const work = (async () => {\n    const result = await socket.invoke(method, args);\n    if (stream && result instanceof ReadableStream) {\n      reader = (result as ReadableStream<unknown>).getReader();\n      for (;;) {\n        const { done, value } = await reader.read();\n        if (done) break;\n        stream.onChunk?.(value);\n      }\n      stream.onDone?.(undefined);\n      return undefined as T;\n    }\n    return result as T;\n  })();\n\n  const expiry = effectiveTimeout\n    ? new Promise<never>((_, reject) => {\n        timer = setTimeout(() => {\n          void reader?.cancel().catch(() => {});\n          reject(\n            new Error(\n              `RPC call to ${method} timed out after ${effectiveTimeout}ms`\n            )\n          );\n        }, effectiveTimeout);\n      })\n    : undefined;\n\n  try {\n    return await (expiry ? Promise.race([work, expiry]) : work);\n  } catch (error) {\n    // Keep the rejection observed on the losing side of the race.\n    void work.catch(() => {});\n    stream?.onError?.(error instanceof Error ? error.message : String(error));\n    throw error;\n  } finally {\n    if (timer) clearTimeout(timer);\n  }\n}\n\n/**\n * Native calls issued while the Cap'n Web socket is still connecting or\n * between reconnects. They must not fall back to JSON frames — that would\n * change which methods are reachable and lose return-by-reference — so\n * they wait here and run on the next open socket, or reject when the\n * connection ends for good. Their timeout starts when they are issued.\n */\nexport class NativeCallQueue {\n  #pending: Array<{\n    run: (socket: CapnWebSocket) => void;\n    reject: (error: Error) => void;\n  }> = [];\n\n  enqueue<T>(\n    method: string,\n    args: unknown[],\n    options: CallOptions | StreamOptions | undefined,\n    defaultTimeout: number\n  ): Promise<T> {\n    return new Promise<T>((resolve, reject) => {\n      const { stream, timeout } = splitCallOptions(options);\n      const effectiveTimeout =\n        timeout !== undefined ? timeout : stream ? undefined : defaultTimeout;\n      const startedAt = Date.now();\n      const entry = {\n        run: (socket: CapnWebSocket) => {\n          // Spend the remaining budget, not a fresh one.\n          const remaining =\n            effectiveTimeout === undefined\n              ? undefined\n              : Math.max(1, effectiveTimeout - (Date.now() - startedAt));\n          const opts =\n            remaining === undefined ? options : { stream, timeout: remaining };\n          nativeCall<T>(socket, method, args, opts, defaultTimeout).then(\n            resolve,\n            reject\n          );\n        },\n        reject: (error: Error) => {\n          stream?.onError?.(error.message);\n          reject(error);\n        }\n      };\n      this.#pending.push(entry);\n      if (effectiveTimeout) {\n        setTimeout(() => {\n          const index = this.#pending.indexOf(entry);\n          if (index === -1) return;\n          this.#pending.splice(index, 1);\n          entry.reject(\n            new Error(\n              `RPC call to ${method} timed out after ${effectiveTimeout}ms`\n            )\n          );\n        }, effectiveTimeout);\n      }\n    });\n  }\n\n  /** Run everything queued on a socket that just opened. */\n  flush(socket: CapnWebSocket): void {\n    const pending = this.#pending;\n    this.#pending = [];\n    for (const entry of pending) entry.run(socket);\n  }\n\n  /** Reject everything queued; the connection will not come back. */\n  rejectAll(reason: string): void {\n    const pending = this.#pending;\n    this.#pending = [];\n    const error = new Error(reason);\n    for (const entry of pending) entry.reject(error);\n  }\n}\n\n/**\n * Options for the agentFetch function\n */\nexport type AgentClientFetchOptions = Omit<\n  PartyFetchOptions,\n  \"party\" | \"room\"\n> & {\n  /** Name of the agent to connect to (ignored if basePath is set) */\n  agent: string;\n  /** Name of the specific Agent instance (ignored if basePath is set) */\n  name?: string;\n  /**\n   * Full URL path - bypasses agent/name URL construction.\n   * When set, the request is made to this path directly.\n   */\n  basePath?: string;\n};\n\n// ---- Shared RPC Type Utilities ----\n\ntype AllOptional<T> = T extends [infer A, ...infer R]\n  ? undefined extends A\n    ? AllOptional<R>\n    : false\n  : true;\n\nexport type RPCMethods<T> = {\n  [K in keyof T as T[K] extends RPCMethod<T[K]> ? K : never]: RPCMethod<T[K]>;\n};\n\ntype OptionalParametersMethod<T extends RPCMethod> =\n  AllOptional<ClientParameters<T>> extends true ? T : never;\n\n// oxlint-disable-next-line @typescript-eslint/no-explicit-any -- generic agent type constraint\nexport type AgentMethods<T> = Omit<RPCMethods<T>, keyof Agent<any, any>>;\n\nexport type OptionalAgentMethods<T> = {\n  [K in keyof AgentMethods<T> as AgentMethods<T>[K] extends OptionalParametersMethod<\n    AgentMethods<T>[K]\n  >\n    ? K\n    : never]: OptionalParametersMethod<AgentMethods<T>[K]>;\n};\n\nexport type RequiredAgentMethods<T> = Omit<\n  AgentMethods<T>,\n  keyof OptionalAgentMethods<T>\n>;\n\nexport type AgentPromiseReturnType<T, K extends keyof AgentMethods<T>> =\n  // oxlint-disable-next-line @typescript-eslint/no-explicit-any -- generic promise return type\n  ReturnType<AgentMethods<T>[K]> extends Promise<any>\n    ? ReturnType<AgentMethods<T>[K]>\n    : Promise<ReturnType<AgentMethods<T>[K]>>;\n\nexport type AgentStub<T> = {\n  [K in keyof AgentMethods<T>]: (\n    ...args: ClientParameters<AgentMethods<T>[K]>\n  ) => AgentPromiseReturnType<AgentMethods<T>, K>;\n};\n\nexport type UntypedAgentStub = Record<string, Method>;\n\ntype AgentClientStub<AgentT> = keyof AgentMethods<AgentT> extends never\n  ? UntypedAgentStub\n  : AgentStub<AgentT>;\n\ntype OptionalArgsAgentClientCall<AgentT> = <\n  K extends keyof OptionalAgentMethods<AgentT>\n>(\n  method: K,\n  args?: ClientParameters<OptionalAgentMethods<AgentT>[K]>,\n  options?: CallOptions | StreamOptions\n) => AgentPromiseReturnType<AgentT, K>;\n\ntype RequiredArgsAgentClientCall<AgentT> = <\n  K extends keyof RequiredAgentMethods<AgentT>\n>(\n  method: K,\n  args: ClientParameters<RequiredAgentMethods<AgentT>[K]>,\n  options?: CallOptions | StreamOptions\n) => AgentPromiseReturnType<AgentT, K>;\n\ntype TypedAgentClientCall<AgentT> = OptionalArgsAgentClientCall<AgentT> &\n  RequiredArgsAgentClientCall<AgentT>;\n\ntype UntypedAgentClientCall = {\n  <T extends SerializableReturnValue>(\n    method: string,\n    args?: SerializableValue[],\n    options?: CallOptions | StreamOptions\n  ): Promise<T>;\n  <T = unknown>(\n    method: string,\n    args?: unknown[],\n    options?: CallOptions | StreamOptions\n  ): Promise<T>;\n};\n\ntype AgentClientCall<AgentT> = keyof AgentMethods<AgentT> extends never\n  ? UntypedAgentClientCall\n  : TypedAgentClientCall<AgentT>;\n\n/**\n * Creates a proxy that wraps RPC method calls.\n * Internal JS methods (toJSON, then, etc.) return undefined to avoid\n * triggering RPC calls during serialization (e.g., console.log)\n */\nexport function createStubProxy<T = Record<string, Method>>(\n  call: (method: string, args: unknown[]) => unknown\n): T {\n  // oxlint-disable-next-line @typescript-eslint/no-explicit-any -- proxy needs any for dynamic method access\n  return new Proxy<any>(\n    {},\n    {\n      get: (_target, method) => {\n        if (isInternalJsStubProp(method)) {\n          return undefined;\n        }\n        return (...args: unknown[]) => call(method as string, args);\n      }\n    }\n  );\n}\n\n/**\n * WebSocket client for connecting to an Agent\n */\nexport class AgentClient<\n  AgentT = unknown,\n  State = AgentT extends { get state(): infer S } ? S : AgentT\n> extends PartySocket {\n  /**\n   * @deprecated Use agentFetch instead\n   */\n  static fetch(_opts: PartyFetchOptions): Promise<Response> {\n    throw new Error(\n      \"AgentClient.fetch is not implemented, use agentFetch instead\"\n    );\n  }\n  agent: string;\n  name: string;\n  call: AgentClientCall<AgentT>;\n  stub: AgentClientStub<AgentT>;\n\n  /**\n   * The current agent state, updated on server broadcasts and client setState calls.\n   * Starts as undefined until the first state message is received from the server.\n   */\n  state: State | undefined = undefined;\n\n  /**\n   * Whether the client has received identity from the server.\n   * Becomes true after the first identity message is received.\n   * Resets to false on connection close.\n   */\n  identified = false;\n\n  /**\n   * Terminal connection error, if the server closed the socket with a code\n   * that should not be retried automatically.\n   */\n  connectionError: AgentConnectionError | null = null;\n\n  /**\n   * Promise that resolves when identity has been received from the server.\n   * Useful for waiting before making calls that depend on knowing the instance.\n   * Resets on connection close so it can be awaited again after reconnect.\n   */\n  get ready(): Promise<void> {\n    return this._readyPromise;\n  }\n\n  private options: AgentClientOptions<State>;\n  private _pendingCalls = new Map<\n    string,\n    {\n      resolve: (value: unknown) => void;\n      reject: (error: Error) => void;\n      stream?: StreamOptions;\n      /**\n       * Whether the request was actually transmitted to the server.\n       * Requests issued while disconnected sit in PartySocket's internal\n       * buffer (transmitted: false) and are flushed on the next open —\n       * they survive a transient close instead of being rejected, since\n       * the server never saw them and re-delivery can't double-execute.\n       */\n      transmitted: boolean;\n    }\n  >();\n  private _readyPromise!: Promise<void>;\n  private _resolveReady!: () => void;\n  private _previousName: string | null = null;\n  private _previousAgent: string | null = null;\n\n  private _resetReady() {\n    this._readyPromise = new Promise((resolve) => {\n      this._resolveReady = resolve;\n    });\n  }\n\n  /**\n   * The live Cap'n Web socket on the `\"capnweb\"` transport. PartySocket\n   * constructs a new one on every reconnect; the bound class reports each\n   * into this holder, which exists before `super()` runs.\n   */\n  readonly #capnWeb: { current: CapnWebSocket | null };\n  readonly #nativeQueue = new NativeCallQueue();\n\n  constructor(options: AgentClientOptions<State>) {\n    const capnWeb: { current: CapnWebSocket | null } = { current: null };\n    const socketClass =\n      options.transport === \"capnweb\"\n        ? {\n            WebSocket: boundCapnWebSocket((socket) => {\n              capnWeb.current = socket;\n            })\n          }\n        : {};\n    const agentNamespace = camelCaseToKebabCase(options.agent);\n    const shouldReconnectOnClose = options.shouldReconnectOnClose;\n    const classifyReconnect = (event: CloseEvent) =>\n      (shouldReconnectOnClose?.(event) ?? true) && !isTerminalCloseEvent(event);\n\n    // If basePath is provided, use it directly; otherwise construct from agent/name\n    const socketOptions = options.basePath\n      ? {\n          basePath: options.basePath,\n          path: options.path,\n          ...options,\n          ...socketClass,\n          shouldReconnectOnClose: classifyReconnect\n        }\n      : {\n          party: agentNamespace,\n          prefix: \"agents\",\n          room: options.name || \"default\",\n          path: options.path,\n          ...options,\n          ...socketClass,\n          shouldReconnectOnClose: classifyReconnect\n        };\n\n    super(socketOptions);\n    this.#capnWeb = capnWeb;\n    this.agent = agentNamespace;\n    this.name = options.name || \"default\";\n    this.options = options;\n\n    // Initialize ready promise\n    this._resetReady();\n\n    this.addEventListener(\"message\", (event) => {\n      if (typeof event.data === \"string\") {\n        let parsedMessage: Record<string, unknown>;\n        try {\n          parsedMessage = JSON.parse(event.data);\n        } catch (_error) {\n          // silently ignore invalid messages for now\n          // TODO: log errors with log levels\n          return;\n        }\n        if (parsedMessage.type === MessageType.CF_AGENT_IDENTITY) {\n          const oldName = this._previousName;\n          const oldAgent = this._previousAgent;\n          const newName = parsedMessage.name as string;\n          const newAgent = parsedMessage.agent as string;\n\n          // Resolve ready/identified\n          this.identified = true;\n          this._resolveReady();\n\n          // Detect identity change on reconnect\n          if (\n            oldName !== null &&\n            oldAgent !== null &&\n            (oldName !== newName || oldAgent !== newAgent)\n          ) {\n            if (this.options.onIdentityChange) {\n              this.options.onIdentityChange(\n                oldName,\n                newName,\n                oldAgent,\n                newAgent\n              );\n            } else {\n              const agentChanged = oldAgent !== newAgent;\n              const nameChanged = oldName !== newName;\n              let changeDescription = \"\";\n              if (agentChanged && nameChanged) {\n                changeDescription = `agent \"${oldAgent}\" → \"${newAgent}\", instance \"${oldName}\" → \"${newName}\"`;\n              } else if (agentChanged) {\n                changeDescription = `agent \"${oldAgent}\" → \"${newAgent}\"`;\n              } else {\n                changeDescription = `instance \"${oldName}\" → \"${newName}\"`;\n              }\n              console.warn(\n                `[agents] Identity changed on reconnect: ${changeDescription}. ` +\n                  \"This can happen with server-side routing (e.g., basePath with getAgentByName) \" +\n                  \"where the instance is determined by auth/session. \" +\n                  \"Provide onIdentityChange callback to handle this explicitly, \" +\n                  \"or ignore if this is expected for your routing pattern.\"\n              );\n            }\n          }\n\n          // Always update from server identity (server is authoritative)\n          this._previousName = newName;\n          this._previousAgent = newAgent;\n          this.name = newName;\n          this.agent = newAgent;\n\n          // Call onIdentity callback\n          this.options.onIdentity?.(newName, newAgent);\n          return;\n        }\n        if (parsedMessage.type === MessageType.CF_AGENT_STATE) {\n          this.state = parsedMessage.state as State;\n          this.options.onStateUpdate?.(parsedMessage.state as State, \"server\");\n          return;\n        }\n        if (parsedMessage.type === MessageType.CF_AGENT_STATE_ERROR) {\n          this.options.onStateUpdateError?.(parsedMessage.error as string);\n          return;\n        }\n        if (parsedMessage.type === MessageType.RPC) {\n          const response = parsedMessage as RPCResponse;\n          const pending = this._pendingCalls.get(response.id);\n          if (!pending) {\n            console.warn(\n              `[AgentClient] Discarded an RPC response with no matching pending call (id \"${response.id}\"). ` +\n                \"The call likely timed out or was rejected when its connection closed before the response arrived.\"\n            );\n            return;\n          }\n\n          if (!response.success) {\n            pending.reject(new Error(response.error));\n            this._pendingCalls.delete(response.id);\n            pending.stream?.onError?.(response.error);\n            return;\n          }\n\n          // Handle streaming responses\n          if (\"done\" in response) {\n            if (response.done) {\n              pending.resolve(response.result);\n              this._pendingCalls.delete(response.id);\n              pending.stream?.onDone?.(response.result);\n            } else {\n              pending.stream?.onChunk?.(response.result);\n            }\n          } else {\n            // Non-streaming response\n            pending.resolve(response.result);\n            this._pendingCalls.delete(response.id);\n          }\n        }\n      }\n    });\n\n    // PartySocket flushes its internal message buffer right before\n    // dispatching \"open\" — anything queued has now been transmitted.\n    this.addEventListener(\"open\", () => {\n      this.connectionError = null;\n      for (const pending of this._pendingCalls.values()) {\n        pending.transmitted = true;\n      }\n      const native = this.#capnWeb.current;\n      if (native) this.#nativeQueue.flush(native);\n    });\n\n    // Clean up pending calls and reset ready state when connection closes\n    this.addEventListener(\"close\", (event) => {\n      const terminalClose = isTerminalCloseEvent(event);\n      // Reset ready state for next connection\n      this.identified = false;\n      this._resetReady();\n\n      if (this.shouldReconnect) {\n        // Transient disconnect: reject calls whose request was already\n        // transmitted — their response can never arrive. Buffered calls\n        // stay pending; PartySocket re-sends them on reconnect.\n        this._rejectPendingCalls(\"Connection closed\", {\n          onlyTransmitted: true\n        });\n      } else {\n        // Permanent close (close() called or retries exhausted): nothing\n        // will ever flush the buffer, so reject everything.\n        this._rejectPendingCalls(\"Connection closed\");\n        this.#nativeQueue.rejectAll(\"Connection closed\");\n        if (terminalClose) {\n          const error = new AgentConnectionError(event);\n          this.connectionError = error;\n          this.options.onConnectionError?.(error);\n        }\n      }\n    });\n\n    this.call = this._callImpl.bind(this) as AgentClientCall<AgentT>;\n    this.stub = createStubProxy((method, args) =>\n      this._callImpl(method, args)\n    ) as AgentClientStub<AgentT>;\n  }\n\n  /**\n   * Reject pending RPC calls with the given reason.\n   * With `onlyTransmitted`, calls still sitting in the send buffer are\n   * kept pending (they'll be flushed on reconnect).\n   */\n  private _rejectPendingCalls(\n    reason: string,\n    { onlyTransmitted = false }: { onlyTransmitted?: boolean } = {}\n  ) {\n    const error = new Error(reason);\n    for (const [id, pending] of this._pendingCalls) {\n      if (onlyTransmitted && !pending.transmitted) continue;\n      this._pendingCalls.delete(id);\n      pending.reject(error);\n      pending.stream?.onError?.(reason);\n    }\n  }\n\n  setState(state: State) {\n    this.send(JSON.stringify({ state, type: MessageType.CF_AGENT_STATE }));\n    this.state = state;\n    this.options.onStateUpdate?.(state, \"client\");\n  }\n\n  /**\n   * Close the connection and immediately reject all pending RPC calls.\n   * This provides immediate feedback on intentional close rather than\n   * waiting for the WebSocket close handshake to complete.\n   *\n   * Note: Any calls made after `close()` will be rejected when the\n   * underlying WebSocket close event fires.\n   */\n  close(code?: number, reason?: string) {\n    // Immediately reject all pending calls on intentional close\n    this._rejectPendingCalls(\"Connection closed\");\n\n    // Then close the underlying socket\n    super.close(code, reason);\n  }\n\n  /**\n   * Call a method on the Agent.\n   * When AgentT is provided, method names are inferred from the agent's methods.\n   * Falls back to untyped string-based calls when AgentT is not provided.\n   */\n  private async _callImpl(\n    method: string,\n    args: unknown[] = [],\n    options?: CallOptions | StreamOptions\n  ): Promise<unknown> {\n    // On the Cap'n Web transport, callables are native methods on the\n    // session root: invoke them directly so an RpcTarget result arrives as\n    // a live stub. The JSON `rpc` frame below is the WebSocket wire's protocol.\n    if (this.options.transport === \"capnweb\") {\n      const timeout =\n        this.options.defaultCallTimeout ?? DEFAULT_CALL_TIMEOUT_MS;\n      const native = this.#capnWeb.current;\n      if (native && this.readyState === this.OPEN) {\n        return nativeCall(native, method, args, options, timeout);\n      }\n      if (this.connectionError && this.readyState === this.CLOSED) {\n        throw new Error(\"Connection closed\");\n      }\n      // Connecting or between reconnects: hold the call as a native call\n      // rather than queueing a JSON frame that would change its meaning.\n      return this.#nativeQueue.enqueue(method, args, options, timeout);\n    }\n    if (this.connectionError && this.readyState === this.CLOSED) {\n      throw new Error(\"Connection closed\");\n    }\n\n    return new Promise((resolve, reject) => {\n      const id = crypto.randomUUID();\n      let timeoutId: ReturnType<typeof setTimeout> | undefined;\n\n      const { stream: streamOptions, timeout } = splitCallOptions(options);\n\n      // Apply the default timeout as a backstop for non-streaming calls\n      // so a lost response rejects instead of hanging forever. An\n      // explicit `timeout` (including 0 = disabled) always wins.\n      const effectiveTimeout =\n        timeout !== undefined\n          ? timeout\n          : streamOptions\n            ? undefined\n            : (this.options.defaultCallTimeout ?? DEFAULT_CALL_TIMEOUT_MS);\n\n      if (effectiveTimeout) {\n        timeoutId = setTimeout(() => {\n          const pending = this._pendingCalls.get(id);\n          this._pendingCalls.delete(id);\n          const errorMessage = `RPC call to ${method} timed out after ${effectiveTimeout}ms`;\n          pending?.stream?.onError?.(errorMessage);\n          reject(new Error(errorMessage));\n        }, effectiveTimeout);\n      }\n\n      this._pendingCalls.set(id, {\n        reject: (e: Error) => {\n          if (timeoutId) clearTimeout(timeoutId);\n          reject(e);\n        },\n        resolve: (value: unknown) => {\n          if (timeoutId) clearTimeout(timeoutId);\n          resolve(value);\n        },\n        stream: streamOptions,\n        // If the socket is open, send() below transmits synchronously;\n        // otherwise the request is buffered until the next open event\n        // (the \"open\" listener then marks it transmitted).\n        transmitted: this.readyState === this.OPEN\n      });\n\n      const request: RPCRequest = {\n        args,\n        id,\n        method,\n        type: MessageType.RPC\n      };\n\n      this.send(JSON.stringify(request));\n    });\n  }\n}\n\n/**\n * Make an HTTP request to an Agent\n * @param opts Connection options\n * @param init Request initialization options\n * @returns Promise resolving to a Response\n */\nexport function agentFetch(opts: AgentClientFetchOptions, init?: RequestInit) {\n  const agentNamespace = camelCaseToKebabCase(opts.agent);\n\n  // If basePath is provided, use it directly; otherwise construct from agent/name\n  // When basePath is set, room/party aren't used by PartySocket (basePath replaces the URL)\n  if (opts.basePath) {\n    return PartySocket.fetch(\n      { basePath: opts.basePath, ...opts } as unknown as PartyFetchOptions,\n      init\n    );\n  }\n\n  return PartySocket.fetch(\n    {\n      party: agentNamespace,\n      prefix: \"agents\",\n      room: opts.name || \"default\",\n      ...opts\n    },\n    init\n  );\n}\n"],"mappings":"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"}

package/dist/{client-jagG8a9_.js → client-fyQrLGkD.js}

@@ -1,5 +1,5 @@
 import { getAgentByName } from "./agent-routing.js";
-import { t as LifecycleCapability } from "./capability-BjSKYpzg.js";
+import { t as LifecycleCapability } from "./capability-B4WbF81e.js";
 import { tryN } from "./retries.js";
 import { n as callV2Tool } from "./invoker-CHMnoxIA.js";
 import { DurableObjectOAuthClientProvider } from "./mcp/client/do-oauth-client-provider.js";
@@ -2474,4 +2474,4 @@ function getNamespacedData(mcpClients, type) {
 //#endregion
 export { ensureMcpServerTable as a, RPCServerTransport as c, DisposableStore as d, normalizeServerId as i, RPC_DO_PREFIX as l, MCP_SERVER_ID_MAX_LENGTH as n, MCPConnectionState as o, getNamespacedData as r, RPCClientTransport as s, MCPClientManager as t, isDurableObjectNamespace as u };
 
-//# sourceMappingURL=client-jagG8a9_.js.map
+//# sourceMappingURL=client-fyQrLGkD.js.map