agents 0.22.0 → 0.23.0

package/dist/websockets-DUfRHPRq.js

@@ -0,0 +1,502 @@
+import { decoratedMethods } from "./callable-decorator.js";
+import { i as _classPrivateFieldInitSpec, n as _classPrivateFieldSet2, r as _assertClassBrand, t as _classPrivateFieldGet2 } from "./classPrivateFieldGet2-DZBYAB34.js";
+import { t as LifecycleCapability } from "./capability-BjSKYpzg.js";
+import { t as _classPrivateMethodInitSpec } from "./classPrivateMethodInitSpec-qMjJ6sHQ.js";
+import "./lifecycle-CMRGjZdw.js";
+import { RpcTarget } from "cloudflare:workers";
+import { nanoid } from "nanoid";
+import { newWorkersWebSocketRpcResponse } from "capnweb";
+//#region src/websockets/connection.ts
+let _Symbol$iterator;
+if (!("OPEN" in WebSocket)) {
+	const WebSocketStatus = {
+		CONNECTING: WebSocket.READY_STATE_CONNECTING,
+		OPEN: WebSocket.READY_STATE_OPEN,
+		CLOSING: WebSocket.READY_STATE_CLOSING,
+		CLOSED: WebSocket.READY_STATE_CLOSED
+	};
+	Object.assign(WebSocket, WebSocketStatus);
+	Object.assign(WebSocket.prototype, WebSocketStatus);
+}
+function tryGetManagedWebSocketMeta(ws) {
+	try {
+		const attachment = WebSocket.prototype.deserializeAttachment.call(ws);
+		if (!attachment || typeof attachment !== "object") return null;
+		if (!("__pk" in attachment)) return null;
+		const pk = attachment.__pk;
+		if (!pk || typeof pk !== "object") return null;
+		const { id, tags } = pk;
+		if (typeof id !== "string") return null;
+		const { uri } = pk;
+		return {
+			id,
+			tags: Array.isArray(tags) ? tags : [],
+			uri: typeof uri === "string" ? uri : void 0
+		};
+	} catch {
+		return null;
+	}
+}
+function isManagedWebSocket(ws) {
+	return tryGetManagedWebSocketMeta(ws) !== null;
+}
+var _cache = /* @__PURE__ */ new WeakMap();
+/**
+* Cache websocket attachments to avoid having to rehydrate them on every property access.
+*/
+var AttachmentCache = class {
+	constructor() {
+		_classPrivateFieldInitSpec(this, _cache, /* @__PURE__ */ new WeakMap());
+	}
+	get(ws) {
+		let attachment = _classPrivateFieldGet2(_cache, this).get(ws);
+		if (!attachment) {
+			attachment = WebSocket.prototype.deserializeAttachment.call(ws);
+			if (attachment !== void 0) _classPrivateFieldGet2(_cache, this).set(ws, attachment);
+			else throw new Error("Missing managed WebSocket lifecycle attachment");
+		}
+		return attachment;
+	}
+	set(ws, attachment) {
+		_classPrivateFieldGet2(_cache, this).set(ws, attachment);
+		WebSocket.prototype.serializeAttachment.call(ws, attachment);
+	}
+};
+const attachments = new AttachmentCache();
+const connections = /* @__PURE__ */ new WeakSet();
+const isWrapped = (ws) => {
+	return connections.has(ws);
+};
+/**
+* Wraps a WebSocket with Connection fields that rehydrate the
+* socket attachments lazily only when requested.
+*/
+const createConnection = (ws) => {
+	if (isWrapped(ws)) return ws;
+	let initialState;
+	if ("state" in ws) {
+		initialState = ws.state;
+		delete ws.state;
+	}
+	const connection = Object.defineProperties(ws, {
+		id: {
+			configurable: true,
+			get() {
+				return attachments.get(ws).__pk.id;
+			}
+		},
+		uri: {
+			configurable: true,
+			get() {
+				return attachments.get(ws).__pk.uri ?? null;
+			}
+		},
+		tags: {
+			configurable: true,
+			get() {
+				return attachments.get(ws).__pk.tags ?? [];
+			}
+		},
+		state: {
+			configurable: true,
+			get() {
+				return attachments.get(ws).__user ?? null;
+			}
+		},
+		setState: {
+			configurable: true,
+			value: function setState(setState) {
+				const state = setState instanceof Function ? setState(this.state) : setState;
+				attachments.set(ws, {
+					...attachments.get(ws),
+					__user: state ?? null
+				});
+				return state;
+			}
+		}
+	});
+	if (initialState) connection.setState(initialState);
+	connections.add(connection);
+	return connection;
+};
+var _sockets = /* @__PURE__ */ new WeakMap();
+_Symbol$iterator = Symbol.iterator;
+var ConnectionIterator = class {
+	constructor(sockets, tag) {
+		this.sockets = sockets;
+		this.tag = tag;
+		this.index = 0;
+		_classPrivateFieldInitSpec(this, _sockets, void 0);
+	}
+	[_Symbol$iterator]() {
+		return this;
+	}
+	next() {
+		const sockets = _classPrivateFieldGet2(_sockets, this) ?? _classPrivateFieldSet2(_sockets, this, this.sockets.get(this.tag));
+		let socket;
+		while (socket = sockets[this.index++]) if (socket.readyState === WebSocket.OPEN) {
+			if (!isManagedWebSocket(socket)) continue;
+			return {
+				done: false,
+				value: createConnection(socket)
+			};
+		}
+		return {
+			done: true,
+			value: void 0
+		};
+	}
+};
+/**
+* Deduplicate and validate connection tags.
+* Returns the final tag array (always includes the connection id as the first tag).
+*/
+function prepareTags(connectionId, userTags) {
+	const tags = [connectionId, ...userTags.filter((t) => t !== connectionId)];
+	if (tags.length > 10) throw new Error("A connection can only have 10 tags, including the default id tag.");
+	for (const tag of tags) {
+		if (typeof tag !== "string") throw new Error(`A connection tag must be a string. Received: ${tag}`);
+		if (tag === "") throw new Error("A connection tag must not be an empty string.");
+		if (tag.length > 256) throw new Error("A connection tag must not exceed 256 characters");
+	}
+	return tags;
+}
+/** The platform-backed manager for hibernating WebSockets. */
+var ConnectionManager = class {
+	constructor(controller) {
+		this.controller = controller;
+	}
+	getConnection(id) {
+		const matching = this.controller.get(id).filter((ws) => {
+			return tryGetManagedWebSocketMeta(ws)?.id === id;
+		});
+		if (matching.length === 0) return void 0;
+		if (matching.length === 1) return createConnection(matching[0]);
+		throw new Error(`More than one connection found for id ${id}. Did you mean to use getConnections(tag) instead?`);
+	}
+	getConnections(tag) {
+		return new ConnectionIterator(this.controller, tag);
+	}
+	accept(connection, options) {
+		const tags = prepareTags(connection.id, options.tags);
+		this.controller.accept(connection, tags);
+		attachments.set(connection, {
+			__pk: {
+				id: connection.id,
+				tags,
+				uri: connection.uri ?? void 0
+			},
+			__user: null
+		});
+		return createConnection(connection);
+	}
+};
+//#endregion
+//#region src/websockets/callables-target.ts
+/**
+* The single exposure policy for callable names. `Object.prototype` and
+* `RpcTarget.prototype` members are unreachable over Cap'n Web anyway
+* and are silently excluded; `then` is rejected loudly because exposing
+* it would make the remote stub thenable.
+*/
+function assertExposable(name) {
+	if (name === "then") throw new Error("A callables target cannot expose a method named \"then\" — it would make the remote stub thenable");
+	return !(name === "constructor" || name in Object.prototype || name in RpcTarget.prototype);
+}
+/**
+* The exposable prototype methods of a callables target, each bound to
+* invoke on the real instance (so private fields and `this` behave).
+*
+* Cap'n Web resolves methods on the prototype chain and rejects own
+* instance properties, so only prototype methods participate. The
+* nearest declaration wins for overridden names.
+*
+* @param target - The callables target to enumerate.
+* @returns Method names mapped to invokers on the target.
+*/
+function exposableMethods(target) {
+	const methods = /* @__PURE__ */ new Map();
+	const seen = /* @__PURE__ */ new Set();
+	let prototype = Object.getPrototypeOf(target);
+	while (prototype && prototype !== RpcTarget.prototype && prototype !== Object.prototype) {
+		for (const name of Object.getOwnPropertyNames(prototype)) {
+			if (seen.has(name)) continue;
+			seen.add(name);
+			if (!assertExposable(name)) continue;
+			const descriptor = Object.getOwnPropertyDescriptor(prototype, name);
+			if (!descriptor || typeof descriptor.value !== "function") continue;
+			const method = descriptor.value;
+			methods.set(name, (...args) => Reflect.apply(method, target, args));
+		}
+		prototype = Object.getPrototypeOf(prototype);
+	}
+	return methods;
+}
+/**
+* Build a Cap'n Web session root exposing exactly the given methods.
+*
+* Cap'n Web resolves methods on the prototype chain, rejects own
+* instance properties, and breaks on Proxy-wrapped roots — so the root
+* is a private `RpcTarget` subclass whose prototype carries the
+* methods and nothing else.
+*
+* @param methods - Method names mapped to their invokers.
+* @returns A root suitable as a Cap'n Web session's local main.
+*/
+function buildCallablesRoot(methods) {
+	class CallablesRoot extends RpcTarget {}
+	for (const [name, invoke] of methods) Object.defineProperty(CallablesRoot.prototype, name, {
+		value: invoke,
+		writable: true,
+		configurable: true,
+		enumerable: false
+	});
+	return new CallablesRoot();
+}
+/**
+* Build a callables target from a host's `@callable()`-decorated
+* methods — the fallback interface source when no `RpcTarget` is
+* configured (an explicit target is preferred and wins).
+*
+* Methods are resolved on the host at call time, so framework wrapping
+* applied after construction (e.g. Agent's context auto-wrapping) is
+* honored. Methods registered with `streaming: true` expect the legacy
+* Agent RPC protocol's injected `StreamingResponse` and are not exposed
+* here — return a `ReadableStream` from an `RpcTarget` method instead.
+*
+* @param host - The object whose decorated methods form the interface.
+* @returns A target exposing the decorated methods, or `undefined`
+* when the host has none.
+*/
+function callablesFromDecorated(host) {
+	const methods = /* @__PURE__ */ new Map();
+	for (const [name, metadata] of decoratedMethods(host)) {
+		if (metadata.streaming || !assertExposable(name)) continue;
+		methods.set(name, (...args) => {
+			const method = Reflect.get(host, name);
+			if (typeof method !== "function") throw new Error(`Method ${name} is not callable`);
+			return Reflect.apply(method, host, args);
+		});
+	}
+	if (methods.size === 0) return void 0;
+	return buildCallablesRoot(methods);
+}
+//#endregion
+//#region src/websockets/protocol.ts
+/**
+* Isomorphic pieces of the callables RPC wire contract.
+*
+* Imported from browser bundles (via the client) and from the Worker
+* runtime, so it must not import `cloudflare:workers`.
+*/
+/** Query parameter selecting the callables Cap'n Web RPC endpoint. */
+const CALLABLES_RPC_QUERY = "__agents_rpc";
+const CALLABLES_RPC_VALUE = "capnweb";
+/** Whether a request is a WebSocket upgrade addressed to callables RPC. */
+function isCallablesRpcUpgrade(request) {
+	return request.headers.get("Upgrade")?.toLowerCase() === "websocket" && new URL(request.url).searchParams.get("__agents_rpc") === "capnweb";
+}
+/**
+* Derive the callables RPC socket URL from a host route. Accepts http(s)
+* or ws(s) URLs and returns a ws(s) URL with the RPC query parameter set.
+*/
+function callablesRpcUrl(url) {
+	const resolved = new URL(url);
+	if (resolved.protocol === "http:") resolved.protocol = "ws:";
+	if (resolved.protocol === "https:") resolved.protocol = "wss:";
+	resolved.searchParams.set(CALLABLES_RPC_QUERY, CALLABLES_RPC_VALUE);
+	return resolved.toString();
+}
+//#endregion
+//#region src/websockets/websockets.ts
+/**
+* Reserved close codes the runtime synthesizes when there was no real
+* Close frame from the peer (1005 NoStatusReceived, 1006 AbnormalClosure,
+* 1015 TLSHandshake). They cannot appear in an outgoing Close frame, and
+* there is no peer left to receive a reciprocation.
+*/
+function isReservedCloseCode(code) {
+	return code === 1005 || code === 1006 || code === 1015;
+}
+/**
+* Reciprocate a peer-initiated Close frame to complete the handshake, as
+* the Hibernation API contract requires. Best-effort: swallows errors
+* from already-closed sockets or invalid codes/reasons, and skips
+* reciprocation entirely for reserved codes (dead transport).
+*/
+function reciprocateClose(ws, code, reason) {
+	if (isReservedCloseCode(code)) return;
+	try {
+		ws.close(code, reason);
+	} catch {}
+}
+var _handlers = /* @__PURE__ */ new WeakMap();
+var _getConnectionTags = /* @__PURE__ */ new WeakMap();
+var _callablesTarget = /* @__PURE__ */ new WeakMap();
+var _manager = /* @__PURE__ */ new WeakMap();
+var _WebSockets_brand = /* @__PURE__ */ new WeakSet();
+/**
+* Opt-in WebSocket support for Lifecycle Objects.
+*
+* Lifecycle itself does not model WebSockets — hosts that want them
+* install this capability, which owns the connection subsystem end to
+* end: it claims upgrades, accepts hibernating sockets, dispatches
+* `onConnect`/`onMessage`/`onClose` inside the host invocation
+* boundary, reciprocates close handshakes, and answers
+* `getConnections()`/`getConnection()`.
+*
+* ```ts
+* class Room extends DurableObject<Env> {
+*   readonly webSockets = new WebSockets({
+*     handlers: {
+*       onConnect: (connection) => connection.send("welcome"),
+*       onMessage: (connection, message) => { ... },
+*       onClose: (connection, code) => { ... }
+*     },
+*     callables: new RoomCallables()
+*   });
+*   readonly lifecycle = Lifecycle.install(this).use(this.webSockets);
+* }
+* ```
+*
+* `callables` exposes an `RpcTarget`'s prototype methods to remote
+* callers over a Cap'n Web session claimed from `?__agents_rpc=capnweb`
+* upgrades. Methods run through the host invocation boundary, may
+* return a `ReadableStream` to stream results, and emit
+* `rpc`/`rpc:error` capability events. Callable sessions are
+* non-hibernating: while a client holds one open, the Durable Object
+* stays pinned in memory.
+*
+* There is no separate browser client: against an `Agent`, the
+* `useAgent` hook's `stub`/`call` reach the same interface over the
+* protocol socket. A plain host's endpoint is reached with capnweb
+* directly — `newWebSocketRpcSession(new WebSocket(callablesRpcUrl(url)))`.
+*
+* @experimental The API surface may change before stabilizing.
+*/
+var WebSockets = class extends LifecycleCapability {
+	constructor(options = {}) {
+		super("websockets");
+		_classPrivateMethodInitSpec(this, _WebSockets_brand);
+		_classPrivateFieldInitSpec(this, _handlers, void 0);
+		_classPrivateFieldInitSpec(this, _getConnectionTags, void 0);
+		_classPrivateFieldInitSpec(this, _callablesTarget, void 0);
+		_classPrivateFieldInitSpec(this, _manager, void 0);
+		_classPrivateFieldSet2(_handlers, this, options.handlers);
+		_classPrivateFieldSet2(_getConnectionTags, this, options.getConnectionTags);
+		_classPrivateFieldSet2(_callablesTarget, this, options.callables ? _assertClassBrand(_WebSockets_brand, this, _buildCallablesTarget).call(this, options.callables) : void 0);
+	}
+	/** Claim callables RPC upgrades and, with handlers, plain upgrades. */
+	onWebSocketUpgrade({ request }) {
+		if (isCallablesRpcUpgrade(request)) {
+			if (!_classPrivateFieldGet2(_callablesTarget, this)) return void 0;
+			return newWorkersWebSocketRpcResponse(request, _classPrivateFieldGet2(_callablesTarget, this));
+		}
+		if (!_classPrivateFieldGet2(_handlers, this)) return void 0;
+		return _assertClassBrand(_WebSockets_brand, this, _acceptConnection).call(this, request);
+	}
+	/** Dispatch a platform message wake for a capability-owned socket. */
+	async onWebSocketMessage(ws, message) {
+		if (!isManagedWebSocket(ws)) return false;
+		const connection = createConnection(ws);
+		await this.lifecycle.runInHostContext(() => _classPrivateFieldGet2(_handlers, this)?.onMessage?.(connection, message), { connection });
+		return true;
+	}
+	/** Dispatch and reciprocate a close wake for an owned socket. */
+	async onWebSocketClose(ws, code, reason, wasClean) {
+		if (!isManagedWebSocket(ws)) return false;
+		const connection = createConnection(ws);
+		try {
+			await this.lifecycle.runInHostContext(() => _classPrivateFieldGet2(_handlers, this)?.onClose?.(connection, code, reason, wasClean), { connection });
+		} finally {
+			reciprocateClose(ws, code, reason);
+		}
+		return true;
+	}
+	/** Dispatch an error wake for an owned socket. */
+	async onWebSocketError(ws, error) {
+		if (!isManagedWebSocket(ws)) return false;
+		const connection = createConnection(ws);
+		await this.lifecycle.runInHostContext(() => _classPrivateFieldGet2(_handlers, this)?.onError?.(connection, error), { connection });
+		return true;
+	}
+	/**
+	* Close every owned connection during explicit host destruction. The
+	* capability owns its sockets' lifetimes, so it also owns tearing
+	* them down.
+	*/
+	dispose() {
+		for (const connection of this.getConnections()) try {
+			connection.close(1001, "Durable Object destroyed");
+		} catch {}
+	}
+	/** Open connections accepted by this capability, optionally by tag. */
+	getConnections(tag) {
+		return _get_connectionManager.call(_assertClassBrand(_WebSockets_brand, this)).getConnections(tag);
+	}
+	/** One connection accepted by this capability, by id. */
+	getConnection(id) {
+		return _get_connectionManager.call(_assertClassBrand(_WebSockets_brand, this)).getConnection(id);
+	}
+};
+function _get_connectionManager() {
+	_classPrivateFieldGet2(_manager, this) ?? _classPrivateFieldSet2(_manager, this, new ConnectionManager(this.lifecycle.sockets));
+	return _classPrivateFieldGet2(_manager, this);
+}
+async function _acceptConnection(request) {
+	const { 0: clientWebSocket, 1: serverWebSocket } = new WebSocketPair();
+	const connectionId = new URL(request.url).searchParams.get("_pk") || nanoid();
+	let connection = Object.assign(serverWebSocket, {
+		id: connectionId,
+		uri: request.url,
+		tags: [],
+		state: null,
+		setState(setState) {
+			const state = setState instanceof Function ? setState(this.state) : setState;
+			this.state = state;
+			return this.state;
+		}
+	});
+	const ctx = { request };
+	const tags = _classPrivateFieldGet2(_getConnectionTags, this) ? await _classPrivateFieldGet2(_getConnectionTags, this).call(this, connection, ctx) : [];
+	connection = _get_connectionManager.call(_assertClassBrand(_WebSockets_brand, this)).accept(connection, { tags });
+	await this.lifecycle.runInHostContext(() => _classPrivateFieldGet2(_handlers, this)?.onConnect?.(connection, ctx), {
+		connection,
+		request
+	});
+	return new Response(null, {
+		status: 101,
+		webSocket: clientWebSocket
+	});
+}
+/**
+* Wrap a callables target for serving: every exposable method
+* dispatches through the host invocation boundary and emits
+* `rpc`/`rpc:error` events.
+*/
+function _buildCallablesTarget(target) {
+	const dispatching = /* @__PURE__ */ new Map();
+	for (const [name, invoke] of exposableMethods(target)) dispatching.set(name, (...args) => _assertClassBrand(_WebSockets_brand, this, _dispatchCallable).call(this, name, () => invoke(...args)));
+	return buildCallablesRoot(dispatching);
+}
+async function _dispatchCallable(name, invoke) {
+	const services = this.lifecycle;
+	try {
+		const result = await services.runInHostContext(invoke);
+		services.events.emit("rpc", {
+			method: name,
+			streaming: result instanceof ReadableStream
+		});
+		return result;
+	} catch (error) {
+		services.events.emit("rpc:error", {
+			method: name,
+			error: error instanceof Error ? error.message : String(error)
+		});
+		throw error;
+	}
+}
+//#endregion
+export { isCallablesRpcUpgrade as a, callablesRpcUrl as i, CALLABLES_RPC_QUERY as n, callablesFromDecorated as o, CALLABLES_RPC_VALUE as r, WebSockets as t };
+
+//# sourceMappingURL=websockets-DUfRHPRq.js.map

package/dist/websockets-DUfRHPRq.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"websockets-DUfRHPRq.js","names":[],"sources":["../src/websockets/connection.ts","../src/websockets/callables-target.ts","../src/websockets/protocol.ts","../src/websockets/websockets.ts"],"sourcesContent":["// Polyfill WebSocket status code constants for environments that don't have them\n// in order to support libraries that expect standards-compatible WebSocket\n// implementations (e.g. PartySocket)\n\nimport type {\n  Connection,\n  ConnectionSetStateFn,\n  ConnectionState,\n  LifecycleSockets\n} from \"../lifecycle\";\n\nif (!(\"OPEN\" in WebSocket)) {\n  const WebSocketStatus = {\n    // @ts-expect-error\n    CONNECTING: WebSocket.READY_STATE_CONNECTING,\n    // @ts-expect-error\n    OPEN: WebSocket.READY_STATE_OPEN,\n    // @ts-expect-error\n    CLOSING: WebSocket.READY_STATE_CLOSING,\n    // @ts-expect-error\n    CLOSED: WebSocket.READY_STATE_CLOSED\n  };\n\n  Object.assign(WebSocket, WebSocketStatus);\n  // @ts-expect-error\n  Object.assign(WebSocket.prototype, WebSocketStatus);\n}\n\n/**\n * Store both platform attachments and user attachments in different namespaces\n */\ntype ConnectionAttachments = {\n  __pk: {\n    id: string;\n    tags: string[];\n    uri?: string;\n  };\n  __user?: unknown;\n};\n\nfunction tryGetManagedWebSocketMeta(\n  ws: WebSocket\n): ConnectionAttachments[\"__pk\"] | null {\n  try {\n    // Avoid AttachmentCache.get() here: externally accepted sockets\n    // can have an attachment without the managed __pk namespace.\n    const attachment = WebSocket.prototype.deserializeAttachment.call(\n      ws\n    ) as unknown;\n    if (!attachment || typeof attachment !== \"object\") {\n      return null;\n    }\n    if (!(\"__pk\" in attachment)) {\n      return null;\n    }\n    const pk = (attachment as ConnectionAttachments).__pk as unknown;\n    if (!pk || typeof pk !== \"object\") {\n      return null;\n    }\n    const { id, tags } = pk as {\n      id?: unknown;\n      tags?: unknown;\n    };\n    if (typeof id !== \"string\") {\n      return null;\n    }\n    const { uri } = pk as { uri?: unknown };\n    return {\n      id,\n      tags: Array.isArray(tags) ? tags : [],\n      uri: typeof uri === \"string\" ? uri : undefined\n    } satisfies ConnectionAttachments[\"__pk\"];\n  } catch {\n    return null;\n  }\n}\n\nexport function isManagedWebSocket(ws: WebSocket): boolean {\n  return tryGetManagedWebSocketMeta(ws) !== null;\n}\n\n/**\n * Cache websocket attachments to avoid having to rehydrate them on every property access.\n */\nclass AttachmentCache {\n  #cache = new WeakMap<WebSocket, ConnectionAttachments>();\n\n  get(ws: WebSocket): ConnectionAttachments {\n    let attachment = this.#cache.get(ws);\n    if (!attachment) {\n      attachment = WebSocket.prototype.deserializeAttachment.call(\n        ws\n      ) as ConnectionAttachments;\n      if (attachment !== undefined) {\n        this.#cache.set(ws, attachment);\n      } else {\n        throw new Error(\"Missing managed WebSocket lifecycle attachment\");\n      }\n    }\n\n    return attachment;\n  }\n\n  set(ws: WebSocket, attachment: ConnectionAttachments) {\n    this.#cache.set(ws, attachment);\n    WebSocket.prototype.serializeAttachment.call(ws, attachment);\n  }\n}\n\nconst attachments = new AttachmentCache();\nconst connections = new WeakSet<Connection>();\nconst isWrapped = (ws: WebSocket): ws is Connection => {\n  return connections.has(ws as Connection);\n};\n\n/**\n * Wraps a WebSocket with Connection fields that rehydrate the\n * socket attachments lazily only when requested.\n */\nexport const createConnection = (ws: WebSocket | Connection): Connection => {\n  if (isWrapped(ws)) {\n    return ws;\n  }\n\n  // if state was set on the socket before initializing the connection,\n  // capture it here so we can persist it again\n  let initialState;\n  if (\"state\" in ws) {\n    initialState = ws.state;\n    delete ws.state;\n  }\n\n  const connection = Object.defineProperties(ws, {\n    id: {\n      configurable: true,\n      get() {\n        return attachments.get(ws).__pk.id;\n      }\n    },\n    uri: {\n      configurable: true,\n      get() {\n        return attachments.get(ws).__pk.uri ?? null;\n      }\n    },\n    tags: {\n      configurable: true,\n      get() {\n        // Default to [] for connections accepted before tags were stored\n        return attachments.get(ws).__pk.tags ?? [];\n      }\n    },\n    state: {\n      configurable: true,\n      get() {\n        const attachment = attachments.get(ws);\n        return (attachment.__user ?? null) as ConnectionState<unknown>;\n      }\n    },\n    setState: {\n      configurable: true,\n      value: function setState<T>(setState: T | ConnectionSetStateFn<T>) {\n        const state =\n          setState instanceof Function\n            ? setState((this as Connection<T>).state)\n            : setState;\n        attachments.set(ws, {\n          ...attachments.get(ws),\n          __user: state ?? null\n        });\n        return state as ConnectionState<T>;\n      }\n    }\n  }) as Connection;\n\n  if (initialState) {\n    connection.setState(initialState);\n  }\n\n  connections.add(connection);\n  return connection;\n};\n\nclass ConnectionIterator<T> implements IterableIterator<Connection<T>> {\n  private index = 0;\n  #sockets: WebSocket[] | undefined;\n  constructor(\n    private sockets: LifecycleSockets,\n    private tag?: string\n  ) {}\n\n  [Symbol.iterator](): IterableIterator<Connection<T>> {\n    return this;\n  }\n\n  next(): IteratorResult<Connection<T>, number | undefined> {\n    const sockets =\n      this.#sockets ?? (this.#sockets = this.sockets.get(this.tag));\n\n    let socket: WebSocket;\n    while ((socket = sockets[this.index++])) {\n      // Only yield open sockets.\n      if (socket.readyState === WebSocket.OPEN) {\n        // Durable Objects hibernation APIs allow storing arbitrary sockets via\n        // `state.acceptWebSocket()`. Ignore sockets without our attachment.\n        if (!isManagedWebSocket(socket)) {\n          continue;\n        }\n        const value = createConnection(socket) as Connection<T>;\n        return { done: false, value };\n      }\n    }\n\n    // reached the end of the iteratee\n    return { done: true, value: undefined };\n  }\n}\n\n/**\n * Deduplicate and validate connection tags.\n * Returns the final tag array (always includes the connection id as the first tag).\n */\nfunction prepareTags(connectionId: string, userTags: string[]): string[] {\n  const tags = [connectionId, ...userTags.filter((t) => t !== connectionId)];\n\n  // validate tags against documented restrictions\n  // https://developers.cloudflare.com/durable-objects/api/hibernatable-websockets-api/#state-methods-for-websockets\n  if (tags.length > 10) {\n    throw new Error(\n      \"A connection can only have 10 tags, including the default id tag.\"\n    );\n  }\n\n  for (const tag of tags) {\n    if (typeof tag !== \"string\") {\n      throw new Error(`A connection tag must be a string. Received: ${tag}`);\n    }\n    if (tag === \"\") {\n      throw new Error(\"A connection tag must not be an empty string.\");\n    }\n    if (tag.length > 256) {\n      throw new Error(\"A connection tag must not exceed 256 characters\");\n    }\n  }\n\n  return tags;\n}\n\n/** The platform-backed manager for hibernating WebSockets. */\nexport class ConnectionManager<TState = unknown> {\n  constructor(private controller: LifecycleSockets) {}\n\n  getConnection<T = TState>(id: string) {\n    // TODO: Should we cache the connections?\n    const sockets = this.controller.get(id);\n    const matching = sockets.filter((ws) => {\n      return tryGetManagedWebSocketMeta(ws)?.id === id;\n    });\n\n    if (matching.length === 0) return undefined;\n    if (matching.length === 1)\n      return createConnection(matching[0]) as Connection<T>;\n\n    throw new Error(\n      `More than one connection found for id ${id}. Did you mean to use getConnections(tag) instead?`\n    );\n  }\n\n  getConnections<T = TState>(tag?: string | undefined) {\n    return new ConnectionIterator<T>(this.controller, tag);\n  }\n\n  accept(connection: Connection, options: { tags: string[] }) {\n    const tags = prepareTags(connection.id, options.tags);\n\n    this.controller.accept(connection, tags);\n    attachments.set(connection, {\n      __pk: {\n        id: connection.id,\n        tags,\n        uri: connection.uri ?? undefined\n      },\n      __user: null\n    });\n\n    return createConnection(connection);\n  }\n}\n","import { RpcTarget } from \"cloudflare:workers\";\nimport { decoratedMethods } from \"../callable-decorator\";\n\n/** A named remote method ready to be exposed on a callables root. */\nexport type CallableInvoker = (...args: unknown[]) => unknown;\n\n/**\n * The single exposure policy for callable names. `Object.prototype` and\n * `RpcTarget.prototype` members are unreachable over Cap'n Web anyway\n * and are silently excluded; `then` is rejected loudly because exposing\n * it would make the remote stub thenable.\n */\nfunction assertExposable(name: string): boolean {\n  if (name === \"then\") {\n    throw new Error(\n      'A callables target cannot expose a method named \"then\" — it would make the remote stub thenable'\n    );\n  }\n  return !(\n    name === \"constructor\" ||\n    name in Object.prototype ||\n    name in RpcTarget.prototype\n  );\n}\n\n/**\n * The exposable prototype methods of a callables target, each bound to\n * invoke on the real instance (so private fields and `this` behave).\n *\n * Cap'n Web resolves methods on the prototype chain and rejects own\n * instance properties, so only prototype methods participate. The\n * nearest declaration wins for overridden names.\n *\n * @param target - The callables target to enumerate.\n * @returns Method names mapped to invokers on the target.\n */\nexport function exposableMethods(\n  target: RpcTarget\n): ReadonlyMap<string, CallableInvoker> {\n  const methods = new Map<string, CallableInvoker>();\n  const seen = new Set<string>();\n  let prototype: object | null = Object.getPrototypeOf(target);\n  while (\n    prototype &&\n    prototype !== RpcTarget.prototype &&\n    prototype !== Object.prototype\n  ) {\n    for (const name of Object.getOwnPropertyNames(prototype)) {\n      if (seen.has(name)) continue;\n      seen.add(name);\n      if (!assertExposable(name)) continue;\n      const descriptor = Object.getOwnPropertyDescriptor(prototype, name);\n      if (!descriptor || typeof descriptor.value !== \"function\") continue;\n      // SAFETY: `typeof descriptor.value === \"function\"` was checked\n      // above; TypeScript cannot narrow a descriptor's `value` field.\n      const method = descriptor.value as CallableInvoker;\n      methods.set(name, (...args) => Reflect.apply(method, target, args));\n    }\n    prototype = Object.getPrototypeOf(prototype);\n  }\n  return methods;\n}\n\n/**\n * Build a Cap'n Web session root exposing exactly the given methods.\n *\n * Cap'n Web resolves methods on the prototype chain, rejects own\n * instance properties, and breaks on Proxy-wrapped roots — so the root\n * is a private `RpcTarget` subclass whose prototype carries the\n * methods and nothing else.\n *\n * @param methods - Method names mapped to their invokers.\n * @returns A root suitable as a Cap'n Web session's local main.\n */\nexport function buildCallablesRoot(\n  methods: ReadonlyMap<string, CallableInvoker>\n): RpcTarget {\n  class CallablesRoot extends RpcTarget {}\n  for (const [name, invoke] of methods) {\n    Object.defineProperty(CallablesRoot.prototype, name, {\n      value: invoke,\n      writable: true,\n      configurable: true,\n      enumerable: false\n    });\n  }\n  return new CallablesRoot();\n}\n\n/**\n * Build a callables target from a host's `@callable()`-decorated\n * methods — the fallback interface source when no `RpcTarget` is\n * configured (an explicit target is preferred and wins).\n *\n * Methods are resolved on the host at call time, so framework wrapping\n * applied after construction (e.g. Agent's context auto-wrapping) is\n * honored. Methods registered with `streaming: true` expect the legacy\n * Agent RPC protocol's injected `StreamingResponse` and are not exposed\n * here — return a `ReadableStream` from an `RpcTarget` method instead.\n *\n * @param host - The object whose decorated methods form the interface.\n * @returns A target exposing the decorated methods, or `undefined`\n * when the host has none.\n */\nexport function callablesFromDecorated(host: object): RpcTarget | undefined {\n  const methods = new Map<string, CallableInvoker>();\n  for (const [name, metadata] of decoratedMethods(host)) {\n    if (metadata.streaming || !assertExposable(name)) continue;\n    methods.set(name, (...args) => {\n      const method = Reflect.get(host, name) as unknown;\n      if (typeof method !== \"function\") {\n        throw new Error(`Method ${name} is not callable`);\n      }\n      return Reflect.apply(method, host, args);\n    });\n  }\n  if (methods.size === 0) return undefined;\n  return buildCallablesRoot(methods);\n}\n","/**\n * Isomorphic pieces of the callables RPC wire contract.\n *\n * Imported from browser bundles (via the client) and from the Worker\n * runtime, so it must not import `cloudflare:workers`.\n */\n\n/** Query parameter selecting the callables Cap'n Web RPC endpoint. */\nexport const CALLABLES_RPC_QUERY = \"__agents_rpc\";\nexport const CALLABLES_RPC_VALUE = \"capnweb\";\n\n/** Whether a request is a WebSocket upgrade addressed to callables RPC. */\nexport function isCallablesRpcUpgrade(request: Request): boolean {\n  return (\n    request.headers.get(\"Upgrade\")?.toLowerCase() === \"websocket\" &&\n    new URL(request.url).searchParams.get(CALLABLES_RPC_QUERY) ===\n      CALLABLES_RPC_VALUE\n  );\n}\n\n/**\n * Derive the callables RPC socket URL from a host route. Accepts http(s)\n * or ws(s) URLs and returns a ws(s) URL with the RPC query parameter set.\n */\nexport function callablesRpcUrl(url: string | URL): string {\n  const resolved = new URL(url);\n  if (resolved.protocol === \"http:\") resolved.protocol = \"ws:\";\n  if (resolved.protocol === \"https:\") resolved.protocol = \"wss:\";\n  resolved.searchParams.set(CALLABLES_RPC_QUERY, CALLABLES_RPC_VALUE);\n  return resolved.toString();\n}\n","import { RpcTarget } from \"cloudflare:workers\";\nimport { newWorkersWebSocketRpcResponse } from \"capnweb\";\nimport { nanoid } from \"nanoid\";\nimport {\n  LifecycleCapability,\n  type CapabilityWebSocketUpgradeContext,\n  type Connection,\n  type ConnectionSetStateFn,\n  type ConnectionState\n} from \"../lifecycle\";\nimport {\n  ConnectionManager,\n  createConnection,\n  isManagedWebSocket\n} from \"./connection\";\nimport {\n  buildCallablesRoot,\n  exposableMethods,\n  type CallableInvoker\n} from \"./callables-target\";\nimport type {\n  WebSocketHandlers,\n  WebSocketMessage,\n  WebSocketsOptions\n} from \"./options\";\nimport { isCallablesRpcUpgrade } from \"./protocol\";\n\n/**\n * Reserved close codes the runtime synthesizes when there was no real\n * Close frame from the peer (1005 NoStatusReceived, 1006 AbnormalClosure,\n * 1015 TLSHandshake). They cannot appear in an outgoing Close frame, and\n * there is no peer left to receive a reciprocation.\n */\nfunction isReservedCloseCode(code: number): boolean {\n  return code === 1005 || code === 1006 || code === 1015;\n}\n\n/**\n * Reciprocate a peer-initiated Close frame to complete the handshake, as\n * the Hibernation API contract requires. Best-effort: swallows errors\n * from already-closed sockets or invalid codes/reasons, and skips\n * reciprocation entirely for reserved codes (dead transport).\n */\nfunction reciprocateClose(ws: WebSocket, code: number, reason: string): void {\n  if (isReservedCloseCode(code)) return;\n  try {\n    ws.close(code, reason);\n  } catch {\n    // Already closed, oversize reason, or another unrecoverable\n    // invariant — the handshake is either done or out of our control.\n  }\n}\n\n/**\n * Opt-in WebSocket support for Lifecycle Objects.\n *\n * Lifecycle itself does not model WebSockets — hosts that want them\n * install this capability, which owns the connection subsystem end to\n * end: it claims upgrades, accepts hibernating sockets, dispatches\n * `onConnect`/`onMessage`/`onClose` inside the host invocation\n * boundary, reciprocates close handshakes, and answers\n * `getConnections()`/`getConnection()`.\n *\n * ```ts\n * class Room extends DurableObject<Env> {\n *   readonly webSockets = new WebSockets({\n *     handlers: {\n *       onConnect: (connection) => connection.send(\"welcome\"),\n *       onMessage: (connection, message) => { ... },\n *       onClose: (connection, code) => { ... }\n *     },\n *     callables: new RoomCallables()\n *   });\n *   readonly lifecycle = Lifecycle.install(this).use(this.webSockets);\n * }\n * ```\n *\n * `callables` exposes an `RpcTarget`'s prototype methods to remote\n * callers over a Cap'n Web session claimed from `?__agents_rpc=capnweb`\n * upgrades. Methods run through the host invocation boundary, may\n * return a `ReadableStream` to stream results, and emit\n * `rpc`/`rpc:error` capability events. Callable sessions are\n * non-hibernating: while a client holds one open, the Durable Object\n * stays pinned in memory.\n *\n * There is no separate browser client: against an `Agent`, the\n * `useAgent` hook's `stub`/`call` reach the same interface over the\n * protocol socket. A plain host's endpoint is reached with capnweb\n * directly — `newWebSocketRpcSession(new WebSocket(callablesRpcUrl(url)))`.\n *\n * @experimental The API surface may change before stabilizing.\n */\nexport class WebSockets extends LifecycleCapability {\n  readonly #handlers: WebSocketHandlers | undefined;\n  readonly #getConnectionTags: WebSocketsOptions[\"getConnectionTags\"];\n  readonly #callablesTarget: RpcTarget | undefined;\n  #manager: ConnectionManager | undefined;\n\n  constructor(options: WebSocketsOptions = {}) {\n    super(\"websockets\");\n    this.#handlers = options.handlers;\n    this.#getConnectionTags = options.getConnectionTags;\n    this.#callablesTarget = options.callables\n      ? this.#buildCallablesTarget(options.callables)\n      : undefined;\n  }\n\n  // ── Lifecycle capability hooks ─────────────────────────────────────────\n\n  /** Claim callables RPC upgrades and, with handlers, plain upgrades. */\n  onWebSocketUpgrade({\n    request\n  }: CapabilityWebSocketUpgradeContext):\n    | Promise<Response>\n    | Response\n    | undefined {\n    if (isCallablesRpcUpgrade(request)) {\n      if (!this.#callablesTarget) return undefined;\n      return newWorkersWebSocketRpcResponse(request, this.#callablesTarget);\n    }\n    if (!this.#handlers) return undefined;\n    return this.#acceptConnection(request);\n  }\n\n  /** Dispatch a platform message wake for a capability-owned socket. */\n  async onWebSocketMessage(\n    ws: WebSocket,\n    message: WebSocketMessage\n  ): Promise<boolean> {\n    if (!isManagedWebSocket(ws)) return false;\n    const connection = createConnection(ws);\n    await this.lifecycle.runInHostContext(\n      () => this.#handlers?.onMessage?.(connection, message),\n      { connection }\n    );\n    return true;\n  }\n\n  /** Dispatch and reciprocate a close wake for an owned socket. */\n  async onWebSocketClose(\n    ws: WebSocket,\n    code: number,\n    reason: string,\n    wasClean: boolean\n  ): Promise<boolean> {\n    if (!isManagedWebSocket(ws)) return false;\n    const connection = createConnection(ws);\n    try {\n      await this.lifecycle.runInHostContext(\n        () => this.#handlers?.onClose?.(connection, code, reason, wasClean),\n        { connection }\n      );\n    } finally {\n      reciprocateClose(ws, code, reason);\n    }\n    return true;\n  }\n\n  /** Dispatch an error wake for an owned socket. */\n  async onWebSocketError(ws: WebSocket, error: unknown): Promise<boolean> {\n    if (!isManagedWebSocket(ws)) return false;\n    const connection = createConnection(ws);\n    await this.lifecycle.runInHostContext(\n      () => this.#handlers?.onError?.(connection, error),\n      { connection }\n    );\n    return true;\n  }\n\n  /**\n   * Close every owned connection during explicit host destruction. The\n   * capability owns its sockets' lifetimes, so it also owns tearing\n   * them down.\n   */\n  dispose(): void {\n    for (const connection of this.getConnections()) {\n      try {\n        connection.close(1001, \"Durable Object destroyed\");\n      } catch {\n        // Already closed or mid-handshake — nothing left to tear down.\n      }\n    }\n  }\n\n  // ── Connections ────────────────────────────────────────────────────────\n\n  /** Open connections accepted by this capability, optionally by tag. */\n  getConnections<TState = unknown>(\n    tag?: string\n  ): IterableIterator<Connection<TState>> {\n    return this.#connectionManager.getConnections<TState>(tag);\n  }\n\n  /** One connection accepted by this capability, by id. */\n  getConnection<TState = unknown>(id: string): Connection<TState> | undefined {\n    return this.#connectionManager.getConnection<TState>(id);\n  }\n\n  get #connectionManager(): ConnectionManager {\n    this.#manager ??= new ConnectionManager(this.lifecycle.sockets);\n    return this.#manager;\n  }\n\n  async #acceptConnection(request: Request): Promise<Response> {\n    const { 0: clientWebSocket, 1: serverWebSocket } = new WebSocketPair();\n    const url = new URL(request.url);\n    // `||`, not `??`: an empty `?_pk=` value must fall back to a\n    // generated id — an empty connection id would later throw in tag\n    // validation and reject the upgrade.\n    const connectionId = url.searchParams.get(\"_pk\") || nanoid();\n\n    let connection: Connection = Object.assign(serverWebSocket, {\n      id: connectionId,\n      uri: request.url,\n      tags: [] as string[],\n      state: null as unknown as ConnectionState<unknown>,\n      setState<T = unknown>(setState: T | ConnectionSetStateFn<T>) {\n        // Pre-accept shim: hold state on the socket until accept()\n        // persists it into the hibernation attachment.\n        const state =\n          setState instanceof Function\n            ? setState(this.state as ConnectionState<T>)\n            : setState;\n        this.state = state as ConnectionState<T>;\n        return this.state as ConnectionState<T>;\n      }\n    });\n\n    const ctx = { request };\n    const tags = this.#getConnectionTags\n      ? await this.#getConnectionTags(connection, ctx)\n      : [];\n\n    // Hibernating WebSockets remain connected while the object is evicted.\n    connection = this.#connectionManager.accept(connection, { tags });\n    await this.lifecycle.runInHostContext(\n      () => this.#handlers?.onConnect?.(connection, ctx),\n      { connection, request }\n    );\n\n    return new Response(null, { status: 101, webSocket: clientWebSocket });\n  }\n\n  // ── Callables ──────────────────────────────────────────────────────────\n\n  /**\n   * Wrap a callables target for serving: every exposable method\n   * dispatches through the host invocation boundary and emits\n   * `rpc`/`rpc:error` events.\n   */\n  #buildCallablesTarget(target: RpcTarget): RpcTarget {\n    const dispatching = new Map<string, CallableInvoker>();\n    for (const [name, invoke] of exposableMethods(target)) {\n      dispatching.set(name, (...args) =>\n        this.#dispatchCallable(name, () => invoke(...args))\n      );\n    }\n    return buildCallablesRoot(dispatching);\n  }\n\n  async #dispatchCallable(\n    name: string,\n    invoke: () => unknown\n  ): Promise<unknown> {\n    // Throws with installation guidance when the capability was never\n    // installed with Lifecycle.use().\n    const services = this.lifecycle;\n    try {\n      const result = await services.runInHostContext(invoke);\n      services.events.emit(\"rpc\", {\n        method: name,\n        streaming: result instanceof ReadableStream\n      });\n      return result;\n    } catch (error) {\n      services.events.emit(\"rpc:error\", {\n        method: name,\n        error: error instanceof Error ? error.message : String(error)\n      });\n      throw error;\n    }\n  }\n}\n"],"mappings":"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"}

package/dist/workflow-types.d.ts

@@ -1,29 +1,29 @@
 import {
-  At as WorkflowRejectedError,
-  Ct as WorkflowErrorCallback,
-  Dt as WorkflowPage,
-  Et as WorkflowInfo,
-  Mt as WorkflowTrackingRow,
-  Ot as WorkflowProgressCallback,
-  St as WorkflowCompleteCallback,
-  Tt as WorkflowEventPayload,
-  _t as RunWorkflowOptions,
-  bt as WorkflowCallbackBase,
-  dt as AgentWorkflowOrigin,
-  ft as AgentWorkflowParams,
-  gt as DefaultProgress,
-  ht as ApprovalEventPayload,
-  jt as WorkflowStatus,
-  kt as WorkflowQueryCriteria,
-  lt as AgentWorkflowEvent,
-  mt as AgentWorkflowStep,
-  pt as AgentWorkflowPathStep,
-  ut as AgentWorkflowInternalParams,
-  vt as WaitForApprovalOptions,
-  wt as WorkflowEventCallback,
-  xt as WorkflowCallbackType,
-  yt as WorkflowCallback
-} from "./agent-routing-CnkaHb-v.js";
+  Ct as WorkflowProgressCallback,
+  Dt as WorkflowTrackingRow,
+  Et as WorkflowStatus,
+  St as WorkflowPage,
+  Tt as WorkflowRejectedError,
+  _t as WorkflowCompleteCallback,
+  at as AgentWorkflowInternalParams,
+  bt as WorkflowEventPayload,
+  ct as AgentWorkflowPathStep,
+  dt as DefaultProgress,
+  ft as RunWorkflowOptions,
+  gt as WorkflowCallbackType,
+  ht as WorkflowCallbackBase,
+  it as AgentWorkflowEvent,
+  lt as AgentWorkflowStep,
+  mt as WorkflowCallback,
+  ot as AgentWorkflowOrigin,
+  pt as WaitForApprovalOptions,
+  st as AgentWorkflowParams,
+  ut as ApprovalEventPayload,
+  vt as WorkflowErrorCallback,
+  wt as WorkflowQueryCriteria,
+  xt as WorkflowInfo,
+  yt as WorkflowEventCallback
+} from "./agent-routing-DE5zmCQ8.js";
 export {
   AgentWorkflowEvent,
   AgentWorkflowInternalParams,