agents 0.0.0-2a6e66e → 0.0.0-2bea91f

package/dist/index.d.ts

@@ -8,11 +8,17 @@ import {
 } from "@modelcontextprotocol/sdk/types.js";
 import { Server, Connection, PartyServerOptions } from "partyserver";
 export { Connection, ConnectionContext, WSMessage } from "partyserver";
-import { M as MCPClientManager } from "./client-DgyzBU_8.js";
+import {
+  e as MCPClientManager,
+  T as TransportType,
+  f as MCPConnectionState
+} from "./client-DVoPb3-C.js";
 import { Observability } from "./observability/index.js";
+import { MessageType } from "./ai-types.js";
 import "zod";
 import "@modelcontextprotocol/sdk/shared/protocol.js";
 import "ai";
+import "./mcp-BH1fJeiU.js";
 import "@modelcontextprotocol/sdk/client/sse.js";
 import "@modelcontextprotocol/sdk/client/streamableHttp.js";
 import "./mcp/do-oauth-client-provider.js";
@@ -32,14 +38,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;
 } & (
   | {
@@ -70,12 +76,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;
@@ -117,11 +129,12 @@ type Schedule<T = string> = {
       cron: 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 = {
@@ -136,7 +149,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;
 };
@@ -153,10 +166,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
@@ -333,55 +351,40 @@ 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;
   }>;
+  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
@@ -489,12 +492,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>>;
 /**
@@ -536,6 +544,8 @@ export {
   type Schedule,
   type StateUpdateMessage,
   StreamingResponse,
+  TransportType,
+  callable,
   createAddressBasedEmailResolver,
   createCatchAllEmailResolver,
   createHeaderBasedEmailResolver,

package/dist/index.js

@@ -1,6 +1,7 @@
 import {
   Agent,
   StreamingResponse,
+  callable,
   createAddressBasedEmailResolver,
   createCatchAllEmailResolver,
   createHeaderBasedEmailResolver,
@@ -9,13 +10,16 @@ import {
   routeAgentEmail,
   routeAgentRequest,
   unstable_callable
-} from "./chunk-CV3L6FQZ.js";
-import "./chunk-HY7ZLHJB.js";
-import "./chunk-PVQZBKN7.js";
-import "./chunk-KUH345EY.js";
+} from "./chunk-254F4GDT.js";
+import "./chunk-3OT2NNEW.js";
+import "./chunk-Z44WASMA.js";
+import "./chunk-QEVM4BVL.js";
+import "./chunk-BER7KXUJ.js";
+import "./chunk-PR4QN5HX.js";
 export {
   Agent,
   StreamingResponse,
+  callable,
   createAddressBasedEmailResolver,
   createCatchAllEmailResolver,
   createHeaderBasedEmailResolver,

package/dist/mcp/client.d.ts

@@ -3,7 +3,8 @@ import '@modelcontextprotocol/sdk/client/index.js';
 import '@modelcontextprotocol/sdk/shared/protocol.js';
 import '@modelcontextprotocol/sdk/types.js';
 import 'ai';
-export { M as MCPClientManager, g as getNamespacedData } from '../client-DgyzBU_8.js';
+export { e as MCPClientManager, d as MCPClientOAuthCallbackConfig, c as MCPClientOAuthResult, g as getNamespacedData } from '../client-DVoPb3-C.js';
+import '../mcp-BH1fJeiU.js';
 import '@modelcontextprotocol/sdk/client/sse.js';
 import '@modelcontextprotocol/sdk/client/streamableHttp.js';
 import './do-oauth-client-provider.js';

package/dist/mcp/client.js

@@ -1,7 +1,8 @@
 import {
   MCPClientManager,
   getNamespacedData
-} from "../chunk-HY7ZLHJB.js";
+} from "../chunk-3OT2NNEW.js";
+import "../chunk-PR4QN5HX.js";
 export {
   MCPClientManager,
   getNamespacedData

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

@@ -15,6 +15,7 @@ declare class DurableObjectOAuthClientProvider implements AgentsOAuthProvider {
     private _clientId_;
     constructor(storage: DurableObjectStorage, clientName: string, baseRedirectUrl: string);
     get clientMetadata(): OAuthClientMetadata;
+    get clientUri(): string;
     get redirectUrl(): string;
     get clientId(): string;
     set clientId(clientId_: string);

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

@@ -1,6 +1,7 @@
 import {
   DurableObjectOAuthClientProvider
-} from "../chunk-PVQZBKN7.js";
+} from "../chunk-Z44WASMA.js";
+import "../chunk-PR4QN5HX.js";
 export {
   DurableObjectOAuthClientProvider
 };

package/dist/mcp/index.d.ts

@@ -1,110 +1,77 @@
-import { M as MCPClientManager } from '../client-DgyzBU_8.js';
-export { S as SSEEdgeClientTransport, a as StreamableHTTPEdgeClientTransport } from '../client-DgyzBU_8.js';
-import { DurableObject } from 'cloudflare:workers';
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { ElicitResult } from '@modelcontextprotocol/sdk/types.js';
+import { JSONRPCMessage, ElicitResult } from '@modelcontextprotocol/sdk/types.js';
 export { ElicitRequest, ElicitRequestSchema, ElicitResult } from '@modelcontextprotocol/sdk/types.js';
-import { Connection, WSMessage } from 'partyserver';
-import 'zod';
+import { Agent } from '../index.js';
+import { M as MaybePromise, B as BaseTransportType, S as ServeOptions } from '../client-DVoPb3-C.js';
+export { d as MCPClientOAuthCallbackConfig, c as MCPClientOAuthResult, a as SSEEdgeClientTransport, b as StreamableHTTPEdgeClientTransport } from '../client-DVoPb3-C.js';
+import { Connection, ConnectionContext } from 'partyserver';
+import 'cloudflare:workers';
 import '@modelcontextprotocol/sdk/client/index.js';
-import '@modelcontextprotocol/sdk/shared/protocol.js';
+import '../observability/index.js';
+import '../mcp-BH1fJeiU.js';
+import '../ai-types.js';
 import 'ai';
+import 'zod';
+import '@modelcontextprotocol/sdk/shared/protocol.js';
 import '@modelcontextprotocol/sdk/client/sse.js';
 import '@modelcontextprotocol/sdk/client/streamableHttp.js';
 import './do-oauth-client-provider.js';
 import '@modelcontextprotocol/sdk/client/auth.js';
 import '@modelcontextprotocol/sdk/shared/auth.js';
 
-interface CORSOptions {
-    origin?: string;
-    methods?: string;
-    headers?: string;
-    maxAge?: number;
-    exposeHeaders?: string;
-}
-type MaybePromise<T> = T | Promise<T>;
-declare abstract class McpAgent<Env = unknown, State = unknown, Props extends Record<string, unknown> = Record<string, unknown>> extends DurableObject<Env> {
-    private _status;
+declare abstract class McpAgent<Env = unknown, State = unknown, Props extends Record<string, unknown> = Record<string, unknown>> extends Agent<Env, State, Props> {
     private _transport?;
-    private _transportType;
-    private _requestIdToConnectionId;
-    /**
-     * Since McpAgent's _aren't_ yet real "Agents", let's only expose a couple of the methods
-     * to the outer class: initialState/state/setState/onStateUpdate/sql
-     */
-    private _agent;
-    get mcp(): MCPClientManager;
-    protected constructor(ctx: DurableObjectState, env: Env);
-    /**
-     * Agents API allowlist
+    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}`.
      */
-    initialState: State;
-    get state(): State;
-    sql<T = Record<string, string | number | boolean | null>>(strings: TemplateStringsArray, ...values: (string | number | boolean | null)[]): T[];
-    setState(state: State): void;
-    /**
-     * Elicit user input with a message and schema
+    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>;
-    onStateUpdate(state: State | undefined, source: Connection | "server"): void;
-    onStart(): Promise<void>;
-    /**
-     * McpAgent API
-     */
-    abstract server: MaybePromise<McpServer | Server>;
-    props: Props;
-    initRun: boolean;
-    abstract init(): Promise<void>;
-    /**
-     * Handle errors that occur during initialization or operation.
-     * Override this method to provide custom error handling.
-     * @param error - The error that occurred
-     * @returns An error response object with status code and message
-     */
-    onError(error: Error): {
-        status: number;
-        message: string;
-    };
-    _init(props: Props): Promise<void>;
-    setInitialized(): Promise<void>;
-    isInitialized(): Promise<boolean>;
-    updateProps(props: Props): Promise<void>;
-    private _initialize;
-    fetch(request: Request): Promise<Response>;
-    getWebSocket(): WebSocket | null;
-    getWebSocketForResponseID(id: string): WebSocket | null;
-    onMessage(connection: Connection, event: WSMessage): Promise<void>;
-    /**
-     * Wait for elicitation response through storage polling
-     */
+    /** Wait for elicitation response through storage polling */
     private _waitForElicitationResponse;
-    /**
-     * Handle elicitation responses   */
+    /** Handle elicitation responses */
     private _handleElicitationResponse;
-    onSSEMcpMessage(_sessionId: string, messageBody: unknown): Promise<Error | null>;
-    webSocketMessage(ws: WebSocket, event: ArrayBuffer | string): Promise<void>;
-    webSocketError(ws: WebSocket, error: unknown): Promise<void>;
-    webSocketClose(ws: WebSocket, code: number, reason: string, wasClean: boolean): Promise<void>;
-    static mount(path: string, { binding, corsOptions }?: {
-        binding?: string;
-        corsOptions?: CORSOptions;
-    }): {
+    /** 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>;
     };
-    static serveSSE(path: string, { binding, corsOptions }?: {
-        binding?: string;
-        corsOptions?: CORSOptions;
-    }): {
+    /**
+     * Legacy api
+     **/
+    static mount(path: string, opts?: Omit<ServeOptions, "transport">): {
         fetch<Env>(this: void, request: Request, env: Env, ctx: ExecutionContext): Promise<Response>;
     };
-    static serve(path: string, { binding, corsOptions }?: {
-        binding?: string;
-        corsOptions?: CORSOptions;
-    }): {
+    static serveSSE(path: string, opts?: Omit<ServeOptions, "transport">): {
         fetch<Env>(this: void, request: Request, env: Env, ctx: ExecutionContext): Promise<Response>;
     };
 }