agents 0.11.3 → 0.11.5

package/dist/index.js

@@ -2,9 +2,10 @@ import { MessageType } from "./types.js";
 import { camelCaseToKebabCase } from "./utils.js";
 import { createHeaderBasedEmailResolver, signAgentHeaders } from "./email.js";
 import { __DO_NOT_USE_WILL_BREAK__agentContext } from "./internal_context.js";
-import { i as _classPrivateFieldInitSpec, n as _classPrivateFieldSet2, t as _classPrivateFieldGet2 } from "./classPrivateFieldGet2-BVdP0e3Z.js";
+import { i as _classPrivateFieldInitSpec, n as _classPrivateFieldSet2, t as _classPrivateFieldGet2 } from "./classPrivateFieldGet2-DAZNVUKb.js";
+import { SUB_PREFIX, getSubAgentByName, parseSubAgentPath, routeSubAgentRequest } from "./sub-routing.js";
 import { isErrorRetryable, tryN, validateRetryOptions } from "./retries.js";
-import { o as RPC_DO_PREFIX, r as MCPConnectionState, s as DisposableStore, t as MCPClientManager } from "./client-PEDsNnfY.js";
+import { o as RPC_DO_PREFIX, r as MCPConnectionState, s as DisposableStore, t as MCPClientManager } from "./client-BYF13FDD.js";
 import { DurableObjectOAuthClientProvider } from "./mcp/do-oauth-client-provider.js";
 import { genericObservability } from "./observability/index.js";
 import { AsyncLocalStorage } from "node:async_hooks";
@@ -19,13 +20,13 @@ let _Symbol$dispose;
 * Type guard for RPC request messages
 */
 function isRPCRequest(msg) {
-	return typeof msg === "object" && msg !== null && "type" in msg && msg.type === MessageType.RPC && "id" in msg && typeof msg.id === "string" && "method" in msg && typeof msg.method === "string" && "args" in msg && Array.isArray(msg.args);
+	return typeof msg === "object" && msg !== null && "type" in msg && msg.type === "rpc" && "id" in msg && typeof msg.id === "string" && "method" in msg && typeof msg.method === "string" && "args" in msg && Array.isArray(msg.args);
 }
 /**
 * Type guard for state update messages
 */
 function isStateUpdateMessage(msg) {
-	return typeof msg === "object" && msg !== null && "type" in msg && msg.type === MessageType.CF_AGENT_STATE && "state" in msg;
+	return typeof msg === "object" && msg !== null && "type" in msg && msg.type === "cf_agent_state" && "state" in msg;
 }
 const callableMetadata = /* @__PURE__ */ new WeakMap();
 /**
@@ -79,6 +80,14 @@ const STATE_ROW_ID = "cf_state_row_id";
 const STATE_WAS_CHANGED = "cf_state_was_changed";
 const DEFAULT_STATE = {};
 /**
+* Validate that a stored `parentPath` has the expected shape. Used
+* when restoring from DO storage to guard against corrupted data.
+*/
+function isValidParentPath(value) {
+	if (!Array.isArray(value)) return false;
+	return value.every((entry) => entry != null && typeof entry === "object" && typeof entry.className === "string" && typeof entry.name === "string");
+}
+/**
 * Internal key used to store the readonly flag in connection state.
 * Prefixed with _cf_ to avoid collision with user state keys.
 */
@@ -459,6 +468,7 @@ var Agent = class Agent extends Server {
 		this._rawStateAccessors = /* @__PURE__ */ new WeakMap();
 		this._persistenceHookMode = "none";
 		this._isFacet = false;
+		this._parentPath = [];
 		this._insideOnStart = false;
 		this._warnedScheduleInOnStart = /* @__PURE__ */ new Set();
 		this._keepAliveRefs = 0;
@@ -468,6 +478,7 @@ var Agent = class Agent extends Server {
 		this.initialState = DEFAULT_STATE;
 		this.observability = genericObservability;
 		this._flushingQueue = false;
+		this._subAgentRegistryReady = false;
 		if (!wrappedClasses.has(this.constructor)) {
 			this._autoWrapCustomMethods();
 			wrappedClasses.add(this.constructor);
@@ -535,7 +546,7 @@ var Agent = class Agent extends Server {
 				if (isStateUpdateMessage(parsed)) {
 					if (this.isConnectionReadonly(connection)) {
 						connection.send(JSON.stringify({
-							type: MessageType.CF_AGENT_STATE_ERROR,
+							type: "cf_agent_state_error",
 							error: "Connection is readonly"
 						}));
 						return;
@@ -545,7 +556,7 @@ var Agent = class Agent extends Server {
 					} catch (e) {
 						console.error("[Agent] State update rejected:", e);
 						connection.send(JSON.stringify({
-							type: MessageType.CF_AGENT_STATE_ERROR,
+							type: "cf_agent_state_error",
 							error: "State update rejected"
 						}));
 					}
@@ -586,7 +597,7 @@ var Agent = class Agent extends Server {
 							id,
 							result,
 							success: true,
-							type: MessageType.RPC
+							type: "rpc"
 						};
 						connection.send(JSON.stringify(response));
 					} catch (e) {
@@ -594,7 +605,7 @@ var Agent = class Agent extends Server {
 							error: e instanceof Error ? e.message : "Unknown error occurred",
 							id: parsed.id,
 							success: false,
-							type: MessageType.RPC
+							type: "rpc"
 						};
 						connection.send(JSON.stringify(response));
 						console.error("RPC error:", e);
@@ -621,7 +632,7 @@ var Agent = class Agent extends Server {
 				if (this.shouldSendProtocolMessages(connection, ctx)) {
 					if (this._resolvedOptions.sendIdentityOnConnect) {
 						const ctor = this.constructor;
-						if (ctor.options?.sendIdentityOnConnect === void 0 && !_sendIdentityWarnedClasses.has(ctor)) {
+						if (ctor.options?.sendIdentityOnConnect === void 0 && !_sendIdentityWarnedClasses.has(ctor) && !this._isFacet) {
 							if (!new URL(ctx.request.url).pathname.includes(this.name)) {
 								_sendIdentityWarnedClasses.add(ctor);
 								console.warn(`[Agent] ${ctor.name}: sending instance name "${this.name}" to clients via sendIdentityOnConnect (the name is not visible in the URL with custom routing). If this name is sensitive, add \`static options = { sendIdentityOnConnect: false }\` to opt out. Set it to true to silence this message.`);
@@ -630,16 +641,16 @@ var Agent = class Agent extends Server {
 						connection.send(JSON.stringify({
 							name: this.name,
 							agent: camelCaseToKebabCase(this._ParentClass.name),
-							type: MessageType.CF_AGENT_IDENTITY
+							type: "cf_agent_identity"
 						}));
 					}
 					if (this.state) connection.send(JSON.stringify({
 						state: this.state,
-						type: MessageType.CF_AGENT_STATE
+						type: "cf_agent_state"
 					}));
 					connection.send(JSON.stringify({
 						mcp: this.getMcpServers(),
-						type: MessageType.CF_AGENT_MCP_SERVERS
+						type: "cf_agent_mcp_servers"
 					}));
 				} else this._setConnectionNoProtocol(connection);
 				this._emit("connect", { connectionId: connection.id });
@@ -671,6 +682,8 @@ var Agent = class Agent extends Server {
 				email: void 0
 			}, async () => {
 				if (await this.ctx.storage.get("cf_agents_is_facet")) this._isFacet = true;
+				const storedParentPath = await this.ctx.storage.get("cf_agents_parent_path");
+				if (isValidParentPath(storedParentPath)) this._parentPath = storedParentPath;
 				await this._tryCatch(async () => {
 					await this.mcp.restoreConnectionsFromStorage(this.name);
 					await this._restoreRpcMcpServers();
@@ -718,23 +731,10 @@ var Agent = class Agent extends Server {
 	* @param excludeIds Additional connection IDs to exclude (e.g. the source)
 	*/
 	_broadcastProtocol(msg, excludeIds = []) {
-		if (this._isFacet) return;
 		const exclude = [...excludeIds];
 		for (const conn of this.getConnections()) if (!this.isConnectionProtocolEnabled(conn)) exclude.push(conn.id);
 		this.broadcast(msg, exclude);
 	}
-	/**
-	* When running as a facet, the parent DO owns the WebSocket registry
-	* (`ctx.getWebSockets()`). Iterating from the child isolate throws
-	* "Cannot perform I/O on behalf of a different Durable Object".
-	* Downstream callers (e.g. chat-streaming paths) invoke
-	* `this.broadcast()` directly, bypassing `_broadcastProtocol`'s
-	* guard, so override at the base to catch every path.
-	*/
-	broadcast(msg, without) {
-		if (this._isFacet) return;
-		super.broadcast(msg, without);
-	}
 	_setStateInternal(nextState, source = "server") {
 		this.validateStateChange(nextState, source);
 		this._state = nextState;
@@ -744,7 +744,7 @@ var Agent = class Agent extends Server {
     `;
 		this._broadcastProtocol(JSON.stringify({
 			state: nextState,
-			type: MessageType.CF_AGENT_STATE
+			type: "cf_agent_state"
 		}), source !== "server" ? [source.id] : []);
 		const { connection, request, email } = __DO_NOT_USE_WILL_BREAK__agentContext.getStore() || {};
 		this.ctx.waitUntil((async () => {
@@ -1690,6 +1690,12 @@ var Agent = class Agent extends Server {
 	* alarm system, without creating schedule rows or emitting observability
 	* events. Configure via `static options = { keepAliveIntervalMs: 5000 }`.
 	*
+	* No-op on facets. Facets share the parent's isolate and don't
+	* need a separate alarm heartbeat — the parent's own activity,
+	* any open WebSocket to the facet, and any in-flight Promise
+	* already keep the shared machine alive for the duration of
+	* real work.
+	*
 	* @example
 	* ```ts
 	* const dispose = await this.keepAlive();
@@ -1701,7 +1707,7 @@ var Agent = class Agent extends Server {
 	* ```
 	*/
 	async keepAlive() {
-		if (this._isFacet) throw new Error("keepAlive() is not supported in sub-agents. Use keepAlive() from the parent agent instead.");
+		if (this._isFacet) return () => {};
 		this._keepAliveRefs++;
 		if (this._keepAliveRefs === 1) await this._scheduleNextAlarm();
 		let disposed = false;
@@ -2001,6 +2007,108 @@ var Agent = class Agent extends Server {
 		await this._scheduleNextAlarm();
 	}
 	/**
+	* Intercept incoming HTTP/WS requests whose URL contains a
+	* `/sub/{child-class}/{child-name}` marker and forward them to
+	* the facet. The `onBeforeSubAgent` hook fires first (authorize,
+	* mutate, or short-circuit). If the hook doesn't return a
+	* Response, the framework resolves the facet and hands the
+	* request off.
+	*
+	* After a WebSocket upgrade completes, subsequent frames route
+	* directly to the child — the parent is only on the path for the
+	* initial request.
+	*
+	* @experimental The API surface may change before stabilizing.
+	*/
+	async fetch(request) {
+		const ctx = this.ctx;
+		const match = parseSubAgentPath(request.url, { knownClasses: ctx.exports ? Object.keys(ctx.exports) : void 0 });
+		if (!match) return super.fetch(request);
+		const decision = await this.onBeforeSubAgent(request, {
+			className: match.childClass,
+			name: match.childName
+		});
+		if (decision instanceof Response) return decision;
+		const forwardReq = decision instanceof Request ? decision : request;
+		return this._cf_forwardToFacet(forwardReq, match);
+	}
+	/**
+	* Parent-side middleware hook. Fires before a request is
+	* forwarded into a facet sub-agent. Mirrors `onBeforeConnect` /
+	* `onBeforeRequest`.
+	*
+	*   - return `void` (default) → forward the original request
+	*   - return `Request`        → forward this (modified) request
+	*   - return `Response`       → return this response to the
+	*                               client; do not wake the child
+	*
+	* Default implementation: return void (permissive).
+	*
+	* The hook receives the **original** request with its URL intact —
+	* including the `/sub/{class}/{name}` segment. The routing
+	* decision for which facet to wake is fixed at parse time, so if
+	* you return a modified `Request`, its headers, body, method, and
+	* query string flow through to the child, but the **pathname**
+	* the child sees is always the tail after `/sub/{class}/{name}`.
+	* Customize via headers/body rather than URL-rewriting.
+	*
+	* WebSocket upgrade requests flow through this hook the same way as
+	* plain HTTP. If you return a mutated `Request`, make sure it still
+	* carries the original `Upgrade: websocket` and `Sec-WebSocket-*`
+	* headers — the simplest safe recipe is to clone the incoming
+	* request's headers (via `new Headers(req.headers)`) and only add
+	* or replace entries, rather than constructing a fresh `Headers`
+	* object from scratch.
+	*
+	* @experimental The API surface may change before stabilizing.
+	*
+	* @example
+	* ```ts
+	* class Inbox extends Agent {
+	*   override async onBeforeSubAgent(req, { className, name }) {
+	*     // Strict registry gate
+	*     if (!this.hasSubAgent(className, name)) {
+	*       return new Response("Not found", { status: 404 });
+	*     }
+	*   }
+	* }
+	* ```
+	*/
+	async onBeforeSubAgent(_request, _child) {}
+	/**
+	* Resolve the facet Fetcher for the match and forward the
+	* request to it with `/sub/{class}/{name}` stripped.
+	*
+	* @internal
+	*/
+	async _cf_forwardToFacet(req, match) {
+		let fetcher;
+		try {
+			fetcher = await this._cf_resolveSubAgent(match.childClass, match.childName);
+		} catch (err) {
+			const message = err instanceof Error ? err.message : String(err);
+			console.error("[agents] sub-agent route failed:", message);
+			if (/null character/i.test(message) || /reserved/i.test(message)) return new Response("Bad Request", { status: 400 });
+			return new Response("Not Found", { status: 404 });
+		}
+		const rewritten = new URL(req.url);
+		rewritten.pathname = match.remainingPath;
+		const forwarded = new Request(rewritten, req);
+		return fetcher.fetch(forwarded);
+	}
+	/**
+	* Bridge method used by `getSubAgentByName`. Resolves the facet
+	* on each call (idempotent via `subAgent`) and dispatches one
+	* RPC method. Stateless — no cached references.
+	*
+	* @internal
+	*/
+	async _cf_invokeSubAgent(className, name, method, args) {
+		const handle = await this._cf_resolveSubAgent(className, name);
+		if (typeof handle[method] !== "function") throw new Error(`Method "${method}" not found on ${className}.`);
+		return await handle[method](...args);
+	}
+	/**
 	* Initialize this agent as a facet in a single RPC.
 	*
 	* Runs entirely inside the child's isolate, so every storage write
@@ -2010,19 +2118,105 @@ var Agent = class Agent extends Server {
 	* parent and triggered "Cannot perform I/O on behalf of a different
 	* Durable Object" on the child.
 	*
-	* Order matters: set `_isFacet` BEFORE triggering initialization, so
-	* the first `onStart()` run (which calls `broadcastMcpServers`) sees
-	* the flag and skips broadcasts that would touch the parent DO's
-	* WebSocket registry.
+	* We still set `_isFacet` eagerly (before `__unsafe_ensureInitialized`)
+	* so any code that legitimately branches on it — e.g. skipping
+	* parent-owned alarms in schedule guards — sees the flag during
+	* the first `onStart()` run. Broadcast paths no longer special-case
+	* facets, since facets can be directly addressed via sub-agent
+	* routing and have their own WebSocket connections.
 	*
 	* @internal Called by {@link subAgent}.
 	*/
-	async _cf_initAsFacet(name) {
+	async _cf_initAsFacet(name, parentPath = []) {
 		this._isFacet = true;
-		await Promise.all([this.ctx.storage.put("cf_agents_is_facet", true), this.ctx.storage.put("__ps_name", name)]);
+		this._parentPath = parentPath;
+		await Promise.all([
+			this.ctx.storage.put("cf_agents_is_facet", true),
+			this.ctx.storage.put("__ps_name", name),
+			this.ctx.storage.put("cf_agents_parent_path", parentPath)
+		]);
 		await this.__unsafe_ensureInitialized();
 	}
 	/**
+	* Ancestor chain for this agent, root-first. Empty for top-level
+	* DOs. Populated at facet init time; survives hibernation.
+	*
+	* @example
+	* ```ts
+	* class Chat extends Agent {
+	*   onStart() {
+	*     console.log("chat started under:", this.parentPath);
+	*     // → [{ className: "Tenant", name: "acme" }, { className: "Inbox", name: "alice" }]
+	*   }
+	* }
+	* ```
+	*
+	* @experimental The API surface may change before stabilizing.
+	*/
+	get parentPath() {
+		return this._parentPath;
+	}
+	/**
+	* Ancestor chain + self, root-first. Convenient for logging.
+	*
+	* @experimental The API surface may change before stabilizing.
+	*/
+	get selfPath() {
+		return [...this._parentPath, {
+			className: this.constructor.name,
+			name: this.name
+		}];
+	}
+	/**
+	* Resolve a typed RPC stub for this facet's **immediate** parent
+	* agent.
+	*
+	* Symmetric with `subAgent(Cls, name)`: while `subAgent` opens a
+	* stub from parent to child, `parentAgent` opens one from child
+	* to parent. Pass the direct parent's class reference — the
+	* framework verifies it matches the last entry of
+	* `this.parentPath` at runtime, then looks up `env[Cls.name]` to
+	* find the namespace binding.
+	*
+	* `this.parentPath` is root-first, so the direct parent is the
+	* **last** entry: `this.parentPath.at(-1)`. For grandparents and
+	* further ancestors, iterate `this.parentPath` and use
+	* `getAgentByName(env.X, this.parentPath[i].name)` directly.
+	*
+	* Assumes the standard "binding name matches class name" convention.
+	* If your `wrangler.jsonc` binds the parent under a different name
+	* (e.g. `{ class_name: "Inbox", name: "MY_INBOX" }`), call
+	* `getAgentByName(env.MY_INBOX, this.parentPath.at(-1)!.name)`
+	* directly instead.
+	*
+	* @experimental The API surface may change before stabilizing.
+	*
+	* @throws If this agent is not a facet (no parent).
+	* @throws If `Cls.name` doesn't match the recorded direct-parent
+	*         class (guards against accidentally reaching the wrong
+	*         DO, especially in nested Root → Mid → Leaf chains).
+	* @throws If no env binding named `Cls.name` is found.
+	*
+	* @example
+	* ```ts
+	* class Chat extends AIChatAgent<Env> {
+	*   async onChatMessage(...) {
+	*     const inbox = await this.parentAgent(Inbox);
+	*     const memory = await inbox.getSharedMemory("facts");
+	*     // ...
+	*   }
+	* }
+	* ```
+	*/
+	async parentAgent(cls) {
+		const parent = this._parentPath[this._parentPath.length - 1];
+		if (!parent) throw new Error(`parentAgent(): ${this.constructor.name} is not a facet — only sub-agents (spawned via \`subAgent()\`) have a parent.`);
+		if (cls.name !== parent.className) throw new Error(`parentAgent(${cls.name}): this facet's recorded parent class is "${parent.className}", not "${cls.name}". Pass the class whose constructor actually spawned this facet.`);
+		const binding = this.env[cls.name];
+		if (!binding) throw new Error(`parentAgent(${cls.name}): no top-level binding "${cls.name}" found in env. If the parent is bound under a different name (e.g. "MY_${cls.name.toUpperCase()}"), use \`getAgentByName(env.MY_${cls.name.toUpperCase()}, this.parentPath.at(-1)!.name)\` directly.`);
+		return await getServerByName(binding, parent.name);
+	}
+	/**
 	* Get or create a named sub-agent — a child Durable Object (facet)
 	* with its own isolated SQLite storage running on the same machine.
 	*
@@ -2043,12 +2237,29 @@ var Agent = class Agent extends Server {
 	* ```
 	*/
 	async subAgent(cls, name) {
+		return await this._cf_resolveSubAgent(cls.name, name);
+	}
+	/**
+	* Shared facet resolution — takes a CamelCase class name string
+	* (matching `ctx.exports`) rather than a class reference. Both
+	* `subAgent(cls, name)` and `_cf_invokeSubAgent(className, ...)`
+	* funnel through here so registry bookkeeping and the
+	* `_cf_initAsFacet` handshake are consistent.
+	*
+	* @internal
+	*/
+	async _cf_resolveSubAgent(className, name) {
 		const ctx = this.ctx;
 		if (!ctx.facets || !ctx.exports) throw new Error("subAgent() is not supported in this runtime — `ctx.facets` / `ctx.exports` are unavailable. Update to the latest `compatibility_date` in your wrangler.jsonc.");
-		if (!ctx.exports[cls.name]) throw new Error(`Sub-agent class "${cls.name}" not found in worker exports. Make sure the class is exported from your worker entry point and that the export name matches the class name.`);
-		const facetKey = `${cls.name}\0${name}`;
-		const stub = ctx.facets.get(facetKey, () => ({ class: ctx.exports[cls.name] }));
-		await stub._cf_initAsFacet(name);
+		if (camelCaseToKebabCase(className) === "sub") throw new Error(`Sub-agent class name "${className}" kebab-cases to "sub", which collides with the reserved URL separator — rename the class (e.g. "SubThing" or "Subtask").`);
+		const Cls = ctx.exports[className];
+		if (!Cls) throw new Error(`Sub-agent class "${className}" not found in worker exports. Make sure the class is exported from your worker entry point and that the export name matches the class name.`);
+		if (name.includes("\0")) throw new Error(`Sub-agent name contains null character (\\0), which is reserved.`);
+		const facetKey = `${className}\0${name}`;
+		const stub = ctx.facets.get(facetKey, () => ({ class: Cls }));
+		const childParentPath = this.selfPath;
+		await stub._cf_initAsFacet(name, childParentPath);
+		this._recordSubAgent(className, name);
 		return stub;
 	}
 	/**
@@ -2082,7 +2293,63 @@ var Agent = class Agent extends Server {
 		const ctx = this.ctx;
 		if (!ctx.facets) throw new Error("deleteSubAgent() is not supported in this runtime — `ctx.facets` is unavailable. Update to the latest `compatibility_date` in your wrangler.jsonc.");
 		const facetKey = `${cls.name}\0${name}`;
-		ctx.facets.delete(facetKey);
+		try {
+			ctx.facets.delete(facetKey);
+		} catch {}
+		this._forgetSubAgent(cls.name, name);
+	}
+	/** @internal */
+	_ensureSubAgentRegistry() {
+		if (this._subAgentRegistryReady) return;
+		this.sql`
+      CREATE TABLE IF NOT EXISTS cf_agents_sub_agents (
+        class TEXT NOT NULL,
+        name TEXT NOT NULL,
+        created_at INTEGER NOT NULL,
+        PRIMARY KEY (class, name)
+      )
+    `;
+		this._subAgentRegistryReady = true;
+	}
+	/** @internal */
+	_recordSubAgent(className, name) {
+		this._ensureSubAgentRegistry();
+		this.sql`
+      INSERT OR IGNORE INTO cf_agents_sub_agents (class, name, created_at)
+      VALUES (${className}, ${name}, ${Date.now()})
+    `;
+	}
+	/** @internal */
+	_forgetSubAgent(className, name) {
+		this._ensureSubAgentRegistry();
+		this.sql`
+      DELETE FROM cf_agents_sub_agents
+      WHERE class = ${className} AND name = ${name}
+    `;
+	}
+	hasSubAgent(classOrName, name) {
+		const className = typeof classOrName === "string" ? classOrName : classOrName.name;
+		this._ensureSubAgentRegistry();
+		return (this.sql`
+      SELECT COUNT(*) AS n FROM cf_agents_sub_agents
+      WHERE class = ${className} AND name = ${name}
+    `[0]?.n ?? 0) > 0;
+	}
+	listSubAgents(classOrName) {
+		const className = typeof classOrName === "string" ? classOrName : classOrName?.name;
+		this._ensureSubAgentRegistry();
+		return (className ? this.sql`
+          SELECT class, name, created_at FROM cf_agents_sub_agents
+          WHERE class = ${className}
+          ORDER BY created_at ASC
+        ` : this.sql`
+          SELECT class, name, created_at FROM cf_agents_sub_agents
+          ORDER BY created_at ASC
+        `).map((r) => ({
+			className: r.class,
+			name: r.name,
+			createdAt: r.created_at
+		}));
 	}
 	/**
 	* Destroy the Agent, removing all state and scheduled tasks
@@ -2093,6 +2360,7 @@ var Agent = class Agent extends Server {
 		this.sql`DROP TABLE IF EXISTS cf_agents_schedules`;
 		this.sql`DROP TABLE IF EXISTS cf_agents_queues`;
 		this.sql`DROP TABLE IF EXISTS cf_agents_workflows`;
+		this.sql`DROP TABLE IF EXISTS cf_agents_sub_agents`;
 		if (!this._isFacet) await this.ctx.storage.deleteAlarm();
 		await this.ctx.storage.deleteAll();
 		this._disposables.dispose();
@@ -3034,7 +3302,7 @@ var Agent = class Agent extends Server {
 	broadcastMcpServers() {
 		this._broadcastProtocol(JSON.stringify({
 			mcp: this.getMcpServers(),
-			type: MessageType.CF_AGENT_MCP_SERVERS
+			type: "cf_agent_mcp_servers"
 		}));
 	}
 	/**
@@ -3225,7 +3493,7 @@ var StreamingResponse = class {
 			id: this._id,
 			result: chunk,
 			success: true,
-			type: MessageType.RPC
+			type: "rpc"
 		};
 		this._connection.send(JSON.stringify(response));
 		return true;
@@ -3243,7 +3511,7 @@ var StreamingResponse = class {
 			id: this._id,
 			result: finalChunk,
 			success: true,
-			type: MessageType.RPC
+			type: "rpc"
 		};
 		this._connection.send(JSON.stringify(response));
 		return true;
@@ -3260,13 +3528,13 @@ var StreamingResponse = class {
 			error: message,
 			id: this._id,
 			success: false,
-			type: MessageType.RPC
+			type: "rpc"
 		};
 		this._connection.send(JSON.stringify(response));
 		return true;
 	}
 };
 //#endregion
-export { Agent, DEFAULT_AGENT_STATIC_OPTIONS, DurableObjectOAuthClientProvider, MessageType, SqlError, StreamingResponse, __DO_NOT_USE_WILL_BREAK__agentContext, callable, createHeaderBasedEmailResolver, getAgentByName, getCurrentAgent, routeAgentEmail, routeAgentRequest, unstable_callable };
+export { Agent, DEFAULT_AGENT_STATIC_OPTIONS, DurableObjectOAuthClientProvider, MessageType, SUB_PREFIX, SqlError, StreamingResponse, __DO_NOT_USE_WILL_BREAK__agentContext, callable, createHeaderBasedEmailResolver, getAgentByName, getCurrentAgent, getSubAgentByName, parseSubAgentPath, routeAgentEmail, routeAgentRequest, routeSubAgentRequest, unstable_callable };
 
 //# sourceMappingURL=index.js.map