@mastra/mcp 0.4.1-alpha.2 → 0.4.1-alpha.4

package/dist/_tsup-dts-rollup.d.ts

@@ -5,13 +5,20 @@ import type { Protocol } from '@modelcontextprotocol/sdk/shared/protocol.js';
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import type { SSEClientTransportOptions } from '@modelcontextprotocol/sdk/client/sse.js';
 import { SSEServerTransport } from '@modelcontextprotocol/sdk/server/sse.js';
-import type { StdioServerParameters } from '@modelcontextprotocol/sdk/client/stdio.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import type { StreamableHTTPClientTransportOptions } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
 import { Tool } from '@mastra/core/tools';
 import { ToolExecutionContext } from '@mastra/core';
 import type { ToolsInput } from '@mastra/core/agent';
 import { z } from 'zod';
 
+declare type BaseServerOptions = {
+    logger?: LogHandler;
+    timeout?: number;
+    capabilities?: ClientCapabilities;
+    enableServerLogs?: boolean;
+};
+
 declare type ConvertedTool = {
     name: string;
     description?: string;
@@ -22,39 +29,26 @@ declare type ConvertedTool = {
 
 export declare function createLogger(server?: Server): Logger;
 
-export declare interface Logger {
-    info: (message: string, data?: any) => Promise<void>;
-    warning: (message: string, data?: any) => Promise<void>;
-    error: (message: string, error?: any) => Promise<void>;
-    debug: (message: string, data?: any) => Promise<void>;
-}
-
-export declare const logger: Logger;
-
-export { LoggingLevel }
-export { LoggingLevel as LoggingLevel_alias_1 }
-
-declare type LogHandler = (logMessage: LogMessage) => void;
-export { LogHandler }
-export { LogHandler as LogHandler_alias_1 }
-
-declare interface LogMessage {
-    level: LoggingLevel;
-    message: string;
-    timestamp: Date;
-    serverName: string;
-    details?: Record<string, any>;
-}
-export { LogMessage }
-export { LogMessage as LogMessage_alias_1 }
+declare type HttpServerDefinition = BaseServerOptions & {
+    url: URL;
+    command?: never;
+    args?: never;
+    env?: never;
+    requestInit?: StreamableHTTPClientTransportOptions['requestInit'];
+    eventSourceInit?: SSEClientTransportOptions['eventSourceInit'];
+    reconnectionOptions?: StreamableHTTPClientTransportOptions['reconnectionOptions'];
+    sessionId?: StreamableHTTPClientTransportOptions['sessionId'];
+};
 
-declare class MastraMCPClient extends MastraBase {
+export declare class InternalMastraMCPClient extends MastraBase {
     name: string;
-    private transport;
     private client;
     private readonly timeout;
     private logHandler?;
     private enableServerLogs?;
+    private static hasWarned;
+    private serverConfig;
+    private transport?;
     constructor({ name, version, server, capabilities, timeout, }: {
         name: string;
         server: MastraMCPServerDefinition;
@@ -70,41 +64,100 @@ declare class MastraMCPClient extends MastraBase {
      */
     private log;
     private setupLogging;
+    private connectStdio;
+    private connectHttp;
     private isConnected;
     connect(): Promise<void>;
+    /**
+     * Get the current session ID if using the Streamable HTTP transport.
+     * Returns undefined if not connected or not using Streamable HTTP.
+     */
+    get sessionId(): string | undefined;
     disconnect(): Promise<void>;
     resources(): Promise<ReturnType<Protocol<any, any, any>['request']>>;
     tools(): Promise<Record<string, any>>;
 }
+
+export declare interface Logger {
+    info: (message: string, data?: any) => Promise<void>;
+    warning: (message: string, data?: any) => Promise<void>;
+    error: (message: string, error?: any) => Promise<void>;
+    debug: (message: string, data?: any) => Promise<void>;
+}
+
+export declare const logger: Logger;
+
+export { LoggingLevel }
+export { LoggingLevel as LoggingLevel_alias_1 }
+
+declare type LogHandler = (logMessage: LogMessage) => void;
+export { LogHandler }
+export { LogHandler as LogHandler_alias_1 }
+
+declare interface LogMessage {
+    level: LoggingLevel;
+    message: string;
+    timestamp: Date;
+    serverName: string;
+    details?: Record<string, any>;
+}
+export { LogMessage }
+export { LogMessage as LogMessage_alias_1 }
+
+/**
+ * @deprecated MastraMCPClient is deprecated and will be removed in a future release. Please use MCPClient instead.
+ */
+declare const MastraMCPClient: typeof InternalMastraMCPClient;
 export { MastraMCPClient }
 export { MastraMCPClient as MastraMCPClient_alias_1 }
 
-declare type MastraMCPServerDefinition = (StdioServerParameters | SSEClientParameters) & {
-    logger?: LogHandler;
-    timeout?: number;
-    capabilities?: ClientCapabilities;
-    enableServerLogs?: boolean;
-};
+declare type MastraMCPServerDefinition = StdioServerDefinition | HttpServerDefinition;
 export { MastraMCPServerDefinition }
 export { MastraMCPServerDefinition as MastraMCPServerDefinition_alias_1 }
 
-declare class MCPConfiguration extends MastraBase {
+declare class MCPClient extends MastraBase {
     private serverConfigs;
     private id;
     private defaultTimeout;
-    constructor(args: MCPConfigurationOptions);
+    private mcpClientsById;
+    private disconnectPromise;
+    constructor(args: MCPClientOptions);
     private addToInstanceCache;
     private makeId;
     disconnect(): Promise<void>;
     getTools(): Promise<Record<string, any>>;
     getToolsets(): Promise<Record<string, Record<string, any>>>;
-    private mcpClientsById;
+    /**
+     * Get the current session IDs for all connected MCP clients using the Streamable HTTP transport.
+     * Returns an object mapping server names to their session IDs.
+     */
+    get sessionIds(): Record<string, string>;
     private getConnectedClient;
     private eachClientTools;
 }
+export { MCPClient }
+export { MCPClient as MCPClient_alias_1 }
+
+declare interface MCPClientOptions {
+    id?: string;
+    servers: Record<string, MastraMCPServerDefinition>;
+    timeout?: number;
+}
+export { MCPClientOptions }
+export { MCPClientOptions as MCPClientOptions_alias_1 }
+
+/**
+ * @deprecated MCPConfiguration is deprecated and will be removed in a future release. Use MCPClient instead.
+ */
+declare class MCPConfiguration extends MCPClient {
+    constructor(args: MCPClientOptions);
+}
 export { MCPConfiguration }
 export { MCPConfiguration as MCPConfiguration_alias_1 }
 
+/**
+ * @deprecated MCPConfigurationOptions is deprecated and will be removed in a future release. Use MCPClientOptions instead.
+ */
 declare interface MCPConfigurationOptions {
     id?: string;
     servers: Record<string, MastraMCPServerDefinition>;
@@ -228,9 +281,16 @@ export declare const server_alias_1: Server<{
     } | undefined;
 }>;
 
-declare type SSEClientParameters = {
-    url: URL;
-} & SSEClientTransportOptions;
+declare type StdioServerDefinition = BaseServerOptions & {
+    command: string;
+    args?: string[];
+    env?: Record<string, string>;
+    url?: never;
+    requestInit?: never;
+    eventSourceInit?: never;
+    reconnectionOptions?: never;
+    sessionId?: never;
+};
 
 export declare const weatherTool: Tool<z.ZodObject<{
 location: z.ZodString;

package/dist/index.cjs

@@ -6,9 +6,11 @@ var utils = require('@mastra/core/utils');
 var index_js = require('@modelcontextprotocol/sdk/client/index.js');
 var sse_js = require('@modelcontextprotocol/sdk/client/sse.js');
 var stdio_js = require('@modelcontextprotocol/sdk/client/stdio.js');
+var streamableHttp_js = require('@modelcontextprotocol/sdk/client/streamableHttp.js');
 var protocol_js = require('@modelcontextprotocol/sdk/shared/protocol.js');
 var types_js = require('@modelcontextprotocol/sdk/types.js');
 var exitHook = require('exit-hook');
+var equal = require('fast-deep-equal');
 var uuid = require('uuid');
 var core = require('@mastra/core');
 var index_js$1 = require('@modelcontextprotocol/sdk/server/index.js');
@@ -18,6 +20,8 @@ var fs = require('fs');
 var os = require('os');
 var path = require('path');
 
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
 function _interopNamespace(e) {
   if (e && e.__esModule) return e;
   var n = Object.create(null);
@@ -36,6 +40,7 @@ function _interopNamespace(e) {
   return Object.freeze(n);
 }
 
+var equal__default = /*#__PURE__*/_interopDefault(equal);
 var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
 var os__namespace = /*#__PURE__*/_interopNamespace(os);
 var path__namespace = /*#__PURE__*/_interopNamespace(path);
@@ -4117,13 +4122,15 @@ function convertLogLevelToLoggerMethod(level) {
       return "info";
   }
 }
-var MastraMCPClient = class extends base.MastraBase {
+var InternalMastraMCPClient = class _InternalMastraMCPClient extends base.MastraBase {
   name;
-  transport;
   client;
   timeout;
   logHandler;
   enableServerLogs;
+  static hasWarned = false;
+  serverConfig;
+  transport;
   constructor({
     name,
     version = "1.0.0",
@@ -4132,23 +4139,17 @@ var MastraMCPClient = class extends base.MastraBase {
     timeout = protocol_js.DEFAULT_REQUEST_TIMEOUT_MSEC
   }) {
     super({ name: "MastraMCPClient" });
+    if (!_InternalMastraMCPClient.hasWarned) {
+      console.warn(
+        "[DEPRECATION] MastraMCPClient is deprecated and will be removed in a future release. Please use MCPClient instead."
+      );
+      _InternalMastraMCPClient.hasWarned = true;
+    }
     this.name = name;
     this.timeout = timeout;
     this.logHandler = server.logger;
     this.enableServerLogs = server.enableServerLogs ?? true;
-    const { logger: logger3, enableServerLogs, ...serverConfig } = server;
-    if (`url` in serverConfig) {
-      this.transport = new sse_js.SSEClientTransport(serverConfig.url, {
-        requestInit: serverConfig.requestInit,
-        eventSourceInit: serverConfig.eventSourceInit
-      });
-    } else {
-      this.transport = new stdio_js.StdioClientTransport({
-        ...serverConfig,
-        // without ...getDefaultEnvironment() commands like npx will fail because there will be no PATH env var
-        env: { ...stdio_js.getDefaultEnvironment(), ...serverConfig.env || {} }
-      });
-    }
+    this.serverConfig = server;
     this.client = new index_js.Client(
       {
         name,
@@ -4168,11 +4169,12 @@ var MastraMCPClient = class extends base.MastraBase {
    */
   log(level, message, details) {
     const loggerMethod = convertLogLevelToLoggerMethod(level);
-    this.logger[loggerMethod](message, details);
+    const msg = `[${this.name}] ${message}`;
+    this.logger[loggerMethod](msg, details);
     if (this.logHandler) {
       this.logHandler({
         level,
-        message,
+        message: msg,
         timestamp: /* @__PURE__ */ new Date(),
         serverName: this.name,
         details
@@ -4195,44 +4197,121 @@ var MastraMCPClient = class extends base.MastraBase {
       );
     }
   }
+  async connectStdio(command) {
+    this.log("debug", `Using Stdio transport for command: ${command}`);
+    try {
+      this.transport = new stdio_js.StdioClientTransport({
+        command,
+        args: this.serverConfig.args,
+        env: { ...stdio_js.getDefaultEnvironment(), ...this.serverConfig.env || {} }
+      });
+      await this.client.connect(this.transport, { timeout: this.serverConfig.timeout ?? this.timeout });
+      this.log("debug", `Successfully connected to MCP server via Stdio`);
+    } catch (e) {
+      this.log("error", e instanceof Error ? e.stack || e.message : JSON.stringify(e));
+      throw e;
+    }
+  }
+  async connectHttp(url) {
+    const { requestInit, eventSourceInit } = this.serverConfig;
+    this.log("debug", `Attempting to connect to URL: ${url}`);
+    let shouldTrySSE = url.pathname.endsWith(`/sse`);
+    if (!shouldTrySSE) {
+      try {
+        this.log("debug", "Trying Streamable HTTP transport...");
+        const streamableTransport = new streamableHttp_js.StreamableHTTPClientTransport(url, {
+          requestInit,
+          reconnectionOptions: this.serverConfig.reconnectionOptions,
+          sessionId: this.serverConfig.sessionId
+        });
+        await this.client.connect(streamableTransport, {
+          timeout: (
+            // this is hardcoded to 3s because the long default timeout would be extremely slow for sse backwards compat (60s)
+            3e3
+          )
+        });
+        this.transport = streamableTransport;
+        this.log("debug", "Successfully connected using Streamable HTTP transport.");
+      } catch (error) {
+        this.log("debug", `Streamable HTTP transport failed: ${error}`);
+        shouldTrySSE = true;
+      }
+    }
+    if (shouldTrySSE) {
+      this.log("debug", "Falling back to deprecated HTTP+SSE transport...");
+      try {
+        const sseTransport = new sse_js.SSEClientTransport(url, { requestInit, eventSourceInit });
+        await this.client.connect(sseTransport, { timeout: this.serverConfig.timeout ?? this.timeout });
+        this.transport = sseTransport;
+        this.log("debug", "Successfully connected using deprecated HTTP+SSE transport.");
+      } catch (sseError) {
+        this.log(
+          "error",
+          `Failed to connect with SSE transport after failing to connect to Streamable HTTP transport first. SSE error: ${sseError}`
+        );
+        throw new Error("Could not connect to server with any available HTTP transport");
+      }
+    }
+  }
   isConnected = false;
   async connect() {
     if (this.isConnected) return;
+    const { command, url } = this.serverConfig;
+    if (command) {
+      await this.connectStdio(command);
+    } else if (url) {
+      await this.connectHttp(url);
+    } else {
+      throw new Error("Server configuration must include either a command or a url.");
+    }
+    this.isConnected = true;
+    const originalOnClose = this.client.onclose;
+    this.client.onclose = () => {
+      this.log("debug", `MCP server connection closed`);
+      this.isConnected = false;
+      if (typeof originalOnClose === `function`) {
+        originalOnClose();
+      }
+    };
+    exitHook.asyncExitHook(
+      async () => {
+        this.log("debug", `Disconnecting MCP server during exit`);
+        await this.disconnect();
+      },
+      { wait: 5e3 }
+    );
+    process.on("SIGTERM", () => exitHook.gracefulExit());
+    this.log("debug", `Successfully connected to MCP server`);
+  }
+  /**
+   * Get the current session ID if using the Streamable HTTP transport.
+   * Returns undefined if not connected or not using Streamable HTTP.
+   */
+  get sessionId() {
+    if (this.transport instanceof streamableHttp_js.StreamableHTTPClientTransport) {
+      return this.transport.sessionId;
+    }
+    return void 0;
+  }
+  async disconnect() {
+    if (!this.transport) {
+      this.log("debug", "Disconnect called but no transport was connected.");
+      return;
+    }
+    this.log("debug", `Disconnecting from MCP server`);
     try {
-      this.log("debug", `Connecting to MCP server`);
-      await this.client.connect(this.transport, {
-        timeout: this.timeout
-      });
-      this.isConnected = true;
-      const originalOnClose = this.client.onclose;
-      this.client.onclose = () => {
-        this.log("debug", `MCP server connection closed`);
-        this.isConnected = false;
-        if (typeof originalOnClose === `function`) {
-          originalOnClose();
-        }
-      };
-      exitHook.asyncExitHook(
-        async () => {
-          this.log("debug", `Disconnecting MCP server during exit`);
-          await this.disconnect();
-        },
-        { wait: 5e3 }
-      );
-      process.on("SIGTERM", () => exitHook.gracefulExit());
-      this.log("info", `Successfully connected to MCP server`);
+      await this.transport.close();
+      this.log("debug", "Successfully disconnected from MCP server");
     } catch (e) {
-      this.log("error", `Failed connecting to MCP server`, {
+      this.log("error", "Error during MCP server disconnect", {
         error: e instanceof Error ? e.stack : JSON.stringify(e, null, 2)
       });
-      this.isConnected = false;
       throw e;
+    } finally {
+      this.transport = void 0;
+      this.isConnected = false;
     }
   }
-  async disconnect() {
-    this.log("debug", `Disconnecting from MCP server`);
-    return await this.client.close();
-  }
   // TODO: do the type magic to return the right method type. Right now we get infinitely deep infered type errors from Zod without using "any"
   async resources() {
     this.log("debug", `Requesting resources from MCP server`);
@@ -4282,48 +4361,74 @@ var MastraMCPClient = class extends base.MastraBase {
     return toolsRes;
   }
 };
-var mastraMCPConfigurationInstances = /* @__PURE__ */ new Map();
-var MCPConfiguration = class extends base.MastraBase {
+var MastraMCPClient = InternalMastraMCPClient;
+var mcpClientInstances = /* @__PURE__ */ new Map();
+var MCPClient = class extends base.MastraBase {
   serverConfigs = {};
   id;
   defaultTimeout;
+  mcpClientsById = /* @__PURE__ */ new Map();
+  disconnectPromise = null;
   constructor(args) {
-    super({ name: "MCPConfiguration" });
+    super({ name: "MCPClient" });
     this.defaultTimeout = args.timeout ?? protocol_js.DEFAULT_REQUEST_TIMEOUT_MSEC;
     this.serverConfigs = args.servers;
     this.id = args.id ?? this.makeId();
-    const existingInstance = mastraMCPConfigurationInstances.get(this.id);
+    if (args.id) {
+      this.id = args.id;
+      const cached = mcpClientInstances.get(this.id);
+      if (cached && !equal__default.default(cached.serverConfigs, args.servers)) {
+        const existingInstance2 = mcpClientInstances.get(this.id);
+        if (existingInstance2) {
+          void existingInstance2.disconnect();
+        }
+      }
+    } else {
+      this.id = this.makeId();
+    }
+    const existingInstance = mcpClientInstances.get(this.id);
     if (existingInstance) {
       if (!args.id) {
-        throw new Error(`MCPConfiguration was initialized multiple times with the same configuration options.
+        throw new Error(`MCPClient was initialized multiple times with the same configuration options.
 
 This error is intended to prevent memory leaks.
 
 To fix this you have three different options:
-1. If you need multiple MCPConfiguration class instances with identical server configurations, set an id when configuring: new MCPConfiguration({ id: "my-unique-id" })
-2. Call "await configuration.disconnect()" after you're done using the configuration and before you recreate another instance with the same options. If the identical MCPConfiguration instance is already closed at the time of re-creating it, you will not see this error.
-3. If you only need one instance of MCPConfiguration in your app, refactor your code so it's only created one time (ex. move it out of a loop into a higher scope code block)
+1. If you need multiple MCPClient class instances with identical server configurations, set an id when configuring: new MCPClient({ id: "my-unique-id" })
+2. Call "await client.disconnect()" after you're done using the client and before you recreate another instance with the same options. If the identical MCPClient instance is already closed at the time of re-creating it, you will not see this error.
+3. If you only need one instance of MCPClient in your app, refactor your code so it's only created one time (ex. move it out of a loop into a higher scope code block)
 `);
       }
       return existingInstance;
     }
+    mcpClientInstances.set(this.id, this);
     this.addToInstanceCache();
     return this;
   }
   addToInstanceCache() {
-    if (!mastraMCPConfigurationInstances.has(this.id)) {
-      mastraMCPConfigurationInstances.set(this.id, this);
+    if (!mcpClientInstances.has(this.id)) {
+      mcpClientInstances.set(this.id, this);
     }
   }
   makeId() {
     const text = JSON.stringify(this.serverConfigs).normalize("NFKC");
-    const idNamespace = uuid.v5(`MCPConfiguration`, uuid.v5.DNS);
+    const idNamespace = uuid.v5(`MCPClient`, uuid.v5.DNS);
     return uuid.v5(text, idNamespace);
   }
   async disconnect() {
-    mastraMCPConfigurationInstances.delete(this.id);
-    await Promise.all(Array.from(this.mcpClientsById.values()).map((client) => client.disconnect()));
-    this.mcpClientsById.clear();
+    if (this.disconnectPromise) {
+      return this.disconnectPromise;
+    }
+    this.disconnectPromise = (async () => {
+      try {
+        mcpClientInstances.delete(this.id);
+        await Promise.all(Array.from(this.mcpClientsById.values()).map((client) => client.disconnect()));
+        this.mcpClientsById.clear();
+      } finally {
+        this.disconnectPromise = null;
+      }
+    })();
+    return this.disconnectPromise;
   }
   async getTools() {
     this.addToInstanceCache();
@@ -4345,16 +4450,34 @@ To fix this you have three different options:
     });
     return connectedToolsets;
   }
-  mcpClientsById = /* @__PURE__ */ new Map();
+  /**
+   * Get the current session IDs for all connected MCP clients using the Streamable HTTP transport.
+   * Returns an object mapping server names to their session IDs.
+   */
+  get sessionIds() {
+    const sessionIds = {};
+    for (const [serverName, client] of this.mcpClientsById.entries()) {
+      if (client.sessionId) {
+        sessionIds[serverName] = client.sessionId;
+      }
+    }
+    return sessionIds;
+  }
   async getConnectedClient(name, config) {
+    if (this.disconnectPromise) {
+      await this.disconnectPromise;
+    }
     const exists = this.mcpClientsById.has(name);
+    const existingClient = this.mcpClientsById.get(name);
     if (exists) {
-      const mcpClient2 = this.mcpClientsById.get(name);
-      await mcpClient2.connect();
-      return mcpClient2;
+      if (!existingClient) {
+        throw new Error(`Client ${name} exists but is undefined`);
+      }
+      await existingClient.connect();
+      return existingClient;
     }
     this.logger.debug(`Connecting to ${name} MCP server`);
-    const mcpClient = new MastraMCPClient({
+    const mcpClient = new InternalMastraMCPClient({
       name,
       server: config,
       timeout: config.timeout ?? this.defaultTimeout
@@ -4364,10 +4487,12 @@ To fix this you have three different options:
       await mcpClient.connect();
     } catch (e) {
       this.mcpClientsById.delete(name);
-      this.logger.error(`MCPConfiguration errored connecting to MCP server ${name}`, {
+      this.logger.error(`MCPClient errored connecting to MCP server ${name}`, {
         error: e instanceof Error ? e.message : String(e)
       });
-      throw new Error(`Failed to connect to MCP server ${name}: ${e instanceof Error ? e.message : String(e)}`);
+      throw new Error(
+        `Failed to connect to MCP server ${name}: ${e instanceof Error ? e.stack || e.message : String(e)}`
+      );
     }
     this.logger.debug(`Connected to ${name} MCP server`);
     return mcpClient;
@@ -4382,6 +4507,14 @@ To fix this you have three different options:
     );
   }
 };
+var MCPConfiguration = class extends MCPClient {
+  constructor(args) {
+    super(args);
+    this.logger.warn(
+      `MCPConfiguration has been renamed to MCPClient and MCPConfiguration is deprecated. The API is identical but the MCPConfiguration export will be removed in the future. Update your imports now to prevent future errors.`
+    );
+  }
+};
 
 // ../../node_modules/.pnpm/json-schema-to-zod@2.6.0/node_modules/json-schema-to-zod/dist/esm/parsers/parseAnyOf.js
 var parseAnyOf = (schema, refs) => {
@@ -6502,6 +6635,7 @@ var MCPServer = class {
   }
 };
 
+exports.MCPClient = MCPClient;
 exports.MCPConfiguration = MCPConfiguration;
 exports.MCPServer = MCPServer;
 exports.MastraMCPClient = MastraMCPClient;

package/dist/index.d.cts

@@ -3,6 +3,8 @@ export { LogMessage_alias_1 as LogMessage } from './_tsup-dts-rollup.cjs';
 export { LogHandler_alias_1 as LogHandler } from './_tsup-dts-rollup.cjs';
 export { MastraMCPServerDefinition_alias_1 as MastraMCPServerDefinition } from './_tsup-dts-rollup.cjs';
 export { MastraMCPClient_alias_1 as MastraMCPClient } from './_tsup-dts-rollup.cjs';
+export { MCPClientOptions_alias_1 as MCPClientOptions } from './_tsup-dts-rollup.cjs';
+export { MCPClient_alias_1 as MCPClient } from './_tsup-dts-rollup.cjs';
 export { MCPConfigurationOptions_alias_1 as MCPConfigurationOptions } from './_tsup-dts-rollup.cjs';
 export { MCPConfiguration_alias_1 as MCPConfiguration } from './_tsup-dts-rollup.cjs';
 export { MCPServer } from './_tsup-dts-rollup.cjs';

package/dist/index.d.ts

@@ -3,6 +3,8 @@ export { LogMessage_alias_1 as LogMessage } from './_tsup-dts-rollup.js';
 export { LogHandler_alias_1 as LogHandler } from './_tsup-dts-rollup.js';
 export { MastraMCPServerDefinition_alias_1 as MastraMCPServerDefinition } from './_tsup-dts-rollup.js';
 export { MastraMCPClient_alias_1 as MastraMCPClient } from './_tsup-dts-rollup.js';
+export { MCPClientOptions_alias_1 as MCPClientOptions } from './_tsup-dts-rollup.js';
+export { MCPClient_alias_1 as MCPClient } from './_tsup-dts-rollup.js';
 export { MCPConfigurationOptions_alias_1 as MCPConfigurationOptions } from './_tsup-dts-rollup.js';
 export { MCPConfiguration_alias_1 as MCPConfiguration } from './_tsup-dts-rollup.js';
 export { MCPServer } from './_tsup-dts-rollup.js';