agents 0.0.0-bcae0ba → 0.0.0-bdbadd3

package/dist/index.d.ts

@@ -1,306 +1,70 @@
-import { Server, Connection, PartyServerOptions } from "partyserver";
-export { Connection, ConnectionContext, WSMessage } from "partyserver";
-import { WorkflowEntrypoint as WorkflowEntrypoint$1 } from "cloudflare:workers";
-
-/**
- * RPC request message from client
- */
-type RPCRequest = {
-  type: "rpc";
-  id: string;
-  method: string;
-  args: unknown[];
-};
-/**
- * State update message from client
- */
-type StateUpdateMessage = {
-  type: "cf_agent_state";
-  state: unknown;
-};
-/**
- * RPC response message to client
- */
-type RPCResponse = {
-  type: "rpc";
-  id: string;
-} & (
-  | {
-      success: true;
-      result: unknown;
-      done?: false;
-    }
-  | {
-      success: true;
-      result: unknown;
-      done: true;
-    }
-  | {
-      success: false;
-      error: string;
-    }
-);
-/**
- * Metadata for a callable method
- */
-type CallableMetadata = {
-  /** Optional description of what the method does */
-  description?: string;
-  /** Whether the method supports streaming responses */
-  streaming?: boolean;
-};
-/**
- * Decorator that marks a method as callable by clients
- * @param metadata Optional metadata about the callable method
- */
-declare function unstable_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
- */
-declare class WorkflowEntrypoint extends WorkflowEntrypoint$1 {}
-/**
- * Represents a scheduled task within an Agent
- * @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 */
-  payload: T;
-} & (
-  | {
-      /** 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 */
-      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 */
-      cron: string;
-    }
-);
-/**
- * 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;
-  /**
-   * Initial state for the Agent
-   * Override to provide default state values
-   */
-  initialState: State;
-  /**
-   * Current state of the Agent
-   */
-  get state(): State;
-  /**
-   * Agent configuration options
-   */
-  static options: {
-    /** Whether the Agent should hibernate when inactive */
-    hibernate: boolean;
-  };
-  /**
-   * Execute SQL queries against the Agent's database
-   * @template T Type of the returned rows
-   * @param strings SQL query template strings
-   * @param values Values to be inserted into the query
-   * @returns Array of query results
-   */
-  sql<T = Record<string, string | number | boolean | null>>(
-    strings: TemplateStringsArray,
-    ...values: (string | number | boolean | null)[]
-  ): T[];
-  constructor(ctx: AgentContext, env: Env);
-  /**
-   * Update the Agent's state
-   * @param state New state to set
-   */
-  setState(state: State): void;
-  /**
-   * Called when the Agent's state is updated
-   * @param state Updated state
-   * @param source Source of the state update ("server" or a client connection)
-   */
-  onStateUpdate(state: State | undefined, source: Connection | "server"): void;
-  /**
-   * Called when the Agent receives an email
-   * @param email Email message to process
-   */
-  onEmail(email: ForwardableEmailMessage): void;
-  /**
-   * Render content (not implemented in base class)
-   */
-  render(): void;
-  /**
-   * Schedule a task to be executed in the future
-   * @template T Type of the payload data
-   * @param when When to execute the task (Date, seconds delay, or cron expression)
-   * @param callback Name of the method to call
-   * @param payload Data to pass to the callback
-   * @returns Schedule object representing the scheduled task
-   */
-  schedule<T = string>(
-    when: Date | string | number,
-    callback: keyof this,
-    payload?: T
-  ): Promise<Schedule<T>>;
-  /**
-   * Get a scheduled task by ID
-   * @template T Type of the payload data
-   * @param id ID of the scheduled task
-   * @returns The Schedule object or undefined if not found
-   */
-  getSchedule<T = string>(id: string): Promise<Schedule<T> | undefined>;
-  /**
-   * Get scheduled tasks matching the given criteria
-   * @template T Type of the payload data
-   * @param criteria Criteria to filter schedules
-   * @returns Array of matching Schedule objects
-   */
-  getSchedules<T = string>(criteria?: {
-    description?: string;
-    id?: string;
-    type?: "scheduled" | "delayed" | "cron";
-    timeRange?: {
-      start?: Date;
-      end?: Date;
-    };
-  }): Schedule<T>[];
-  /**
-   * Cancel a scheduled task
-   * @param id ID of the task to cancel
-   * @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
-   */
-  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;
-}
-/**
- * Namespace for creating Agent instances
- * @template Agentic Type of the Agent class
- */
-type AgentNamespace<Agentic extends Agent<unknown>> =
-  DurableObjectNamespace<Agentic>;
-/**
- * Agent's durable context
- */
-type AgentContext = DurableObjectState;
-/**
- * Configuration options for Agent routing
- */
-type AgentOptions<Env> = PartyServerOptions<Env> & {
-  /**
-   * Whether to enable CORS for the Agent
-   */
-  cors?: boolean | HeadersInit | undefined;
-};
-/**
- * Route a request to the appropriate Agent
- * @param request Request to route
- * @param env Environment containing Agent bindings
- * @param options Routing options
- * @returns Response from the Agent or undefined if no route matched
- */
-declare function routeAgentRequest<Env>(
-  request: Request,
-  env: Env,
-  options?: AgentOptions<Env>
-): Promise<Response | null>;
-/**
- * Route an email to the appropriate Agent
- * @param email Email message to route
- * @param env Environment containing Agent bindings
- * @param options Routing options
- */
-declare function routeAgentEmail<Env>(
-  email: ForwardableEmailMessage,
-  env: Env,
-  options?: AgentOptions<Env>
-): Promise<void>;
-/**
- * Get or create an Agent by name
- * @template Env Environment type containing bindings
- * @template T Type of the Agent class
- * @param namespace Agent namespace
- * @param name Name of the Agent instance
- * @param options Options for Agent creation
- * @returns Promise resolving to an Agent instance stub
- */
-declare function getAgentByName<Env, T extends Agent<Env>>(
-  namespace: AgentNamespace<T>,
-  name: string,
-  options?: {
-    jurisdiction?: DurableObjectJurisdiction;
-    locationHint?: DurableObjectLocationHint;
-  }
-): Promise<DurableObjectStub<T>>;
-/**
- * A wrapper for streaming responses in callable methods
- */
-declare class StreamingResponse {
-  #private;
-  constructor(connection: Connection, id: string);
-  /**
-   * Send a chunk of data to the client
-   * @param chunk The data to send
-   */
-  send(chunk: unknown): void;
-  /**
-   * End the stream and send the final chunk (if any)
-   * @param finalChunk Optional final chunk of data to send
-   */
-  end(finalChunk?: unknown): void;
-}
-
+import { u as TransportType } from "./client-skWSTEiU.js";
+import "./mcp-Dw5vDrY8.js";
+import "./do-oauth-client-provider-DGc5pP0l.js";
+import "./index-DhJCaDWd.js";
+import "./ai-types-D5YoPrBZ.js";
+import {
+  A as unstable_callable,
+  C as createAddressBasedEmailResolver,
+  D as getCurrentAgent,
+  E as getAgentByName,
+  O as routeAgentEmail,
+  S as callable,
+  T as createHeaderBasedEmailResolver,
+  _ as RPCResponse,
+  a as AgentOptions,
+  b as StreamingResponse,
+  c as ConnectionContext,
+  d as EmailSendOptions,
+  f as MCPServer,
+  g as RPCRequest,
+  h as QueueItem,
+  i as AgentNamespace,
+  k as routeAgentRequest,
+  l as EmailResolver,
+  m as MCPServersState,
+  n as AgentContext,
+  o as CallableMetadata,
+  p as MCPServerMessage,
+  r as AgentEmail,
+  s as Connection,
+  t as Agent,
+  u as EmailRoutingOptions,
+  v as Schedule,
+  w as createCatchAllEmailResolver,
+  x as WSMessage,
+  y as StateUpdateMessage
+} from "./index-C1wSj5kj.js";
 export {
   Agent,
-  type AgentContext,
-  type AgentNamespace,
-  type AgentOptions,
-  type CallableMetadata,
-  type RPCRequest,
-  type RPCResponse,
-  type Schedule,
-  type StateUpdateMessage,
+  AgentContext,
+  AgentEmail,
+  AgentNamespace,
+  AgentOptions,
+  CallableMetadata,
+  Connection,
+  ConnectionContext,
+  EmailResolver,
+  EmailRoutingOptions,
+  EmailSendOptions,
+  MCPServer,
+  MCPServerMessage,
+  MCPServersState,
+  QueueItem,
+  RPCRequest,
+  RPCResponse,
+  Schedule,
+  StateUpdateMessage,
   StreamingResponse,
-  WorkflowEntrypoint,
+  TransportType,
+  WSMessage,
+  callable,
+  createAddressBasedEmailResolver,
+  createCatchAllEmailResolver,
+  createHeaderBasedEmailResolver,
   getAgentByName,
+  getCurrentAgent,
   routeAgentEmail,
   routeAgentRequest,
-  unstable_callable,
+  unstable_callable
 };

package/dist/index.js

@@ -1,20 +1,7 @@
-import {
-  Agent,
-  StreamingResponse,
-  WorkflowEntrypoint,
-  getAgentByName,
-  routeAgentEmail,
-  routeAgentRequest,
-  unstable_callable
-} from "./chunk-PDF5WEP4.js";
-import "./chunk-HMLY7DHA.js";
-export {
-  Agent,
-  StreamingResponse,
-  WorkflowEntrypoint,
-  getAgentByName,
-  routeAgentEmail,
-  routeAgentRequest,
-  unstable_callable
-};
-//# sourceMappingURL=index.js.map
+import "./ai-types-B3aQaFv3.js";
+import "./client-BfiZ3HQd.js";
+import "./client-9Ld2_lnt.js";
+import "./do-oauth-client-provider-CswoD5Lu.js";
+import { a as createCatchAllEmailResolver, c as getCurrentAgent, d as unstable_callable, i as createAddressBasedEmailResolver, l as routeAgentEmail, n as StreamingResponse, o as createHeaderBasedEmailResolver, r as callable, s as getAgentByName, t as Agent, u as routeAgentRequest } from "./src-Dz0H9hSU.js";
+
+export { Agent, StreamingResponse, callable, createAddressBasedEmailResolver, createCatchAllEmailResolver, createHeaderBasedEmailResolver, getAgentByName, getCurrentAgent, routeAgentEmail, routeAgentRequest, unstable_callable };

package/dist/mcp/client.d.ts

@@ -0,0 +1,4 @@
+import { i as getNamespacedData, n as MCPClientOAuthCallbackConfig, r as MCPClientOAuthResult, t as MCPClientManager } from "../client-skWSTEiU.js";
+import "../mcp-Dw5vDrY8.js";
+import "../do-oauth-client-provider-DGc5pP0l.js";
+export { MCPClientManager, MCPClientOAuthCallbackConfig, MCPClientOAuthResult, getNamespacedData };

package/dist/mcp/client.js

@@ -0,0 +1,3 @@
+import { n as getNamespacedData, t as MCPClientManager } from "../client-9Ld2_lnt.js";
+
+export { MCPClientManager, getNamespacedData };

package/dist/mcp/do-oauth-client-provider.d.ts

@@ -0,0 +1,2 @@
+import { n as DurableObjectOAuthClientProvider, t as AgentsOAuthProvider } from "../do-oauth-client-provider-DGc5pP0l.js";
+export { AgentsOAuthProvider, DurableObjectOAuthClientProvider };

package/dist/mcp/do-oauth-client-provider.js

@@ -0,0 +1,3 @@
+import { t as DurableObjectOAuthClientProvider } from "../do-oauth-client-provider-CswoD5Lu.js";
+
+export { DurableObjectOAuthClientProvider };

package/dist/mcp/index.d.ts

@@ -0,0 +1,153 @@
+import { c as MaybePromise, d as StreamableHTTPEdgeClientTransport, f as SSEEdgeClientTransport, l as ServeOptions, n as MCPClientOAuthCallbackConfig, o as BaseTransportType, r as MCPClientOAuthResult, s as CORSOptions } from "../client-skWSTEiU.js";
+import "../mcp-Dw5vDrY8.js";
+import "../do-oauth-client-provider-DGc5pP0l.js";
+import "../index-DhJCaDWd.js";
+import "../ai-types-D5YoPrBZ.js";
+import { c as ConnectionContext, s as Connection, t as Agent } from "../index-C1wSj5kj.js";
+import { ElicitRequest, ElicitRequestSchema, ElicitResult, ElicitResult as ElicitResult$1, JSONRPCMessage } from "@modelcontextprotocol/sdk/types.js";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
+
+//#region src/mcp/worker-transport.d.ts
+interface WorkerTransportOptions {
+  sessionIdGenerator?: () => string;
+  enableJsonResponse?: boolean;
+  onsessioninitialized?: (sessionId: string) => void;
+  corsOptions?: CORSOptions;
+}
+declare class WorkerTransport implements Transport {
+  private started;
+  private initialized;
+  private sessionIdGenerator?;
+  private enableJsonResponse;
+  private onsessioninitialized?;
+  private standaloneSseStreamId;
+  private streamMapping;
+  private requestToStreamMapping;
+  private requestResponseMap;
+  private corsOptions?;
+  private protocolVersion?;
+  sessionId?: string;
+  onclose?: () => void;
+  onerror?: (error: Error) => void;
+  onmessage?: (message: JSONRPCMessage) => void;
+  constructor(options?: WorkerTransportOptions);
+  start(): Promise<void>;
+  private validateProtocolVersion;
+  private getHeaders;
+  handleRequest(request: Request, parsedBody?: unknown): Promise<Response>;
+  private handleGetRequest;
+  private handlePostRequest;
+  private handleDeleteRequest;
+  private handleOptionsRequest;
+  private handleUnsupportedRequest;
+  private validateSession;
+  close(): Promise<void>;
+  send(message: JSONRPCMessage): Promise<void>;
+}
+//#endregion
+//#region src/mcp/handler.d.ts
+interface CreateMcpHandlerOptions extends WorkerTransportOptions {
+  /**
+   * The route path that this MCP handler should respond to.
+   * If specified, the handler will only process requests that match this route.
+   * @default "/mcp"
+   */
+  route?: string;
+  /**
+   * CORS configuration options for handling cross-origin requests.
+   * These options are passed to the WorkerTransport which handles adding
+   * CORS headers to all responses.
+   *
+   * Default values are:
+   * - origin: "*"
+   * - headers: "Content-Type, Accept, Authorization, mcp-session-id, MCP-Protocol-Version"
+   * - methods: "GET, POST, DELETE, OPTIONS"
+   * - exposeHeaders: "mcp-session-id"
+   * - maxAge: 86400
+   *
+   * Provided options will overwrite the defaults.
+   */
+  corsOptions?: CORSOptions;
+}
+type OAuthExecutionContext = ExecutionContext & {
+  props?: Record<string, unknown>;
+};
+declare function createMcpHandler(server: McpServer | Server, options?: CreateMcpHandlerOptions): (request: Request, env: unknown, ctx: ExecutionContext) => Promise<Response>;
+/**
+ * @deprecated This has been renamed to createMcpHandler, and experimental_createMcpHandler will be removed in the next major version
+ */
+declare function experimental_createMcpHandler(server: McpServer | Server, options?: CreateMcpHandlerOptions): (request: Request, env: unknown, ctx: ExecutionContext) => Promise<Response>;
+//#endregion
+//#region src/mcp/auth-context.d.ts
+interface McpAuthContext {
+  props: Record<string, unknown>;
+}
+declare function getMcpAuthContext(): McpAuthContext | undefined;
+//#endregion
+//#region src/mcp/index.d.ts
+declare abstract class McpAgent<Env = unknown, State = unknown, Props extends Record<string, unknown> = Record<string, unknown>> extends Agent<Env, State, Props> {
+  private _transport?;
+  props?: Props;
+  abstract server: MaybePromise<McpServer | Server>;
+  abstract init(): Promise<void>;
+  setInitializeRequest(initializeRequest: JSONRPCMessage): Promise<void>;
+  getInitializeRequest(): Promise<JSONRPCMessage | undefined>;
+  /** Read the transport type for this agent.
+   * This relies on the naming scheme being `sse:${sessionId}`
+   * or `streamable-http:${sessionId}`.
+   */
+  getTransportType(): BaseTransportType;
+  /** Read the sessionId for this agent.
+   * This relies on the naming scheme being `sse:${sessionId}`
+   * or `streamable-http:${sessionId}`.
+   */
+  getSessionId(): string;
+  /** Get the unique WebSocket. SSE transport only. */
+  private getWebSocket;
+  /** Returns a new transport matching the type of the Agent. */
+  private initTransport;
+  /** Update and store the props */
+  updateProps(props?: Props): Promise<void>;
+  reinitializeServer(): Promise<void>;
+  /** Sets up the MCP transport and server every time the Agent is started.*/
+  onStart(props?: Props): Promise<void>;
+  /** Validates new WebSocket connections. */
+  onConnect(conn: Connection, {
+    request: req
+  }: ConnectionContext): Promise<void>;
+  /** Handles MCP Messages for the legacy SSE transport. */
+  onSSEMcpMessage(_sessionId: string, messageBody: unknown): Promise<Error | null>;
+  /** Elicit user input with a message and schema */
+  elicitInput(params: {
+    message: string;
+    requestedSchema: unknown;
+  }): Promise<ElicitResult$1>;
+  /** Wait for elicitation response through storage polling */
+  private _waitForElicitationResponse;
+  /** Handle elicitation responses */
+  private _handleElicitationResponse;
+  /** Return a handler for the given path for this MCP.
+   * Defaults to Streamable HTTP transport.
+   */
+  static serve(path: string, {
+    binding,
+    corsOptions,
+    transport
+  }?: ServeOptions): {
+    fetch<Env>(this: void, request: Request, env: Env, ctx: ExecutionContext): Promise<Response>;
+  };
+  /**
+   * Legacy api
+   **/
+  static mount(path: string, opts?: Omit<ServeOptions, "transport">): {
+    fetch<Env>(this: void, request: Request, env: Env, ctx: ExecutionContext): Promise<Response>;
+  };
+  static serveSSE(path: string, opts?: Omit<ServeOptions, "transport">): {
+    fetch<Env>(this: void, request: Request, env: Env, ctx: ExecutionContext): Promise<Response>;
+  };
+}
+//#endregion
+export { type CreateMcpHandlerOptions, type ElicitRequest, ElicitRequestSchema, type ElicitResult, type MCPClientOAuthCallbackConfig, type MCPClientOAuthResult, McpAgent, type McpAuthContext, type OAuthExecutionContext, SSEEdgeClientTransport, StreamableHTTPEdgeClientTransport, WorkerTransport, type WorkerTransportOptions, createMcpHandler, experimental_createMcpHandler, getMcpAuthContext };
+//# sourceMappingURL=index.d.ts.map