agents 0.0.0-8c2713f → 0.0.0-8c9aadd

package/dist/{index-BCJclX6q.d.ts → index-DWJSBMbz.d.ts}

@@ -1,89 +1,186 @@
-import { env } from "cloudflare:workers";
+import {
+  BaseTransportType,
+  MCPClientManager,
+  MCPConnectionState,
+  MaybePromise,
+  ServeOptions,
+  TransportType
+} from "./client-C-nwz-3N.js";
+import { Observability } from "./index-W4JUkafc.js";
+import { MessageType } from "./ai-types-BWW4umHY.js";
+import {
+  Connection,
+  Connection as Connection$1,
+  ConnectionContext,
+  PartyServerOptions,
+  Server,
+  WSMessage
+} from "partyserver";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import {
-  ServerCapabilities,
-  Tool,
+  ElicitRequest as ElicitRequest$1,
+  ElicitRequestSchema as ElicitRequestSchema$1,
+  ElicitResult,
+  ElicitResult as ElicitResult$1,
+  JSONRPCMessage,
   Prompt,
-  Resource
+  Resource,
+  ServerCapabilities,
+  Tool
 } from "@modelcontextprotocol/sdk/types.js";
-import { Server, Connection, PartyServerOptions } from "partyserver";
-import { M as MCPClientManager } from "./client-DgyzBU_8.js";
-import { Message } from "ai";
+import { env } from "cloudflare:workers";
+import { Server as Server$1 } from "@modelcontextprotocol/sdk/server/index.js";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
 
-type BaseEvent<
-  T extends string,
-  Payload extends Record<string, unknown> = {}
-> = {
-  type: T;
-  /**
-   * The unique identifier for the event
-   */
-  id: string;
-  /**
-   * The message to display in the logs for this event, should the implementation choose to display
-   * a human-readable message.
-   */
-  displayMessage: string;
-  /**
-   * The payload of the event
-   */
-  payload: Payload;
+//#region src/mcp/worker-transport.d.ts
+interface WorkerTransportOptions {
+  sessionIdGenerator?: () => string;
+  enableJsonResponse?: boolean;
+  onsessioninitialized?: (sessionId: string) => void;
+}
+declare class WorkerTransport implements Transport {
+  private started;
+  private initialized;
+  private sessionIdGenerator?;
+  private enableJsonResponse;
+  private onsessioninitialized?;
+  private standaloneSseStreamId;
+  private streamMapping;
+  private requestToStreamMapping;
+  private requestResponseMap;
+  sessionId?: string;
+  onclose?: () => void;
+  onerror?: (error: Error) => void;
+  onmessage?: (message: JSONRPCMessage) => void;
+  constructor(options?: WorkerTransportOptions);
+  start(): Promise<void>;
+  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 timestamp of the event in milliseconds since epoch
+   * The route path that this MCP handler should respond to.
+   * If specified, the handler will only process requests that match this route.
+   * @default "/mcp"
    */
-  timestamp: number;
+  route?: string;
+}
+type OAuthExecutionContext = ExecutionContext & {
+  props?: Record<string, unknown>;
 };
-/**
- * The type of events that can be emitted by an Agent
- */
-type ObservabilityEvent =
-  | BaseEvent<
-      "state:update",
-      {
-        state: unknown;
-        previousState: unknown;
-      }
-    >
-  | BaseEvent<
-      "rpc",
-      {
-        method: string;
-        args: unknown[];
-        streaming?: boolean;
-        success: boolean;
-      }
-    >
-  | BaseEvent<
-      "message:request" | "message:response",
-      {
-        message: Message[];
-      }
-    >
-  | BaseEvent<"message:clear">
-  | BaseEvent<
-      "schedule:create" | "schedule:execute" | "schedule:cancel",
-      Schedule<unknown>
-    >
-  | BaseEvent<"destroy">
-  | BaseEvent<
-      "connect",
-      {
-        connectionId: string;
-      }
-    >;
-interface Observability {
-  /**
-   * Emit an event for the Agent's observability implementation to handle.
-   * @param event - The event to emit
-   * @param ctx - The execution context of the invocation
-   */
-  emit(event: ObservabilityEvent, ctx: DurableObjectState): void;
+declare function experimental_createMcpHandler(
+  server: McpServer | Server$1,
+  options?: CreateMcpHandlerOptions
+): (request: Request, env: unknown, ctx: ExecutionContext) => Promise<Response>;
+//#endregion
+//#region src/mcp/auth-context.d.ts
+interface McpAuthContext {
+  props: Record<string, unknown>;
 }
-/**
- * A generic observability implementation that logs events to the console.
- */
-declare const genericObservability: Observability;
-
+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$1>;
+  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$1,
+    { 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>;
+  /** 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
+//#region src/index.d.ts
 /**
  * RPC request message from client
  */
@@ -97,14 +194,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;
 } & (
   | {
@@ -135,12 +232,18 @@ 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;
+/**
+ * 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 const unstable_callable: (metadata?: CallableMetadata) => void;
 type QueueItem<T = string> = {
   id: string;
   payload: T;
@@ -186,7 +289,7 @@ type Schedule<T = string> = {
  * MCP Server state update message from server -> Client
  */
 type MCPServerMessage = {
-  type: "cf_agent_mcp_servers";
+  type: MessageType.CF_AGENT_MCP_SERVERS;
   mcp: MCPServersState;
 };
 type MCPServersState = {
@@ -201,7 +304,7 @@ type MCPServer = {
   name: string;
   server_url: string;
   auth_url: string | null;
-  state: "authenticating" | "connecting" | "ready" | "discovering" | "failed";
+  state: MCPConnectionState;
   instructions: string | null;
   capabilities: ServerCapabilities | null;
 };
@@ -218,10 +321,15 @@ declare function getCurrentAgent<
  * @template Env Environment type containing bindings
  * @template State State type to store within the Agent
  */
-declare class Agent<Env = typeof env, State = unknown> extends Server<Env> {
+declare class Agent<
+  Env = typeof env,
+  State = unknown,
+  Props extends Record<string, unknown> = Record<string, unknown>
+> extends Server<Env, Props> {
   private _state;
+  private _disposables;
   private _ParentClass;
-  mcp: MCPClientManager;
+  readonly mcp: MCPClientManager;
   /**
    * Initial state for the Agent
    * Override to provide default state values
@@ -398,55 +506,50 @@ declare class Agent<Env = typeof env, State = unknown> extends Server<Env> {
   /**
    * 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.
+   * @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
+   * @param options MCP client and transport options
    * @returns authUrl
    */
   addMcpServer(
     serverName: string,
     url: string,
-    callbackHost: 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;
   }>;
+  /**
+   * Handle potential OAuth callback requests after DO hibernation.
+   * Detects OAuth callbacks, restores state from database, and processes the callback.
+   * Returns a Response if this was an OAuth callback, otherwise returns undefined.
+   */
+  private _handlePotentialOAuthCallback;
+  /**
+   * Process an OAuth callback request (assumes state is already restored)
+   */
+  private _processOAuthCallback;
+  private _connectToMcpServerInternal;
   removeMcpServer(id: string): Promise<void>;
   getMcpServers(): MCPServersState;
+  private broadcastMcpServers;
+  /**
+   * Handle OAuth callback response using MCPClientManager configuration
+   * @param result OAuth callback result
+   * @param request The original request (needed for base URL)
+   * @returns Response for the OAuth callback
+   */
+  private handleOAuthCallbackResponse;
 }
 /**
  * Namespace for creating Agent instances
@@ -554,12 +657,17 @@ type EmailSendOptions = {
  * @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>>;
 /**
@@ -581,35 +689,48 @@ declare class StreamingResponse {
    */
   end(finalChunk?: unknown): void;
 }
-
+//#endregion
 export {
-  Agent as A,
-  type CallableMetadata as C,
-  type EmailResolver as E,
-  type MCPServersState as M,
-  type ObservabilityEvent as O,
-  type QueueItem as Q,
-  type RPCRequest as R,
-  type StateUpdateMessage as S,
-  type AgentContext as a,
-  type Observability as b,
-  type RPCResponse as c,
-  type Schedule as d,
-  type MCPServerMessage as e,
-  type MCPServer as f,
-  genericObservability as g,
-  getCurrentAgent as h,
-  type AgentNamespace as i,
-  type AgentOptions as j,
-  createHeaderBasedEmailResolver as k,
-  createAddressBasedEmailResolver as l,
-  createCatchAllEmailResolver as m,
-  type EmailRoutingOptions as n,
-  routeAgentEmail as o,
-  type AgentEmail as p,
-  type EmailSendOptions as q,
-  routeAgentRequest as r,
-  getAgentByName as s,
-  StreamingResponse as t,
-  unstable_callable as u
+  Agent,
+  AgentContext,
+  AgentEmail,
+  AgentNamespace,
+  AgentOptions,
+  CallableMetadata,
+  type Connection$1 as Connection,
+  type ConnectionContext,
+  type CreateMcpHandlerOptions,
+  type ElicitRequest$1 as ElicitRequest,
+  ElicitRequestSchema$1 as ElicitRequestSchema,
+  type ElicitResult$1 as ElicitResult,
+  EmailResolver,
+  EmailRoutingOptions,
+  EmailSendOptions,
+  MCPServer,
+  MCPServerMessage,
+  MCPServersState,
+  McpAgent,
+  type McpAuthContext,
+  type OAuthExecutionContext,
+  QueueItem,
+  RPCRequest,
+  RPCResponse,
+  Schedule,
+  StateUpdateMessage,
+  StreamingResponse,
+  type WSMessage,
+  WorkerTransport,
+  type WorkerTransportOptions,
+  callable,
+  createAddressBasedEmailResolver,
+  createCatchAllEmailResolver,
+  createHeaderBasedEmailResolver,
+  experimental_createMcpHandler,
+  getAgentByName,
+  getCurrentAgent,
+  getMcpAuthContext,
+  routeAgentEmail,
+  routeAgentRequest,
+  unstable_callable
 };
+//# sourceMappingURL=index-DWJSBMbz.d.ts.map

package/dist/index-W4JUkafc.d.ts

@@ -0,0 +1,54 @@
+import { BaseEvent, MCPObservabilityEvent } from "./mcp-BEwaCsxO.js";
+
+//#region src/observability/agent.d.ts
+
+/**
+ * Agent-specific observability events
+ * These track the lifecycle and operations of an Agent
+ */
+type AgentObservabilityEvent =
+  | BaseEvent<"state:update", {}>
+  | BaseEvent<
+      "rpc",
+      {
+        method: string;
+        streaming?: boolean;
+      }
+    >
+  | BaseEvent<"message:request" | "message:response", {}>
+  | BaseEvent<"message:clear">
+  | BaseEvent<
+      "schedule:create" | "schedule:execute" | "schedule:cancel",
+      {
+        callback: string;
+        id: string;
+      }
+    >
+  | BaseEvent<"destroy">
+  | BaseEvent<
+      "connect",
+      {
+        connectionId: string;
+      }
+    >;
+//#endregion
+//#region src/observability/index.d.ts
+/**
+ * Union of all observability event types from different domains
+ */
+type ObservabilityEvent = AgentObservabilityEvent | MCPObservabilityEvent;
+interface Observability {
+  /**
+   * Emit an event for the Agent's observability implementation to handle.
+   * @param event - The event to emit
+   * @param ctx - The execution context of the invocation (optional)
+   */
+  emit(event: ObservabilityEvent, ctx?: DurableObjectState): void;
+}
+/**
+ * A generic observability implementation that logs events to the console.
+ */
+declare const genericObservability: Observability;
+//#endregion
+export { Observability, ObservabilityEvent, genericObservability };
+//# sourceMappingURL=index-W4JUkafc.d.ts.map

package/dist/index.d.ts

@@ -1,41 +1,84 @@
-import "cloudflare:workers";
-import "@modelcontextprotocol/sdk/client/index.js";
-import "@modelcontextprotocol/sdk/types.js";
-export { Connection, ConnectionContext, WSMessage } from "partyserver";
-import "./client-DgyzBU_8.js";
+import { TransportType } from "./client-C-nwz-3N.js";
+import "./mcp-BEwaCsxO.js";
+import "./do-oauth-client-provider-CCwGwnrA.js";
+import "./index-W4JUkafc.js";
+import "./ai-types-BWW4umHY.js";
+import {
+  Agent,
+  AgentContext,
+  AgentEmail,
+  AgentNamespace,
+  AgentOptions,
+  CallableMetadata,
+  Connection,
+  ConnectionContext,
+  CreateMcpHandlerOptions,
+  EmailResolver,
+  EmailRoutingOptions,
+  EmailSendOptions,
+  MCPServer,
+  MCPServerMessage,
+  MCPServersState,
+  McpAuthContext,
+  OAuthExecutionContext,
+  QueueItem,
+  RPCRequest,
+  RPCResponse,
+  Schedule,
+  StateUpdateMessage,
+  StreamingResponse,
+  WSMessage,
+  WorkerTransport,
+  WorkerTransportOptions,
+  callable,
+  createAddressBasedEmailResolver,
+  createCatchAllEmailResolver,
+  createHeaderBasedEmailResolver,
+  experimental_createMcpHandler,
+  getAgentByName,
+  getCurrentAgent,
+  getMcpAuthContext,
+  routeAgentEmail,
+  routeAgentRequest,
+  unstable_callable
+} from "./index-DWJSBMbz.js";
 export {
-  A as Agent,
-  a as AgentContext,
-  p as AgentEmail,
-  i as AgentNamespace,
-  j as AgentOptions,
-  C as CallableMetadata,
-  E as EmailResolver,
-  n as EmailRoutingOptions,
-  q as EmailSendOptions,
-  f as MCPServer,
-  e as MCPServerMessage,
-  M as MCPServersState,
-  Q as QueueItem,
-  R as RPCRequest,
-  c as RPCResponse,
-  d as Schedule,
-  S as StateUpdateMessage,
-  t as StreamingResponse,
-  l as createAddressBasedEmailResolver,
-  m as createCatchAllEmailResolver,
-  k as createHeaderBasedEmailResolver,
-  s as getAgentByName,
-  h as getCurrentAgent,
-  o as routeAgentEmail,
-  r as routeAgentRequest,
-  u as unstable_callable
-} from "./index-BCJclX6q.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";
+  Agent,
+  AgentContext,
+  AgentEmail,
+  AgentNamespace,
+  AgentOptions,
+  CallableMetadata,
+  Connection,
+  ConnectionContext,
+  CreateMcpHandlerOptions,
+  EmailResolver,
+  EmailRoutingOptions,
+  EmailSendOptions,
+  MCPServer,
+  MCPServerMessage,
+  MCPServersState,
+  McpAuthContext,
+  OAuthExecutionContext,
+  QueueItem,
+  RPCRequest,
+  RPCResponse,
+  Schedule,
+  StateUpdateMessage,
+  StreamingResponse,
+  TransportType,
+  WSMessage,
+  WorkerTransport,
+  WorkerTransportOptions,
+  callable,
+  createAddressBasedEmailResolver,
+  createCatchAllEmailResolver,
+  createHeaderBasedEmailResolver,
+  experimental_createMcpHandler,
+  getAgentByName,
+  getCurrentAgent,
+  getMcpAuthContext,
+  routeAgentEmail,
+  routeAgentRequest,
+  unstable_callable
+};