agents 0.0.0-b5aee9f → 0.0.0-b6af48a

package/dist/mcp/client.js

@@ -1,7 +1,8 @@
 import {
   MCPClientManager,
   getNamespacedData
-} from "../chunk-UNG3FXYX.js";
+} from "../chunk-QUOGV3WN.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-C2OEBJZ2.js";
+import "../chunk-PR4QN5HX.js";
 export {
   DurableObjectOAuthClientProvider
 };

package/dist/mcp/index.d.ts

@@ -1,107 +1,79 @@
-import { MCPClientManager } from './client.js';
-import { DurableObject } from 'cloudflare:workers';
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { Connection, WSMessage } from 'partyserver';
-import { SSEClientTransport, SSEClientTransportOptions } from '@modelcontextprotocol/sdk/client/sse.js';
-import { StreamableHTTPClientTransport, StreamableHTTPClientTransportOptions } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
-import 'zod';
+import { JSONRPCMessage, ElicitResult } from '@modelcontextprotocol/sdk/types.js';
+export { ElicitRequest, ElicitRequestSchema, ElicitResult } from '@modelcontextprotocol/sdk/types.js';
+import { Agent } from '../index.js';
+import { M as MaybePromise, B as BaseTransportType, S as ServeOptions } from '../client-C8tswVoM.js';
+export { d as MCPClientOAuthCallbackConfig, c as MCPClientOAuthResult, a as SSEEdgeClientTransport, b as StreamableHTTPEdgeClientTransport } from '../client-C8tswVoM.js';
+import { Connection, ConnectionContext } from 'partyserver';
+import 'cloudflare:workers';
 import '@modelcontextprotocol/sdk/client/index.js';
-import '@modelcontextprotocol/sdk/shared/protocol.js';
-import '@modelcontextprotocol/sdk/types.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';
 
-declare class SSEEdgeClientTransport extends SSEClientTransport {
-    private authProvider;
-    /**
-     * Creates a new EdgeSSEClientTransport, which overrides fetch to be compatible with the CF workers environment
-     */
-    constructor(url: URL, options: SSEClientTransportOptions);
-    authHeaders(): Promise<{
-        Authorization: string;
-    } | undefined>;
-}
-
-declare class StreamableHTTPEdgeClientTransport extends StreamableHTTPClientTransport {
-    private authProvider;
-    /**
-     * Creates a new StreamableHTTPEdgeClientTransport, which overrides fetch to be compatible with the CF workers environment
-     */
-    constructor(url: URL, options: StreamableHTTPClientTransportOptions);
-    authHeaders(): Promise<{
-        Authorization: string;
-    } | undefined>;
-}
-
-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
+    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}`.
      */
-    private _agent;
-    get mcp(): MCPClientManager;
-    protected constructor(ctx: DurableObjectState, env: Env);
-    /**
-     * Agents API allowlist
+    getTransportType(): BaseTransportType;
+    /** Read the sessionId 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;
-    onStateUpdate(state: State | undefined, source: Connection | "server"): void;
-    onStart(): Promise<void>;
-    /**
-     * McpAgent API
+    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>;
+    /** 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.
      */
-    abstract server: MaybePromise<McpServer | Server>;
-    props: Props;
-    initRun: boolean;
-    abstract init(): Promise<void>;
-    _init(props: Props): Promise<void>;
-    setInitialized(): Promise<void>;
-    isInitialized(): Promise<boolean>;
-    private _initialize;
-    fetch(request: Request): Promise<Response>;
-    getWebSocket(): WebSocket | null;
-    getWebSocketForResponseID(id: string): WebSocket | null;
-    onMessage(connection: Connection, event: WSMessage): Promise<void>;
-    onSSEMcpMessage(_sessionId: string, request: Request): 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;
-    }): {
+    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>;
     };
 }
 
-export { McpAgent, SSEEdgeClientTransport, StreamableHTTPEdgeClientTransport };
+export { McpAgent };