@mastra/mcp-docs-server 1.1.32-alpha.4 → 1.1.32-alpha.5

package/.docs/docs/server/server-adapters.md

@@ -20,6 +20,7 @@ Mastra currently provides these official server adapters:
 - [@mastra/hono](https://mastra.ai/reference/server/hono-adapter)
 - [@mastra/fastify](https://mastra.ai/reference/server/fastify-adapter)
 - [@mastra/koa](https://mastra.ai/reference/server/koa-adapter)
+- [@mastra/nestjs](https://mastra.ai/reference/server/nestjs-adapter)
 
 You can build your own adapter, read [custom adapters](https://mastra.ai/docs/server/custom-adapters) for details.
 
@@ -71,7 +72,7 @@ pnpm add @mastra/express@latest
 yarn add @mastra/express@latest
 ```
 
-**Tab 5**:
+**NestJS**:
 
 ```bash
 bun add @mastra/express@latest
@@ -227,6 +228,56 @@ yarn add @mastra/koa@latest
 bun add @mastra/koa@latest
 ```
 
+**Tab 21**:
+
+**npm**:
+
+```bash
+npm install @mastra/nestjs@latest
+```
+
+**pnpm**:
+
+```bash
+pnpm add @mastra/nestjs@latest
+```
+
+**Yarn**:
+
+```bash
+yarn add @mastra/nestjs@latest
+```
+
+**Bun**:
+
+```bash
+bun add @mastra/nestjs@latest
+```
+
+**Tab 22**:
+
+```bash
+npm install @mastra/nestjs@latest
+```
+
+**Tab 23**:
+
+```bash
+pnpm add @mastra/nestjs@latest
+```
+
+**Tab 24**:
+
+```bash
+yarn add @mastra/nestjs@latest
+```
+
+**Tab 25**:
+
+```bash
+bun add @mastra/nestjs@latest
+```
+
 ## Configuration
 
 Initialize your app as usual, then create a `MastraServer` by passing in the `app` and your main `mastra` instance from `src/mastra/index.ts`. Calling `init()` automatically registers Mastra middleware and all available endpoints. You can continue adding your own routes as normal, either before or after `init()`, and they’ll run alongside Mastra’s endpoints.
@@ -336,6 +387,37 @@ app.listen(port, () => {
 
 > **Info:** See the [Koa Adapter](https://mastra.ai/reference/server/koa-adapter) documentation for full configuration options.
 
+**NestJS**:
+
+```typescript
+import { Module } from '@nestjs/common'
+import { MastraModule } from '@mastra/nestjs'
+import { mastra } from './mastra'
+
+@Module({
+  imports: [
+    MastraModule.register({
+      mastra,
+    }),
+  ],
+})
+export class AppModule {}
+```
+
+```typescript
+import { NestFactory } from '@nestjs/core'
+import { AppModule } from './app.module'
+
+async function bootstrap() {
+  const app = await NestFactory.create(AppModule)
+  await app.listen(3000)
+}
+
+bootstrap()
+```
+
+> **Info:** See the [NestJS Adapter](https://mastra.ai/reference/server/nestjs-adapter) documentation for full configuration options.
+
 ## Initialization flow
 
 Calling `init()` runs three steps in order. Understanding this flow helps when you need to insert your own middleware at specific points.
@@ -553,10 +635,11 @@ See [MCP](https://mastra.ai/docs/mcp/overview) for configuration details and how
 
 ## Related
 
-- [Hono Adapter](https://mastra.ai/reference/server/hono-adapter): Hono-specific setup
-- [Express Adapter](https://mastra.ai/reference/server/express-adapter): Express-specific setup
-- [Custom Adapters](https://mastra.ai/docs/server/custom-adapters): Building adapters for other frameworks
-- [Server Configuration](https://mastra.ai/docs/server/mastra-server): Using `mastra build` instead
-- [Authentication](https://mastra.ai/docs/server/auth): Configuring auth for your server
-- [MastraServer Reference](https://mastra.ai/reference/server/mastra-server): Full API reference
-- [createRoute() Reference](https://mastra.ai/reference/server/create-route): Creating type-safe custom routes
+- [Hono Adapter](https://mastra.ai/reference/server/hono-adapter) - Hono-specific setup
+- [Express Adapter](https://mastra.ai/reference/server/express-adapter) - Express-specific setup
+- [NestJS Adapter](https://mastra.ai/reference/server/nestjs-adapter) - NestJS-specific setup
+- [Custom Adapters](https://mastra.ai/docs/server/custom-adapters) - Building adapters for other frameworks
+- [Server Configuration](https://mastra.ai/docs/server/mastra-server) - Using `mastra build` instead
+- [Authentication](https://mastra.ai/docs/server/auth) - Configuring auth for your server
+- [MastraServer Reference](https://mastra.ai/reference/server/mastra-server) - Full API reference
+- [createRoute() Reference](https://mastra.ai/reference/server/create-route) - Creating type-safe custom routes

package/.docs/docs/workspace/search.md

@@ -83,6 +83,45 @@ const workspace = new Workspace({
 })
 ```
 
+### Batch embedding
+
+The embedder above takes one text at a time. Indexing a workspace with hundreds of files calls the provider hundreds of times, which is slow and expensive.
+
+When the provider supports batching (for example, OpenAI's `embedMany`), pass an embedder that takes an array of texts and accepts many embeddings back in one call. To opt in, set a `batch: true` property on the function. Mastra checks for that property at runtime and switches to the batched path.
+
+The following example replaces the single-text embedder with a batched one. The embedder function takes an array, returns an array of embeddings in the same order, and carries two extra properties:
+
+- `batch: true`: marks the function as batch-capable. Without this property, Mastra calls it one text at a time.
+- `maxBatchSize`: the largest array the provider accepts in one call. Mastra splits larger requests into chunks of this size and sends them in parallel. Set this to your provider's documented limit (for example, 2048 for OpenAI, 96 for Cohere, 128 for Voyage). Omit it to send every pending text in one request.
+
+```typescript
+import { Workspace, LocalFilesystem } from '@mastra/core/workspace'
+import { PineconeVector } from '@mastra/pinecone'
+import { embedMany } from 'ai'
+import { openai } from '@ai-sdk/openai'
+
+const model = openai.embedding('text-embedding-3-small')
+
+const workspace = new Workspace({
+  filesystem: new LocalFilesystem({ basePath: './workspace' }),
+  vectorStore: new PineconeVector({
+    apiKey: process.env.PINECONE_API_KEY,
+    index: 'workspace-index',
+  }),
+  embedder: Object.assign(
+    async (texts: string[]) => {
+      const { embeddings } = await embedMany({ model, values: texts })
+      return embeddings
+    },
+    { batch: true as const, maxBatchSize: 2048 },
+  ),
+})
+```
+
+`Object.assign` adds the `batch` and `maxBatchSize` properties to the embedder function. Mastra reads them as metadata and never passes them to the provider.
+
+Single-text embedders still work. The function signature `(text: string) => Promise<number[]>` is unchanged, so existing code keeps running without modification.
+
 ## Hybrid search
 
 Configure both BM25 and vector search to enable hybrid mode, which combines keyword matching with semantic understanding.

package/.docs/guides/getting-started/nestjs.md

@@ -0,0 +1,238 @@
+# Integrate Mastra in Your NestJS Project
+
+In this guide, you'll build a tool-calling AI agent using Mastra and NestJS. The [NestJS server adapter](https://mastra.ai/reference/server/nestjs-adapter) registers Mastra's agent and workflow routes as a NestJS module, so they run inside your existing NestJS application.
+
+## Before you begin
+
+- You'll need an API key from a supported [model provider](https://mastra.ai/models). If you don't have a preference, use [OpenAI](https://mastra.ai/models/providers/openai).
+- Install Node.js `v22.13.0` or later
+- Use the NestJS Express platform (`@nestjs/platform-express`)
+
+## Create a new NestJS app (optional)
+
+If you already have a NestJS app, skip to the next step.
+
+Run the following command to create a new NestJS app:
+
+**npm**:
+
+```bash
+npx @nestjs/cli new mastra-nest
+```
+
+**pnpm**:
+
+```bash
+pnpm dlx @nestjs/cli new mastra-nest
+```
+
+**Yarn**:
+
+```bash
+yarn dlx @nestjs/cli new mastra-nest
+```
+
+**Bun**:
+
+```bash
+bun x @nestjs/cli new mastra-nest
+```
+
+This creates a project called `mastra-nest`, but you can replace it with any name you want.
+
+## Initialize Mastra
+
+Navigate to your NestJS project directory:
+
+```bash
+cd mastra-nest
+```
+
+Run [`mastra init`](https://mastra.ai/reference/cli/mastra). When prompted, choose a provider (e.g. OpenAI) and enter your key:
+
+**npm**:
+
+```bash
+npx mastra@latest init
+```
+
+**pnpm**:
+
+```bash
+pnpm dlx mastra@latest init
+```
+
+**Yarn**:
+
+```bash
+yarn dlx mastra@latest init
+```
+
+**Bun**:
+
+```bash
+bun x mastra@latest init
+```
+
+This creates a `src/mastra` folder with an example weather agent and the following files:
+
+- `index.ts` - Mastra config, including memory
+- `tools/weather-tool.ts` - a tool to fetch weather for a given location
+- `agents/weather-agent.ts` - a weather agent with a prompt that uses the tool
+
+You'll pass the `src/mastra/index.ts` file to the NestJS adapter in the next step.
+
+## Add server adapter
+
+Install the NestJS server adapter package:
+
+**npm**:
+
+```bash
+npm install @mastra/nestjs@latest
+```
+
+**pnpm**:
+
+```bash
+pnpm add @mastra/nestjs@latest
+```
+
+**Yarn**:
+
+```bash
+yarn add @mastra/nestjs@latest
+```
+
+**Bun**:
+
+```bash
+bun add @mastra/nestjs@latest
+```
+
+Open `src/app.module.ts` and register `MastraModule`:
+
+```typescript
+import { Module } from '@nestjs/common'
+import { MastraModule } from '@mastra/nestjs'
+import { mastra } from './mastra'
+
+@Module({
+  imports: [
+    MastraModule.register({
+      mastra,
+    }),
+  ],
+})
+export class AppModule {}
+```
+
+> **Note:** `MastraModule` registers a catch-all controller (`@All('*')`). If it is imported before your app modules, it can intercept unrelated routes and return 404s. To avoid conflicts, import `MastraModule` last or mount it under a dedicated prefix (e.g., `/api/v1/mastra`).
+
+## Test your agent
+
+By default, Mastra's endpoints are added under the `/api` subpath and use your agent/workflow IDs. The default `weather-agent` created by `mastra init` is available at `/api/agents/weather-agent`.
+
+Start your NestJS server:
+
+**npm**:
+
+```bash
+npm run start
+```
+
+**pnpm**:
+
+```bash
+pnpm run start
+```
+
+**Yarn**:
+
+```bash
+yarn run start
+```
+
+**Bun**:
+
+```bash
+bun run start
+```
+
+In a separate terminal window, use `curl` to ask the weather agent:
+
+```bash
+curl -X POST http://localhost:3000/api/agents/weather-agent/generate -H "Content-Type: application/json" -d "{\"messages\":[{\"role\":\"user\",\"content\":\"What is the weather like in Seoul?\"}]}"
+```
+
+## Use Mastra in Your Own Services
+
+The module exports two ways to access Mastra from your NestJS services: the `MastraService` wrapper and the `MASTRA` injection token.
+
+### MastraService
+
+`MastraService` is an injectable wrapper with convenience methods for common operations:
+
+```typescript
+import { Injectable } from '@nestjs/common'
+import { MastraService } from '@mastra/nestjs'
+
+@Injectable()
+export class AgentService {
+  constructor(private readonly mastraService: MastraService) {}
+
+  async chat(agentId: string, message: string) {
+    const agent = this.mastraService.getAgent(agentId)
+    return agent.generate({
+      messages: [{ role: 'user', content: message }],
+    })
+  }
+
+  async runWorkflow(workflowId: string, input: Record<string, unknown>) {
+    const workflow = this.mastraService.getWorkflow(workflowId)
+    return workflow.start({ inputData: input })
+  }
+}
+```
+
+`MastraService` exposes:
+
+- `getMastra()` — returns the underlying `Mastra` instance
+- `getAgent(id)` — shorthand for `mastra.getAgent(id)`
+- `getWorkflow(id)` — shorthand for `mastra.getWorkflow(id)`
+- `getOptions()` — returns the module configuration
+- `isShuttingDown` — `true` after graceful shutdown begins
+
+### MASTRA token
+
+If you need the `Mastra` instance directly (e.g., to access storage, memory, or other core APIs), inject it with the `MASTRA` token:
+
+```typescript
+import { Injectable, Inject } from '@nestjs/common'
+import { MASTRA } from '@mastra/nestjs'
+import type { Mastra } from '@mastra/core/mastra'
+
+@Injectable()
+export class MemoryService {
+  constructor(@Inject(MASTRA) private readonly mastra: Mastra) {}
+
+  async getThreadMessages(threadId: string) {
+    const memory = this.mastra.getMemory()
+    return memory?.getMessages({ threadId })
+  }
+}
+```
+
+Both approaches use the same singleton `Mastra` instance registered by `MastraModule`.
+
+## Next steps
+
+You now have a working Mastra agent running inside NestJS. To extend the project:
+
+- [Agents overview](https://mastra.ai/docs/agents/overview)
+- [Using tools](https://mastra.ai/docs/agents/using-tools)
+- [Agent memory](https://mastra.ai/docs/memory/overview)
+
+For details on the NestJS integration:
+
+- [NestJS Adapter reference](https://mastra.ai/reference/server/nestjs-adapter)

package/.docs/reference/datasets/startExperiment.md

@@ -15,7 +15,7 @@ const mastra = new Mastra({
 
 const dataset = await mastra.datasets.get({ id: 'dataset-id' })
 
-// Run against a registered agent with scorers
+// Run against a registered agent with a flat scorer list
 const summary = await dataset.startExperiment({
   targetType: 'agent',
   targetId: 'my-agent',
@@ -23,8 +23,34 @@ const summary = await dataset.startExperiment({
   maxConcurrency: 10,
 })
 
+// Or pass the same categorised shape accepted by runEvals
+const summary2 = await dataset.startExperiment({
+  targetType: 'agent',
+  targetId: 'my-agent',
+  scorers: {
+    agent: [accuracyScorer],
+    trajectory: [toolOrderScorer],
+  },
+})
+
+// For workflow targets, score individual steps with their own scorers
+const summary3 = await dataset.startExperiment({
+  targetType: 'workflow',
+  targetId: 'my-workflow',
+  scorers: {
+    workflow: [overallScorer],
+    steps: {
+      'fetch-data': [fetchScorer],
+      transform: [transformScorer],
+    },
+    trajectory: [executionPathScorer],
+  },
+})
+
 console.log(`${summary.succeededCount}/${summary.totalItems} succeeded`)
 console.log(`Status: ${summary.status}`)
+console.log(`${summary2.succeededCount}/${summary2.totalItems} succeeded`)
+console.log(`Status: ${summary2.status}`)
 ```
 
 ## Parameters
@@ -33,7 +59,7 @@ console.log(`Status: ${summary.status}`)
 
 **targetId** (`string`): ID of the registered target. Use with \`targetType\`.
 
-**scorers** (`(MastraScorer | string)[]`): Scorers to evaluate each result. Pass \`MastraScorer\` instances or registered scorer IDs.
+**scorers** (`(MastraScorer | string)[] | AgentScorerConfig | WorkflowScorerConfig`): Scorers to evaluate each result. Accepts a flat array of \`MastraScorer\` instances or registered scorer IDs, or the same categorised config shape used by \`runEvals\` (\`AgentScorerConfig\` / \`WorkflowScorerConfig\`). Trajectory scorers (\`type: "trajectory"\`) automatically receive a pre-extracted \`Trajectory\` as their output regardless of which form is used. For workflow targets, per-step scorers can be passed via \`scorers: { steps: { stepId: \[...] } }\` and run against each step's output; their results carry the originating \`stepId\` and keep \`targetScope: "span"\` (matching \`runEvals\`).
 
 **name** (`string`): Display name for the experiment.
 

package/.docs/reference/index.md

@@ -191,6 +191,7 @@ The Reference section provides documentation of Mastra's API, including paramete
 - [Hono Adapter](https://mastra.ai/reference/server/hono-adapter)
 - [Koa Adapter](https://mastra.ai/reference/server/koa-adapter)
 - [MastraServer](https://mastra.ai/reference/server/mastra-server)
+- [NestJS Adapter](https://mastra.ai/reference/server/nestjs-adapter)
 - [registerApiRoute()](https://mastra.ai/reference/server/register-api-route)
 - [Server Routes](https://mastra.ai/reference/server/routes)
 - [Overview](https://mastra.ai/reference/storage/overview)

package/.docs/reference/server/nestjs-adapter.md

@@ -0,0 +1,169 @@
+# NestJS Adapter
+
+The `@mastra/nestjs` package provides a NestJS module for running Mastra with the Express-based NestJS platform.
+
+It is intentionally Express-only for v1. If Nest is bootstrapped with a different HTTP adapter, `MastraModule` throws during startup instead of attempting a partial integration.
+
+> **Info:** For general adapter concepts, see [Server Adapters](https://mastra.ai/docs/server/server-adapters).
+
+## Installation
+
+Install the NestJS adapter and ensure your app uses the Express platform:
+
+**npm**:
+
+```bash
+npm install @mastra/nestjs@latest
+```
+
+**pnpm**:
+
+```bash
+pnpm add @mastra/nestjs@latest
+```
+
+**Yarn**:
+
+```bash
+yarn add @mastra/nestjs@latest
+```
+
+**Bun**:
+
+```bash
+bun add @mastra/nestjs@latest
+```
+
+## Usage example
+
+```typescript
+import { Module } from '@nestjs/common'
+import { MastraModule } from '@mastra/nestjs'
+import { mastra } from './mastra'
+
+@Module({
+  imports: [
+    MastraModule.register({
+      mastra,
+    }),
+  ],
+})
+export class AppModule {}
+```
+
+> **Note:** `MastraModule` registers a catch-all controller (`@All('*')`). If it is imported before your app modules, it can intercept unrelated routes and return 404s. To avoid conflicts, import `MastraModule` last or mount it under a dedicated prefix (e.g., `/api/v1/mastra`).
+
+```typescript
+import { NestFactory } from '@nestjs/core'
+import { AppModule } from './app.module'
+
+async function bootstrap() {
+  const app = await NestFactory.create(AppModule)
+  await app.listen(3000)
+}
+
+bootstrap()
+```
+
+By default, Mastra routes mount under `/api`. Use `prefix` to change it.
+
+## Module options
+
+**mastra** (`Mastra`): Mastra instance
+
+**prefix** (`string`): Route path prefix (e.g., \`/api/v2\`) (Default: `` `/api` ``)
+
+**rateLimitOptions** (`{ enabled?: boolean; defaultLimit?: number; windowMs?: number; generateLimit?: number }`): Rate limiting config (enabled by default)
+
+**shutdownOptions** (`{ timeoutMs?: number; notifyClients?: boolean }`): Graceful shutdown configuration
+
+**bodyLimitOptions** (`{ maxSize?: number; maxFileSize?: number; tempDir?: string; allowedMimeTypes?: string[] }`): Request body size limits
+
+**streamOptions** (`{ redact?: boolean; heartbeatMs?: number }`): Streaming configuration
+
+**tracingOptions** (`{ enabled?: boolean; serviceName?: string }`): OpenTelemetry tracing configuration
+
+**contextOptions** (`{ strict?: boolean; logWarnings?: boolean }`): Request context parsing config
+
+**customRouteAuthConfig** (`Map<string, boolean>`): Per-route auth overrides. Keys are \`METHOD:PATH\`.
+
+**tools** (`Record<string, Tool>`): Registered tools for the server
+
+**taskStore** (`InMemoryTaskStore`): Task store for A2A (Agent-to-Agent) operations
+
+**mcpOptions** (`{ serverless?: boolean; sessionIdGenerator?: () => string }`): MCP transport options
+
+**auth** (`{ enabled?: boolean; allowQueryApiKey?: boolean }`): Enable Mastra token auth. Disabled by default — most NestJS apps use their own auth guards. Query-string \`apiKey\` auth is opt-in for backward compatibility. (Default: `` `{ enabled: false }` ``)
+
+## Async registration
+
+```typescript
+import { Module } from '@nestjs/common'
+import { ConfigModule, ConfigService } from '@nestjs/config'
+import { MastraModule } from '@mastra/nestjs'
+import { Mastra } from '@mastra/core/mastra'
+
+@Module({
+  imports: [
+    ConfigModule.forRoot(),
+    MastraModule.registerAsync({
+      imports: [ConfigModule],
+      useFactory: (config: ConfigService) => ({
+        mastra: new Mastra({
+          agents: {
+            greeter: {
+              name: 'greeter',
+              description: 'Greets the user',
+              model: config.get('MASTRA_MODEL', 'openai/gpt-4o-mini'),
+            },
+          },
+        }),
+        prefix: config.get('MASTRA_PREFIX', '/api'),
+      }),
+      inject: [ConfigService],
+    }),
+  ],
+})
+export class AppModule {}
+```
+
+## Accessing Mastra
+
+Use the `MASTRA` token or `MastraService` in your services:
+
+```typescript
+import { Injectable, Inject } from '@nestjs/common'
+import { MASTRA, MastraService } from '@mastra/nestjs'
+import type { Mastra } from '@mastra/core/mastra'
+
+@Injectable()
+export class AgentService {
+  constructor(@Inject(MASTRA) private readonly mastra: Mastra) {}
+}
+
+@Injectable()
+export class WorkflowService {
+  constructor(private readonly mastraService: MastraService) {}
+}
+```
+
+## MCP routes
+
+MCP endpoints are exposed under the API prefix:
+
+- `POST /api/mcp/:serverId/mcp`
+- `GET /api/mcp/:serverId/sse`
+- `POST /api/mcp/:serverId/messages`
+
+## Health routes
+
+Operational endpoints stay unprefixed on purpose for infrastructure compatibility:
+
+- `GET /health`
+- `GET /ready`
+- `GET /info`
+
+## Related
+
+- [Server Adapters](https://mastra.ai/docs/server/server-adapters)
+- [MastraServer Reference](https://mastra.ai/reference/server/mastra-server)

package/.docs/reference/workspace/workspace-class.md

@@ -37,7 +37,7 @@ const workspace = new Workspace({
 
 **vectorStore** (`MastraVector`): Vector store for semantic search
 
-**embedder** (`(text: string) => Promise<number[]>`): Embedder function for generating vectors. Required when vectorStore is provided.
+**embedder** (`Embedder`): Function that turns text into vectors. Required when \`vectorStore\` is set. Accepts either a single-text function \`(text: string) => Promise\<number\[]>\` or a batch-capable function \`(texts: string\[]) => Promise\<number\[]\[]>\` that has a \`batch: true\` property and an optional \`maxBatchSize\`. See \[Batch embedding]\(/docs/workspace/search#batch-embedding).
 
 **autoIndexPaths** (`string[]`): Paths or glob patterns to auto-index on init(). Supports glob patterns like '\*\*/\*.md' for selective indexing.
 

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # @mastra/mcp-docs-server
 
+## 1.1.32-alpha.5
+
+### Patch Changes
+
+- Updated dependencies [[`8091c7c`](https://github.com/mastra-ai/mastra/commit/8091c7c944d15e13fef6d61b6cfd903f158d4006), [`04151c7`](https://github.com/mastra-ai/mastra/commit/04151c7dcea934b4fe9076708a23fac161195414), [`8091c7c`](https://github.com/mastra-ai/mastra/commit/8091c7c944d15e13fef6d61b6cfd903f158d4006)]:
+  - @mastra/core@1.31.0-alpha.4
+
 ## 1.1.32-alpha.4
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/mcp-docs-server",
-  "version": "1.1.32-alpha.4",
+  "version": "1.1.32-alpha.5",
   "description": "MCP server for accessing Mastra.ai documentation, changelogs, and news.",
   "type": "module",
   "main": "dist/index.js",
@@ -29,8 +29,8 @@
     "jsdom": "^26.1.0",
     "local-pkg": "^1.1.2",
     "zod": "^4.3.6",
-    "@mastra/core": "1.31.0-alpha.3",
-    "@mastra/mcp": "^1.6.0"
+    "@mastra/mcp": "^1.6.0",
+    "@mastra/core": "1.31.0-alpha.4"
   },
   "devDependencies": {
     "@hono/node-server": "^1.19.11",
@@ -48,7 +48,7 @@
     "vitest": "4.1.5",
     "@internal/lint": "0.0.89",
     "@internal/types-builder": "0.0.64",
-    "@mastra/core": "1.31.0-alpha.3"
+    "@mastra/core": "1.31.0-alpha.4"
   },
   "homepage": "https://mastra.ai",
   "repository": {