@mastra/core 1.2.1-alpha.0 → 1.3.0-alpha.2

package/dist/docs/references/docs-tools-mcp-advanced-usage.md

@@ -1,143 +0,0 @@
-# Advanced Tool Usage
-
-This page covers more advanced techniques and features related to using tools in Mastra.
-
-## Abort Signals
-
-When you initiate an agent interaction using `generate()` or `stream()`, you can provide an `AbortSignal`. Mastra automatically forwards this signal to any tool executions that occur during that interaction.
-
-This allows you to cancel long-running operations within your tools, such as network requests or intensive computations, if the parent agent call is aborted.
-
-You access the `abortSignal` in the second parameter of the tool's `execute` function.
-
-```typescript
-import { createTool } from "@mastra/core/tools";
-import { z } from "zod";
-
-export const longRunningTool = createTool({
-  id: "long-computation",
-  description: "Performs a potentially long computation",
-  inputSchema: z.object({ /* ... */ }),
-  execute: async (inputData, context) => {
-    // Example: Forwarding signal to fetch
-    const response = await fetch("https://api.example.com/data", {
-      signal: context?.abortSignal, // Pass the signal here
-    });
-
-    if (context?.abortSignal?.aborted) {
-      console.log("Tool execution aborted.");
-      throw new Error("Aborted");
-    }
-
-    // Example: Checking signal during a loop
-    for (let i = 0; i < 1000000; i++) {
-      if (context?.abortSignal?.aborted) {
-        console.log("Tool execution aborted during loop.");
-        throw new Error("Aborted");
-      }
-      // ... perform computation step ...
-    }
-
-    const data = await response.json();
-    return { result: data };
-  },\n});
-```
-
-To use this, provide an `AbortController`'s signal when calling the agent:
-
-```typescript
-import { Agent } from "@mastra/core/agent";
-// Assume 'agent' is an Agent instance with longRunningTool configured
-
-const controller = new AbortController();
-
-// Start the agent call
-const promise = agent.generate("Perform the long computation.", {
-  abortSignal: controller.signal,
-});
-
-// Sometime later, if needed:
-// controller.abort();
-
-try {
-  const result = await promise;
-  console.log(result.text);
-} catch (error) {
-  if (error.name === "AbortError") {
-    console.log("Agent generation was aborted.");
-  } else {
-    console.error("An error occurred:", error);
-  }
-}
-```
-
-## AI SDK Tool Format
-
-Mastra maintains compatibility with the tool format used by the Vercel AI SDK (`ai` package). You can define tools using the `tool` function from the `ai` package and use them directly within your Mastra agents alongside tools created with Mastra's `createTool`.
-
-First, ensure you have the `ai` package installed:
-
-**npm**:
-
-```bash
-npm install ai
-```
-
-**pnpm**:
-
-```bash
-pnpm add ai
-```
-
-**Yarn**:
-
-```bash
-yarn add ai
-```
-
-**Bun**:
-
-```bash
-bun add ai
-```
-
-Here's an example of a tool defined using the Vercel AI SDK format:
-
-```typescript
-import { tool } from "ai";
-import { z } from "zod";
-
-export const vercelWeatherTool = tool({
-  description: "Fetches current weather using Vercel AI SDK format",
-  parameters: z.object({
-    city: z.string().describe("The city to get weather for"),
-  }),
-  execute: async ({ city }) => {
-    console.log(`Fetching weather for ${city} (Vercel format tool)`);
-    // Replace with actual API call
-    const data = await fetch(`https://api.example.com/weather?city=${city}`);
-    return data.json();
-  },
-});
-```
-
-You can then add this tool to your Mastra agent just like any other tool:
-
-```typescript
-import { Agent } from "@mastra/core/agent";
-import { vercelWeatherTool } from "../tools/vercelWeatherTool"; // Vercel AI SDK tool
-import { mastraTool } from "../tools/mastraTool"; // Mastra createTool tool
-
-export const mixedToolsAgent = new Agent({
-  id: "mixed-tools-agent",
-  name: "Mixed Tools Agent",
-  instructions: "You can use tools defined in different formats.",
-  model: "openai/gpt-5.1",
-  tools: {
-    weatherVercel: vercelWeatherTool,
-    someMastraTool: mastraTool,
-  },
-});
-```
-
-Mastra supports both tool formats, allowing you to mix and match as needed.

package/dist/docs/references/docs-tools-mcp-mcp-overview.md

@@ -1,383 +0,0 @@
-# MCP Overview
-
-Mastra supports the [Model Context Protocol (MCP)](https://modelcontextprotocol.io/introduction), an open standard for connecting AI agents to external tools and resources. It serves as a universal plugin system, enabling agents to call tools regardless of language or hosting environment.
-
-Mastra can also be used to author MCP servers, exposing agents, tools, and other structured resources via the MCP interface. These can then be accessed by any system or agent that supports the protocol.
-
-Mastra currently supports two MCP classes:
-
-1. **`MCPClient`**: Connects to one or many MCP servers to access their tools, resources, prompts, and handle elicitation requests.
-2. **`MCPServer`**: Exposes Mastra tools, agents, workflows, prompts, and resources to MCP compatible clients.
-
-## Getting started
-
-To use MCP, install the required dependency:
-
-**npm**:
-
-```bash
-npm install @mastra/mcp@latest
-```
-
-**pnpm**:
-
-```bash
-pnpm add @mastra/mcp@latest
-```
-
-**Yarn**:
-
-```bash
-yarn add @mastra/mcp@latest
-```
-
-**Bun**:
-
-```bash
-bun add @mastra/mcp@latest
-```
-
-## Configuring `MCPClient`
-
-The `MCPClient` connects Mastra primitives to external MCP servers, which can be local packages (invoked using `npx`) or remote HTTP(S) endpoints. Each server must be configured with either a `command` or a `url`, depending on how it's hosted.
-
-```typescript
-import { MCPClient } from "@mastra/mcp";
-
-export const testMcpClient = new MCPClient({
-  id: "test-mcp-client",
-  servers: {
-    wikipedia: {
-      command: "npx",
-      args: ["-y", "wikipedia-mcp"],
-    },
-    weather: {
-      url: new URL(
-        `https://server.smithery.ai/@smithery-ai/national-weather-service/mcp?api_key=${process.env.SMITHERY_API_KEY}`,
-      ),
-    },
-  },
-});
-```
-
-> **Info:** Visit [MCPClient](https://mastra.ai/reference/tools/mcp-client) for a full list of configuration options.
-
-> **Authentication:** For connecting to OAuth-protected MCP servers, see the [OAuth Authentication](https://mastra.ai/reference/tools/mcp-client) section.
-
-## Using `MCPClient` with an agent
-
-To use tools from an MCP server in an agent, import your `MCPClient` and call `.listTools()` in the `tools` parameter. This loads from the defined MCP servers, making them available to the agent.
-
-```typescript
-import { Agent } from "@mastra/core/agent";
-
-import { testMcpClient } from "../mcp/test-mcp-client";
-
-export const testAgent = new Agent({
-  id: "test-agent",
-  name: "Test Agent",
-  description: "You are a helpful AI assistant",
-  instructions: `
-      You are a helpful assistant that has access to the following MCP Servers.
-      - Wikipedia MCP Server
-      - US National Weather Service
-
-      Answer questions using the information you find using the MCP Servers.`,
-  model: "openai/gpt-5.1",
-  tools: await testMcpClient.listTools(),
-});
-```
-
-> **Info:** Visit [Agent Class](https://mastra.ai/reference/agents/agent) for a full list of configuration options.
-
-## Configuring `MCPServer`
-
-To expose agents, tools, and workflows from your Mastra application to external systems over HTTP(S) use the `MCPServer` class. This makes them accessible to any system or agent that supports the protocol.
-
-```typescript
-import { MCPServer } from "@mastra/mcp";
-
-import { testAgent } from "../agents/test-agent";
-import { testWorkflow } from "../workflows/test-workflow";
-import { testTool } from "../tools/test-tool";
-
-export const testMcpServer = new MCPServer({
-  id: "test-mcp-server",  // Required: unique identifier for the server
-  name: "Test MCP Server",
-  version: "1.0.0",
-  agents: { testAgent },
-  tools: { testTool },
-  workflows: { testWorkflow },
-});
-```
-
-> **Info:** Visit [MCPServer](https://mastra.ai/reference/tools/mcp-server) for a full list of configuration options.
-
-> **Authentication:** To protect your MCP server with OAuth, see the [OAuth Protection](https://mastra.ai/reference/tools/mcp-server) section.
-
-### Serverless deployments
-
-`MCPServer` can be deployed in serverless environments (Cloudflare Workers, Vercel Edge Functions, AWS Lambda, etc.) by enabling the `serverless: true` option in `startHTTP()`. This runs the server in stateless mode, where each request is handled independently without session management.
-
-**Note:** Some MCP features require persistent connections and won't work in serverless mode, including elicitation, resource subscriptions, and update notifications. See the [serverless section](https://mastra.ai/reference/tools/mcp-server) in the API reference for full details and limitations.
-
-## Registering an `MCPServer`
-
-To make an MCP server available to other systems or agents that support the protocol, register it in the main `Mastra` instance using `mcpServers`.
-
-```typescript
-import { Mastra } from "@mastra/core";
-
-import { testMcpServer } from "./mcp/test-mcp-server";
-
-export const mastra = new Mastra({
-  mcpServers: {
-    testMcpServer,  // Registry key: 'testMcpServer'
-  },
-});
-
-// Both retrieval methods work:
-mastra.getMCPServer('testMcpServer');          // By registry key
-mastra.getMCPServerById('test-mcp-server');    // By intrinsic ID
-```
-
-## Static and dynamic tools
-
-`MCPClient` offers two approaches to retrieving tools from connected servers, suitable for different application architectures:
-
-| Feature           | Static Configuration (`await mcp.listTools()`) | Dynamic Configuration (`await mcp.listToolsets()`)   |
-| ----------------- | ---------------------------------------------- | ---------------------------------------------------- |
-| **Use Case**      | Single-user, static config (e.g., CLI tool)    | Multi-user, dynamic config (e.g., SaaS app)          |
-| **Configuration** | Fixed at agent initialization                  | Per-request, dynamic                                 |
-| **Credentials**   | Shared across all uses                         | Can vary per user/request                            |
-| **Agent Setup**   | Tools added in `Agent` constructor             | Tools passed in `.generate()` or `.stream()` options |
-
-### Static tools
-
-Use the `.listTools()` method to fetch tools from all configured MCP servers. This is suitable when configuration (such as API keys) is static and consistent across users or requests. Call it once and pass the result to the `tools` property when defining your agent.
-
-> **Info:** Visit [listTools()](https://mastra.ai/reference/tools/mcp-client) for more information.
-
-```typescript
-import { Agent } from "@mastra/core/agent";
-
-import { testMcpClient } from "../mcp/test-mcp-client";
-
-export const testAgent = new Agent({
-  // ...
-  tools: await testMcpClient.listTools(),
-});
-```
-
-### Dynamic tools
-
-Use the `.listToolsets()` method when tool configuration may vary by request or user, such as in a multi-tenant system where each user provides their own API key. This method returns toolsets that can be passed to the `toolsets` option in the agent's `.generate()` or `.stream()` calls.
-
-```typescript
-import { MCPClient } from "@mastra/mcp";
-import { mastra } from "./mastra";
-
-async function handleRequest(userPrompt: string, userApiKey: string) {
-  const userMcp = new MCPClient({
-    servers: {
-      weather: {
-        url: new URL("http://localhost:8080/mcp"),
-        requestInit: {
-          headers: {
-            Authorization: `Bearer ${userApiKey}`,
-          },
-        },
-      },
-    },
-  });
-
-  const agent = mastra.getAgent("testAgent");
-
-  const response = await agent.generate(userPrompt, {
-    toolsets: await userMcp.listToolsets(),
-  });
-
-  await userMcp.disconnect();
-
-  return Response.json({
-    data: response.text,
-  });
-}
-```
-
-> **Info:** Visit [listToolsets()](https://mastra.ai/reference/tools/mcp-client) for more information.
-
-## Connecting to an MCP registry
-
-MCP servers can be discovered through registries. Here's how to connect to some popular ones using `MCPClient`:
-
-**Klavis AI**:
-
-[Klavis AI](https://klavis.ai) provides hosted, enterprise-authenticated, high-quality MCP servers.
-
-```typescript
-import { MCPClient } from "@mastra/mcp";
-
-const mcp = new MCPClient({
-  servers: {
-    salesforce: {
-      url: new URL("https://salesforce-mcp-server.klavis.ai/mcp/?instance_id={private-instance-id}"),
-    },
-    hubspot: {
-      url: new URL("https://hubspot-mcp-server.klavis.ai/mcp/?instance_id={private-instance-id}"),
-    },
-  },
-});
-```
-
-Klavis AI offers enterprise-grade authentication and security for production deployments.
-
-For more details on how to integrate Mastra with Klavis, check out their [documentation](https://docs.klavis.ai/documentation/ai-platform-integration/mastra).
-
-**mcp.run**:
-
-[mcp.run](https://www.mcp.run/) provides pre-authenticated, managed MCP servers. Tools are grouped into Profiles, each with a unique, signed URL.
-
-```typescript
-import { MCPClient } from "@mastra/mcp";
-
-const mcp = new MCPClient({
-  servers: {
-    marketing: { // Example profile name
-      url: new URL(process.env.MCP_RUN_SSE_URL!), // Get URL from mcp.run profile
-    },
-  },
-});
-```
-
-> **Important:** Treat the mcp.run SSE URL like a password. Store it securely, for example, in an environment variable.
->
-> ```bash
-> MCP_RUN_SSE_URL=https://www.mcp.run/api/mcp/sse?nonce=...
-> ```
-
-**Composio.dev**:
-
-[Composio.dev](https://composio.dev) offers a registry of [SSE-based MCP servers](https://mcp.composio.dev). You can use the SSE URL generated for tools like Cursor directly.
-
-```typescript
-import { MCPClient } from "@mastra/mcp";
-
-const mcp = new MCPClient({
-  servers: {
-    googleSheets: {
-      url: new URL("https://mcp.composio.dev/googlesheets/[private-url-path]"),
-    },
-    gmail: {
-      url: new URL("https://mcp.composio.dev/gmail/[private-url-path]"),
-    },
-  },
-});
-```
-
-Authentication with services like Google Sheets often happens interactively through the agent conversation.
-
-_Note: Composio URLs are typically tied to a single user account, making them best suited for personal automation rather than multi-tenant applications._
-
-**Smithery.ai**:
-
-[Smithery.ai](https://smithery.ai) provides a registry accessible via their CLI.
-
-```typescript
-// Unix/Mac
-import { MCPClient } from "@mastra/mcp";
-
-const mcp = new MCPClient({
-  servers: {
-    sequentialThinking: {
-      command: "npx",
-      args: [
-        "-y",
-        "@smithery/cli@latest",
-        "run",
-        "@smithery-ai/server-sequential-thinking",
-        "--config",
-        "{}",
-      ],
-    },
-  },
-});
-```
-
-```typescript
-// Windows
-import { MCPClient } from "@mastra/mcp";
-
-const mcp = new MCPClient({
-  servers: {
-    sequentialThinking: {
-      command: "npx",
-      args: [
-        "-y",
-        "@smithery/cli@latest",
-        "run",
-        "@smithery-ai/server-sequential-thinking",
-        "--config",
-        "{}",
-      ],
-    },
-  },
-});
-```
-
-**Ampersand**:
-
-[Ampersand](https://withampersand.com?utm_source=mastra-docs) offers an [MCP Server](https://docs.withampersand.com/mcp) that allows you to connect your agent to 150+ integrations with SaaS products like Salesforce, Hubspot, and Zendesk.
-
-```typescript
-// MCPClient with Ampersand MCP Server using SSE
-export const mcp = new MCPClient({
-  servers: {
-    "@amp-labs/mcp-server": {
-      url: `https://mcp.withampersand.com/v1/sse?${new URLSearchParams({
-        apiKey: process.env.AMPERSAND_API_KEY,
-        project: process.env.AMPERSAND_PROJECT_ID,
-        integrationName: process.env.AMPERSAND_INTEGRATION_NAME,
-        groupRef: process.env.AMPERSAND_GROUP_REF,
-      })}`,
-    },
-  },
-});
-```
-
-```typescript
-// If you prefer to run the MCP server locally:
-import { MCPClient } from "@mastra/mcp";
-
-// MCPClient with Ampersand MCP Server using stdio transport
-export const mcp = new MCPClient({
-  servers: {
-    "@amp-labs/mcp-server": {
-      command: "npx",
-      args: [
-        "-y",
-        "@amp-labs/mcp-server@latest",
-        "--transport",
-        "stdio",
-        "--project",
-        process.env.AMPERSAND_PROJECT_ID,
-        "--integrationName",
-        process.env.AMPERSAND_INTEGRATION_NAME,
-        "--groupRef",
-        process.env.AMPERSAND_GROUP_REF, // optional
-      ],
-      env: {
-        AMPERSAND_API_KEY: process.env.AMPERSAND_API_KEY,
-      },
-    },
-  },
-});
-```
-
-As an alternative to MCP, Ampersand's AI SDK also has an adapter for Mastra, so you can [directly import Ampersand tools](https://docs.withampersand.com/ai-sdk#use-with-mastra) for your agent to access.
-
-## Related
-
-- [Using Tools](https://mastra.ai/docs/agents/using-tools)
-- [MCPClient](https://mastra.ai/reference/tools/mcp-client)
-- [MCPServer](https://mastra.ai/reference/tools/mcp-server)

package/dist/docs/references/docs-tools-mcp-overview.md

@@ -1,78 +0,0 @@
-# Using Tools
-
-Tools are functions that agents can execute to perform specific tasks or access external information. They extend an agent's capabilities beyond simple text generation, allowing interaction with APIs, databases, or other systems.
-
-Each tool typically defines:
-
-- **Inputs:** What information the tool needs to run (defined with an `inputSchema`, often using Zod).
-- **Outputs:** The structure of the data the tool returns (defined with an `outputSchema`).
-- **Execution Logic:** The code that performs the tool's action.
-- **Description:** Text that helps the agent understand what the tool does and when to use it.
-
-## Creating Tools
-
-In Mastra, you create tools using the [`createTool`](https://mastra.ai/reference/tools/create-tool) function from the `@mastra/core/tools` package.
-
-```typescript
-import { createTool } from "@mastra/core/tools";
-import { z } from "zod";
-
-const getWeatherInfo = async (city: string) => {
-  // Replace with an actual API call to a weather service
-  console.log(`Fetching weather for ${city}...`);
-  // Example data structure
-  return { temperature: 20, conditions: "Sunny" };
-};
-
-export const weatherTool = createTool({
-  id: "Get Weather Information",
-  description: `Fetches the current weather information for a given city`,
-  inputSchema: z.object({
-    city: z.string().describe("City name"),
-  }),
-  outputSchema: z.object({
-    temperature: z.number(),
-    conditions: z.string(),
-  }),
-  execute: async (inputData) => {
-    console.log("Using tool to fetch weather information for", inputData.city);
-    return await getWeatherInfo(inputData.city);
-  },
-});
-```
-
-This example defines a `weatherTool` with an input schema for the city, an output schema for the weather data, and an `execute` function that contains the tool's logic.
-
-When creating tools, keep tool descriptions simple and focused on **what** the tool does and **when** to use it, emphasizing its primary use case. Technical details belong in the parameter schemas, guiding the agent on _how_ to use the tool correctly with descriptive names, clear descriptions, and explanations of default values.
-
-## Adding Tools to an Agent
-
-To make tools available to an agent, you configure them in the agent's definition. Mentioning available tools and their general purpose in the agent's system prompt can also improve tool usage. For detailed steps and examples, see the guide on [Using Tools with Agents](https://mastra.ai/docs/agents/using-tools).
-
-## Using `RequestContext`
-
-Use [RequestContext](https://mastra.ai/docs/server/request-context) to access request-specific values. This lets you conditionally adjust behavior based on the context of the request.
-
-```typescript
-export type UserTier = {
-  "user-tier": "enterprise" | "pro";
-};
-
-const advancedTools = () => {};
-
-const baseTools = () => {};
-
-export const testTool = createTool({
-  execute: async (inputData, context) => {
-    const userTier = context?.requestContext?.get("user-tier") as UserTier["user-tier"];
-
-    return userTier === "enterprise" ? advancedTools : baseTools;
-  },
-});
-```
-
-> **Info:** Visit [Request Context](https://mastra.ai/docs/server/request-context) for more information.
-
-## Testing with Studio
-
-Use [Studio](https://mastra.ai/docs/getting-started/studio) to test tools with different inputs, inspect execution results, and verify tool behavior.

package/dist/docs/references/docs-workflows-input-data-mapping.md

@@ -1,102 +0,0 @@
-# Input Data Mapping
-
-Input data mapping allows explicit mapping of values for the inputs of the next step. These values can come from a number of sources:
-
-- The outputs of a previous step
-- The request context
-- A constant value
-- The initial input of the workflow
-
-## Mapping with `.map()`
-
-In this example the `output` from `step1` is transformed to match the `inputSchema` required for the `step2`. The value from `step1` is available using the `inputData` parameter of the `.map` function.
-
-![Mapping with .map()](/assets/images/workflows-data-mapping-map-87fd84a06b4bbf4b93868a5db99ca179.jpg)
-
-```typescript
-const step1 = createStep({...});
-const step2 = createStep({...});
-
-export const testWorkflow = createWorkflow({...})
-  .then(step1)
-  .map(async ({ inputData }) => {
-    const { value } = inputData;
-    return {
-      output: `new ${value}`
-    };
-  })
-  .then(step2)
-  .commit();
-```
-
-## Using `inputData`
-
-Use `inputData` to access the full output of the previous step:
-
-```typescript
-.then(step1)
-  .map(({ inputData }) => {
-    console.log(inputData);
-  })
-```
-
-## Using `getStepResult()`
-
-Use `getStepResult` to access the full output of a specific step by referencing the step's instance:
-
-```typescript
-.then(step1)
-  .map(async ({ getStepResult }) => {
-    console.log(getStepResult(step1));
-  })
-```
-
-## Using `getInitData<any>()`
-
-Use `getInitData<any>` to access the initial input data provided to the workflow:
-
-```typescript
-.then(step1)
-  .map(async ({ getInitData }) => {
-      console.log(getInitData<any>());
-  })
-```
-
-## Using `mapVariable()`
-
-To use `mapVariable` import the necessary function from the workflows module:
-
-```typescript
-import { mapVariable } from "@mastra/core/workflows";
-```
-
-### Renaming step with `mapVariable()`
-
-You can rename step outputs using the object syntax in `.map()`. In the example below, the `value` output from `step1` is renamed to `details`:
-
-```typescript
-.then(step1)
-  .map({
-    details: mapVariable({
-      step: step,
-      path: "value"
-    })
-  })
-```
-
-### Renaming workflows with `mapVariable()`
-
-You can rename workflow outputs by using **referential composition**. This involves passing the workflow instance as the `initData`.
-
-```typescript
-export const testWorkflow = createWorkflow({...});
-
-testWorkflow
-  .then(step1)
-  .map({
-    details: mapVariable({
-      initData: testWorkflow,
-      path: "value"
-    })
-  })
-```