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

package/dist/index.cjs

@@ -6,6 +6,7 @@ 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');
@@ -4119,11 +4120,12 @@ function convertLogLevelToLoggerMethod(level) {
 }
 var MastraMCPClient = class extends base.MastraBase {
   name;
-  transport;
   client;
   timeout;
   logHandler;
   enableServerLogs;
+  serverConfig;
+  transport;
   constructor({
     name,
     version = "1.0.0",
@@ -4136,19 +4138,7 @@ var MastraMCPClient = class extends base.MastraBase {
     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 +4158,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 +4186,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`);
@@ -4345,6 +4413,19 @@ To fix this you have three different options:
     });
     return connectedToolsets;
   }
+  /**
+   * 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;
+  }
   mcpClientsById = /* @__PURE__ */ new Map();
   async getConnectedClient(name, config) {
     const exists = this.mcpClientsById.has(name);
@@ -4367,7 +4448,9 @@ To fix this you have three different options:
       this.logger.error(`MCPConfiguration 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;

package/dist/index.js

@@ -4,6 +4,7 @@ import { jsonSchemaToModel } from '@mastra/core/utils';
 import { Client } from '@modelcontextprotocol/sdk/client/index.js';
 import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js';
 import { StdioClientTransport, getDefaultEnvironment } from '@modelcontextprotocol/sdk/client/stdio.js';
+import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
 import { DEFAULT_REQUEST_TIMEOUT_MSEC } from '@modelcontextprotocol/sdk/shared/protocol.js';
 import { ListResourcesResultSchema, CallToolResultSchema, ListToolsRequestSchema, CallToolRequestSchema } from '@modelcontextprotocol/sdk/types.js';
 import { asyncExitHook, gracefulExit } from 'exit-hook';
@@ -4095,11 +4096,12 @@ function convertLogLevelToLoggerMethod(level) {
 }
 var MastraMCPClient = class extends MastraBase {
   name;
-  transport;
   client;
   timeout;
   logHandler;
   enableServerLogs;
+  serverConfig;
+  transport;
   constructor({
     name,
     version = "1.0.0",
@@ -4112,19 +4114,7 @@ var MastraMCPClient = class extends MastraBase {
     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 SSEClientTransport(serverConfig.url, {
-        requestInit: serverConfig.requestInit,
-        eventSourceInit: serverConfig.eventSourceInit
-      });
-    } else {
-      this.transport = new StdioClientTransport({
-        ...serverConfig,
-        // without ...getDefaultEnvironment() commands like npx will fail because there will be no PATH env var
-        env: { ...getDefaultEnvironment(), ...serverConfig.env || {} }
-      });
-    }
+    this.serverConfig = server;
     this.client = new Client(
       {
         name,
@@ -4144,11 +4134,12 @@ var MastraMCPClient = class extends 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
@@ -4171,44 +4162,121 @@ var MastraMCPClient = class extends MastraBase {
       );
     }
   }
+  async connectStdio(command) {
+    this.log("debug", `Using Stdio transport for command: ${command}`);
+    try {
+      this.transport = new StdioClientTransport({
+        command,
+        args: this.serverConfig.args,
+        env: { ...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 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 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();
+      }
+    };
+    asyncExitHook(
+      async () => {
+        this.log("debug", `Disconnecting MCP server during exit`);
+        await this.disconnect();
+      },
+      { wait: 5e3 }
+    );
+    process.on("SIGTERM", () => 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 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();
-        }
-      };
-      asyncExitHook(
-        async () => {
-          this.log("debug", `Disconnecting MCP server during exit`);
-          await this.disconnect();
-        },
-        { wait: 5e3 }
-      );
-      process.on("SIGTERM", () => 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`);
@@ -4321,6 +4389,19 @@ To fix this you have three different options:
     });
     return connectedToolsets;
   }
+  /**
+   * 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;
+  }
   mcpClientsById = /* @__PURE__ */ new Map();
   async getConnectedClient(name, config) {
     const exists = this.mcpClientsById.has(name);
@@ -4343,7 +4424,9 @@ To fix this you have three different options:
       this.logger.error(`MCPConfiguration 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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/mcp",
-  "version": "0.4.1-alpha.2",
+  "version": "0.4.1-alpha.3",
   "description": "",
   "type": "module",
   "main": "dist/index.js",
@@ -22,11 +22,11 @@
   "author": "",
   "license": "Elastic-2.0",
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.9.0",
+    "@modelcontextprotocol/sdk": "^1.10.2",
     "date-fns": "^4.1.0",
     "exit-hook": "^4.0.0",
     "uuid": "^11.1.0",
-    "@mastra/core": "^0.9.1-alpha.2"
+    "@mastra/core": "^0.9.1-alpha.3"
   },
   "devDependencies": {
     "@ai-sdk/anthropic": "^1.1.15",

package/src/client.test.ts

@@ -1,49 +1,137 @@
-import { anthropic } from '@ai-sdk/anthropic';
-import { Agent } from '@mastra/core/agent';
-import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { randomUUID } from 'node:crypto';
+import { createServer } from 'node:http';
+import type { Server as HttpServer } from 'node:http';
+import type { AddressInfo } from 'node:net';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { z } from 'zod';
 
 import { MastraMCPClient } from './client.js';
 
-const everArtClient = new MastraMCPClient({
-  name: 'everart',
-  server: {
-    command: '/usr/local/bin/docker',
-    args: ['run', '-i', '--rm', '--network=host', '-e', 'EVERART_API_KEY', 'mcp/everart'],
-    env: {
-      EVERART_API_KEY: process.env.EVERART_API_KEY!,
+async function setupTestServer(withSessionManagement: boolean) {
+  const httpServer: HttpServer = createServer();
+  const mcpServer = new McpServer(
+    { name: 'test-http-server', version: '1.0.0' },
+    {
+      capabilities: {
+        logging: {},
+        tools: {},
+      },
     },
-  },
-});
+  );
 
-const agent = new Agent({
-  name: 'everart',
-  instructions: 'You are my artist. Include the url in your response.',
-  model: anthropic('claude-3-5-sonnet-20241022'),
-});
+  mcpServer.tool(
+    'greet',
+    'A simple greeting tool',
+    {
+      name: z.string().describe('Name to greet').default('World'),
+    },
+    async ({ name }): Promise<CallToolResult> => {
+      return {
+        content: [{ type: 'text', text: `Hello, ${name}!` }],
+      };
+    },
+  );
 
-describe.skip('MastraMCPClient', () => {
-  beforeAll(async () => {
-    await everArtClient.connect();
+  const serverTransport = new StreamableHTTPServerTransport({
+    sessionIdGenerator: withSessionManagement ? () => randomUUID() : undefined,
   });
 
-  afterAll(async () => {
-    await everArtClient.disconnect();
+  await mcpServer.connect(serverTransport);
+
+  httpServer.on('request', async (req, res) => {
+    await serverTransport.handleRequest(req, res);
   });
 
-  it('Converting tools into Mastra', async () => {
-    const list = await everArtClient.resources();
+  const baseUrl = await new Promise<URL>(resolve => {
+    httpServer.listen(0, '127.0.0.1', () => {
+      const addr = httpServer.address() as AddressInfo;
+      resolve(new URL(`http://127.0.0.1:${addr.port}/mcp`));
+    });
+  });
 
-    expect(list.resources.length).toBeGreaterThan(0);
+  return { httpServer, mcpServer, serverTransport, baseUrl };
+}
 
-    // The MCP server tools are now available to your Mastra Agents
-    const tools = await everArtClient.tools();
+describe('MastraMCPClient with Streamable HTTP', () => {
+  let testServer: {
+    httpServer: HttpServer;
+    mcpServer: McpServer;
+    serverTransport: StreamableHTTPServerTransport;
+    baseUrl: URL;
+  };
+  let client: MastraMCPClient;
 
-    await agent.generate('Can you make me a picture of a dog?', {
-      toolsets: {
-        everart: tools,
-      },
+  describe('Stateless Mode', () => {
+    beforeEach(async () => {
+      testServer = await setupTestServer(false);
+      client = new MastraMCPClient({
+        name: 'test-stateless-client',
+        server: {
+          url: testServer.baseUrl,
+        },
+      });
+      await client.connect();
+    });
+
+    afterEach(async () => {
+      await client?.disconnect().catch(() => {});
+      await testServer?.mcpServer.close().catch(() => {});
+      await testServer?.serverTransport.close().catch(() => {});
+      testServer?.httpServer.close();
+    });
+
+    it('should connect and list tools', async () => {
+      const tools = await client.tools();
+      expect(tools).toHaveProperty('greet');
+      expect(tools.greet.description).toBe('A simple greeting tool');
     });
 
-    expect(Object.keys(tools).length).toBeGreaterThan(0);
-  }, 50000);
+    it('should call a tool', async () => {
+      const tools = await client.tools();
+      const result = await tools.greet.execute({ context: { name: 'Stateless' } });
+      expect(result).toEqual({ content: [{ type: 'text', text: 'Hello, Stateless!' }] });
+    });
+  });
+
+  describe('Stateful Mode', () => {
+    beforeEach(async () => {
+      testServer = await setupTestServer(true);
+      client = new MastraMCPClient({
+        name: 'test-stateful-client',
+        server: {
+          url: testServer.baseUrl,
+        },
+      });
+      await client.connect();
+    });
+
+    afterEach(async () => {
+      await client?.disconnect().catch(() => {});
+      await testServer?.mcpServer.close().catch(() => {});
+      await testServer?.serverTransport.close().catch(() => {});
+      testServer?.httpServer.close();
+    });
+
+    it('should connect and list tools', async () => {
+      const tools = await client.tools();
+      expect(tools).toHaveProperty('greet');
+    });
+
+    it('should capture the session ID after connecting', async () => {
+      // The setupTestServer(true) is configured for stateful mode
+      // The client should capture the session ID from the server's response
+      expect(client.sessionId).toBeDefined();
+      expect(typeof client.sessionId).toBe('string');
+      expect(client.sessionId?.length).toBeGreaterThan(0);
+    });
+
+    it('should call a tool', async () => {
+      const tools = await client.tools();
+      const result = await tools.greet.execute({ context: { name: 'Stateful' } });
+      expect(result).toEqual({ content: [{ type: 'text', text: 'Hello, Stateful!' }] });
+    });
+  });
 });