agents 0.0.0-25aeaf2 → 0.0.0-25b261e

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
@@ -48,13 +49,14 @@ 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;
   /**
@@ -64,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[],
@@ -87,5 +94,5 @@ export {
   type AgentClientOptions,
   type StreamOptions,
   agentFetch,
-  camelCaseToKebabCase,
+  camelCaseToKebabCase
 };

package/dist/client.js

@@ -2,8 +2,7 @@ import {
   AgentClient,
   agentFetch,
   camelCaseToKebabCase
-} from "./chunk-RN4SNE73.js";
-import "./chunk-HMLY7DHA.js";
+} from "./chunk-KUH345EY.js";
 export {
   AgentClient,
   agentFetch,

package/dist/index.d.ts

@@ -1,15 +1,23 @@
+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 { MCPClientManager } from "./mcp/client.js";
-import { Tool, Prompt, Resource } from "@modelcontextprotocol/sdk/types.js";
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { M as MCPClientManager } from "./client-DgyzBU_8.js";
+import { Observability } from "./observability/index.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";
-import "@modelcontextprotocol/sdk/shared/protocol.js";
-import "ai";
 
 /**
  * RPC request message from client
@@ -68,6 +76,12 @@ declare function unstable_callable(
   target: (this: This, ...args: Args) => Return,
   context: ClassMethodDecoratorContext
 ) => (this: This, ...args: Args) => Return;
+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
@@ -123,21 +137,25 @@ type MCPServer = {
   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>,
+  T extends Agent<unknown, unknown> = Agent<unknown, unknown>
 >(): {
   agent: T | undefined;
   connection: Connection | undefined;
-  request: Request<unknown, CfProperties<unknown>> | 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> extends Server<Env> {
+  private _state;
+  private _ParentClass;
   mcp: MCPClientManager;
   /**
    * Initial state for the Agent
@@ -155,6 +173,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
@@ -167,6 +189,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
@@ -179,16 +202,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
@@ -229,6 +311,7 @@ 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.
@@ -242,6 +325,11 @@ declare class Agent<Env, State = unknown> extends Server<Env> {
    * 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
    *
@@ -266,7 +354,34 @@ declare class Agent<Env, State = unknown> extends Server<Env> {
     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;
+      };
+    },
+    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
@@ -299,17 +414,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
@@ -331,7 +501,9 @@ declare function getAgentByName<Env, T extends Agent<Env>>(
  * 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
@@ -348,20 +520,28 @@ 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,
+  createAddressBasedEmailResolver,
+  createCatchAllEmailResolver,
+  createHeaderBasedEmailResolver,
   getAgentByName,
   getCurrentAgent,
   routeAgentEmail,
   routeAgentRequest,
-  unstable_callable,
+  unstable_callable
 };

package/dist/index.js

@@ -1,19 +1,24 @@
 import {
   Agent,
   StreamingResponse,
+  createAddressBasedEmailResolver,
+  createCatchAllEmailResolver,
+  createHeaderBasedEmailResolver,
   getAgentByName,
   getCurrentAgent,
   routeAgentEmail,
   routeAgentRequest,
   unstable_callable
-} from "./chunk-YFPCCSZO.js";
-import "./chunk-D6UOOELW.js";
-import "./chunk-RN4SNE73.js";
-import "./chunk-25YDMV4H.js";
-import "./chunk-HMLY7DHA.js";
+} from "./chunk-DQJFYHG3.js";
+import "./chunk-EM3J4KV7.js";
+import "./chunk-PVQZBKN7.js";
+import "./chunk-KUH345EY.js";
 export {
   Agent,
   StreamingResponse,
+  createAddressBasedEmailResolver,
+  createCatchAllEmailResolver,
+  createHeaderBasedEmailResolver,
   getAgentByName,
   getCurrentAgent,
   routeAgentEmail,