agents 0.3.6 → 0.3.7

package/dist/index.d.ts

@@ -1,11 +1,23 @@
-import { n as AgentEmail } from "./internal_context-neg89p5n.js";
+import { n as AgentEmail } from "./internal_context-CEu5ji80.js";
+import {
+  l as createHeaderBasedEmailResolver,
+  r as EmailResolver
+} from "./email-8ljcpvwV.js";
 import {
   h as TransportType,
   t as MCPClientManager,
   u as MCPConnectionState
-} from "./client-Cxno-5sH.js";
-import { t as Observability } from "./index-B7Ny-XfU.js";
-import { t as MessageType } from "./types-C5vR2Gzv.js";
+} from "./client-DGpERepg.js";
+import {
+  _ as WorkflowPage,
+  g as WorkflowInfo,
+  h as WorkflowEventPayload,
+  l as WorkflowCallback,
+  s as RunWorkflowOptions,
+  y as WorkflowQueryCriteria
+} from "./workflow-types-Z_Oem1FJ.js";
+import { t as Observability } from "./index-N6791tVt.js";
+import { t as MessageType } from "./types-DSSHBW6w.js";
 import {
   Connection,
   Connection as Connection$1,
@@ -23,7 +35,6 @@ import {
 } from "@modelcontextprotocol/sdk/types.js";
 
 //#region src/index.d.ts
-
 /**
  * RPC request message from client
  */
@@ -66,9 +77,7 @@ type RPCResponse = {
  * Metadata for a callable method
  */
 type CallableMetadata = {
-  /** Optional description of what the method does */
-  description?: string;
-  /** Whether the method supports streaming responses */
+  /** Optional description of what the method does */ description?: string; /** Whether the method supports streaming responses */
   streaming?: boolean;
 };
 /**
@@ -94,7 +103,12 @@ declare function callable(
  * @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 const unstable_callable: (metadata?: CallableMetadata) => void;
+declare const unstable_callable: (
+  metadata?: CallableMetadata
+) => <This, Args extends unknown[], Return>(
+  target: (this: This, ...args: Args) => Return,
+  context: ClassMethodDecoratorContext
+) => (this: This, ...args: Args) => Return;
 type QueueItem<T = string> = {
   id: string;
   payload: T;
@@ -106,35 +120,29 @@ type QueueItem<T = string> = {
  * @template T Type of the payload data
  */
 type Schedule<T = string> = {
-  /** Unique identifier for the schedule */
-  id: string;
-  /** Name of the method to be called */
-  callback: string;
-  /** Data to be passed to the callback */
+  /** Unique identifier for the schedule */ id: string; /** Name of the method to be called */
+  callback: string; /** Data to be passed to the callback */
   payload: T;
 } & (
   | {
-      /** Type of schedule for one-time execution at a specific time */
-      type: "scheduled";
-      /** Timestamp when the task should execute */
+      /** Type of schedule for one-time execution at a specific time */ type: "scheduled"; /** Timestamp when the task should execute */
       time: number;
     }
   | {
-      /** Type of schedule for delayed execution */
-      type: "delayed";
-      /** Timestamp when the task should execute */
-      time: number;
-      /** Number of seconds to delay execution */
+      /** Type of schedule for delayed execution */ type: "delayed"; /** Timestamp when the task should execute */
+      time: number; /** Number of seconds to delay execution */
       delayInSeconds: number;
     }
   | {
-      /** Type of schedule for recurring execution based on cron expression */
-      type: "cron";
-      /** Timestamp for the next execution */
-      time: number;
-      /** Cron expression defining the schedule */
+      /** Type of schedule for recurring execution based on cron expression */ type: "cron"; /** Timestamp for the next execution */
+      time: number; /** Cron expression defining the schedule */
       cron: string;
     }
+  | {
+      /** Type of schedule for recurring execution at fixed intervals */ type: "interval"; /** Timestamp for the next execution */
+      time: number; /** Number of seconds between executions */
+      intervalSeconds: number;
+    }
 );
 /**
  * MCP Server state update message from server -> Client
@@ -165,6 +173,40 @@ type MCPServer = {
   instructions: string | null;
   capabilities: ServerCapabilities | null;
 };
+/**
+ * Options for adding an MCP server
+ */
+type AddMcpServerOptions = {
+  /** OAuth callback host (auto-derived from request if omitted) */ callbackHost?: string; /** Agents routing prefix (default: "agents") */
+  agentsPrefix?: string; /** MCP client options */
+  client?: ConstructorParameters<typeof Client>[1]; /** Transport options */
+  transport?: {
+    /** Custom headers for authentication (e.g., bearer tokens, CF Access) */ headers?: HeadersInit; /** Transport type: "sse", "streamable-http", or "auto" (default) */
+    type?: TransportType;
+  };
+};
+/**
+ * Default options for Agent configuration.
+ * Child classes can override specific options without spreading.
+ */
+declare const DEFAULT_AGENT_STATIC_OPTIONS: {
+  /** Whether the Agent should hibernate when inactive */ hibernate: boolean; /** Whether to send identity (name, agent) to clients on connect */
+  sendIdentityOnConnect: boolean;
+  /**
+   * 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: number;
+};
+type ResolvedAgentOptions = typeof DEFAULT_AGENT_STATIC_OPTIONS;
+/**
+ * Configuration options for the Agent.
+ * Override in subclasses via `static options`.
+ * All fields are optional - defaults are applied at runtime.
+ * Note: `hibernate` defaults to `true` if not specified.
+ */
+type AgentStaticOptions = Partial<ResolvedAgentOptions>;
 declare function getCurrentAgent<
   T extends Agent<Cloudflare.Env> = Agent<Cloudflare.Env>
 >(): {
@@ -173,6 +215,19 @@ declare function getCurrentAgent<
   request: Request | undefined;
   email: AgentEmail | undefined;
 };
+/**
+ * Extract string keys from Env where the value is a Workflow binding.
+ */
+type WorkflowBinding<E> = {
+  [K in keyof E & string]: E[K] extends Workflow ? K : never;
+}[keyof E & string];
+/**
+ * Type for workflow name parameter.
+ * When Env has typed Workflow bindings, provides autocomplete for those keys.
+ * Also accepts any string for dynamic use cases and compatibility.
+ * The `string & {}` trick preserves autocomplete while allowing any string.
+ */
+type WorkflowName<E> = WorkflowBinding<E> | (string & {});
 /**
  * Base class for creating Agent implementations
  * @template Env Environment type containing bindings
@@ -198,12 +253,18 @@ declare class Agent<
    */
   get state(): State;
   /**
-   * Agent configuration options
+   * Agent configuration options.
+   * Override in subclasses - only specify what you want to change.
+   * @example
+   * class SecureAgent extends Agent {
+   *   static options = { sendIdentityOnConnect: false };
+   * }
    */
-  static options: {
-    /** Whether the Agent should hibernate when inactive */
-    hibernate: boolean;
-  };
+  static options: AgentStaticOptions;
+  /**
+   * Resolved options (merges defaults with subclass overrides)
+   */
+  private get _resolvedOptions();
   /**
    * The observability implementation to use for the Agent
    */
@@ -220,12 +281,23 @@ declare class Agent<
     ...values: (string | number | boolean | null)[]
   ): T[];
   constructor(ctx: AgentContext, env: Env);
+  /**
+   * Check for workflows referencing unknown bindings and warn with migration suggestion.
+   */
+  private _checkOrphanedWorkflows;
   private _setStateInternal;
   /**
    * Update the Agent's state
    * @param state New state to set
    */
   setState(state: State): void;
+  /**
+   * Called before the Agent's state is persisted and broadcast.
+   * Override to validate or reject an update by throwing an error.
+   *
+   * IMPORTANT: This hook must be synchronous.
+   */
+  validateStateChange(nextState: State, source: Connection$1 | "server"): void;
   /**
    * Called when the Agent's state is updated
    * @param state Updated state
@@ -245,6 +317,9 @@ declare class Agent<
    * Reply to an email
    * @param email The email to reply to
    * @param options Options for the reply
+   * @param options.secret Secret for signing agent headers (enables secure reply routing).
+   *   Required if the email was routed via createSecureReplyEmailResolver.
+   *   Pass explicit `null` to opt-out of signing (not recommended for secure routing).
    * @returns void
    */
   replyToEmail(
@@ -255,6 +330,7 @@ declare class Agent<
       body: string;
       contentType?: string;
       headers?: Record<string, string>;
+      secret?: string | null;
     }
   ): Promise<void>;
   private _tryCatch;
@@ -318,6 +394,19 @@ declare class Agent<
     callback: keyof this,
     payload?: T
   ): Promise<Schedule<T>>;
+  /**
+   * Schedule a task to run repeatedly at a fixed interval
+   * @template T Type of the payload data
+   * @param intervalSeconds Number of seconds between executions
+   * @param callback Name of the method to call
+   * @param payload Data to pass to the callback
+   * @returns Schedule object representing the scheduled task
+   */
+  scheduleEvery<T = string>(
+    intervalSeconds: number,
+    callback: keyof this,
+    payload?: T
+  ): Promise<Schedule<T>>;
   /**
    * Get a scheduled task by ID
    * @template T Type of the payload data
@@ -333,7 +422,7 @@ declare class Agent<
    */
   getSchedules<T = string>(criteria?: {
     id?: string;
-    type?: "scheduled" | "delayed" | "cron";
+    type?: "scheduled" | "delayed" | "cron" | "interval";
     timeRange?: {
       start?: Date;
       end?: Date;
@@ -359,26 +448,418 @@ declare class Agent<
    * Destroy the Agent, removing all state and scheduled tasks
    */
   destroy(): Promise<void>;
+  /**
+   * Check if a method is callable
+   * @param method The method name to check
+   * @returns True if the method is marked as callable
+   */
+  private _isCallable;
   /**
    * Get all methods marked as callable on this Agent
    * @returns A map of method names to their metadata
    */
-  private _isCallable;
+  getCallableMethods(): Map<string, CallableMetadata>;
+  /**
+   * Start a workflow and track it in this Agent's database.
+   * Automatically injects agent identity into the workflow params.
+   *
+   * @template P - Type of params to pass to the workflow
+   * @param workflowName - Name of the workflow binding in env (e.g., 'MY_WORKFLOW')
+   * @param params - Params to pass to the workflow
+   * @param options - Optional workflow options
+   * @returns The workflow instance ID
+   *
+   * @example
+   * ```typescript
+   * const workflowId = await this.runWorkflow(
+   *   'MY_WORKFLOW',
+   *   { taskId: '123', data: 'process this' }
+   * );
+   * ```
+   */
+  runWorkflow<P = unknown>(
+    workflowName: WorkflowName<Env>,
+    params: P,
+    options?: RunWorkflowOptions
+  ): Promise<string>;
+  /**
+   * Send an event to a running workflow.
+   * The workflow can wait for this event using step.waitForEvent().
+   *
+   * @param workflowName - Name of the workflow binding in env (e.g., 'MY_WORKFLOW')
+   * @param workflowId - ID of the workflow instance
+   * @param event - Event to send
+   *
+   * @example
+   * ```typescript
+   * await this.sendWorkflowEvent(
+   *   'MY_WORKFLOW',
+   *   workflowId,
+   *   { type: 'approval', payload: { approved: true } }
+   * );
+   * ```
+   */
+  sendWorkflowEvent(
+    workflowName: WorkflowName<Env>,
+    workflowId: string,
+    event: WorkflowEventPayload
+  ): Promise<void>;
+  /**
+   * Approve a waiting workflow.
+   * Sends an approval event to the workflow that can be received by waitForApproval().
+   *
+   * @param workflowId - ID of the workflow to approve
+   * @param data - Optional approval data (reason, metadata)
+   *
+   * @example
+   * ```typescript
+   * await this.approveWorkflow(workflowId, {
+   *   reason: 'Approved by admin',
+   *   metadata: { approvedBy: userId }
+   * });
+   * ```
+   */
+  approveWorkflow(
+    workflowId: string,
+    data?: {
+      reason?: string;
+      metadata?: Record<string, unknown>;
+    }
+  ): Promise<void>;
+  /**
+   * Reject a waiting workflow.
+   * Sends a rejection event to the workflow that will cause waitForApproval() to throw.
+   *
+   * @param workflowId - ID of the workflow to reject
+   * @param data - Optional rejection data (reason)
+   *
+   * @example
+   * ```typescript
+   * await this.rejectWorkflow(workflowId, {
+   *   reason: 'Request denied by admin'
+   * });
+   * ```
+   */
+  rejectWorkflow(
+    workflowId: string,
+    data?: {
+      reason?: string;
+    }
+  ): Promise<void>;
+  /**
+   * Terminate a running workflow.
+   * This immediately stops the workflow and sets its status to "terminated".
+   *
+   * @param workflowId - ID of the workflow to terminate (must be tracked via runWorkflow)
+   * @throws Error if workflow not found in tracking table
+   * @throws Error if workflow binding not found in environment
+   * @throws Error if workflow is already completed/errored/terminated (from Cloudflare)
+   *
+   * @note `terminate()` is not yet supported in local development (wrangler dev).
+   * It will throw an error locally but works when deployed to Cloudflare.
+   *
+   * @example
+   * ```typescript
+   * await this.terminateWorkflow(workflowId);
+   * ```
+   */
+  terminateWorkflow(workflowId: string): Promise<void>;
+  /**
+   * Pause a running workflow.
+   * The workflow can be resumed later with resumeWorkflow().
+   *
+   * @param workflowId - ID of the workflow to pause (must be tracked via runWorkflow)
+   * @throws Error if workflow not found in tracking table
+   * @throws Error if workflow binding not found in environment
+   * @throws Error if workflow is not running (from Cloudflare)
+   *
+   * @note `pause()` is not yet supported in local development (wrangler dev).
+   * It will throw an error locally but works when deployed to Cloudflare.
+   *
+   * @example
+   * ```typescript
+   * await this.pauseWorkflow(workflowId);
+   * ```
+   */
+  pauseWorkflow(workflowId: string): Promise<void>;
+  /**
+   * Resume a paused workflow.
+   *
+   * @param workflowId - ID of the workflow to resume (must be tracked via runWorkflow)
+   * @throws Error if workflow not found in tracking table
+   * @throws Error if workflow binding not found in environment
+   * @throws Error if workflow is not paused (from Cloudflare)
+   *
+   * @note `resume()` is not yet supported in local development (wrangler dev).
+   * It will throw an error locally but works when deployed to Cloudflare.
+   *
+   * @example
+   * ```typescript
+   * await this.resumeWorkflow(workflowId);
+   * ```
+   */
+  resumeWorkflow(workflowId: string): Promise<void>;
+  /**
+   * Restart a workflow instance.
+   * This re-runs the workflow from the beginning with the same ID.
+   *
+   * @param workflowId - ID of the workflow to restart (must be tracked via runWorkflow)
+   * @param options - Optional settings
+   * @param options.resetTracking - If true (default), resets created_at and clears error fields.
+   *                                If false, preserves original timestamps.
+   * @throws Error if workflow not found in tracking table
+   * @throws Error if workflow binding not found in environment
+   *
+   * @note `restart()` is not yet supported in local development (wrangler dev).
+   * It will throw an error locally but works when deployed to Cloudflare.
+   *
+   * @example
+   * ```typescript
+   * // Reset tracking (default)
+   * await this.restartWorkflow(workflowId);
+   *
+   * // Preserve original timestamps
+   * await this.restartWorkflow(workflowId, { resetTracking: false });
+   * ```
+   */
+  restartWorkflow(
+    workflowId: string,
+    options?: {
+      resetTracking?: boolean;
+    }
+  ): Promise<void>;
+  /**
+   * Find a workflow binding by its name.
+   */
+  private _findWorkflowBindingByName;
+  /**
+   * Get all workflow binding names from the environment.
+   */
+  private _getWorkflowBindingNames;
+  /**
+   * Get the status of a workflow and update the tracking record.
+   *
+   * @param workflowName - Name of the workflow binding in env (e.g., 'MY_WORKFLOW')
+   * @param workflowId - ID of the workflow instance
+   * @returns The workflow status
+   */
+  getWorkflowStatus(
+    workflowName: WorkflowName<Env>,
+    workflowId: string
+  ): Promise<InstanceStatus>;
+  /**
+   * Get a tracked workflow by ID.
+   *
+   * @param workflowId - Workflow instance ID
+   * @returns Workflow info or undefined if not found
+   */
+  getWorkflow(workflowId: string): WorkflowInfo | undefined;
+  /**
+   * Query tracked workflows with cursor-based pagination.
+   *
+   * @param criteria - Query criteria including optional cursor for pagination
+   * @returns WorkflowPage with workflows, total count, and next cursor
+   *
+   * @example
+   * ```typescript
+   * // First page
+   * const page1 = this.getWorkflows({ status: 'running', limit: 20 });
+   *
+   * // Next page
+   * if (page1.nextCursor) {
+   *   const page2 = this.getWorkflows({
+   *     status: 'running',
+   *     limit: 20,
+   *     cursor: page1.nextCursor
+   *   });
+   * }
+   * ```
+   */
+  getWorkflows(criteria?: WorkflowQueryCriteria): WorkflowPage;
+  /**
+   * Count workflows matching criteria (for pagination total).
+   */
+  private _countWorkflows;
+  /**
+   * Encode a cursor from workflow info for pagination.
+   * Stores createdAt as Unix timestamp in seconds (matching DB storage).
+   */
+  private _encodeCursor;
+  /**
+   * Decode a pagination cursor.
+   * Returns createdAt as Unix timestamp in seconds (matching DB storage).
+   */
+  private _decodeCursor;
+  /**
+   * Delete a workflow tracking record.
+   *
+   * @param workflowId - ID of the workflow to delete
+   * @returns true if a record was deleted, false if not found
+   */
+  deleteWorkflow(workflowId: string): boolean;
+  /**
+   * Delete workflow tracking records matching criteria.
+   * Useful for cleaning up old completed/errored workflows.
+   *
+   * @param criteria - Criteria for which workflows to delete
+   * @returns Number of records matching criteria (expected deleted count)
+   *
+   * @example
+   * ```typescript
+   * // Delete all completed workflows created more than 7 days ago
+   * const deleted = this.deleteWorkflows({
+   *   status: 'complete',
+   *   createdBefore: new Date(Date.now() - 7 * 24 * 60 * 60 * 1000)
+   * });
+   *
+   * // Delete all errored and terminated workflows
+   * const deleted = this.deleteWorkflows({
+   *   status: ['errored', 'terminated']
+   * });
+   * ```
+   */
+  deleteWorkflows(
+    criteria?: Omit<WorkflowQueryCriteria, "limit" | "orderBy"> & {
+      createdBefore?: Date;
+    }
+  ): number;
+  /**
+   * Migrate workflow tracking records from an old binding name to a new one.
+   * Use this after renaming a workflow binding in wrangler.toml.
+   *
+   * @param oldName - Previous workflow binding name
+   * @param newName - New workflow binding name
+   * @returns Number of records migrated
+   *
+   * @example
+   * ```typescript
+   * // After renaming OLD_WORKFLOW to NEW_WORKFLOW in wrangler.toml
+   * async onStart() {
+   *   const migrated = this.migrateWorkflowBinding('OLD_WORKFLOW', 'NEW_WORKFLOW');
+   * }
+   * ```
+   */
+  migrateWorkflowBinding(oldName: string, newName: string): number;
+  /**
+   * Update workflow tracking record from InstanceStatus
+   */
+  private _updateWorkflowTracking;
+  /**
+   * Convert a database row to WorkflowInfo
+   */
+  private _rowToWorkflowInfo;
+  /**
+   * Find the binding name for this Agent's namespace by matching class name.
+   * Returns undefined if no match found - use options.agentBinding as fallback.
+   */
+  private _findAgentBindingName;
+  /**
+   * Handle a callback from a workflow.
+   * Called when the Agent receives a callback at /_workflow/callback.
+   * Override this to handle all callback types in one place.
+   *
+   * @param callback - The callback payload
+   */
+  onWorkflowCallback(callback: WorkflowCallback): Promise<void>;
+  /**
+   * Called when a workflow reports progress.
+   * Override to handle progress updates.
+   *
+   * @param workflowName - Workflow binding name
+   * @param workflowId - ID of the workflow
+   * @param progress - Typed progress data (default: DefaultProgress)
+   */
+  onWorkflowProgress(
+    _workflowName: string,
+    _workflowId: string,
+    _progress: unknown
+  ): Promise<void>;
+  /**
+   * Called when a workflow completes successfully.
+   * Override to handle completion.
+   *
+   * @param workflowName - Workflow binding name
+   * @param workflowId - ID of the workflow
+   * @param result - Optional result data
+   */
+  onWorkflowComplete(
+    _workflowName: string,
+    _workflowId: string,
+    _result?: unknown
+  ): Promise<void>;
+  /**
+   * Called when a workflow encounters an error.
+   * Override to handle errors.
+   *
+   * @param workflowName - Workflow binding name
+   * @param workflowId - ID of the workflow
+   * @param error - Error message
+   */
+  onWorkflowError(
+    _workflowName: string,
+    _workflowId: string,
+    _error: string
+  ): Promise<void>;
+  /**
+   * Called when a workflow sends a custom event.
+   * Override to handle custom events.
+   *
+   * @param workflowName - Workflow binding name
+   * @param workflowId - ID of the workflow
+   * @param event - Custom event payload
+   */
+  onWorkflowEvent(
+    _workflowName: string,
+    _workflowId: string,
+    _event: unknown
+  ): Promise<void>;
+  /**
+   * Handle a workflow callback via RPC.
+   * @internal - Called by AgentWorkflow, do not call directly
+   */
+  _workflow_handleCallback(callback: WorkflowCallback): Promise<void>;
+  /**
+   * Broadcast a message to all connected clients via RPC.
+   * @internal - Called by AgentWorkflow, do not call directly
+   */
+  _workflow_broadcast(message: unknown): void;
+  /**
+   * Update agent state via RPC.
+   * @internal - Called by AgentWorkflow, do not call directly
+   */
+  _workflow_updateState(
+    action: "set" | "merge" | "reset",
+    state?: unknown
+  ): void;
   /**
    * Connect to a new MCP Server
    *
+   * @example
+   * // Simple usage
+   * await this.addMcpServer("github", "https://mcp.github.com");
+   *
+   * @example
+   * // With options (preferred for custom headers, transport, etc.)
+   * await this.addMcpServer("github", "https://mcp.github.com", {
+   *   transport: { headers: { "Authorization": "Bearer ..." } }
+   * });
+   *
+   * @example
+   * // Legacy 5-parameter signature (still supported)
+   * await this.addMcpServer("github", url, callbackHost, agentsPrefix, options);
+   *
    * @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 options
+   * @param url MCP Server URL
+   * @param callbackHostOrOptions Options object, or callback host string (legacy)
+   * @param agentsPrefix agents routing prefix if not using `agents` (legacy)
+   * @param options MCP client and transport options (legacy)
    * @returns Server id and state - either "authenticating" with authUrl, or "ready"
    * @throws If connection or discovery fails
    */
   addMcpServer(
     serverName: string,
     url: string,
-    callbackHost?: string,
+    callbackHostOrOptions?: string | AddMcpServerOptions,
     agentsPrefix?: string,
     options?: {
       client?: ConstructorParameters<typeof Client>[1];
@@ -456,38 +937,14 @@ 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>;
+  /**
+   * Callback invoked when no routing information is found for an email.
+   * Use this to reject the email or perform custom handling.
+   * If not provided, a warning is logged and the email is dropped.
+   */
+  onNoRoute?: (email: ForwardableEmailMessage) => void | Promise<void>;
 };
 /**
  * Route an email to the appropriate Agent
@@ -501,17 +958,6 @@ declare function routeAgentEmail<Env extends Cloudflare.Env = Cloudflare.Env>(
   env: Env,
   options: EmailRoutingOptions<Env>
 ): 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
@@ -542,30 +988,42 @@ declare class StreamingResponse {
   private _id;
   private _closed;
   constructor(connection: Connection$1, id: string);
+  /**
+   * Whether the stream has been closed (via end() or error())
+   */
+  get isClosed(): boolean;
   /**
    * Send a chunk of data to the client
    * @param chunk The data to send
+   * @returns false if stream is already closed (no-op), true if sent
    */
-  send(chunk: unknown): void;
+  send(chunk: unknown): boolean;
   /**
    * End the stream and send the final chunk (if any)
    * @param finalChunk Optional final chunk of data to send
+   * @returns false if stream is already closed (no-op), true if sent
+   */
+  end(finalChunk?: unknown): boolean;
+  /**
+   * Send an error to the client and close the stream
+   * @param message Error message to send
+   * @returns false if stream is already closed (no-op), true if sent
    */
-  end(finalChunk?: unknown): void;
+  error(message: string): boolean;
 }
 //#endregion
 export {
+  AddMcpServerOptions,
   Agent,
   AgentContext,
-  type AgentEmail,
   AgentNamespace,
   AgentOptions,
+  AgentStaticOptions,
   CallableMetadata,
   type Connection,
   type ConnectionContext,
-  EmailResolver,
+  DEFAULT_AGENT_STATIC_OPTIONS,
   EmailRoutingOptions,
-  EmailSendOptions,
   MCPServer,
   MCPServerMessage,
   MCPServersState,
@@ -579,8 +1037,6 @@ export {
   type TransportType,
   type WSMessage,
   callable,
-  createAddressBasedEmailResolver,
-  createCatchAllEmailResolver,
   createHeaderBasedEmailResolver,
   getAgentByName,
   getCurrentAgent,