agents 0.0.0-6de101a → 0.0.0-6e0420c

package/dist/mcp/client.js

@@ -1,786 +1,3 @@
-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 { MCPClientManager, getNamespacedData } from "../client-WbaRgKYN.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);
-    }
-  }
-  /**
-   * 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.
-   */
-  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"
-        }
-      }).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
-    };
-    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;
-      }
-      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 }
-        };
-      }
-      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 : {};
-  }
-  /**
-   * Registers new capabilities. This can only be called before connecting to a transport.
-   *
-   * The new capabilities will be merged with any existing capabilities previously given (e.g., at initialization).
-   */
-  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);
-    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}`);
-      }
-      if (!SUPPORTED_PROTOCOL_VERSIONS.includes(result.protocolVersion)) {
-        throw new Error(`Server's protocol version is not supported: ${result.protocolVersion}`);
-      }
-      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;
-    }
-  }
-  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.serverCapabilities = await this.client.getServerCapabilities();
-    if (!this.serverCapabilities) {
-      throw new Error(
-        `The MCP Server ${this.info.name} failed to return server capabilities`
-      );
-    }
-    const [instructions, tools, resources, prompts, resourceTemplates] = await Promise.all([
-      this.client.getInstructions(),
-      this.registerTools(),
-      this.registerResources(),
-      this.registerPrompts(),
-      this.registerResourceTemplates()
-    ]);
-    this.instructions = instructions;
-    this.tools = tools;
-    this.resources = resources;
-    this.prompts = prompts;
-    this.resourceTemplates = resourceTemplates;
-  }
-  /**
-   * Notification handler registration
-   */
-  async registerTools() {
-    if (!this.serverCapabilities || !this.serverCapabilities.tools) {
-      return [];
-    }
-    if (this.serverCapabilities.tools.listChanged) {
-      this.client.setNotificationHandler(
-        ToolListChangedNotificationSchema,
-        async (_notification) => {
-          this.tools = await this.fetchTools();
-        }
-      );
-    }
-    return this.fetchTools();
-  }
-  async registerResources() {
-    if (!this.serverCapabilities || !this.serverCapabilities.resources) {
-      return [];
-    }
-    if (this.serverCapabilities.resources.listChanged) {
-      this.client.setNotificationHandler(
-        ResourceListChangedNotificationSchema,
-        async (_notification) => {
-          this.resources = await this.fetchResources();
-        }
-      );
-    }
-    return this.fetchResources();
-  }
-  async registerPrompts() {
-    if (!this.serverCapabilities || !this.serverCapabilities.prompts) {
-      return [];
-    }
-    if (this.serverCapabilities.prompts.listChanged) {
-      this.client.setNotificationHandler(
-        PromptListChangedNotificationSchema,
-        async (_notification) => {
-          this.prompts = await this.fetchPrompts();
-        }
-      );
-    }
-    return this.fetchPrompts();
-  }
-  async registerResourceTemplates() {
-    if (!this.serverCapabilities || !this.serverCapabilities.resources) {
-      return [];
-    }
-    return this.fetchResourceTemplates();
-  }
-  async fetchTools() {
-    let toolsAgg = [];
-    let toolsResult = { tools: [] };
-    do {
-      toolsResult = await this.client.listTools({
-        cursor: toolsResult.nextCursor
-      });
-      toolsAgg = toolsAgg.concat(toolsResult.tools);
-    } while (toolsResult.nextCursor);
-    return toolsAgg;
-  }
-  async fetchResources() {
-    let resourcesAgg = [];
-    let resourcesResult = { resources: [] };
-    do {
-      resourcesResult = await this.client.listResources({
-        cursor: resourcesResult.nextCursor
-      });
-      resourcesAgg = resourcesAgg.concat(resourcesResult.resources);
-    } while (resourcesResult.nextCursor);
-    return resourcesAgg;
-  }
-  async fetchPrompts() {
-    let promptsAgg = [];
-    let promptsResult = { prompts: [] };
-    do {
-      promptsResult = await this.client.listPrompts({
-        cursor: promptsResult.nextCursor
-      });
-      promptsAgg = promptsAgg.concat(promptsResult.prompts);
-    } while (promptsResult.nextCursor);
-    return promptsAgg;
-  }
-  async fetchResourceTemplates() {
-    let templatesAgg = [];
-    let templatesResult = {
-      resourceTemplates: []
-    };
-    do {
-      templatesResult = await this.client.listResourceTemplates({
-        cursor: templatesResult.nextCursor
-      });
-      templatesAgg = templatesAgg.concat(templatesResult.resourceTemplates);
-    } while (templatesResult.nextCursor);
-    return templatesAgg;
-  }
-};
-
-// src/mcp/client.ts
-var MCPClientManager = class {
-  mcpConnections = {};
-  /**
-   * Connect to and register an MCP server
-   *
-   * @param transportConfig Transport config
-   * @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) {
-      throw new Error(
-        `An existing MCP client has already been registered under the name "${info.name}". The MCP client name must be unique.`
-      );
-    }
-    this.mcpConnections[info.name] = new MCPClientConnection(url, info, opts);
-    await this.mcpConnections[info.name].init();
-  }
-  /**
-   * @returns namespaced list of tools
-   */
-  listTools() {
-    return getNamespacedData(this.mcpConnections, "tools");
-  }
-  /**
-   * @returns namespaced list of prompts
-   */
-  listPrompts() {
-    return getNamespacedData(this.mcpConnections, "prompts");
-  }
-  /**
-   * @returns namespaced list of tools
-   */
-  listResources() {
-    return getNamespacedData(this.mcpConnections, "resources");
-  }
-  /**
-   * @returns namespaced list of resource templates
-   */
-  listResourceTemplates() {
-    return getNamespacedData(this.mcpConnections, "resourceTemplates");
-  }
-  /**
-   * Namespaced version of callTool
-   */
-  callTool(params, resultSchema, options) {
-    const unqualifiedName = params.name.replace(`${params.serverName}.`, "");
-    return this.mcpConnections[params.serverName].client.callTool(
-      {
-        ...params,
-        name: unqualifiedName
-      },
-      resultSchema,
-      options
-    );
-  }
-  /**
-   * Namespaced version of readResource
-   */
-  readResource(params, options) {
-    return this.mcpConnections[params.serverName].client.readResource(
-      params,
-      options
-    );
-  }
-  /**
-   * Namespaced version of getPrompt
-   */
-  getPrompt(params, options) {
-    return this.mcpConnections[params.serverName].client.getPrompt(
-      params,
-      options
-    );
-  }
-};
-function getNamespacedData(mcpClients, type) {
-  const sets = Object.entries(mcpClients).map(([name, conn]) => {
-    return { name, data: conn[type] };
-  });
-  const namespacedData = sets.flatMap(({ name: serverName, 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}`
-      };
-    });
-  });
-  return namespacedData;
-}
-export {
-  MCPClientManager,
-  getNamespacedData
-};
-//# sourceMappingURL=client.js.map
+export { MCPClientManager, getNamespacedData };