agents 0.0.0-74a8c74 → 0.0.0-7b22285

package/dist/mcp/client.js

@@ -1,577 +1,93 @@
-import {
-  CallToolResultSchema,
-  CancelledNotificationSchema,
-  CompleteResultSchema,
-  EmptyResultSchema,
-  ErrorCode,
-  GetPromptResultSchema,
-  InitializeResultSchema,
-  LATEST_PROTOCOL_VERSION,
-  ListPromptsResultSchema,
-  ListResourceTemplatesResultSchema,
-  ListResourcesResultSchema,
-  ListToolsResultSchema,
-  McpError,
-  PingRequestSchema,
-  ProgressNotificationSchema,
-  PromptListChangedNotificationSchema,
-  ReadResourceResultSchema,
-  ResourceListChangedNotificationSchema,
-  SSEEdgeClientTransport,
-  SUPPORTED_PROTOCOL_VERSIONS,
-  ToolListChangedNotificationSchema
-} from "../chunk-EZ76ZGDB.js";
+import "../chunk-HMLY7DHA.js";
 
-// ../../node_modules/@modelcontextprotocol/sdk/dist/esm/shared/protocol.js
-var DEFAULT_REQUEST_TIMEOUT_MSEC = 6e4;
-var Protocol = class {
-  constructor(_options) {
-    this._options = _options;
-    this._requestMessageId = 0;
-    this._requestHandlers = /* @__PURE__ */ new Map();
-    this._requestHandlerAbortControllers = /* @__PURE__ */ new Map();
-    this._notificationHandlers = /* @__PURE__ */ new Map();
-    this._responseHandlers = /* @__PURE__ */ new Map();
-    this._progressHandlers = /* @__PURE__ */ new Map();
-    this._timeoutInfo = /* @__PURE__ */ new Map();
-    this.setNotificationHandler(CancelledNotificationSchema, (notification) => {
-      const controller = this._requestHandlerAbortControllers.get(notification.params.requestId);
-      controller === null || controller === void 0 ? void 0 : controller.abort(notification.params.reason);
-    });
-    this.setNotificationHandler(ProgressNotificationSchema, (notification) => {
-      this._onprogress(notification);
-    });
-    this.setRequestHandler(
-      PingRequestSchema,
-      // Automatic pong by default.
-      (_request) => ({})
-    );
-  }
-  _setupTimeout(messageId, timeout, maxTotalTimeout, onTimeout) {
-    this._timeoutInfo.set(messageId, {
-      timeoutId: setTimeout(onTimeout, timeout),
-      startTime: Date.now(),
-      timeout,
-      maxTotalTimeout,
-      onTimeout
-    });
-  }
-  _resetTimeout(messageId) {
-    const info = this._timeoutInfo.get(messageId);
-    if (!info)
-      return false;
-    const totalElapsed = Date.now() - info.startTime;
-    if (info.maxTotalTimeout && totalElapsed >= info.maxTotalTimeout) {
-      this._timeoutInfo.delete(messageId);
-      throw new McpError(ErrorCode.RequestTimeout, "Maximum total timeout exceeded", { maxTotalTimeout: info.maxTotalTimeout, totalElapsed });
-    }
-    clearTimeout(info.timeoutId);
-    info.timeoutId = setTimeout(info.onTimeout, info.timeout);
-    return true;
-  }
-  _cleanupTimeout(messageId) {
-    const info = this._timeoutInfo.get(messageId);
-    if (info) {
-      clearTimeout(info.timeoutId);
-      this._timeoutInfo.delete(messageId);
-    }
-  }
+// src/mcp/sse-edge.ts
+import {
+  SSEClientTransport
+} from "@modelcontextprotocol/sdk/client/sse.js";
+var SSEEdgeClientTransport = class extends SSEClientTransport {
   /**
-   * Attaches to the given transport, starts it, and starts listening for messages.
-   *
-   * The Protocol object assumes ownership of the Transport, replacing any callbacks that have already been set, and expects that it is the only user of the Transport instance going forward.
+   * Creates a new EdgeSSEClientTransport, which overrides fetch to be compatible with the CF workers environment
    */
-  async connect(transport) {
-    this._transport = transport;
-    this._transport.onclose = () => {
-      this._onclose();
-    };
-    this._transport.onerror = (error) => {
-      this._onerror(error);
-    };
-    this._transport.onmessage = (message) => {
-      if (!("method" in message)) {
-        this._onresponse(message);
-      } else if ("id" in message) {
-        this._onrequest(message);
-      } else {
-        this._onnotification(message);
-      }
-    };
-    await this._transport.start();
-  }
-  _onclose() {
-    var _a;
-    const responseHandlers = this._responseHandlers;
-    this._responseHandlers = /* @__PURE__ */ new Map();
-    this._progressHandlers.clear();
-    this._transport = void 0;
-    (_a = this.onclose) === null || _a === void 0 ? void 0 : _a.call(this);
-    const error = new McpError(ErrorCode.ConnectionClosed, "Connection closed");
-    for (const handler of responseHandlers.values()) {
-      handler(error);
-    }
-  }
-  _onerror(error) {
-    var _a;
-    (_a = this.onerror) === null || _a === void 0 ? void 0 : _a.call(this, error);
-  }
-  _onnotification(notification) {
-    var _a;
-    const handler = (_a = this._notificationHandlers.get(notification.method)) !== null && _a !== void 0 ? _a : this.fallbackNotificationHandler;
-    if (handler === void 0) {
-      return;
-    }
-    Promise.resolve().then(() => handler(notification)).catch((error) => this._onerror(new Error(`Uncaught error in notification handler: ${error}`)));
-  }
-  _onrequest(request) {
-    var _a, _b, _c;
-    const handler = (_a = this._requestHandlers.get(request.method)) !== null && _a !== void 0 ? _a : this.fallbackRequestHandler;
-    if (handler === void 0) {
-      (_b = this._transport) === null || _b === void 0 ? void 0 : _b.send({
-        jsonrpc: "2.0",
-        id: request.id,
-        error: {
-          code: ErrorCode.MethodNotFound,
-          message: "Method not found"
+  constructor(url, options) {
+    const fetchOverride = async (fetchUrl, fetchInit = {}) => {
+      const headers = await this.authHeaders();
+      const workerOptions = {
+        ...fetchInit,
+        headers: {
+          ...fetchInit?.headers,
+          ...headers
         }
-      }).catch((error) => this._onerror(new Error(`Failed to send an error response: ${error}`)));
-      return;
-    }
-    const abortController = new AbortController();
-    this._requestHandlerAbortControllers.set(request.id, abortController);
-    const extra = {
-      signal: abortController.signal,
-      sessionId: (_c = this._transport) === null || _c === void 0 ? void 0 : _c.sessionId
+      };
+      delete workerOptions.mode;
+      return fetch(fetchUrl, workerOptions);
     };
-    Promise.resolve().then(() => handler(request, extra)).then((result) => {
-      var _a2;
-      if (abortController.signal.aborted) {
-        return;
-      }
-      return (_a2 = this._transport) === null || _a2 === void 0 ? void 0 : _a2.send({
-        result,
-        jsonrpc: "2.0",
-        id: request.id
-      });
-    }, (error) => {
-      var _a2, _b2;
-      if (abortController.signal.aborted) {
-        return;
+    super(url, {
+      ...options,
+      eventSourceInit: {
+        fetch: fetchOverride
       }
-      return (_a2 = this._transport) === null || _a2 === void 0 ? void 0 : _a2.send({
-        jsonrpc: "2.0",
-        id: request.id,
-        error: {
-          code: Number.isSafeInteger(error["code"]) ? error["code"] : ErrorCode.InternalError,
-          message: (_b2 = error.message) !== null && _b2 !== void 0 ? _b2 : "Internal error"
-        }
-      });
-    }).catch((error) => this._onerror(new Error(`Failed to send response: ${error}`))).finally(() => {
-      this._requestHandlerAbortControllers.delete(request.id);
     });
-  }
-  _onprogress(notification) {
-    const { progressToken, ...params } = notification.params;
-    const messageId = Number(progressToken);
-    const handler = this._progressHandlers.get(messageId);
-    if (!handler) {
-      this._onerror(new Error(`Received a progress notification for an unknown token: ${JSON.stringify(notification)}`));
-      return;
-    }
-    const responseHandler = this._responseHandlers.get(messageId);
-    if (this._timeoutInfo.has(messageId) && responseHandler) {
-      try {
-        this._resetTimeout(messageId);
-      } catch (error) {
-        responseHandler(error);
-        return;
-      }
-    }
-    handler(params);
-  }
-  _onresponse(response) {
-    const messageId = Number(response.id);
-    const handler = this._responseHandlers.get(messageId);
-    if (handler === void 0) {
-      this._onerror(new Error(`Received a response for an unknown message ID: ${JSON.stringify(response)}`));
-      return;
-    }
-    this._responseHandlers.delete(messageId);
-    this._progressHandlers.delete(messageId);
-    this._cleanupTimeout(messageId);
-    if ("result" in response) {
-      handler(response);
-    } else {
-      const error = new McpError(response.error.code, response.error.message, response.error.data);
-      handler(error);
-    }
-  }
-  get transport() {
-    return this._transport;
-  }
-  /**
-   * Closes the connection.
-   */
-  async close() {
-    var _a;
-    await ((_a = this._transport) === null || _a === void 0 ? void 0 : _a.close());
-  }
-  /**
-   * Sends a request and wait for a response.
-   *
-   * Do not use this method to emit notifications! Use notification() instead.
-   */
-  request(request, resultSchema, options) {
-    return new Promise((resolve, reject) => {
-      var _a, _b, _c, _d;
-      if (!this._transport) {
-        reject(new Error("Not connected"));
-        return;
-      }
-      if (((_a = this._options) === null || _a === void 0 ? void 0 : _a.enforceStrictCapabilities) === true) {
-        this.assertCapabilityForMethod(request.method);
-      }
-      (_b = options === null || options === void 0 ? void 0 : options.signal) === null || _b === void 0 ? void 0 : _b.throwIfAborted();
-      const messageId = this._requestMessageId++;
-      const jsonrpcRequest = {
-        ...request,
-        jsonrpc: "2.0",
-        id: messageId
-      };
-      if (options === null || options === void 0 ? void 0 : options.onprogress) {
-        this._progressHandlers.set(messageId, options.onprogress);
-        jsonrpcRequest.params = {
-          ...request.params,
-          _meta: { progressToken: messageId }
+    this.authProvider = options.authProvider;
+  }
+  async authHeaders() {
+    if (this.authProvider) {
+      const tokens = await this.authProvider.tokens();
+      if (tokens) {
+        return {
+          Authorization: `Bearer ${tokens.access_token}`
         };
       }
-      const cancel = (reason) => {
-        var _a2;
-        this._responseHandlers.delete(messageId);
-        this._progressHandlers.delete(messageId);
-        this._cleanupTimeout(messageId);
-        (_a2 = this._transport) === null || _a2 === void 0 ? void 0 : _a2.send({
-          jsonrpc: "2.0",
-          method: "notifications/cancelled",
-          params: {
-            requestId: messageId,
-            reason: String(reason)
-          }
-        }).catch((error) => this._onerror(new Error(`Failed to send cancellation: ${error}`)));
-        reject(reason);
-      };
-      this._responseHandlers.set(messageId, (response) => {
-        var _a2;
-        if ((_a2 = options === null || options === void 0 ? void 0 : options.signal) === null || _a2 === void 0 ? void 0 : _a2.aborted) {
-          return;
-        }
-        if (response instanceof Error) {
-          return reject(response);
-        }
-        try {
-          const result = resultSchema.parse(response.result);
-          resolve(result);
-        } catch (error) {
-          reject(error);
-        }
-      });
-      (_c = options === null || options === void 0 ? void 0 : options.signal) === null || _c === void 0 ? void 0 : _c.addEventListener("abort", () => {
-        var _a2;
-        cancel((_a2 = options === null || options === void 0 ? void 0 : options.signal) === null || _a2 === void 0 ? void 0 : _a2.reason);
-      });
-      const timeout = (_d = options === null || options === void 0 ? void 0 : options.timeout) !== null && _d !== void 0 ? _d : DEFAULT_REQUEST_TIMEOUT_MSEC;
-      const timeoutHandler = () => cancel(new McpError(ErrorCode.RequestTimeout, "Request timed out", { timeout }));
-      this._setupTimeout(messageId, timeout, options === null || options === void 0 ? void 0 : options.maxTotalTimeout, timeoutHandler);
-      this._transport.send(jsonrpcRequest).catch((error) => {
-        this._cleanupTimeout(messageId);
-        reject(error);
-      });
-    });
-  }
-  /**
-   * Emits a notification, which is a one-way message that does not expect a response.
-   */
-  async notification(notification) {
-    if (!this._transport) {
-      throw new Error("Not connected");
     }
-    this.assertNotificationCapability(notification.method);
-    const jsonrpcNotification = {
-      ...notification,
-      jsonrpc: "2.0"
-    };
-    await this._transport.send(jsonrpcNotification);
-  }
-  /**
-   * Registers a handler to invoke when this protocol object receives a request with the given method.
-   *
-   * Note that this will replace any previous request handler for the same method.
-   */
-  setRequestHandler(requestSchema, handler) {
-    const method = requestSchema.shape.method.value;
-    this.assertRequestHandlerCapability(method);
-    this._requestHandlers.set(method, (request, extra) => Promise.resolve(handler(requestSchema.parse(request), extra)));
-  }
-  /**
-   * Removes the request handler for the given method.
-   */
-  removeRequestHandler(method) {
-    this._requestHandlers.delete(method);
-  }
-  /**
-   * Asserts that a request handler has not already been set for the given method, in preparation for a new one being automatically installed.
-   */
-  assertCanSetRequestHandler(method) {
-    if (this._requestHandlers.has(method)) {
-      throw new Error(`A request handler for ${method} already exists, which would be overridden`);
-    }
-  }
-  /**
-   * Registers a handler to invoke when this protocol object receives a notification with the given method.
-   *
-   * Note that this will replace any previous notification handler for the same method.
-   */
-  setNotificationHandler(notificationSchema, handler) {
-    this._notificationHandlers.set(notificationSchema.shape.method.value, (notification) => Promise.resolve(handler(notificationSchema.parse(notification))));
-  }
-  /**
-   * Removes the notification handler for the given method.
-   */
-  removeNotificationHandler(method) {
-    this._notificationHandlers.delete(method);
   }
 };
-function mergeCapabilities(base, additional) {
-  return Object.entries(additional).reduce((acc, [key, value]) => {
-    if (value && typeof value === "object") {
-      acc[key] = acc[key] ? { ...acc[key], ...value } : value;
-    } else {
-      acc[key] = value;
-    }
-    return acc;
-  }, { ...base });
-}
 
-// ../../node_modules/@modelcontextprotocol/sdk/dist/esm/client/index.js
-var Client = class extends Protocol {
-  /**
-   * Initializes this client with the given name and version information.
-   */
-  constructor(_clientInfo, options) {
-    var _a;
-    super(options);
-    this._clientInfo = _clientInfo;
-    this._capabilities = (_a = options === null || options === void 0 ? void 0 : options.capabilities) !== null && _a !== void 0 ? _a : {};
+// src/mcp/client-connection.ts
+import {
+  ToolListChangedNotificationSchema,
+  ResourceListChangedNotificationSchema,
+  PromptListChangedNotificationSchema
+} from "@modelcontextprotocol/sdk/types.js";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+var MCPClientConnection = class {
+  constructor(url, info, options = { transport: {}, client: {}, capabilities: {} }) {
+    this.url = url;
+    this.options = options;
+    this.connectionState = "connecting";
+    this.tools = [];
+    this.prompts = [];
+    this.resources = [];
+    this.resourceTemplates = [];
+    this.client = new Client(info, options.client);
+    this.client.registerCapabilities(options.capabilities);
   }
   /**
-   * Registers new capabilities. This can only be called before connecting to a transport.
+   * Initialize a client connection
    *
-   * The new capabilities will be merged with any existing capabilities previously given (e.g., at initialization).
+   * @param code Optional OAuth code to initialize the connection with if auth hasn't been initialized
+   * @returns
    */
-  registerCapabilities(capabilities) {
-    if (this.transport) {
-      throw new Error("Cannot register capabilities after connecting to transport");
-    }
-    this._capabilities = mergeCapabilities(this._capabilities, capabilities);
-  }
-  assertCapability(capability, method) {
-    var _a;
-    if (!((_a = this._serverCapabilities) === null || _a === void 0 ? void 0 : _a[capability])) {
-      throw new Error(`Server does not support ${capability} (required for ${method})`);
-    }
-  }
-  async connect(transport) {
-    await super.connect(transport);
+  async init(code, clientId) {
     try {
-      const result = await this.request({
-        method: "initialize",
-        params: {
-          protocolVersion: LATEST_PROTOCOL_VERSION,
-          capabilities: this._capabilities,
-          clientInfo: this._clientInfo
-        }
-      }, InitializeResultSchema);
-      if (result === void 0) {
-        throw new Error(`Server sent invalid initialize result: ${result}`);
+      const transport = new SSEEdgeClientTransport(
+        this.url,
+        this.options.transport
+      );
+      if (code) {
+        await transport.finishAuth(code);
       }
-      if (!SUPPORTED_PROTOCOL_VERSIONS.includes(result.protocolVersion)) {
-        throw new Error(`Server's protocol version is not supported: ${result.protocolVersion}`);
+      await this.client.connect(transport);
+    } catch (e) {
+      if (e.toString().includes("Unauthorized")) {
+        this.connectionState = "authenticating";
+        return;
       }
-      this._serverCapabilities = result.capabilities;
-      this._serverVersion = result.serverInfo;
-      this._instructions = result.instructions;
-      await this.notification({
-        method: "notifications/initialized"
-      });
-    } catch (error) {
-      void this.close();
-      throw error;
-    }
-  }
-  /**
-   * After initialization has completed, this will be populated with the server's reported capabilities.
-   */
-  getServerCapabilities() {
-    return this._serverCapabilities;
-  }
-  /**
-   * After initialization has completed, this will be populated with information about the server's name and version.
-   */
-  getServerVersion() {
-    return this._serverVersion;
-  }
-  /**
-   * After initialization has completed, this may be populated with information about the server's instructions.
-   */
-  getInstructions() {
-    return this._instructions;
-  }
-  assertCapabilityForMethod(method) {
-    var _a, _b, _c, _d, _e;
-    switch (method) {
-      case "logging/setLevel":
-        if (!((_a = this._serverCapabilities) === null || _a === void 0 ? void 0 : _a.logging)) {
-          throw new Error(`Server does not support logging (required for ${method})`);
-        }
-        break;
-      case "prompts/get":
-      case "prompts/list":
-        if (!((_b = this._serverCapabilities) === null || _b === void 0 ? void 0 : _b.prompts)) {
-          throw new Error(`Server does not support prompts (required for ${method})`);
-        }
-        break;
-      case "resources/list":
-      case "resources/templates/list":
-      case "resources/read":
-      case "resources/subscribe":
-      case "resources/unsubscribe":
-        if (!((_c = this._serverCapabilities) === null || _c === void 0 ? void 0 : _c.resources)) {
-          throw new Error(`Server does not support resources (required for ${method})`);
-        }
-        if (method === "resources/subscribe" && !this._serverCapabilities.resources.subscribe) {
-          throw new Error(`Server does not support resource subscriptions (required for ${method})`);
-        }
-        break;
-      case "tools/call":
-      case "tools/list":
-        if (!((_d = this._serverCapabilities) === null || _d === void 0 ? void 0 : _d.tools)) {
-          throw new Error(`Server does not support tools (required for ${method})`);
-        }
-        break;
-      case "completion/complete":
-        if (!((_e = this._serverCapabilities) === null || _e === void 0 ? void 0 : _e.prompts)) {
-          throw new Error(`Server does not support prompts (required for ${method})`);
-        }
-        break;
-      case "initialize":
-        break;
-      case "ping":
-        break;
-    }
-  }
-  assertNotificationCapability(method) {
-    var _a;
-    switch (method) {
-      case "notifications/roots/list_changed":
-        if (!((_a = this._capabilities.roots) === null || _a === void 0 ? void 0 : _a.listChanged)) {
-          throw new Error(`Client does not support roots list changed notifications (required for ${method})`);
-        }
-        break;
-      case "notifications/initialized":
-        break;
-      case "notifications/cancelled":
-        break;
-      case "notifications/progress":
-        break;
-    }
-  }
-  assertRequestHandlerCapability(method) {
-    switch (method) {
-      case "sampling/createMessage":
-        if (!this._capabilities.sampling) {
-          throw new Error(`Client does not support sampling capability (required for ${method})`);
-        }
-        break;
-      case "roots/list":
-        if (!this._capabilities.roots) {
-          throw new Error(`Client does not support roots capability (required for ${method})`);
-        }
-        break;
-      case "ping":
-        break;
+      this.connectionState = "failed";
+      throw e;
     }
-  }
-  async ping(options) {
-    return this.request({ method: "ping" }, EmptyResultSchema, options);
-  }
-  async complete(params, options) {
-    return this.request({ method: "completion/complete", params }, CompleteResultSchema, options);
-  }
-  async setLoggingLevel(level, options) {
-    return this.request({ method: "logging/setLevel", params: { level } }, EmptyResultSchema, options);
-  }
-  async getPrompt(params, options) {
-    return this.request({ method: "prompts/get", params }, GetPromptResultSchema, options);
-  }
-  async listPrompts(params, options) {
-    return this.request({ method: "prompts/list", params }, ListPromptsResultSchema, options);
-  }
-  async listResources(params, options) {
-    return this.request({ method: "resources/list", params }, ListResourcesResultSchema, options);
-  }
-  async listResourceTemplates(params, options) {
-    return this.request({ method: "resources/templates/list", params }, ListResourceTemplatesResultSchema, options);
-  }
-  async readResource(params, options) {
-    return this.request({ method: "resources/read", params }, ReadResourceResultSchema, options);
-  }
-  async subscribeResource(params, options) {
-    return this.request({ method: "resources/subscribe", params }, EmptyResultSchema, options);
-  }
-  async unsubscribeResource(params, options) {
-    return this.request({ method: "resources/unsubscribe", params }, EmptyResultSchema, options);
-  }
-  async callTool(params, resultSchema = CallToolResultSchema, options) {
-    return this.request({ method: "tools/call", params }, resultSchema, options);
-  }
-  async listTools(params, options) {
-    return this.request({ method: "tools/list", params }, ListToolsResultSchema, options);
-  }
-  async sendRootsListChanged() {
-    return this.notification({ method: "notifications/roots/list_changed" });
-  }
-};
-
-// src/mcp/client-connection.ts
-var MCPClientConnection = class {
-  constructor(url, info, opts = { transport: {}, client: {}, capabilities: {} }) {
-    this.info = info;
-    this.transport = new SSEEdgeClientTransport(url, opts.transport);
-    this.client = new Client(info, opts.client);
-    this.client.registerCapabilities(opts.capabilities);
-    this.connected = false;
-    this.tools = [];
-    this.prompts = [];
-    this.resources = [];
-    this.resourceTemplates = [];
-  }
-  client;
-  transport;
-  connected;
-  instructions;
-  tools;
-  prompts;
-  resources;
-  resourceTemplates;
-  serverCapabilities;
-  async init() {
-    await this.client.connect(this.transport);
+    this.connectionState = "discovering";
     this.serverCapabilities = await this.client.getServerCapabilities();
     if (!this.serverCapabilities) {
-      throw new Error(
-        `The MCP Server ${this.info.name} failed to return server capabilities`
-      );
+      throw new Error("The MCP Server failed to return server capabilities");
     }
     const [instructions, tools, resources, prompts, resourceTemplates] = await Promise.all([
       this.client.getInstructions(),
@@ -585,6 +101,7 @@ var MCPClientConnection = class {
     this.resources = resources;
     this.prompts = prompts;
     this.resourceTemplates = resourceTemplates;
+    this.connectionState = "ready";
   }
   /**
    * Notification handler registration
@@ -643,7 +160,7 @@ var MCPClientConnection = class {
     do {
       toolsResult = await this.client.listTools({
         cursor: toolsResult.nextCursor
-      });
+      }).catch(capabilityErrorHandler({ tools: [] }, "tools/list"));
       toolsAgg = toolsAgg.concat(toolsResult.tools);
     } while (toolsResult.nextCursor);
     return toolsAgg;
@@ -654,7 +171,7 @@ var MCPClientConnection = class {
     do {
       resourcesResult = await this.client.listResources({
         cursor: resourcesResult.nextCursor
-      });
+      }).catch(capabilityErrorHandler({ resources: [] }, "resources/list"));
       resourcesAgg = resourcesAgg.concat(resourcesResult.resources);
     } while (resourcesResult.nextCursor);
     return resourcesAgg;
@@ -665,7 +182,7 @@ var MCPClientConnection = class {
     do {
       promptsResult = await this.client.listPrompts({
         cursor: promptsResult.nextCursor
-      });
+      }).catch(capabilityErrorHandler({ prompts: [] }, "prompts/list"));
       promptsAgg = promptsAgg.concat(promptsResult.prompts);
     } while (promptsResult.nextCursor);
     return promptsAgg;
@@ -678,16 +195,42 @@ var MCPClientConnection = class {
     do {
       templatesResult = await this.client.listResourceTemplates({
         cursor: templatesResult.nextCursor
-      });
+      }).catch(
+        capabilityErrorHandler(
+          { resourceTemplates: [] },
+          "resources/templates/list"
+        )
+      );
       templatesAgg = templatesAgg.concat(templatesResult.resourceTemplates);
     } while (templatesResult.nextCursor);
     return templatesAgg;
   }
 };
+function capabilityErrorHandler(empty, method) {
+  return (e) => {
+    if (e.code === -32601) {
+      console.error(
+        `The server advertised support for the capability ${method.split("/")[0]}, but returned "Method not found" for '${method}'.`
+      );
+      return empty;
+    }
+    throw e;
+  };
+}
 
 // src/mcp/client.ts
 var MCPClientManager = class {
-  mcpConnections = {};
+  /**
+   * @param name Name of the MCP client
+   * @param version Version of the MCP Client
+   * @param auth Auth paramters if being used to create a DurableObjectOAuthClientProvider
+   */
+  constructor(name, version) {
+    this.name = name;
+    this.version = version;
+    this.mcpConnections = {};
+    this.callbackUrls = [];
+  }
   /**
    * Connect to and register an MCP server
    *
@@ -695,14 +238,96 @@ var MCPClientManager = class {
    * @param clientConfig Client config
    * @param capabilities Client capabilities (i.e. if the client supports roots/sampling)
    */
-  async connectToServer(url, info, opts = { transport: {}, client: {}, capabilities: {} }) {
-    if (info.name in this.mcpConnections) {
+  async connect(url, options = {}) {
+    const id = options.reconnect?.id ?? crypto.randomUUID();
+    if (!options.transport?.authProvider) {
+      console.warn(
+        "No authProvider provided in the transport options. This client will only support unauthenticated remote MCP Servers"
+      );
+    } else {
+      options.transport.authProvider.serverId = id;
+    }
+    this.mcpConnections[id] = new MCPClientConnection(
+      new URL(url),
+      {
+        name: this.name,
+        version: this.version
+      },
+      {
+        transport: options.transport ?? {},
+        client: options.client ?? {},
+        capabilities: options.client ?? {}
+      }
+    );
+    await this.mcpConnections[id].init(
+      options.reconnect?.oauthCode,
+      options.reconnect?.oauthClientId
+    );
+    const authUrl = options.transport?.authProvider?.authUrl;
+    if (authUrl && options.transport?.authProvider?.redirectUrl) {
+      this.callbackUrls.push(
+        options.transport.authProvider.redirectUrl.toString()
+      );
+    }
+    return {
+      id,
+      authUrl
+    };
+  }
+  isCallbackRequest(req) {
+    return req.method === "GET" && !!this.callbackUrls.find((url) => {
+      return req.url.startsWith(url);
+    });
+  }
+  async handleCallbackRequest(req) {
+    const url = new URL(req.url);
+    const urlMatch = this.callbackUrls.find((url2) => {
+      return req.url.startsWith(url2);
+    });
+    if (!urlMatch) {
+      throw new Error(
+        `No callback URI match found for the request url: ${req.url}. Was the request matched with \`isCallbackRequest()\`?`
+      );
+    }
+    const code = url.searchParams.get("code");
+    const clientId = url.searchParams.get("state");
+    const urlParams = urlMatch.split("/");
+    const serverId = urlParams[urlParams.length - 1];
+    if (!code) {
+      throw new Error("Unauthorized: no code provided");
+    }
+    if (!clientId) {
+      throw new Error("Unauthorized: no state provided");
+    }
+    if (this.mcpConnections[serverId] === void 0) {
+      throw new Error(`Could not find serverId: ${serverId}`);
+    }
+    if (this.mcpConnections[serverId].connectionState !== "authenticating") {
       throw new Error(
-        `An existing MCP client has already been registered under the name "${info.name}". The MCP client name must be unique.`
+        "Failed to authenticate: the client isn't in the `authenticating` state"
       );
     }
-    this.mcpConnections[info.name] = new MCPClientConnection(url, info, opts);
-    await this.mcpConnections[info.name].init();
+    const conn = this.mcpConnections[serverId];
+    if (!conn.options.transport.authProvider) {
+      throw new Error(
+        "Trying to finalize authentication for a server connection without an authProvider"
+      );
+    }
+    conn.options.transport.authProvider.clientId = clientId;
+    conn.options.transport.authProvider.serverId = serverId;
+    const serverUrl = conn.url.toString();
+    await this.connect(serverUrl, {
+      reconnect: {
+        id: serverId,
+        oauthClientId: clientId,
+        oauthCode: code
+      },
+      ...conn.options
+    });
+    if (this.mcpConnections[serverId].connectionState === "authenticating") {
+      throw new Error("Failed to authenticate: client failed to initialize");
+    }
+    return { serverId };
   }
   /**
    * @returns namespaced list of tools
@@ -732,8 +357,8 @@ var MCPClientManager = class {
    * Namespaced version of callTool
    */
   callTool(params, resultSchema, options) {
-    const unqualifiedName = params.name.replace(`${params.serverName}.`, "");
-    return this.mcpConnections[params.serverName].client.callTool(
+    const unqualifiedName = params.name.replace(`${params.serverId}.`, "");
+    return this.mcpConnections[params.serverId].client.callTool(
       {
         ...params,
         name: unqualifiedName
@@ -746,7 +371,7 @@ var MCPClientManager = class {
    * Namespaced version of readResource
    */
   readResource(params, options) {
-    return this.mcpConnections[params.serverName].client.readResource(
+    return this.mcpConnections[params.serverId].client.readResource(
       params,
       options
     );
@@ -755,7 +380,7 @@ var MCPClientManager = class {
    * Namespaced version of getPrompt
    */
   getPrompt(params, options) {
-    return this.mcpConnections[params.serverName].client.getPrompt(
+    return this.mcpConnections[params.serverId].client.getPrompt(
       params,
       options
     );
@@ -765,15 +390,12 @@ function getNamespacedData(mcpClients, type) {
   const sets = Object.entries(mcpClients).map(([name, conn]) => {
     return { name, data: conn[type] };
   });
-  const namespacedData = sets.flatMap(({ name: serverName, data }) => {
+  const namespacedData = sets.flatMap(({ name: serverId, data }) => {
     return data.map((item) => {
       return {
         ...item,
-        // we add a servername so we can easily pull it out and convert between qualified<->unqualified name
-        // just in case the server name or item name includes a "."
-        serverName: `${serverName}`,
-        // qualified name
-        name: `${serverName}.${item.name}`
+        // we add a serverId so we can easily pull it out and send the tool call to the right server
+        serverId
       };
     });
   });