@mastra/mcp 1.0.1 → 1.0.2-alpha.0

package/dist/docs/references/reference-tools-mcp-client.md

@@ -60,7 +60,7 @@ Each server in the `servers` map is configured using the `MastraMCPServerDefinit
 Retrieves all tools from all configured servers, with tool names namespaced by their server name (in the format `serverName_toolName`) to prevent conflicts. Intended to be passed onto an Agent definition.
 
 ```ts
-new Agent({ id: "agent", tools: await mcp.listTools() });
+new Agent({ id: 'agent', tools: await mcp.listTools() })
 ```
 
 ### listToolsets()
@@ -70,7 +70,7 @@ Returns an object mapping namespaced tool names (in the format `serverName.toolN
 ```typescript
 const res = await agent.stream(prompt, {
   toolsets: await mcp.listToolsets(),
-});
+})
 ```
 
 ### disconnect()
@@ -88,11 +88,11 @@ The `MCPClient` instance has a `resources` property that provides access to reso
 ```typescript
 const mcpClient = new MCPClient({
   /* ...servers configuration... */
-});
+})
 
 // Access resource methods via mcpClient.resources
-const allResourcesByServer = await mcpClient.resources.list();
-const templatesByServer = await mcpClient.resources.templates();
+const allResourcesByServer = await mcpClient.resources.list()
+const templatesByServer = await mcpClient.resources.templates()
 // ... and so on for other resource methods.
 ```
 
@@ -107,9 +107,9 @@ async list(): Promise<Record<string, Resource[]>>
 Example:
 
 ```typescript
-const resourcesByServer = await mcpClient.resources.list();
+const resourcesByServer = await mcpClient.resources.list()
 for (const serverName in resourcesByServer) {
-  console.log(`Resources from ${serverName}:`, resourcesByServer[serverName]);
+  console.log(`Resources from ${serverName}:`, resourcesByServer[serverName])
 }
 ```
 
@@ -124,9 +124,9 @@ async templates(): Promise<Record<string, ResourceTemplate[]>>
 Example:
 
 ```typescript
-const templatesByServer = await mcpClient.resources.templates();
+const templatesByServer = await mcpClient.resources.templates()
 for (const serverName in templatesByServer) {
-  console.log(`Templates from ${serverName}:`, templatesByServer[serverName]);
+  console.log(`Templates from ${serverName}:`, templatesByServer[serverName])
 }
 ```
 
@@ -144,11 +144,8 @@ async read(serverName: string, uri: string): Promise<ReadResourceResult>
 Example:
 
 ```typescript
-const content = await mcpClient.resources.read(
-  "myWeatherServer",
-  "weather://current",
-);
-console.log("Current weather:", content.contents[0].text);
+const content = await mcpClient.resources.read('myWeatherServer', 'weather://current')
+console.log('Current weather:', content.contents[0].text)
 ```
 
 #### `resources.subscribe(serverName: string, uri: string)`
@@ -162,7 +159,7 @@ async subscribe(serverName: string, uri: string): Promise<object>
 Example:
 
 ```typescript
-await mcpClient.resources.subscribe("myWeatherServer", "weather://current");
+await mcpClient.resources.subscribe('myWeatherServer', 'weather://current')
 ```
 
 #### `resources.unsubscribe(serverName: string, uri: string)`
@@ -176,7 +173,7 @@ async unsubscribe(serverName: string, uri: string): Promise<object>
 Example:
 
 ```typescript
-await mcpClient.resources.unsubscribe("myWeatherServer", "weather://current");
+await mcpClient.resources.unsubscribe('myWeatherServer', 'weather://current')
 ```
 
 #### `resources.onUpdated(serverName: string, handler: (params: { uri: string }) => void)`
@@ -190,11 +187,11 @@ async onUpdated(serverName: string, handler: (params: { uri: string }) => void):
 Example:
 
 ```typescript
-mcpClient.resources.onUpdated("myWeatherServer", (params) => {
-  console.log(`Resource updated on myWeatherServer: ${params.uri}`);
+mcpClient.resources.onUpdated('myWeatherServer', params => {
+  console.log(`Resource updated on myWeatherServer: ${params.uri}`)
   // You might want to re-fetch the resource content here
   // await mcpClient.resources.read("myWeatherServer", params.uri);
-});
+})
 ```
 
 #### `resources.onListChanged(serverName: string, handler: () => void)`
@@ -208,11 +205,11 @@ async onListChanged(serverName: string, handler: () => void): Promise<void>
 Example:
 
 ```typescript
-mcpClient.resources.onListChanged("myWeatherServer", () => {
-  console.log("Resource list changed on myWeatherServer.");
+mcpClient.resources.onListChanged('myWeatherServer', () => {
+  console.log('Resource list changed on myWeatherServer.')
   // You should re-fetch the list of resources
   // await mcpClient.resources.list();
-});
+})
 ```
 
 ### `elicitation` Property
@@ -222,27 +219,27 @@ The `MCPClient` instance has an `elicitation` property that provides access to e
 ```typescript
 const mcpClient = new MCPClient({
   /* ...servers configuration... */
-});
+})
 
 // Set up elicitation handler
-mcpClient.elicitation.onRequest("serverName", async (request) => {
+mcpClient.elicitation.onRequest('serverName', async request => {
   // Handle elicitation request from server
-  console.log("Server requests:", request.message);
-  console.log("Schema:", request.requestedSchema);
+  console.log('Server requests:', request.message)
+  console.log('Schema:', request.requestedSchema)
 
   // Return user response
   return {
-    action: "accept",
-    content: { name: "John Doe", email: "john@example.com" },
-  };
-});
+    action: 'accept',
+    content: { name: 'John Doe', email: 'john@example.com' },
+  }
+})
 ```
 
 #### `elicitation.onRequest(serverName: string, handler: ElicitationHandler)`
 
 Sets up a handler function that will be called when any connected MCP server sends an elicitation request. The handler receives the request and must return a response.
 
-**ElicitationHandler Function:**
+##### ElicitationHandler Function
 
 The handler function receives a request object with:
 
@@ -257,105 +254,103 @@ The handler must return an `ElicitResult` with:
 **Example:**
 
 ```typescript
-mcpClient.elicitation.onRequest("serverName", async (request) => {
-  console.log(`Server requests: ${request.message}`);
+mcpClient.elicitation.onRequest('serverName', async request => {
+  console.log(`Server requests: ${request.message}`)
 
   // Example: Simple user input collection
   if (request.requestedSchema.properties.name) {
     // Simulate user accepting and providing data
     return {
-      action: "accept",
+      action: 'accept',
       content: {
-        name: "Alice Smith",
-        email: "alice@example.com",
+        name: 'Alice Smith',
+        email: 'alice@example.com',
       },
-    };
+    }
   }
 
   // Simulate user declining the request
-  return { action: "decline" };
-});
+  return { action: 'decline' }
+})
 ```
 
 **Complete Interactive Example:**
 
 ```typescript
-import { MCPClient } from "@mastra/mcp";
-import { createInterface } from "readline";
+import { MCPClient } from '@mastra/mcp'
+import { createInterface } from 'readline'
 
 const readline = createInterface({
   input: process.stdin,
   output: process.stdout,
-});
+})
 
 function askQuestion(question: string): Promise<string> {
-  return new Promise((resolve) => {
-    readline.question(question, (answer) => resolve(answer.trim()));
-  });
+  return new Promise(resolve => {
+    readline.question(question, answer => resolve(answer.trim()))
+  })
 }
 
 const mcpClient = new MCPClient({
   servers: {
     interactiveServer: {
-      url: new URL("http://localhost:3000/mcp"),
+      url: new URL('http://localhost:3000/mcp'),
     },
   },
-});
+})
 
 // Set up interactive elicitation handler
-await mcpClient.elicitation.onRequest("interactiveServer", async (request) => {
-  console.log(`\n📋 Server Request: ${request.message}`);
-  console.log("Required information:");
+await mcpClient.elicitation.onRequest('interactiveServer', async request => {
+  console.log(`\n📋 Server Request: ${request.message}`)
+  console.log('Required information:')
 
-  const schema = request.requestedSchema;
-  const properties = schema.properties || {};
-  const required = schema.required || [];
-  const content: Record<string, any> = {};
+  const schema = request.requestedSchema
+  const properties = schema.properties || {}
+  const required = schema.required || []
+  const content: Record<string, any> = {}
 
   // Collect input for each field
   for (const [fieldName, fieldSchema] of Object.entries(properties)) {
-    const field = fieldSchema as any;
-    const isRequired = required.includes(fieldName);
+    const field = fieldSchema as any
+    const isRequired = required.includes(fieldName)
 
-    let prompt = `${field.title || fieldName}`;
-    if (field.description) prompt += ` (${field.description})`;
-    if (isRequired) prompt += " *required*";
-    prompt += ": ";
+    let prompt = `${field.title || fieldName}`
+    if (field.description) prompt += ` (${field.description})`
+    if (isRequired) prompt += ' *required*'
+    prompt += ': '
 
-    const answer = await askQuestion(prompt);
+    const answer = await askQuestion(prompt)
 
     // Handle cancellation
-    if (answer.toLowerCase() === "cancel") {
-      return { action: "cancel" };
+    if (answer.toLowerCase() === 'cancel') {
+      return { action: 'cancel' }
     }
 
     // Validate required fields
-    if (answer === "" && isRequired) {
-      console.log(`❌ ${fieldName} is required`);
-      return { action: "decline" };
+    if (answer === '' && isRequired) {
+      console.log(`❌ ${fieldName} is required`)
+      return { action: 'decline' }
     }
 
-    if (answer !== "") {
-      content[fieldName] = answer;
+    if (answer !== '') {
+      content[fieldName] = answer
     }
   }
 
   // Confirm submission
-  console.log("\n📝 You provided:");
-  console.log(JSON.stringify(content, null, 2));
+  console.log('\n📝 You provided:')
+  console.log(JSON.stringify(content, null, 2))
 
-  const confirm = await askQuestion(
-    "\nSubmit this information? (yes/no/cancel): ",
-  );
+  const confirm = await askQuestion('\nSubmit this information? (yes/no/cancel): ')
 
-  if (confirm.toLowerCase() === "yes" || confirm.toLowerCase() === "y") {
-    return { action: "accept", content };
-  } else if (confirm.toLowerCase() === "cancel") {
-    return { action: "cancel" };
+  if (confirm.toLowerCase() === 'yes' || confirm.toLowerCase() === 'y') {
+    return { action: 'accept', content }
+  } else if (confirm.toLowerCase() === 'cancel') {
+    return { action: 'cancel' }
   } else {
-    return { action: "decline" };
+    return { action: 'decline' }
   }
-});
+})
 ```
 
 ### `prompts` Property
@@ -365,14 +360,14 @@ The `MCPClient` instance has a `prompts` property that provides access to prompt
 ```typescript
 const mcpClient = new MCPClient({
   /* ...servers configuration... */
-});
+})
 
 // Access prompt methods via mcpClient.prompts
-const allPromptsByServer = await mcpClient.prompts.list();
+const allPromptsByServer = await mcpClient.prompts.list()
 const { prompt, messages } = await mcpClient.prompts.get({
-  serverName: "myWeatherServer",
-  name: "current",
-});
+  serverName: 'myWeatherServer',
+  name: 'current',
+})
 ```
 
 #### `prompts.list()`
@@ -386,9 +381,9 @@ async list(): Promise<Record<string, Prompt[]>>
 Example:
 
 ```typescript
-const promptsByServer = await mcpClient.prompts.list();
+const promptsByServer = await mcpClient.prompts.list()
 for (const serverName in promptsByServer) {
-  console.log(`Prompts from ${serverName}:`, promptsByServer[serverName]);
+  console.log(`Prompts from ${serverName}:`, promptsByServer[serverName])
 }
 ```
 
@@ -414,12 +409,12 @@ Example:
 
 ```typescript
 const { prompt, messages } = await mcpClient.prompts.get({
-  serverName: "myWeatherServer",
-  name: "current",
-  args: { location: "London" },
-});
-console.log(prompt);
-console.log(messages);
+  serverName: 'myWeatherServer',
+  name: 'current',
+  args: { location: 'London' },
+})
+console.log(prompt)
+console.log(messages)
 ```
 
 #### `prompts.onListChanged(serverName: string, handler: () => void)`
@@ -433,11 +428,11 @@ async onListChanged(serverName: string, handler: () => void): Promise<void>
 Example:
 
 ```typescript
-mcpClient.prompts.onListChanged("myWeatherServer", () => {
-  console.log("Prompt list changed on myWeatherServer.");
+mcpClient.prompts.onListChanged('myWeatherServer', () => {
+  console.log('Prompt list changed on myWeatherServer.')
   // You should re-fetch the list of prompts
   // await mcpClient.prompts.list();
-});
+})
 ```
 
 ### `progress` Property
@@ -453,14 +448,14 @@ const mcpClient = new MCPClient({
       enableProgressTracking: true,
     },
   },
-});
+})
 
 // Subscribe to progress updates for a specific server
-await mcpClient.progress.onUpdate('myServer', (params) => {
-  console.log('📊 Progress:', params.progress, '/', params.total);
-  if (params.message) console.log('Message:', params.message);
-  if (params.progressToken) console.log('Token:', params.progressToken);
-});
+await mcpClient.progress.onUpdate('myServer', params => {
+  console.log('📊 Progress:', params.progress, '/', params.total)
+  if (params.message) console.log('Message:', params.message)
+  if (params.progressToken) console.log('Token:', params.progressToken)
+})
 ```
 
 #### `progress.onUpdate(serverName: string, handler)`
@@ -494,7 +489,7 @@ const mcpClient = new MCPClient({
       enableProgressTracking: false,
     },
   },
-});
+})
 ```
 
 ## Elicitation
@@ -514,29 +509,29 @@ Elicitation is a feature that allows MCP servers to request structured informati
 You must set up an elicitation handler before tools that use elicitation are called:
 
 ```typescript
-import { MCPClient } from "@mastra/mcp";
+import { MCPClient } from '@mastra/mcp'
 
 const mcpClient = new MCPClient({
   servers: {
     interactiveServer: {
-      url: new URL("http://localhost:3000/mcp"),
+      url: new URL('http://localhost:3000/mcp'),
     },
   },
-});
+})
 
 // Set up elicitation handler
-mcpClient.elicitation.onRequest("interactiveServer", async (request) => {
+mcpClient.elicitation.onRequest('interactiveServer', async request => {
   // Handle the server's request for user input
-  console.log(`Server needs: ${request.message}`);
+  console.log(`Server needs: ${request.message}`)
 
   // Your logic to collect user input
-  const userData = await collectUserInput(request.requestedSchema);
+  const userData = await collectUserInput(request.requestedSchema)
 
   return {
-    action: "accept",
+    action: 'accept',
     content: userData,
-  };
-});
+  }
+})
 ```
 
 ### Response Types
@@ -547,21 +542,21 @@ Your elicitation handler must return one of three response types:
 
   ```typescript
   return {
-    action: "accept",
-    content: { name: "John Doe", email: "john@example.com" },
-  };
+    action: 'accept',
+    content: { name: 'John Doe', email: 'john@example.com' },
+  }
   ```
 
 - **Decline**: User explicitly declined to provide the information
 
   ```typescript
-  return { action: "decline" };
+  return { action: 'decline' }
   ```
 
 - **Cancel**: User dismissed or cancelled the request
 
   ```typescript
-  return { action: "cancel" };
+  return { action: 'cancel' }
   ```
 
 ### Schema-Based Input Collection
@@ -569,13 +564,13 @@ Your elicitation handler must return one of three response types:
 The `requestedSchema` provides structure for the data the server needs:
 
 ```typescript
-await mcpClient.elicitation.onRequest("interactiveServer", async (request) => {
-  const { properties, required = [] } = request.requestedSchema;
-  const content: Record<string, any> = {};
+await mcpClient.elicitation.onRequest('interactiveServer', async request => {
+  const { properties, required = [] } = request.requestedSchema
+  const content: Record<string, any> = {}
 
   for (const [fieldName, fieldSchema] of Object.entries(properties || {})) {
-    const field = fieldSchema as any;
-    const isRequired = required.includes(fieldName);
+    const field = fieldSchema as any
+    const isRequired = required.includes(fieldName)
 
     // Collect input based on field type and requirements
     const value = await promptUser({
@@ -586,15 +581,15 @@ await mcpClient.elicitation.onRequest("interactiveServer", async (request) => {
       required: isRequired,
       format: field.format,
       enum: field.enum,
-    });
+    })
 
     if (value !== null) {
-      content[fieldName] = value;
+      content[fieldName] = value
     }
   }
 
-  return { action: "accept", content };
-});
+  return { action: 'accept', content }
+})
 ```
 
 ### Best Practices
@@ -610,32 +605,32 @@ await mcpClient.elicitation.onRequest("interactiveServer", async (request) => {
 For connecting to MCP servers that require OAuth authentication per the [MCP Auth Specification](https://modelcontextprotocol.io/specification/2025-06-18/basic/authorization), use the `MCPOAuthClientProvider`:
 
 ```typescript
-import { MCPClient, MCPOAuthClientProvider } from "@mastra/mcp";
+import { MCPClient, MCPOAuthClientProvider } from '@mastra/mcp'
 
 // Create an OAuth provider
 const oauthProvider = new MCPOAuthClientProvider({
-  redirectUrl: "http://localhost:3000/oauth/callback",
+  redirectUrl: 'http://localhost:3000/oauth/callback',
   clientMetadata: {
-    redirect_uris: ["http://localhost:3000/oauth/callback"],
-    client_name: "My MCP Client",
-    grant_types: ["authorization_code", "refresh_token"],
-    response_types: ["code"],
+    redirect_uris: ['http://localhost:3000/oauth/callback'],
+    client_name: 'My MCP Client',
+    grant_types: ['authorization_code', 'refresh_token'],
+    response_types: ['code'],
   },
-  onRedirectToAuthorization: (url) => {
+  onRedirectToAuthorization: url => {
     // Handle authorization redirect (open browser, redirect response, etc.)
-    console.log(`Please visit: ${url}`);
+    console.log(`Please visit: ${url}`)
   },
-});
+})
 
 // Use the provider with MCPClient
 const client = new MCPClient({
   servers: {
     protectedServer: {
-      url: new URL("https://mcp.example.com/mcp"),
+      url: new URL('https://mcp.example.com/mcp'),
       authProvider: oauthProvider,
     },
   },
-});
+})
 ```
 
 ### Quick Token Provider
@@ -643,24 +638,24 @@ const client = new MCPClient({
 For testing or when you already have a valid access token:
 
 ```typescript
-import { MCPClient, createSimpleTokenProvider } from "@mastra/mcp";
+import { MCPClient, createSimpleTokenProvider } from '@mastra/mcp'
 
-const provider = createSimpleTokenProvider("your-access-token", {
-  redirectUrl: "http://localhost:3000/callback",
+const provider = createSimpleTokenProvider('your-access-token', {
+  redirectUrl: 'http://localhost:3000/callback',
   clientMetadata: {
-    redirect_uris: ["http://localhost:3000/callback"],
-    client_name: "Test Client",
+    redirect_uris: ['http://localhost:3000/callback'],
+    client_name: 'Test Client',
   },
-});
+})
 
 const client = new MCPClient({
   servers: {
     testServer: {
-      url: new URL("https://mcp.example.com/mcp"),
+      url: new URL('https://mcp.example.com/mcp'),
       authProvider: provider,
     },
   },
-});
+})
 ```
 
 ### Custom Token Storage
@@ -668,39 +663,44 @@ const client = new MCPClient({
 For persistent token storage across sessions, implement the `OAuthStorage` interface:
 
 ```typescript
-import { MCPOAuthClientProvider, OAuthStorage } from "@mastra/mcp";
+import { MCPOAuthClientProvider, OAuthStorage } from '@mastra/mcp'
 
 class DatabaseOAuthStorage implements OAuthStorage {
-  constructor(private db: Database, private userId: string) {}
+  constructor(
+    private db: Database,
+    private userId: string,
+  ) {}
 
   async set(key: string, value: string): Promise<void> {
     await this.db.query(
-      "INSERT INTO oauth_tokens (user_id, key, value) VALUES (?, ?, ?) ON CONFLICT DO UPDATE SET value = ?",
-      [this.userId, key, value, value]
-    );
+      'INSERT INTO oauth_tokens (user_id, key, value) VALUES (?, ?, ?) ON CONFLICT DO UPDATE SET value = ?',
+      [this.userId, key, value, value],
+    )
   }
 
   async get(key: string): Promise<string | undefined> {
     const result = await this.db.query(
-      "SELECT value FROM oauth_tokens WHERE user_id = ? AND key = ?",
-      [this.userId, key]
-    );
-    return result?.[0]?.value;
+      'SELECT value FROM oauth_tokens WHERE user_id = ? AND key = ?',
+      [this.userId, key],
+    )
+    return result?.[0]?.value
   }
 
   async delete(key: string): Promise<void> {
-    await this.db.query(
-      "DELETE FROM oauth_tokens WHERE user_id = ? AND key = ?",
-      [this.userId, key]
-    );
+    await this.db.query('DELETE FROM oauth_tokens WHERE user_id = ? AND key = ?', [
+      this.userId,
+      key,
+    ])
   }
 }
 
 const provider = new MCPOAuthClientProvider({
-  redirectUrl: "http://localhost:3000/callback",
-  clientMetadata: { /* ... */ },
-  storage: new DatabaseOAuthStorage(db, "user-123"),
-});
+  redirectUrl: 'http://localhost:3000/callback',
+  clientMetadata: {
+    /* ... */
+  },
+  storage: new DatabaseOAuthStorage(db, 'user-123'),
+})
 ```
 
 ## Examples
@@ -710,74 +710,69 @@ const provider = new MCPOAuthClientProvider({
 For tools where you have a single connection to the MCP server for you entire app, use `listTools()` and pass the tools to your agent:
 
 ```typescript
-import { MCPClient } from "@mastra/mcp";
-import { Agent } from "@mastra/core/agent";
+import { MCPClient } from '@mastra/mcp'
+import { Agent } from '@mastra/core/agent'
 
 const mcp = new MCPClient({
   servers: {
     stockPrice: {
-      command: "npx",
-      args: ["tsx", "stock-price.ts"],
+      command: 'npx',
+      args: ['tsx', 'stock-price.ts'],
       env: {
-        API_KEY: "your-api-key",
+        API_KEY: 'your-api-key',
       },
-      log: (logMessage) => {
-        console.log(`[${logMessage.level}] ${logMessage.message}`);
+      log: logMessage => {
+        console.log(`[${logMessage.level}] ${logMessage.message}`)
       },
     },
     weather: {
-      url: new URL("http://localhost:8080/sse"),
+      url: new URL('http://localhost:8080/sse'),
     },
   },
   timeout: 30000, // Global 30s timeout
-});
+})
 
 // Create an agent with access to all tools
 const agent = new Agent({
-  id: "multi-tool-agent",
-  name: "Multi-tool Agent",
-  instructions: "You have access to multiple tool servers.",
-  model: "openai/gpt-5.1",
+  id: 'multi-tool-agent',
+  name: 'Multi-tool Agent',
+  instructions: 'You have access to multiple tool servers.',
+  model: 'openai/gpt-5.1',
   tools: await mcp.listTools(),
-});
+})
 
 // Example of using resource methods
 async function checkWeatherResource() {
   try {
-    const weatherResources = await mcp.resources.list();
+    const weatherResources = await mcp.resources.list()
     if (weatherResources.weather && weatherResources.weather.length > 0) {
-      const currentWeatherURI = weatherResources.weather[0].uri;
-      const weatherData = await mcp.resources.read(
-        "weather",
-        currentWeatherURI,
-      );
-      console.log("Weather data:", weatherData.contents[0].text);
+      const currentWeatherURI = weatherResources.weather[0].uri
+      const weatherData = await mcp.resources.read('weather', currentWeatherURI)
+      console.log('Weather data:', weatherData.contents[0].text)
     }
   } catch (error) {
-    console.error("Error fetching weather resource:", error);
+    console.error('Error fetching weather resource:', error)
   }
 }
-checkWeatherResource();
+checkWeatherResource()
 
 // Example of using prompt methods
 async function checkWeatherPrompt() {
   try {
-    const weatherPrompts = await mcp.prompts.list();
+    const weatherPrompts = await mcp.prompts.list()
     if (weatherPrompts.weather && weatherPrompts.weather.length > 0) {
-      const currentWeatherPrompt = weatherPrompts.weather.find(
-        (p) => p.name === "current",
-      );
+      const currentWeatherPrompt = weatherPrompts.weather.find(p => p.name === 'current')
       if (currentWeatherPrompt) {
-        console.log("Weather prompt:", currentWeatherPrompt);
+        console.log('Weather prompt:', currentWeatherPrompt)
       } else {
-        console.log("Current weather prompt not found");
+        console.log('Current weather prompt not found')
       }
     }
   } catch (error) {
-    console.error("Error fetching weather prompt:", error);
+    console.error('Error fetching weather prompt:', error)
   }
 }
-checkWeatherPrompt();
+checkWeatherPrompt()
 ```
 
 ### Dynamic toolsets
@@ -785,30 +780,30 @@ checkWeatherPrompt();
 When you need a new MCP connection for each user, use `listToolsets()` and add the tools when calling stream or generate:
 
 ```typescript
-import { Agent } from "@mastra/core/agent";
-import { MCPClient } from "@mastra/mcp";
+import { Agent } from '@mastra/core/agent'
+import { MCPClient } from '@mastra/mcp'
 
 // Create the agent first, without any tools
 const agent = new Agent({
-  id: "multi-tool-agent",
-  name: "Multi-tool Agent",
-  instructions: "You help users check stocks and weather.",
-  model: "openai/gpt-5.1",
-});
+  id: 'multi-tool-agent',
+  name: 'Multi-tool Agent',
+  instructions: 'You help users check stocks and weather.',
+  model: 'openai/gpt-5.1',
+})
 
 // Later, configure MCP with user-specific settings
 const mcp = new MCPClient({
   servers: {
     stockPrice: {
-      command: "npx",
-      args: ["tsx", "stock-price.ts"],
+      command: 'npx',
+      args: ['tsx', 'stock-price.ts'],
       env: {
-        API_KEY: "user-123-api-key",
+        API_KEY: 'user-123-api-key',
       },
       timeout: 20000, // Server-specific timeout
     },
     weather: {
-      url: new URL("http://localhost:8080/sse"),
+      url: new URL('http://localhost:8080/sse'),
       requestInit: {
         headers: {
           Authorization: `Bearer user-123-token`,
@@ -816,15 +811,12 @@ const mcp = new MCPClient({
       },
     },
   },
-});
+})
 
 // Pass all toolsets to stream() or generate()
-const response = await agent.stream(
-  "How is AAPL doing and what is the weather?",
-  {
-    toolsets: await mcp.listToolsets(),
-  },
-);
+const response = await agent.stream('How is AAPL doing and what is the weather?', {
+  toolsets: await mcp.listToolsets(),
+})
 ```
 
 ## Instance Management
@@ -844,31 +836,31 @@ const mcp1 = new MCPClient({
   servers: {
     /* ... */
   },
-});
+})
 
 // Second instance with same config - Will throw an error
 const mcp2 = new MCPClient({
   servers: {
     /* ... */
   },
-});
+})
 
 // To fix, either:
 // 1. Add unique IDs
 const mcp3 = new MCPClient({
-  id: "instance-1",
+  id: 'instance-1',
   servers: {
     /* ... */
   },
-});
+})
 
 // 2. Or disconnect before recreating
-await mcp1.disconnect();
+await mcp1.disconnect()
 const mcp4 = new MCPClient({
   servers: {
     /* ... */
   },
-});
+})
 ```
 
 ## Server Lifecycle
@@ -889,10 +881,10 @@ When `fetch` is provided, `requestInit`, `eventSourceInit`, and `authProvider` b
 const mcpClient = new MCPClient({
   servers: {
     apiServer: {
-      url: new URL("https://api.example.com/mcp"),
+      url: new URL('https://api.example.com/mcp'),
       fetch: async (url, init) => {
         // Refresh token on each request
-        const token = await getAuthToken(); // Your token refresh logic
+        const token = await getAuthToken() // Your token refresh logic
 
         return fetch(url, {
           ...init,
@@ -900,11 +892,11 @@ const mcpClient = new MCPClient({
             ...init?.headers,
             Authorization: `Bearer ${token}`,
           },
-        });
+        })
       },
     },
   },
-});
+})
 ```
 
 ## Using SSE Request Headers
@@ -916,44 +908,44 @@ When using the legacy SSE MCP transport, you must configure both `requestInit` a
 const sseClient = new MCPClient({
   servers: {
     exampleServer: {
-      url: new URL("https://your-mcp-server.com/sse"),
+      url: new URL('https://your-mcp-server.com/sse'),
       // Note: requestInit alone isn't enough for SSE
       requestInit: {
         headers: {
-          Authorization: "Bearer your-token",
+          Authorization: 'Bearer your-token',
         },
       },
       // This is also required for SSE connections with custom headers
       eventSourceInit: {
         fetch(input: Request | URL | string, init?: RequestInit) {
-          const headers = new Headers(init?.headers || {});
-          headers.set("Authorization", "Bearer your-token");
+          const headers = new Headers(init?.headers || {})
+          headers.set('Authorization', 'Bearer your-token')
           return fetch(input, {
             ...init,
             headers,
-          });
+          })
         },
       },
     },
   },
-});
+})
 
 // Option 2: Using custom fetch (simpler, works for both Streamable HTTP and SSE)
 const sseClientWithFetch = new MCPClient({
   servers: {
     exampleServer: {
-      url: new URL("https://your-mcp-server.com/sse"),
+      url: new URL('https://your-mcp-server.com/sse'),
       fetch: async (url, init) => {
-        const headers = new Headers(init?.headers || {});
-        headers.set("Authorization", "Bearer your-token");
+        const headers = new Headers(init?.headers || {})
+        headers.set('Authorization', 'Bearer your-token')
         return fetch(url, {
           ...init,
           headers,
-        });
+        })
       },
     },
   },
-});
+})
 ```
 
 ## Related Information