@mastra/mcp-docs-server 0.13.20 → 0.13.21-alpha.1

package/.docs/raw/reference/scorers/answer-similarity.mdx

@@ -0,0 +1,179 @@
+---
+title: "Reference: Answer Similarity | Scorers | Mastra Docs"
+description: Documentation for the Answer Similarity Scorer in Mastra, which compares agent outputs against ground truth answers for CI/CD testing.
+---
+
+# Answer Similarity Scorer
+
+The `createAnswerSimilarityScorer()` function creates a scorer that evaluates how similar an agent's output is to a ground truth answer. This scorer is specifically designed for CI/CD testing scenarios where you have expected answers and want to ensure consistency over time.
+
+For usage examples, see the [Answer Similarity Examples](/examples/scorers/answer-similarity).
+
+## Parameters
+
+<PropertiesTable
+  content={[
+    {
+      name: "model",
+      type: "LanguageModel",
+      required: true,
+      description: "The language model used to evaluate semantic similarity between outputs and ground truth.",
+    },
+    {
+      name: "options",
+      type: "AnswerSimilarityOptions",
+      required: false,
+      description: "Configuration options for the scorer.",
+    },
+  ]}
+/>
+
+### AnswerSimilarityOptions
+
+<PropertiesTable
+  content={[
+    {
+      name: "requireGroundTruth",
+      type: "boolean",
+      required: false,
+      defaultValue: "true",
+      description: "Whether to require ground truth for evaluation. If false, missing ground truth returns score 0.",
+    },
+    {
+      name: "semanticThreshold",
+      type: "number",
+      required: false,
+      defaultValue: "0.8",
+      description: "Weight for semantic matches vs exact matches (0-1).",
+    },
+    {
+      name: "exactMatchBonus",
+      type: "number",
+      required: false,
+      defaultValue: "0.2",
+      description: "Additional score bonus for exact matches (0-1).",
+    },
+    {
+      name: "missingPenalty",
+      type: "number",
+      required: false,
+      defaultValue: "0.15",
+      description: "Penalty per missing key concept from ground truth.",
+    },
+    {
+      name: "contradictionPenalty",
+      type: "number",
+      required: false,
+      defaultValue: "1.0",
+      description: "Penalty for contradictory information. High value ensures wrong answers score near 0.",
+    },
+    {
+      name: "extraInfoPenalty",
+      type: "number",
+      required: false,
+      defaultValue: "0.05",
+      description: "Mild penalty for extra information not present in ground truth (capped at 0.2).",
+    },
+    {
+      name: "scale",
+      type: "number",
+      required: false,
+      defaultValue: "1",
+      description: "Score scaling factor.",
+    },
+  ]}
+/>
+
+This function returns an instance of the MastraScorer class. The `.run()` method accepts the same input as other scorers (see the [MastraScorer reference](./mastra-scorer)), but **requires ground truth** to be provided in the run object.
+
+## .run() Returns
+
+<PropertiesTable
+  content={[
+    {
+      name: "runId",
+      type: "string",
+      description: "The id of the run (optional).",
+    },
+    {
+      name: "score",
+      type: "number",
+      description: "Similarity score between 0-1 (or 0-scale if custom scale used). Higher scores indicate better similarity to ground truth.",
+    },
+    {
+      name: "reason",
+      type: "string",
+      description: "Human-readable explanation of the score with actionable feedback.",
+    },
+    {
+      name: "preprocessStepResult",
+      type: "object",
+      description: "Extracted semantic units from output and ground truth.",
+    },
+    {
+      name: "analyzeStepResult",
+      type: "object",
+      description: "Detailed analysis of matches, contradictions, and extra information.",
+    },
+    {
+      name: "preprocessPrompt",
+      type: "string",
+      description: "The prompt used for semantic unit extraction.",
+    },
+    {
+      name: "analyzePrompt",
+      type: "string",
+      description: "The prompt used for similarity analysis.",
+    },
+    {
+      name: "generateReasonPrompt",
+      type: "string",
+      description: "The prompt used for generating the explanation.",
+    },
+  ]}
+/>
+
+## Usage with runExperiment
+
+This scorer is designed for use with `runExperiment` for CI/CD testing:
+
+```typescript
+import { runExperiment } from '@mastra/core/scores';
+import { createAnswerSimilarityScorer } from '@mastra/evals/scorers/llm';
+
+const scorer = createAnswerSimilarityScorer({ model });
+
+await runExperiment({
+  data: [
+    { 
+      input: "What is the capital of France?",
+      groundTruth: "Paris is the capital of France"
+    }
+  ],
+  scorers: [scorer],
+  target: myAgent,
+  onItemComplete: ({ scorerResults }) => {
+    // Assert similarity score meets threshold
+    expect(scorerResults['Answer Similarity Scorer'].score).toBeGreaterThan(0.8);
+  }
+});
+```
+
+## Key Features
+
+- **Semantic Analysis**: Uses LLM to extract and compare semantic units rather than simple string matching
+- **Contradiction Detection**: Identifies factually incorrect information and scores it near 0
+- **Flexible Matching**: Supports exact, semantic, partial, and missing match types
+- **CI/CD Ready**: Designed for automated testing with ground truth comparison
+- **Actionable Feedback**: Provides specific explanations of what matched and what needs improvement
+
+## Scoring Algorithm
+
+The scorer uses a multi-step process:
+
+1. **Extract**: Breaks down output and ground truth into semantic units
+2. **Analyze**: Compares units and identifies matches, contradictions, and gaps
+3. **Score**: Calculates weighted similarity with penalties for contradictions
+4. **Reason**: Generates human-readable explanation
+
+Score calculation: `max(0, base_score - contradiction_penalty - missing_penalty - extra_info_penalty) × scale`

package/.docs/raw/scorers/off-the-shelf-scorers.mdx

@@ -14,6 +14,7 @@ Mastra provides a comprehensive set of built-in scorers for evaluating AI output
 These scorers evaluate how correct, truthful, and complete your agent's answers are:
 
 - [`answer-relevancy`](/reference/scorers/answer-relevancy): Evaluates how well responses address the input query (`0-1`, higher is better)
+- [`answer-similarity`](/reference/scorers/answer-similarity): Compares agent outputs against ground truth answers for CI/CD testing using semantic analysis (`0-1`, higher is better)
 - [`faithfulness`](/reference/scorers/faithfulness): Measures how accurately responses represent provided context (`0-1`, higher is better)
 - [`hallucination`](/reference/scorers/hallucination): Detects factual contradictions and unsupported claims (`0-1`, lower is better)
 - [`completeness`](/reference/scorers/completeness): Checks if responses include all necessary information (`0-1`, higher is better)

package/.docs/raw/server-db/production-server.mdx

@@ -7,7 +7,7 @@ description: "Learn how to configure and deploy a production-ready Mastra server
 
 When deploying your Mastra application to production, it runs as an HTTP server that exposes your agents, workflows, and other functionality as API endpoints. This page covers how to configure and customize the server for a production environment.
 
-## Server Architecture
+## Server architecture
 
 Mastra uses [Hono](https://hono.dev) as its underlying HTTP server framework. When you build a Mastra application using `mastra build`, it generates a Hono-based HTTP server in the `.mastra` directory.
 
@@ -45,7 +45,32 @@ The `method` option can be one of `"GET"`, `"POST"`, `"PUT"`,
 `"DELETE"` or `"ALL"`. Using `"ALL"` will cause the handler to be
 invoked for any HTTP method that matches the path.
 
-## Custom CORS Config
+## TypeScript configuration
+
+Mastra requires `module` and `moduleResolution` values that support modern Node.js versions. Older settings like `CommonJS` or `node` are incompatible with Mastra’s packages and will cause resolution errors.
+
+```json {4-5} filename="tsconfig.json" copy
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ES2022",
+    "moduleResolution": "bundler",
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "noEmit": true,
+    "outDir": "dist"
+  },
+  "include": [
+    "src/**/*"
+  ]
+}
+```
+
+> This TypeScript configuration is optimized for Mastra projects, using modern module resolution and strict type checking.
+
+## CORS configuration
 
 Mastra allows you to configure CORS (Cross-Origin Resource Sharing) settings for your server.
 

package/.docs/raw/tools-mcp/mcp-overview.mdx

@@ -7,108 +7,177 @@ import { Tabs } from "nextra/components";
 
 # MCP Overview
 
-[Model Context Protocol (MCP)](https://modelcontextprotocol.io/introduction) is an open standard designed to let AI models discover and interact with external tools and resources. Think of it as a universal plugin system for AI agents, allowing them to use tools regardless of the language they were written in or where they are hosted.
+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 uses MCP to connect agents to external tool servers.
+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.
 
-## Use third-party tools with an MCP Client
+Mastra currently supports two MCP classes:
 
-Mastra provides the `MCPClient` class to manage connections to one or more MCP servers and access their tools.
+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.
 
-### Installation
+## Getting started
 
-If you haven't already, install the Mastra MCP package:
+To use MCP, install the required dependency:
 
-```bash npm2yarn copy
+```bash
 npm install @mastra/mcp@latest
 ```
 
-### Registering the MCPServer
+## Configuring `MCPClient`
 
-Register your MCP server with Mastra to enable logging and access to configured tools and integrations:
+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.
 
-```ts showLineNumbers filename="src/mastra/index.ts" copy
-import { Mastra } from "@mastra/core";
-import { myMcpServer } from "./mcpServers";
-
-export const mastra = new Mastra({
-  mcpServers: { myMcpServer },
-});
-```
-
-### Configuring `MCPClient`
-
-You configure `MCPClient` with a map of servers you want to connect to. It supports connections via subprocess (Stdio) or HTTP (Streamable HTTP with SSE fallback).
-
-```typescript
+```typescript filename="src/mastra/mcp/test-mcp-client.ts" showLineNumbers copy
 import { MCPClient } from "@mastra/mcp";
 
-const mcp = new MCPClient({
+export const testMcpClient = new MCPClient({
+  id: "test-mcp-client",
   servers: {
-    // Stdio example
-    sequential: {
+    wikipedia: {
       command: "npx",
-      args: ["-y", "@modelcontextprotocol/server-sequential-thinking"],
+      args: ["-y", "wikipedia-mcp"]
     },
-    // HTTP example
     weather: {
-      url: new URL("http://localhost:8080/mcp"),
-      requestInit: {
-        headers: {
-          Authorization: "Bearer your-token",
-        },
-      },
+      url: new URL(`https://server.smithery.ai/@smithery-ai/national-weather-service/mcp?api_key=${process.env.SMITHERY_API_KEY}`)
     },
-  },
+  }
 });
 ```
 
-For detailed configuration options, see the [`MCPClient` reference documentation](/reference/tools/mcp-client).
+> See [MCPClient](../../reference/tools/mcp-client.mdx) for a full list of configuration options.
+
+## Using `MCPClient` with an agent
+
+To use tools from an MCP server in an agent, import your `MCPClient` and call `.getTools()` in the `tools` parameter. This loads from the defined MCP servers, making them available to the agent.
 
-### Static vs Dynamic Tool Configurations
+```typescript {4,16} filename="src/mastra/agents/test-agent.ts" showLineNumbers copy
+import { openai } from "@ai-sdk/openai";
+import { Agent } from "@mastra/core/agent";
+
+import { testMcpClient } from "../mcp/test-mcp-client";
+
+export const testAgent = new 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-4o-mini"),
+  tools: await testMcpClient.getTools()
+});
+```
+> See the [Agent Class](../../reference/agents/agent.mdx) 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 filename="src/mastra/mcp/test-mcp-server.ts" showLineNumbers copy
+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",
+  name: "Test Server",
+  version: "1.0.0",
+  agents: { testAgent },
+  tools: { testTool },
+  workflows: { testWorkflow }
+});
+```
+
+> See [MCPServer](../../reference/tools/mcp-server.mdx) for a full list of configuration options.
+
+## 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 filename="src/mastra/index.ts" showLineNumbers copy
+import { Mastra } from "@mastra/core/mastra";
+
+import { testMcpServer } from "./mcp/test-mcp-server";
+
+export const mastra = new Mastra({
+  // ...
+  mcpServers: { testMcpServer }
+});
+```
+
+## Static and dynamic tools
 
 `MCPClient` offers two approaches to retrieving tools from connected servers, suitable for different application architectures:
 
-| Feature           | Static Configuration (`await mcp.getTools()`) | Dynamic Configuration (`await mcp.getToolsets()`)  |
-| :---------------- | :-------------------------------------------- | :------------------------------------------------- |
-| **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 |
+| Feature           | Static Configuration (`await mcp.getTools()`)  | Dynamic Configuration (`await mcp.getToolsets()`)     |
+| :---------------- | :---------------------------------------------| :--------------------------------------------------- |
+| **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 `.getTools()` 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.
+
+> See [getTools()](../../reference/tools/mcp-client.mdx#gettools) for more information.
+
+```typescript {8} filename="src/mastra/agents/test-agent.ts" showLineNumbers copy
+import { openai } from "@ai-sdk/openai";
+import { Agent } from "@mastra/core/agent";
+
+import { testMcpClient } from "../mcp/test-mcp-client";
 
-- **Static Configuration (`getTools()`):** Fetches all tools from all configured servers. Best when the tool configuration (like API keys) is static and shared across all users or requests. You typically call this once and pass the result to the `tools` property when defining your `Agent`.
-  [Reference: `getTools()`](/reference/tools/mcp-client#gettools)
+export const testAgent = new Agent({
+  // ...
+  tools: await testMcpClient.getTools()
+});
+```
+
+### Dynamic tools
 
-  ```typescript
-  import { Agent } from "@mastra/core/agent";
-  // ... mcp client setup
+Use the `.getToolsets()` 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.
 
-  const agent = new Agent({
-    // ... other agent config
-    tools: await mcp.getTools(),
+```typescript {5-16,21} showLineNumbers copy
+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}`
+          }
+        }
+      }
+    }
   });
-  ```
 
-- **Dynamic Configuration (`getToolsets()`):** Designed for scenarios where configuration might change per request or per user (e.g., different API keys for different tenants in a multi-user application). You pass the result of `getToolsets()` to the `toolsets` option in the agent's `generate()` or `stream()` method.
-  [Reference: `getToolsets()`](/reference/tools/mcp-client#gettoolsets)
+  const agent = mastra.getAgent("testAgent");
 
-  ```typescript
-  import { Agent } from "@mastra/core/agent";
-  // ... agent setup without tools initially
+  const response = await agent.generate(userPrompt, {
+    toolsets: await userMcp.getToolsets()
+  });
+
+  await userMcp.disconnect();
+
+  return Response.json({
+    data: response.text
+  });
+}
+```
+
+> See [getToolsets()](../../reference/tools/mcp-client.mdx#gettoolsets) for more information.
 
-  async function handleRequest(userPrompt: string, userApiKey: string) {
-    const userMcp = new MCPClient({
-      /* config with userApiKey */
-    });
-    const toolsets = await userMcp.getToolsets();
 
-    const response = await agent.stream(userPrompt, {
-      toolsets, // Pass dynamic toolsets
-    });
-    // ... handle response
-    await userMcp.disconnect();
-  }
-  ```
 
 ## Connecting to an MCP registry
 
@@ -239,7 +308,7 @@ Each tab shows the specific URL patterns and configuration needed for that regis
     <Tabs.Tab>
 
     [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
 
@@ -261,7 +330,7 @@ Each tab shows the specific URL patterns and configuration needed for that regis
 
     ```typescript
     // If you prefer to run the MCP server locally:
-    
+
     import { MCPClient } from "@mastra/mcp";
 
     // MCPClient with Ampersand MCP Server using stdio transport
@@ -294,92 +363,8 @@ Each tab shows the specific URL patterns and configuration needed for that regis
   </Tabs.Tab>
 </Tabs>
 
-## Share your tools with an MCP server
-
-If you have created your own Mastra tools, you can expose them to any MCP-compatible client using Mastra's `MCPServer` class.
-
-Similarly, Mastra `Agent` and `Workflow` instances can also be exposed as tools via `MCPServer`. This allows other MCP clients to interact with your agents by "asking" them questions or run your workflows. Each agent provided in the `MCPServer` configuration will be converted into a tool named `ask_<agentKey>`, using the agent's `description` property. Each workflow will be converted into a tool named `run_<workflowKey>`, using its `inputSchema` and `description`.
-
-This allows others to use your tools, agents, and workflows without needing direct access to your codebase.
-
-### Using `MCPServer`
-
-You initialize `MCPServer` with a name, version, and the Mastra tools, agents, and/or workflows you want to share.
-
-```typescript
-import { MCPServer } from "@mastra/mcp";
-import { Agent } from "@mastra/core/agent";
-import { openai } from "@ai-sdk/openai";
-import { weatherTool } from "./tools"; // Your Mastra tool
-import { weatherAgent } from "./agents"; // Your Mastra Agent
-import { dataWorkflow } from "./workflows"; // Your Mastra Workflow
-
-const server = new MCPServer({
-  name: "My Custom Server",
-  version: "1.0.0",
-  tools: { weatherTool }, // Provide your tool(s) here
-  agents: { weatherAgent }, // Provide your agent(s) here
-  workflows: { dataWorkflow }, // Provide your workflow(s) here
-});
-
-// Start the server (e.g., using stdio for a CLI tool)
-// await server.startStdio();
-
-// Or integrate with an HTTP server using startSSE()
-// See MCPServer reference for details
-```
-
-For an agent to be exposed as a tool, it must have a non-empty `description` string. Similarly, for a workflow to be exposed, its `description` must also be a non-empty string. If the description is missing or empty for either, `MCPServer` will throw an error during initialization.
-Workflows will use their `inputSchema` for the tool's input.
-
-### Tools with Structured Outputs
-
-You can define an `outputSchema` for your tools to enforce a specific structure for the tool's output. This is useful for ensuring that the tool returns data in a consistent and predictable format, which can then be validated by the client.
-
-When a tool includes an `outputSchema`, its `execute` function **must** return an object. The value of the object must conform to the `outputSchema`. Mastra will automatically validate this output on both the server and client sides.
-
-Here's an example of a tool with an `outputSchema`:
-
-```typescript filename="src/tools/structured-tool.ts"
-import { createTool } from '@mastra/core/tools';
-import { z } from 'zod';
-
-export const structuredTool = createTool({
-  description: 'A test tool that returns structured data.',
-  parameters: z.object({
-    input: z.string().describe('Some input string.'),
-  }),
-  outputSchema: z.object({
-    processedInput: z.string().describe('The processed input string.'),
-    timestamp: z.string().describe('An ISO timestamp.'),
-  }),
-  execute: async ({ input }) => {
-    // When outputSchema is defined, you must return an object
-    return {
-      processedInput: `processed: ${input}`,
-      timestamp: new Date().toISOString(),
-    };
-  },
-});
-```
-
-When this tool is called, the MCP client will receive both the structured data and a text representation of it.
-
-```
-Tool result
-
-{
-  "content": [
-    {
-      "type": "text",
-      "text": "{\"processedInput\": \"hello\", \"timestamp\": \"2025-06-19T16:53:16.472Z\"}"
-    }
-  ],
-  "structuredContent": {
-    "processedInput": "processed: hello",
-    "timestamp": "2025-06-19T16:53:16.472Z",
-  }
-}
-```
+## Related
 
-For detailed usage and examples, see the [`MCPServer` reference documentation](/reference/tools/mcp-server).
+- [Using Tools and MCP](../agents/using-tools-and-mcp.mdx)
+- [MCPClient](../../reference/tools/mcp-client.mdx)
+- [MCPServer](../../reference/tools/mcp-server.mdx)

package/.docs/raw/workflows/control-flow.mdx

@@ -55,7 +55,7 @@ This executes `step1` and `step2` concurrently, then continues to `step3` after
 
 > See [Parallel Execution with Steps](../../examples/workflows/parallel-steps.mdx) for more information.
 
-> 📹 Watch: How to run steps in parallel and optimize your Mastra workflow → [YouTube (3 minutes)](https://youtu.be/pTSOSWbreE0)
+> 📹 Watch: How to run steps in parallel and optimize your Mastra workflow → [YouTube (3 minutes)](https://youtu.be/GQJxve5Hki4)
 
 ## Conditional logic with `.branch()`
 

package/.docs/raw/workflows/suspend-and-resume.mdx

@@ -15,6 +15,11 @@ Common scenarios for suspending workflows include:
 - Rate limiting or throttling expensive operations
 - Handling event-driven processes with external triggers
 
+> **New to suspend and resume?** Watch these official video tutorials:
+>
+> - **[Mastering Human-in-the-Loop with Suspend & Resume](https://youtu.be/aORuNG8Tq_k)** - Learn how to suspend workflows and accept user inputs
+> - **[Building Multi-Turn Chat Interfaces with React](https://youtu.be/UMVm8YZwlxc)** - Implement multi-turn human-involved interactions with a React chat interface
+
 ## Workflow status types
 
 When running a workflow, its `status` can be one of the following:

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @mastra/mcp-docs-server
 
+## 0.13.21-alpha.1
+
+### Patch Changes
+
+- Updated dependencies [[`2a6585f`](https://github.com/mastra-ai/mastra/commit/2a6585f7cb71f023f805d521d1c3c95fb9a3aa59), [`3d26e83`](https://github.com/mastra-ai/mastra/commit/3d26e8353a945719028f087cc6ac4b06f0ce27d2), [`56e55d1`](https://github.com/mastra-ai/mastra/commit/56e55d1e9eb63e7d9e41aa46e012aae471256812)]:
+  - @mastra/core@0.16.3-alpha.1
+
+## 0.13.21-alpha.0
+
+### Patch Changes
+
+- Improve security ([#7648](https://github.com/mastra-ai/mastra/pull/7648))
+
+- Updated dependencies [[`b4379f7`](https://github.com/mastra-ai/mastra/commit/b4379f703fd74474f253420e8c3a684f2c4b2f8e), [`dd9119b`](https://github.com/mastra-ai/mastra/commit/dd9119b175a8f389082f75c12750e51f96d65dca), [`d34aaa1`](https://github.com/mastra-ai/mastra/commit/d34aaa1da5d3c5f991740f59e2fe6d28d3e2dd91), [`ce1e580`](https://github.com/mastra-ai/mastra/commit/ce1e580f6391e94a0c6816a9c5db0a21566a262f), [`b2babfa`](https://github.com/mastra-ai/mastra/commit/b2babfa9e75b22f2759179e71d8473f6dc5421ed), [`d8c3ba5`](https://github.com/mastra-ai/mastra/commit/d8c3ba516f4173282d293f7e64769cfc8738d360), [`a566c4e`](https://github.com/mastra-ai/mastra/commit/a566c4e92d86c1671707c54359b1d33934f7cc13), [`af333aa`](https://github.com/mastra-ai/mastra/commit/af333aa30fe6d1b127024b03a64736c46eddeca2), [`3863c52`](https://github.com/mastra-ai/mastra/commit/3863c52d44b4e5779968b802d977e87adf939d8e), [`6424c7e`](https://github.com/mastra-ai/mastra/commit/6424c7ec38b6921d66212431db1e0958f441b2a7), [`db94750`](https://github.com/mastra-ai/mastra/commit/db94750a41fd29b43eb1f7ce8e97ba8b9978c91b), [`a66a371`](https://github.com/mastra-ai/mastra/commit/a66a3716b00553d7f01842be9deb34f720b10fab), [`69fc3cd`](https://github.com/mastra-ai/mastra/commit/69fc3cd0fd814901785bdcf49bf536ab1e7fd975)]:
+  - @mastra/core@0.16.3-alpha.0
+
 ## 0.13.20
 
 ### Patch Changes