agents 0.0.0-9ae8ee3 → 0.0.0-9beccdd

package/dist/mcp/client.js

@@ -1,7 +1,7 @@
 import {
   MCPClientManager,
   getNamespacedData
-} from "../chunk-UNG3FXYX.js";
+} from "../chunk-VYENMKFS.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,6 @@
 import {
   DurableObjectOAuthClientProvider
-} from "../chunk-PVQZBKN7.js";
+} from "../chunk-LL2AFX7V.js";
 export {
   DurableObjectOAuthClientProvider
 };

package/dist/mcp/index.d.ts

@@ -1,41 +1,21 @@
-import { MCPClientManager } from './client.js';
+import { M as MCPClientManager } from '../client-CcIORE73.js';
+export { S as SSEEdgeClientTransport, a as StreamableHTTPEdgeClientTransport } from '../client-CcIORE73.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';
+export { ElicitRequest, ElicitRequestSchema, ElicitResult } from '@modelcontextprotocol/sdk/types.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 '@modelcontextprotocol/sdk/client/index.js';
 import '@modelcontextprotocol/sdk/shared/protocol.js';
-import '@modelcontextprotocol/sdk/types.js';
 import 'ai';
+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;
@@ -63,6 +43,13 @@ declare abstract class McpAgent<Env = unknown, State = unknown, Props extends Re
     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
+     */
+    elicitInput(params: {
+        message: string;
+        requestedSchema: unknown;
+    }): Promise<ElicitResult>;
     onStateUpdate(state: State | undefined, source: Connection | "server"): void;
     onStart(): Promise<void>;
     /**
@@ -72,15 +59,33 @@ declare abstract class McpAgent<Env = unknown, State = unknown, Props extends Re
     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>;
-    onSSEMcpMessage(_sessionId: string, request: Request): Promise<Error | null>;
+    /**
+     * Wait for elicitation response through storage polling
+     */
+    private _waitForElicitationResponse;
+    /**
+     * 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>;
@@ -104,4 +109,4 @@ declare abstract class McpAgent<Env = unknown, State = unknown, Props extends Re
     };
 }
 
-export { McpAgent, SSEEdgeClientTransport, StreamableHTTPEdgeClientTransport };
+export { McpAgent };

package/dist/mcp/index.js

@@ -1,12 +1,13 @@
 import {
   Agent
-} from "../chunk-3IQQY2UH.js";
+} from "../chunk-PNF6ZMUA.js";
 import {
   SSEEdgeClientTransport,
   StreamableHTTPEdgeClientTransport
-} from "../chunk-UNG3FXYX.js";
-import "../chunk-PVQZBKN7.js";
-import "../chunk-KUH345EY.js";
+} from "../chunk-VYENMKFS.js";
+import "../chunk-LL2AFX7V.js";
+import "../chunk-QEVM4BVL.js";
+import "../chunk-AVYJQSLW.js";
 
 // src/mcp/index.ts
 import { DurableObject } from "cloudflare:workers";
@@ -18,6 +19,9 @@ import {
   isJSONRPCRequest,
   isJSONRPCResponse
 } from "@modelcontextprotocol/sdk/types.js";
+import {
+  ElicitRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
 var MAXIMUM_MESSAGE_SIZE_BYTES = 4 * 1024 * 1024;
 function corsHeaders(_request, corsOptions = {}) {
   const origin = "*";
@@ -144,6 +148,45 @@ var McpAgent = class _McpAgent extends DurableObject {
   setState(state) {
     return this._agent.setState(state);
   }
+  /**
+   * Elicit user input with a message and schema
+   */
+  async elicitInput(params) {
+    const requestId = `elicit_${Math.random().toString(36).substring(2, 11)}`;
+    await this.ctx.storage.put(`elicitation:${requestId}`, {
+      message: params.message,
+      requestedSchema: params.requestedSchema,
+      timestamp: Date.now()
+    });
+    const elicitRequest = {
+      jsonrpc: "2.0",
+      id: requestId,
+      method: "elicitation/create",
+      params: {
+        message: params.message,
+        requestedSchema: params.requestedSchema
+      }
+    };
+    if (this._transport) {
+      await this._transport.send(elicitRequest);
+    } else {
+      const connections = this._agent?.getConnections();
+      if (!connections || Array.from(connections).length === 0) {
+        await this.ctx.storage.delete(`elicitation:${requestId}`);
+        throw new Error("No active connections available for elicitation");
+      }
+      const connectionList = Array.from(connections);
+      for (const connection of connectionList) {
+        try {
+          connection.send(JSON.stringify(elicitRequest));
+        } catch (error) {
+          console.error("Failed to send elicitation request:", error);
+        }
+      }
+    }
+    return this._waitForElicitationResponse(requestId);
+  }
+  // we leave the variables as unused for autocomplete purposes
   // biome-ignore lint/correctness/noUnusedFunctionParameters: overriden later
   onStateUpdate(state, source) {
   }
@@ -181,15 +224,32 @@ var McpAgent = class _McpAgent extends DurableObject {
       await server.connect(this._transport);
     }
   }
+  /**
+   * 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) {
+    console.error("McpAgent error:", error);
+    return {
+      status: 500,
+      message: error.message || "An unexpected error occurred during initialization"
+    };
+  }
   async _init(props) {
-    await this.ctx.storage.put("props", props ?? {});
+    await this.updateProps(props);
     if (!this.ctx.storage.get("transportType")) {
       await this.ctx.storage.put("transportType", "unset");
     }
-    this.props = props;
     if (!this.initRun) {
       this.initRun = true;
-      await this.init();
+      try {
+        await this.init();
+      } catch (error) {
+        const errorResponse = this.onError(error);
+        throw new Error(`Initialization failed: ${errorResponse.message}`);
+      }
     }
   }
   async setInitialized() {
@@ -198,6 +258,10 @@ var McpAgent = class _McpAgent extends DurableObject {
   async isInitialized() {
     return await this.ctx.storage.get("initialized") === true;
   }
+  async updateProps(props) {
+    await this.ctx.storage.put("props", props ?? {});
+    this.props = props;
+  }
   async _initialize() {
     await this.ctx.blockConcurrencyWhile(async () => {
       this._status = "starting";
@@ -284,14 +348,78 @@ var McpAgent = class _McpAgent extends DurableObject {
       this._transport?.onerror?.(error);
       return;
     }
+    if (await this._handleElicitationResponse(message)) {
+      return;
+    }
     if (isJSONRPCRequest(message)) {
       this._requestIdToConnectionId.set(message.id.toString(), connection.id);
     }
     this._transport?.onmessage?.(message);
   }
+  /**
+   * Wait for elicitation response through storage polling
+   */
+  async _waitForElicitationResponse(requestId) {
+    const startTime = Date.now();
+    const timeout = 6e4;
+    try {
+      while (Date.now() - startTime < timeout) {
+        const response = await this.ctx.storage.get(
+          `elicitation:response:${requestId}`
+        );
+        if (response) {
+          await this.ctx.storage.delete(`elicitation:${requestId}`);
+          await this.ctx.storage.delete(`elicitation:response:${requestId}`);
+          return response;
+        }
+        await new Promise((resolve) => setTimeout(resolve, 100));
+      }
+      throw new Error("Elicitation request timed out");
+    } finally {
+      await this.ctx.storage.delete(`elicitation:${requestId}`);
+      await this.ctx.storage.delete(`elicitation:response:${requestId}`);
+    }
+  }
+  /**
+   * Handle elicitation responses   */
+  async _handleElicitationResponse(message) {
+    if (isJSONRPCResponse(message) && message.result) {
+      const requestId = message.id?.toString();
+      if (!requestId || !requestId.startsWith("elicit_")) return false;
+      const pendingRequest = await this.ctx.storage.get(
+        `elicitation:${requestId}`
+      );
+      if (!pendingRequest) return false;
+      await this.ctx.storage.put(
+        `elicitation:response:${requestId}`,
+        message.result
+      );
+      return true;
+    }
+    if (isJSONRPCError(message)) {
+      const requestId = message.id?.toString();
+      if (!requestId || !requestId.startsWith("elicit_")) return false;
+      const pendingRequest = await this.ctx.storage.get(
+        `elicitation:${requestId}`
+      );
+      if (!pendingRequest) return false;
+      const errorResult = {
+        action: "cancel",
+        content: {
+          error: message.error.message || "Elicitation request failed"
+        }
+      };
+      await this.ctx.storage.put(
+        `elicitation:response:${requestId}`,
+        errorResult
+      );
+      return true;
+    }
+    return false;
+  }
   // All messages received over SSE after the initial connection has been established
   // will be passed here
-  async onSSEMcpMessage(_sessionId, request) {
+  async onSSEMcpMessage(_sessionId, messageBody) {
     if (this._status !== "started") {
       await this._initialize();
     }
@@ -299,14 +427,16 @@ var McpAgent = class _McpAgent extends DurableObject {
       return new Error("Internal Server Error: Expected SSE protocol");
     }
     try {
-      const message = await request.json();
       let parsedMessage;
       try {
-        parsedMessage = JSONRPCMessageSchema.parse(message);
+        parsedMessage = JSONRPCMessageSchema.parse(messageBody);
       } catch (error) {
         this._transport?.onerror?.(error);
         throw error;
       }
+      if (await this._handleElicitationResponse(parsedMessage)) {
+        return null;
+      }
       this._transport?.onmessage?.(parsedMessage);
       return null;
     } catch (error) {
@@ -383,7 +513,16 @@ data: ${relativeUrlWithSession}
           writer.write(encoder.encode(endpointMessage));
           const id = namespace.idFromName(`sse:${sessionId}`);
           const doStub = namespace.get(id);
-          await doStub._init(ctx.props);
+          try {
+            await doStub._init(ctx.props);
+          } catch (error) {
+            console.error("Failed to initialize McpAgent:", error);
+            await writer.close();
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            return new Response(`Initialization failed: ${errorMessage}`, {
+              status: 500
+            });
+          }
           const upgradeUrl = new URL(request.url);
           upgradeUrl.pathname = "/sse";
           const existingHeaders = {};
@@ -484,7 +623,9 @@ data: ${JSON.stringify(result.data)}
           }
           const id = namespace.idFromName(`sse:${sessionId}`);
           const doStub = namespace.get(id);
-          const error = await doStub.onSSEMcpMessage(sessionId, request);
+          const messageBody = await request.json();
+          await doStub.updateProps(ctx.props);
+          const error = await doStub.onSSEMcpMessage(sessionId, messageBody);
           if (error) {
             return new Response(error.message, {
               headers: {
@@ -654,8 +795,22 @@ data: ${JSON.stringify(result.data)}
           const doStub = namespace.get(id);
           const isInitialized = await doStub.isInitialized();
           if (isInitializationRequest) {
-            await doStub._init(ctx.props);
-            await doStub.setInitialized();
+            try {
+              await doStub._init(ctx.props);
+              await doStub.setInitialized();
+            } catch (error) {
+              console.error("Failed to initialize McpAgent:", error);
+              const errorMessage = error instanceof Error ? error.message : String(error);
+              const body2 = JSON.stringify({
+                error: {
+                  code: -32001,
+                  message: `Initialization failed: ${errorMessage}`
+                },
+                id: null,
+                jsonrpc: "2.0"
+              });
+              return new Response(body2, { status: 500 });
+            }
           } else if (!isInitialized) {
             const body2 = JSON.stringify({
               error: {
@@ -666,6 +821,8 @@ data: ${JSON.stringify(result.data)}
               jsonrpc: "2.0"
             });
             return new Response(body2, { status: 404 });
+          } else {
+            await doStub.updateProps(ctx.props);
           }
           const { readable, writable } = new TransformStream();
           const writer = writable.getWriter();
@@ -791,6 +948,7 @@ data: ${JSON.stringify(result.data)}
   }
 };
 export {
+  ElicitRequestSchema,
   McpAgent,
   SSEEdgeClientTransport,
   StreamableHTTPEdgeClientTransport