agents 0.11.4 → 0.11.6

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-DAZNVUKb.js";
+import { i as _classPrivateFieldInitSpec, n as _classPrivateFieldSet2, t as _classPrivateFieldGet2 } from "./classPrivateFieldGet2-Bqby-AHD.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-B_xdiZbn.js";
+import { o as RPC_DO_PREFIX, r as MCPConnectionState, s as DisposableStore, t as MCPClientManager } from "./client-D1kFXo80.js";
 import { DurableObjectOAuthClientProvider } from "./mcp/do-oauth-client-provider.js";
 import { genericObservability } from "./observability/index.js";
 import { AsyncLocalStorage } from "node:async_hooks";
@@ -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.
 */
@@ -148,10 +157,22 @@ const _sendIdentityWarnedClasses = /* @__PURE__ */ new WeakSet();
 * Child classes can override specific options without spreading.
 */
 const DEFAULT_AGENT_STATIC_OPTIONS = {
+	/** Whether the Agent should hibernate when inactive */
 	hibernate: true,
+	/** Whether to send identity (name, agent) to clients on connect */
 	sendIdentityOnConnect: true,
+	/**
+	* Timeout in seconds before a running interval schedule is considered "hung"
+	* and force-reset. Increase this if you have callbacks that legitimately
+	* take longer than 30 seconds.
+	*/
 	hungScheduleTimeoutSeconds: 30,
+	/**
+	* Interval in milliseconds for keepAlive() alarm heartbeats.
+	* Lower values mean faster recovery after eviction but more frequent alarms.
+	*/
 	keepAliveIntervalMs: DEFAULT_KEEP_ALIVE_INTERVAL_MS,
+	/** Default retry options for schedule(), queue(), and this.retry() */
 	retry: {
 		maxAttempts: 3,
 		baseDelayMs: 100,
@@ -459,6 +480,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 +490,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);
@@ -621,7 +644,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.`);
@@ -671,6 +694,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 +743,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;
@@ -1690,6 +1702,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 +1719,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;
@@ -1888,7 +1906,10 @@ var Agent = class Agent extends Server {
 	* Executes any scheduled tasks that are due.
 	*
 	* Calls super.alarm() first to ensure PartyServer's #ensureInitialized()
-	* runs, which hydrates this.name from storage and calls onStart() if needed.
+	* runs, which resolves this.name from ctx.id.name (including for
+	* facets, which are spawned with an explicit id so they have their
+	* own ctx.id.name; pre-2026-03-15 alarms fall back to the legacy
+	* __ps_name storage record) and calls onStart() if needed.
 	*
 	* @remarks
 	* To schedule a task, please use the `this.schedule` method instead.
@@ -2001,6 +2022,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 +2133,111 @@ 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 set `_isFacet` eagerly (before `__unsafe_ensureInitialized`
+	* runs `onStart()`) 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.
+	*
+	* The facet's name (and `this.name` getter) is handled entirely by
+	* partyserver via `ctx.id.name`, which is populated because the
+	* parent passed an explicit `id: parentNs.idFromName(name)` to
+	* `ctx.facets.get()` — see {@link _cf_resolveSubAgent}. No
+	* `setName()` call or `__ps_name` storage write is needed; the
+	* facet's name survives cold wake automatically because the
+	* factory re-runs and `idFromName` is deterministic.
 	*
 	* @internal Called by {@link subAgent}.
 	*/
-	async _cf_initAsFacet(name) {
+	async _cf_initAsFacet(name, parentPath = []) {
+		if (this.name !== name) throw new Error(`Facet bootstrap mismatch: expected this.name === "${name}" but got "${this.name}". This usually means the parent passed the wrong (or no) id to ctx.facets.get(). See _cf_resolveSubAgent.`);
 		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("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 +2258,39 @@ 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 parentClassName = this.constructor.name;
+		const parentNs = ctx.exports[parentClassName];
+		if (!parentNs?.idFromName) {
+			const minificationHint = /^_*[a-z][a-z0-9]{0,2}$/.test(parentClassName) ? ` The class name "${parentClassName}" looks minified — make sure your bundler preserves class names (e.g. esbuild's \`keepNames: true\`).` : "";
+			throw new Error(`Sub-agent bootstrap requires the parent class "${parentClassName}" to be bound as a Durable Object namespace, but ctx.exports["${parentClassName}"] is missing or doesn't expose idFromName.${minificationHint} Make sure the parent agent class is registered in your wrangler.jsonc durable_objects.bindings under its class name.`);
+		}
+		const facetId = parentNs.idFromName(name);
+		const stub = ctx.facets.get(facetKey, () => ({
+			class: Cls,
+			id: facetId
+		}));
+		const childParentPath = this.selfPath;
+		await stub._cf_initAsFacet(name, childParentPath);
+		this._recordSubAgent(className, name);
 		return stub;
 	}
 	/**
@@ -2082,7 +2324,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 +2391,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();
@@ -3267,6 +3566,6 @@ var StreamingResponse = class {
 	}
 };
 //#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