agents 0.0.0-7ff0509 → 0.0.0-804e02e

package/dist/client.d.ts

@@ -1,8 +1,9 @@
 import {
   PartySocketOptions,
   PartyFetchOptions,
-  PartySocket,
+  PartySocket
 } from "partysocket";
+import { SerializableReturnValue, SerializableValue } from "./serializable.js";
 
 /**
  * Options for creating an AgentClient
@@ -38,17 +39,24 @@ type AgentClientFetchOptions = Omit<PartyFetchOptions, "party" | "room"> & {
   /** Name of the specific Agent instance */
   name?: string;
 };
+/**
+ * Convert a camelCase string to a kebab-case string
+ * @param str The string to convert
+ * @returns The kebab-case string
+ */
+declare function camelCaseToKebabCase(str: string): string;
 /**
  * WebSocket client for connecting to an Agent
  */
 declare class AgentClient<State = unknown> extends PartySocket {
-  #private;
   /**
    * @deprecated Use agentFetch instead
    */
   static fetch(_opts: PartyFetchOptions): Promise<Response>;
   agent: string;
   name: string;
+  private options;
+  private _pendingCalls;
   constructor(options: AgentClientOptions<State>);
   setState(state: State): void;
   /**
@@ -58,6 +66,11 @@ declare class AgentClient<State = unknown> extends PartySocket {
    * @param streamOptions Options for handling streaming responses
    * @returns Promise that resolves with the method's return value
    */
+  call<T extends SerializableReturnValue>(
+    method: string,
+    args?: SerializableValue[],
+    streamOptions?: StreamOptions
+  ): Promise<T>;
   call<T = unknown>(
     method: string,
     args?: unknown[],
@@ -81,4 +94,5 @@ export {
   type AgentClientOptions,
   type StreamOptions,
   agentFetch,
+  camelCaseToKebabCase
 };

package/dist/client.js

@@ -1,138 +1,13 @@
 import {
-  __privateAdd,
-  __privateGet,
-  __privateSet
-} from "./chunk-HMLY7DHA.js";
-
-// src/client.ts
-import {
-  PartySocket
-} from "partysocket";
-var _options, _pendingCalls;
-var AgentClient = class extends PartySocket {
-  constructor(options) {
-    super({
-      prefix: "agents",
-      party: options.agent,
-      room: options.name || "default",
-      ...options
-    });
-    __privateAdd(this, _options);
-    __privateAdd(this, _pendingCalls, /* @__PURE__ */ new Map());
-    this.agent = options.agent;
-    this.name = options.name || "default";
-    __privateSet(this, _options, options);
-    if (this.agent !== this.agent.toLowerCase()) {
-      console.warn(
-        `Agent name: ${this.agent} should probably be in lowercase. Received: ${this.agent}`
-      );
-    }
-    if (this.name !== this.name.toLowerCase()) {
-      console.warn(
-        `Agent instance name: ${this.name} should probably be in lowercase. Received: ${this.name}`
-      );
-    }
-    this.addEventListener("message", (event) => {
-      if (typeof event.data === "string") {
-        let parsedMessage;
-        try {
-          parsedMessage = JSON.parse(event.data);
-        } catch (error) {
-          return;
-        }
-        if (parsedMessage.type === "cf_agent_state") {
-          __privateGet(this, _options).onStateUpdate?.(parsedMessage.state, "server");
-          return;
-        }
-        if (parsedMessage.type === "rpc") {
-          const response = parsedMessage;
-          const pending = __privateGet(this, _pendingCalls).get(response.id);
-          if (!pending) return;
-          if (!response.success) {
-            pending.reject(new Error(response.error));
-            __privateGet(this, _pendingCalls).delete(response.id);
-            pending.stream?.onError?.(response.error);
-            return;
-          }
-          if ("done" in response) {
-            if (response.done) {
-              pending.resolve(response.result);
-              __privateGet(this, _pendingCalls).delete(response.id);
-              pending.stream?.onDone?.(response.result);
-            } else {
-              pending.stream?.onChunk?.(response.result);
-            }
-          } else {
-            pending.resolve(response.result);
-            __privateGet(this, _pendingCalls).delete(response.id);
-          }
-        }
-      }
-    });
-  }
-  /**
-   * @deprecated Use agentFetch instead
-   */
-  static fetch(_opts) {
-    throw new Error(
-      "AgentClient.fetch is not implemented, use agentFetch instead"
-    );
-  }
-  setState(state) {
-    this.send(JSON.stringify({ type: "cf_agent_state", state }));
-    __privateGet(this, _options).onStateUpdate?.(state, "client");
-  }
-  /**
-   * Call a method on the Agent
-   * @param method Name of the method to call
-   * @param args Arguments to pass to the method
-   * @param streamOptions Options for handling streaming responses
-   * @returns Promise that resolves with the method's return value
-   */
-  async call(method, args = [], streamOptions) {
-    return new Promise((resolve, reject) => {
-      const id = Math.random().toString(36).slice(2);
-      __privateGet(this, _pendingCalls).set(id, {
-        resolve: (value) => resolve(value),
-        reject,
-        stream: streamOptions,
-        type: null
-      });
-      const request = {
-        type: "rpc",
-        id,
-        method,
-        args
-      };
-      this.send(JSON.stringify(request));
-    });
-  }
-};
-_options = new WeakMap();
-_pendingCalls = new WeakMap();
-function agentFetch(opts, init) {
-  if (opts.agent !== opts.agent.toLowerCase()) {
-    console.warn(
-      `Agent name: ${opts.agent} should probably be in lowercase. Received: ${opts.agent}`
-    );
-  }
-  if (opts.name && opts.name !== opts.name.toLowerCase()) {
-    console.warn(
-      `Agent instance name: ${opts.name} should probably be in lowercase. Received: ${opts.name}`
-    );
-  }
-  return PartySocket.fetch(
-    {
-      prefix: "agents",
-      party: opts.agent,
-      room: opts.name || "default",
-      ...opts
-    },
-    init
-  );
-}
+  AgentClient,
+  agentFetch,
+  camelCaseToKebabCase
+} from "./chunk-QEVM4BVL.js";
+import "./chunk-BER7KXUJ.js";
+import "./chunk-PR4QN5HX.js";
 export {
   AgentClient,
-  agentFetch
+  agentFetch,
+  camelCaseToKebabCase
 };
 //# sourceMappingURL=client.js.map

package/dist/client.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/client.ts"],"sourcesContent":["import {\n  PartySocket,\n  type PartySocketOptions,\n  type PartyFetchOptions,\n} from \"partysocket\";\nimport type { RPCRequest, RPCResponse } from \"./\";\n\n/**\n * Options for creating an AgentClient\n */\nexport type AgentClientOptions<State = unknown> = Omit<\n  PartySocketOptions,\n  \"party\" | \"room\"\n> & {\n  /** Name of the agent to connect to */\n  agent: string;\n  /** Name of the specific Agent instance */\n  name?: string;\n  /** Called when the Agent's state is updated */\n  onStateUpdate?: (state: State, source: \"server\" | \"client\") => void;\n};\n\n/**\n * Options for streaming RPC calls\n */\nexport type StreamOptions = {\n  /** Called when a chunk of data is received */\n  onChunk?: (chunk: unknown) => void;\n  /** Called when the stream ends */\n  onDone?: (finalChunk: unknown) => void;\n  /** Called when an error occurs */\n  onError?: (error: string) => void;\n};\n\n/**\n * Options for the agentFetch function\n */\nexport type AgentClientFetchOptions = Omit<\n  PartyFetchOptions,\n  \"party\" | \"room\"\n> & {\n  /** Name of the agent to connect to */\n  agent: string;\n  /** Name of the specific Agent instance */\n  name?: string;\n};\n\n/**\n * WebSocket client for connecting to an Agent\n */\nexport class AgentClient<State = unknown> extends PartySocket {\n  /**\n   * @deprecated Use agentFetch instead\n   */\n  static fetch(_opts: PartyFetchOptions): Promise<Response> {\n    throw new Error(\n      \"AgentClient.fetch is not implemented, use agentFetch instead\"\n    );\n  }\n  agent: string;\n  name: string;\n  #options: AgentClientOptions<State>;\n  #pendingCalls = new Map<\n    string,\n    {\n      resolve: (value: unknown) => void;\n      reject: (error: Error) => void;\n      stream?: StreamOptions;\n      type?: unknown;\n    }\n  >();\n\n  constructor(options: AgentClientOptions<State>) {\n    super({\n      prefix: \"agents\",\n      party: options.agent,\n      room: options.name || \"default\",\n      ...options,\n    });\n    this.agent = options.agent;\n    this.name = options.name || \"default\";\n    this.#options = options;\n\n    // warn if agent or name isn't in lowercase\n    if (this.agent !== this.agent.toLowerCase()) {\n      console.warn(\n        `Agent name: ${this.agent} should probably be in lowercase. Received: ${this.agent}`\n      );\n    }\n    if (this.name !== this.name.toLowerCase()) {\n      console.warn(\n        `Agent instance name: ${this.name} should probably be in lowercase. Received: ${this.name}`\n      );\n    }\n\n    this.addEventListener(\"message\", (event) => {\n      if (typeof event.data === \"string\") {\n        let parsedMessage: Record<string, unknown>;\n        try {\n          parsedMessage = JSON.parse(event.data);\n        } catch (error) {\n          // silently ignore invalid messages for now\n          // TODO: log errors with log levels\n          return;\n        }\n        if (parsedMessage.type === \"cf_agent_state\") {\n          this.#options.onStateUpdate?.(parsedMessage.state as State, \"server\");\n          return;\n        }\n        if (parsedMessage.type === \"rpc\") {\n          const response = parsedMessage as RPCResponse;\n          const pending = this.#pendingCalls.get(response.id);\n          if (!pending) return;\n\n          if (!response.success) {\n            pending.reject(new Error(response.error));\n            this.#pendingCalls.delete(response.id);\n            pending.stream?.onError?.(response.error);\n            return;\n          }\n\n          // Handle streaming responses\n          if (\"done\" in response) {\n            if (response.done) {\n              pending.resolve(response.result);\n              this.#pendingCalls.delete(response.id);\n              pending.stream?.onDone?.(response.result);\n            } else {\n              pending.stream?.onChunk?.(response.result);\n            }\n          } else {\n            // Non-streaming response\n            pending.resolve(response.result);\n            this.#pendingCalls.delete(response.id);\n          }\n        }\n      }\n    });\n  }\n\n  setState(state: State) {\n    this.send(JSON.stringify({ type: \"cf_agent_state\", state }));\n    this.#options.onStateUpdate?.(state, \"client\");\n  }\n\n  /**\n   * Call a method on the Agent\n   * @param method Name of the method to call\n   * @param args Arguments to pass to the method\n   * @param streamOptions Options for handling streaming responses\n   * @returns Promise that resolves with the method's return value\n   */\n  async call<T = unknown>(\n    method: string,\n    args: unknown[] = [],\n    streamOptions?: StreamOptions\n  ): Promise<T> {\n    return new Promise<T>((resolve, reject) => {\n      const id = Math.random().toString(36).slice(2);\n      this.#pendingCalls.set(id, {\n        resolve: (value: unknown) => resolve(value as T),\n        reject,\n        stream: streamOptions,\n        type: null as T,\n      });\n\n      const request: RPCRequest = {\n        type: \"rpc\",\n        id,\n        method,\n        args,\n      };\n\n      this.send(JSON.stringify(request));\n    });\n  }\n}\n\n/**\n * Make an HTTP request to an Agent\n * @param opts Connection options\n * @param init Request initialization options\n * @returns Promise resolving to a Response\n */\nexport function agentFetch(opts: AgentClientFetchOptions, init?: RequestInit) {\n  // warn if agent or name isn't in lowercase\n  if (opts.agent !== opts.agent.toLowerCase()) {\n    console.warn(\n      `Agent name: ${opts.agent} should probably be in lowercase. Received: ${opts.agent}`\n    );\n  }\n  if (opts.name && opts.name !== opts.name.toLowerCase()) {\n    console.warn(\n      `Agent instance name: ${opts.name} should probably be in lowercase. Received: ${opts.name}`\n    );\n  }\n\n  return PartySocket.fetch(\n    {\n      prefix: \"agents\",\n      party: opts.agent,\n      room: opts.name || \"default\",\n      ...opts,\n    },\n    init\n  );\n}\n"],"mappings":"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","names":[]}
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/index.d.ts

@@ -1,7 +1,27 @@
+import { env } from "cloudflare:workers";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import {
+  ServerCapabilities,
+  Tool,
+  Prompt,
+  Resource
+} from "@modelcontextprotocol/sdk/types.js";
 import { Server, Connection, PartyServerOptions } from "partyserver";
 export { Connection, ConnectionContext, WSMessage } from "partyserver";
-import { AsyncLocalStorage } from "node:async_hooks";
-import { WorkflowEntrypoint as WorkflowEntrypoint$1 } from "cloudflare:workers";
+import {
+  c as MCPClientManager,
+  T as TransportType
+} from "./client-BohGLma8.js";
+import { Observability } from "./observability/index.js";
+import { MessageType } from "./ai-types.js";
+import "zod";
+import "@modelcontextprotocol/sdk/shared/protocol.js";
+import "ai";
+import "@modelcontextprotocol/sdk/client/sse.js";
+import "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import "./mcp/do-oauth-client-provider.js";
+import "@modelcontextprotocol/sdk/client/auth.js";
+import "@modelcontextprotocol/sdk/shared/auth.js";
 
 /**
  * RPC request message from client
@@ -16,14 +36,14 @@ type RPCRequest = {
  * State update message from client
  */
 type StateUpdateMessage = {
-  type: "cf_agent_state";
+  type: MessageType.CF_AGENT_STATE;
   state: unknown;
 };
 /**
  * RPC response message to client
  */
 type RPCResponse = {
-  type: "rpc";
+  type: MessageType.RPC;
   id: string;
 } & (
   | {
@@ -54,16 +74,24 @@ type CallableMetadata = {
  * Decorator that marks a method as callable by clients
  * @param metadata Optional metadata about the callable method
  */
-declare function unstable_callable(
+declare function callable(
   metadata?: CallableMetadata
 ): <This, Args extends unknown[], Return>(
   target: (this: This, ...args: Args) => Return,
   context: ClassMethodDecoratorContext
 ) => (this: This, ...args: Args) => Return;
 /**
- * A class for creating workflow entry points that can be used with Cloudflare Workers
+ * Decorator that marks a method as callable by clients
+ * @deprecated this has been renamed to callable, and unstable_callable will be removed in the next major version
+ * @param metadata Optional metadata about the callable method
  */
-declare class WorkflowEntrypoint extends WorkflowEntrypoint$1 {}
+declare const unstable_callable: (metadata?: CallableMetadata) => void;
+type QueueItem<T = string> = {
+  id: string;
+  payload: T;
+  callback: keyof Agent<unknown>;
+  created_at: number;
+};
 /**
  * Represents a scheduled task within an Agent
  * @template T Type of the payload data
@@ -99,18 +127,51 @@ type Schedule<T = string> = {
       cron: string;
     }
 );
-declare const unstable_context: AsyncLocalStorage<{
-  agent: Agent<unknown>;
+
+/**
+ * MCP Server state update message from server -> Client
+ */
+type MCPServerMessage = {
+  type: MessageType.CF_AGENT_MCP_SERVERS;
+  mcp: MCPServersState;
+};
+type MCPServersState = {
+  servers: {
+    [id: string]: MCPServer;
+  };
+  tools: Tool[];
+  prompts: Prompt[];
+  resources: Resource[];
+};
+type MCPServer = {
+  name: string;
+  server_url: string;
+  auth_url: string | null;
+  state: "authenticating" | "connecting" | "ready" | "discovering" | "failed";
+  instructions: string | null;
+  capabilities: ServerCapabilities | null;
+};
+declare function getCurrentAgent<
+  T extends Agent<unknown, unknown> = Agent<unknown, unknown>
+>(): {
+  agent: T | undefined;
   connection: Connection | undefined;
   request: Request | undefined;
-}>;
+  email: AgentEmail | undefined;
+};
 /**
  * Base class for creating Agent implementations
  * @template Env Environment type containing bindings
  * @template State State type to store within the Agent
  */
-declare class Agent<Env, State = unknown> extends Server<Env> {
-  #private;
+declare class Agent<
+  Env = typeof env,
+  State = unknown,
+  Props extends Record<string, unknown> = Record<string, unknown>
+> extends Server<Env, Props> {
+  private _state;
+  private _ParentClass;
+  readonly mcp: MCPClientManager;
   /**
    * Initial state for the Agent
    * Override to provide default state values
@@ -127,6 +188,10 @@ declare class Agent<Env, State = unknown> extends Server<Env> {
     /** Whether the Agent should hibernate when inactive */
     hibernate: boolean;
   };
+  /**
+   * The observability implementation to use for the Agent
+   */
+  observability?: Observability;
   /**
    * Execute SQL queries against the Agent's database
    * @template T Type of the returned rows
@@ -139,6 +204,7 @@ declare class Agent<Env, State = unknown> extends Server<Env> {
     ...values: (string | number | boolean | null)[]
   ): T[];
   constructor(ctx: AgentContext, env: Env);
+  private _setStateInternal;
   /**
    * Update the Agent's state
    * @param state New state to set
@@ -151,16 +217,75 @@ declare class Agent<Env, State = unknown> extends Server<Env> {
    */
   onStateUpdate(state: State | undefined, source: Connection | "server"): void;
   /**
-   * Called when the Agent receives an email
+   * Called when the Agent receives an email via routeAgentEmail()
+   * Override this method to handle incoming emails
    * @param email Email message to process
    */
-  onEmail(email: ForwardableEmailMessage): Promise<void>;
+  _onEmail(email: AgentEmail): Promise<void>;
+  /**
+   * Reply to an email
+   * @param email The email to reply to
+   * @param options Options for the reply
+   * @returns void
+   */
+  replyToEmail(
+    email: AgentEmail,
+    options: {
+      fromName: string;
+      subject?: string | undefined;
+      body: string;
+      contentType?: string;
+      headers?: Record<string, string>;
+    }
+  ): Promise<void>;
+  private _tryCatch;
+  /**
+   * Automatically wrap custom methods with agent context
+   * This ensures getCurrentAgent() works in all custom methods without decorators
+   */
+  private _autoWrapCustomMethods;
   onError(connection: Connection, error: unknown): void | Promise<void>;
   onError(error: unknown): void | Promise<void>;
   /**
    * Render content (not implemented in base class)
    */
   render(): void;
+  /**
+   * Queue a task to be executed in the future
+   * @param payload Payload to pass to the callback
+   * @param callback Name of the method to call
+   * @returns The ID of the queued task
+   */
+  queue<T = unknown>(callback: keyof this, payload: T): Promise<string>;
+  private _flushingQueue;
+  private _flushQueue;
+  /**
+   * Dequeue a task by ID
+   * @param id ID of the task to dequeue
+   */
+  dequeue(id: string): Promise<void>;
+  /**
+   * Dequeue all tasks
+   */
+  dequeueAll(): Promise<void>;
+  /**
+   * Dequeue all tasks by callback
+   * @param callback Name of the callback to dequeue
+   */
+  dequeueAllByCallback(callback: string): Promise<void>;
+  /**
+   * Get a queued task by ID
+   * @param id ID of the task to get
+   * @returns The task or undefined if not found
+   */
+  getQueue(id: string): Promise<QueueItem<string> | undefined>;
+  /**
+   * Get all queues by key and value
+   * @param key Key to filter by
+   * @param value Value to filter by
+   * @returns Array of matching QueueItem objects
+   */
+  getQueues(key: string, value: string): Promise<QueueItem<string>[]>;
   /**
    * Schedule a task to be executed in the future
    * @template T Type of the payload data
@@ -188,7 +313,6 @@ declare class Agent<Env, State = unknown> extends Server<Env> {
    * @returns Array of matching Schedule objects
    */
   getSchedules<T = string>(criteria?: {
-    description?: string;
     id?: string;
     type?: "scheduled" | "delayed" | "cron";
     timeRange?: {
@@ -202,15 +326,79 @@ declare class Agent<Env, State = unknown> extends Server<Env> {
    * @returns true if the task was cancelled, false otherwise
    */
   cancelSchedule(id: string): Promise<boolean>;
+  private _scheduleNextAlarm;
   /**
-   * Method called when an alarm fires
-   * Executes any scheduled tasks that are due
+   * Method called when an alarm fires.
+   * Executes any scheduled tasks that are due.
+   *
+   * @remarks
+   * To schedule a task, please use the `this.schedule` method instead.
+   * See {@link https://developers.cloudflare.com/agents/api-reference/schedule-tasks/}
    */
-  alarm(): Promise<void>;
+  readonly alarm: () => Promise<void>;
   /**
    * Destroy the Agent, removing all state and scheduled tasks
    */
   destroy(): Promise<void>;
+  /**
+   * Get all methods marked as callable on this Agent
+   * @returns A map of method names to their metadata
+   */
+  private _isCallable;
+  /**
+   * Connect to a new MCP Server
+   *
+   * @param serverName Name of the MCP server
+   * @param url MCP Server SSE URL
+   * @param callbackHost Base host for the agent, used for the redirect URI. If not provided, will be derived from the current request.
+   * @param agentsPrefix agents routing prefix if not using `agents`
+   * @param options MCP client and transport (header) options
+   * @returns authUrl
+   */
+  addMcpServer(
+    serverName: string,
+    url: string,
+    callbackHost?: string,
+    agentsPrefix?: string,
+    options?: {
+      client?: ConstructorParameters<typeof Client>[1];
+      transport?: {
+        headers: HeadersInit;
+      };
+    }
+  ): Promise<{
+    id: string;
+    authUrl: string | undefined;
+  }>;
+  _connectToMcpServerInternal(
+    _serverName: string,
+    url: string,
+    callbackUrl: string,
+    options?: {
+      client?: ConstructorParameters<typeof Client>[1];
+      /**
+       * We don't expose the normal set of transport options because:
+       * 1) we can't serialize things like the auth provider or a fetch function into the DB for reconnection purposes
+       * 2) We probably want these options to be agnostic to the transport type (SSE vs Streamable)
+       *
+       * This has the limitation that you can't override fetch, but I think headers should handle nearly all cases needed (i.e. non-standard bearer auth).
+       */
+      transport?: {
+        headers?: HeadersInit;
+        type?: TransportType;
+      };
+    },
+    reconnect?: {
+      id: string;
+      oauthClientId?: string;
+    }
+  ): Promise<{
+    id: string;
+    authUrl: string | undefined;
+    clientId: string | undefined;
+  }>;
+  removeMcpServer(id: string): Promise<void>;
+  getMcpServers(): MCPServersState;
 }
 /**
  * Namespace for creating Agent instances
@@ -243,17 +431,72 @@ declare function routeAgentRequest<Env>(
   env: Env,
   options?: AgentOptions<Env>
 ): Promise<Response | null>;
+type EmailResolver<Env> = (
+  email: ForwardableEmailMessage,
+  env: Env
+) => Promise<{
+  agentName: string;
+  agentId: string;
+} | null>;
+/**
+ * Create a resolver that uses the message-id header to determine the agent to route the email to
+ * @returns A function that resolves the agent to route the email to
+ */
+declare function createHeaderBasedEmailResolver<Env>(): EmailResolver<Env>;
+/**
+ * Create a resolver that uses the email address to determine the agent to route the email to
+ * @param defaultAgentName The default agent name to use if the email address does not contain a sub-address
+ * @returns A function that resolves the agent to route the email to
+ */
+declare function createAddressBasedEmailResolver<Env>(
+  defaultAgentName: string
+): EmailResolver<Env>;
+/**
+ * Create a resolver that uses the agentName and agentId to determine the agent to route the email to
+ * @param agentName The name of the agent to route the email to
+ * @param agentId The id of the agent to route the email to
+ * @returns A function that resolves the agent to route the email to
+ */
+declare function createCatchAllEmailResolver<Env>(
+  agentName: string,
+  agentId: string
+): EmailResolver<Env>;
+type EmailRoutingOptions<Env> = AgentOptions<Env> & {
+  resolver: EmailResolver<Env>;
+};
 /**
  * Route an email to the appropriate Agent
- * @param email Email message to route
- * @param env Environment containing Agent bindings
- * @param options Routing options
+ * @param email The email to route
+ * @param env The environment containing the Agent bindings
+ * @param options The options for routing the email
+ * @returns A promise that resolves when the email has been routed
  */
 declare function routeAgentEmail<Env>(
   email: ForwardableEmailMessage,
   env: Env,
-  options?: AgentOptions<Env>
+  options: EmailRoutingOptions<Env>
 ): Promise<void>;
+type AgentEmail = {
+  from: string;
+  to: string;
+  getRaw: () => Promise<Uint8Array>;
+  headers: Headers;
+  rawSize: number;
+  setReject: (reason: string) => void;
+  forward: (rcptTo: string, headers?: Headers) => Promise<void>;
+  reply: (options: { from: string; to: string; raw: string }) => Promise<void>;
+};
+type EmailSendOptions = {
+  to: string;
+  subject: string;
+  body: string;
+  contentType?: string;
+  headers?: Record<string, string>;
+  includeRoutingHeaders?: boolean;
+  agentName?: string;
+  agentId?: string;
+  domain?: string;
+};
 /**
  * Get or create an Agent by name
  * @template Env Environment type containing bindings
@@ -263,19 +506,26 @@ declare function routeAgentEmail<Env>(
  * @param options Options for Agent creation
  * @returns Promise resolving to an Agent instance stub
  */
-declare function getAgentByName<Env, T extends Agent<Env>>(
+declare function getAgentByName<
+  Env,
+  T extends Agent<Env>,
+  Props extends Record<string, unknown> = Record<string, unknown>
+>(
   namespace: AgentNamespace<T>,
   name: string,
   options?: {
     jurisdiction?: DurableObjectJurisdiction;
     locationHint?: DurableObjectLocationHint;
+    props?: Props;
   }
 ): Promise<DurableObjectStub<T>>;
 /**
  * A wrapper for streaming responses in callable methods
  */
 declare class StreamingResponse {
-  #private;
+  private _connection;
+  private _id;
+  private _closed;
   constructor(connection: Connection, id: string);
   /**
    * Send a chunk of data to the client
@@ -292,18 +542,30 @@ declare class StreamingResponse {
 export {
   Agent,
   type AgentContext,
+  type AgentEmail,
   type AgentNamespace,
   type AgentOptions,
   type CallableMetadata,
+  type EmailResolver,
+  type EmailRoutingOptions,
+  type EmailSendOptions,
+  type MCPServer,
+  type MCPServerMessage,
+  type MCPServersState,
+  type QueueItem,
   type RPCRequest,
   type RPCResponse,
   type Schedule,
   type StateUpdateMessage,
   StreamingResponse,
-  WorkflowEntrypoint,
+  TransportType,
+  callable,
+  createAddressBasedEmailResolver,
+  createCatchAllEmailResolver,
+  createHeaderBasedEmailResolver,
   getAgentByName,
+  getCurrentAgent,
   routeAgentEmail,
   routeAgentRequest,
-  unstable_callable,
-  unstable_context,
+  unstable_callable
 };