@mastra/mcp-docs-server 1.1.41 → 1.1.42-alpha.4

package/.docs/docs/agent-builder/access-control.md

@@ -0,0 +1,97 @@
+# Access control
+
+> **Note:** The Agent Builder is part of the Mastra Enterprise Edition. Production deployments require a valid EE license. [Contact sales](https://mastra.ai/contact) for more information.
+
+The Agent Builder ships with two supported roles: `admin` and `member`. Wire them through `Mastra.server.rbac`. Without an RBAC provider, every authenticated user has full Builder access; without authentication, the Builder is open to anyone who can reach the server.
+
+## Roles
+
+| Role     | Permissions         | What they can do                                                                                |
+| -------- | ------------------- | ----------------------------------------------------------------------------------------------- |
+| `admin`  | `*`                 | Full access. Create, edit, publish, and delete agents and skills. Manage every Builder surface. |
+| `member` | scoped list (below) | Open the Builder, browse agents and skills, populate pickers, and chat with the Builder agent.  |
+
+## Minimum permissions
+
+The Builder UI calls several resources on load, so a usable `member` role needs explicit grants on each. The Builder action layer (`/agent-builder/*`) is one resource; the data it reads and writes lives under separate resources.
+
+| Permission                            | Used for                                                      |
+| ------------------------------------- | ------------------------------------------------------------- |
+| `agent-builder:*`                     | Load Builder actions, runs, and stream Builder workflows      |
+| `agents:read`, `agents:execute`       | List registered agents and chat with the Builder agent        |
+| `stored-agents:*`                     | List, view, create, and edit agents                           |
+| `stored-skills:*`                     | List, view, create, and edit stored skills                    |
+| `stored-workspaces:*`                 | Pick a workspace when editing an agent                        |
+| `tools:read`, `tools:execute`         | Populate the tool picker and run tools through agents         |
+| `workflows:read`, `workflows:execute` | Populate the workflow picker and run workflows through agents |
+| `memory:read`                         | Preview memory configuration in the picker                    |
+| `channels:read`                       | Show Slack/channel chips on agent pages                       |
+| `infrastructure:read`                 | Builder diagnostics banner on the shell                       |
+
+Grant `:write`, `:delete`, and `:publish` on `stored-agents` and `stored-skills` for users who should create or modify agents. The `:*` wildcards in the table above cover those actions. `admin` covers everything through the `*` wildcard.
+
+## Quickstart with WorkOS
+
+`@mastra/auth-workos` provides `MastraAuthWorkos` for SSO and `MastraRBACWorkos` for role-based access. Map WorkOS organization roles to the Builder's `admin` and `member` roles via `roleMapping`:
+
+```typescript
+import { MastraAuthWorkos, MastraRBACWorkos } from '@mastra/auth-workos'
+
+export const mastraAuth = new MastraAuthWorkos({
+  redirectUri: process.env.WORKOS_REDIRECT_URI || 'http://localhost:4111/api/auth/callback',
+})
+
+export const rbacProvider = new MastraRBACWorkos({
+  roleMapping: {
+    admin: ['*'],
+    member: [
+      'agent-builder:*',
+      'agents:read',
+      'agents:execute',
+      'stored-agents:*',
+      'stored-skills:*',
+      'stored-workspaces:*',
+      'tools:read',
+      'tools:execute',
+      'workflows:read',
+      'workflows:execute',
+      'memory:read',
+      'channels:read',
+      'infrastructure:read',
+    ],
+    _default: [],
+  },
+})
+```
+
+Register both providers on the Mastra server:
+
+```typescript
+import { Mastra } from '@mastra/core/mastra'
+import { mastraAuth, rbacProvider } from './auth'
+
+export const mastra = new Mastra({
+  server: {
+    auth: mastraAuth,
+    rbac: rbacProvider,
+  },
+  // ...storage, agents, editor
+})
+```
+
+`_default` covers WorkOS roles not listed in the mapping. Omit it to deny unmapped users. Set `WORKOS_API_KEY` and `WORKOS_CLIENT_ID` in your environment.
+
+## Permission grammar
+
+Permission patterns follow `resource:action`. Wildcards are supported on either side:
+
+- `*` — full access (every resource, every action). Used by `admin`.
+- `agent-builder:*` — every action on the `agent-builder` resource.
+- `*:read` — `read` across every resource.
+
+Patterns resolve through `matchesPermission()`. The first matching role permission grants the action.
+
+## Related
+
+- [Configuration](https://mastra.ai/docs/agent-builder/configuration) — wire RBAC alongside the rest of the Builder config.
+- [Deploying](https://mastra.ai/docs/agent-builder/deploying) — auth, RBAC, and EE license setup for production.

package/.docs/docs/agent-builder/browser.md

@@ -0,0 +1,61 @@
+# Browser
+
+> **Note:** The Agent Builder is part of the Mastra Enterprise Edition. Production deployments require a valid EE license. [Contact sales](https://mastra.ai/contact) for more information.
+
+The Agent Builder can give end-user agents a browser tool driven by a registered provider. Unlike filesystems and sandboxes, **there are no built-in browser providers** — you must register one through `MastraEditor.browsers`.
+
+## Quickstart
+
+Register a browser provider on `MastraEditor`, then pin it as the Builder default through `builder.configuration.agent.browser`:
+
+```typescript
+import { MastraEditor } from '@mastra/editor'
+import { StagehandBrowser } from '@mastra/stagehand'
+
+new MastraEditor({
+  browsers: {
+    stagehand: {
+      id: 'stagehand',
+      name: 'Stagehand Browser',
+      createBrowser: config =>
+        new StagehandBrowser({
+          ...config,
+          apiKey: process.env.BROWSERBASE_API_KEY ?? '',
+          env: 'BROWSERBASE',
+          projectId: process.env.BROWSERBASE_PROJECT_ID ?? '',
+        }),
+    },
+  },
+  builder: {
+    enabled: true,
+    configuration: {
+      agent: {
+        browser: {
+          type: 'inline',
+          config: { provider: 'stagehand', headless: true },
+        },
+      },
+    },
+  },
+})
+```
+
+## Browser providers
+
+`MastraEditor.browsers` accepts a `Record<string, BrowserProvider>`. Each provider exposes:
+
+- `id` — provider identifier, matched against `StorageBrowserConfig.provider` (e.g., `'stagehand'`).
+- `name` — display name shown in the Builder UI.
+- `createBrowser(config)` — hydrates a stored browser config into a runtime `MastraBrowser`. This is where you inject runtime-only credentials (API keys, project IDs) that are not stored in the agent snapshot.
+
+Browser classes ship as separate packages (e.g., `@mastra/stagehand`, `@mastra/agent-browser`). The provider entry is a plain object wrapping the class — register one entry per browser you want the Builder to expose to end users. See the [StorageBrowserRef reference](https://mastra.ai/reference/editor/storage-browser-ref) for the full `browser` field schema, including all `StorageBrowserConfig` options.
+
+## Feature toggle
+
+The `features.agent.browser` toggle controls whether end users can enable browser access per agent in the Builder UI. It defaults to `true` only when a valid `configuration.agent.browser` (with a `config.provider`) is provided. Without a registered provider matching the pinned config, the toggle is forced off.
+
+## Related
+
+- [BuilderAgentDefaults reference](https://mastra.ai/reference/editor/agent-builder/builder-agent-defaults) — the full `browser` field schema.
+- [AgentBuilderOptions reference](https://mastra.ai/reference/editor/agent-builder/agent-builder-options) — the full Builder config surface, including `features.agent.browser`.
+- [Configuration](https://mastra.ai/docs/agent-builder/configuration) — wire `browser` alongside the rest of the Builder config.

package/.docs/docs/agent-builder/channels.md

@@ -0,0 +1,76 @@
+# Channels
+
+> **Note:** The Agent Builder is part of the Mastra Enterprise Edition. Production deployments require a valid EE license. [Contact sales](https://mastra.ai/contact) for more information.
+
+Channels let Builder-created agents reach users outside the Mastra server. Register a channel provider on `Mastra.channels` and the Builder exposes the channel as an integration option for every agent.
+
+Slack is currently the only supported channel.
+
+## Quickstart
+
+Install the Slack provider:
+
+**npm**:
+
+```bash
+npm install @mastra/slack
+```
+
+**pnpm**:
+
+```bash
+pnpm add @mastra/slack
+```
+
+**Yarn**:
+
+```bash
+yarn add @mastra/slack
+```
+
+**Bun**:
+
+```bash
+bun add @mastra/slack
+```
+
+Register `SlackProvider` on `Mastra.channels`:
+
+```typescript
+import { Mastra } from '@mastra/core/mastra'
+import { MastraEditor } from '@mastra/editor'
+import { createBuilderAgent } from '@mastra/editor/ee'
+import { SlackProvider } from '@mastra/slack'
+
+export const mastra = new Mastra({
+  storage,
+  channels: {
+    slack: new SlackProvider({
+      refreshToken: process.env.SLACK_APP_CONFIG_REFRESH_TOKEN,
+      baseUrl: process.env.SLACK_BASE_URL,
+    }),
+  },
+  agents: { builderAgent: createBuilderAgent() },
+  editor: new MastraEditor({
+    builder: { enabled: true },
+  }),
+})
+```
+
+The Slack provider handles app creation, OAuth, slash commands, and message routing for every Builder-created agent that opts in.
+
+## Configuration
+
+`SlackProvider` requires one environment variable and accepts one optional override:
+
+- `SLACK_APP_CONFIG_REFRESH_TOKEN` (required): the refresh token from your Slack app configuration tokens, available under **Your App Configuration Tokens** on [api.slack.com/apps](https://api.slack.com/apps). The refresh token does not expire, but the access tokens it issues rotate every 12 hours and are auto-persisted to `Mastra.storage`.
+- `baseUrl` (optional): the public URL Slack should send events and OAuth callbacks to. Defaults to the running Mastra server's host and port (for example, `http://localhost:4111` in local development). Pass `baseUrl` explicitly when the public URL differs from the server's resolved address — typically a tunnel for local development (`cloudflared tunnel --url http://localhost:4111`) or a deployed URL in production.
+
+## Storage requirement
+
+`SlackProvider` requires a persistent storage backend on the `Mastra` instance. Without storage, rotated tokens and app installations are lost on restart.
+
+## Related
+
+- [Deploying](https://mastra.ai/docs/agent-builder/deploying) — set a public `baseUrl` for production deployments.
+- [Configuration](https://mastra.ai/docs/agent-builder/configuration) — wire channel toggles into the Builder UI.

package/.docs/docs/agent-builder/configuration.md

@@ -0,0 +1,147 @@
+# Configuration
+
+> **Note:** The Agent Builder is part of the Mastra Enterprise Edition. Production deployments require a valid EE license. [Contact sales](https://mastra.ai/contact) for more information.
+
+The Agent Builder is configured through `MastraEditor.builder`. Two top-level keys control its behavior: `features` toggles UI visibility and `configuration` pins admin-controlled defaults onto every new agent.
+
+## Quickstart
+
+```typescript
+import { MastraEditor } from '@mastra/editor'
+
+new MastraEditor({
+  builder: {
+    enabled: true,
+    features: {
+      agent: { browser: false },
+    },
+    configuration: {
+      agent: {
+        memory: { observationalMemory: true },
+      },
+    },
+  },
+})
+```
+
+This hides the browser tab in the Builder UI and pins observational memory as the default for every Builder-created agent.
+
+## Feature toggles
+
+`builder.features.agent` controls which sections appear in the Agent Builder UI. Set a key to `false` to hide the corresponding surface.
+
+```typescript
+new MastraEditor({
+  builder: {
+    enabled: true,
+    features: {
+      agent: {
+        tools: true,
+        agents: true,
+        workflows: true,
+        skills: true,
+        memory: true,
+        model: true,
+        browser: true,
+        avatarUpload: true,
+        favorites: true,
+      },
+    },
+  },
+})
+```
+
+The shipping UI consumes these `AgentFeatures` keys: `tools`, `agents`, `workflows`, `skills`, `memory`, `model`, `browser`, `avatarUpload`, and `favorites`. See the [AgentBuilderOptions reference](https://mastra.ai/reference/editor/agent-builder/agent-builder-options) for the full schema.
+
+## Admin defaults
+
+`builder.configuration.agent` pins admin-controlled defaults onto every agent the Builder produces.
+
+```typescript
+new MastraEditor({
+  builder: {
+    enabled: true,
+    configuration: {
+      agent: {
+        models: {
+          allowed: [
+            { provider: 'openai', modelId: 'gpt-5.4-mini' },
+            { provider: 'openai', modelId: 'gpt-5.4' },
+            { provider: 'anthropic', modelId: 'claude-opus-4-7' },
+          ],
+        },
+      },
+    },
+  },
+})
+```
+
+`configuration.agent` accepts `models`, `memory`, `workspace`, `browser`, `tools`, `agents`, and `workflows`. See the [BuilderAgentDefaults reference](https://mastra.ai/reference/editor/agent-builder/builder-agent-defaults) for the full shape.
+
+## Making tools, agents, and workflows available
+
+The Builder picks from whatever you register on the `Mastra` instance. Tools registered through `Mastra({ tools })`, agents registered through `Mastra({ agents })`, and workflows registered through `Mastra({ workflows })` are all candidates for Builder-created agents.
+
+```typescript
+import { Mastra } from '@mastra/core/mastra'
+import { MastraEditor } from '@mastra/editor'
+import { createBuilderAgent } from '@mastra/editor/ee'
+import { weatherInfo } from './tools/weather-info'
+import { webSearch } from './tools/web-search'
+
+export const mastra = new Mastra({
+  tools: {
+    weatherInfo,
+    webSearch,
+    // add MCP tools or additional tools here
+  },
+  agents: {
+    builderAgent: createBuilderAgent(),
+    // add additional agents here
+  },
+  workflows: {
+    // add workflows here
+  },
+  editor: new MastraEditor({
+    builder: { enabled: true },
+  }),
+})
+```
+
+With no `configuration.agent.tools.allowed` set, both `weather-info` and `web-search` appear in the Builder's tool picker. End users can attach either tool to any agent they create.
+
+Entries match on `tool.id`, `Agent.id`, or `workflow.id` — the string the entity reports at runtime, not the export name.
+
+MCP tools work the same way: load them via `MCPClient.getTools()` and spread the result into the `tools` map.
+
+## Tool, agent, and workflow allowlists
+
+`configuration.agent.tools`, `configuration.agent.agents`, and `configuration.agent.workflows` constrain which registered entries appear in the Builder's pickers. Allowlist semantics are the same for all three:
+
+- **Omitted**: unrestricted. The picker shows every registered entry.
+- **`allowed: []`**: explicit lockdown. The picker is empty.
+- **`allowed: [...ids]`**: the picker shows only the listed IDs.
+
+Unknown IDs are dropped and surfaced as warnings through `getModelPolicyWarnings()` and the server logs.
+
+```typescript
+new MastraEditor({
+  builder: {
+    enabled: true,
+    configuration: {
+      agent: {
+        tools: { allowed: ['weather-info', 'web-search'] },
+        agents: { allowed: ['weather-agent'] },
+        workflows: { allowed: ['greet-workflow'] },
+      },
+    },
+  },
+})
+```
+
+## Related
+
+- [Model policy](https://mastra.ai/docs/agent-builder/model-policy) — pin the allowed models and default model.
+- [Memory](https://mastra.ai/docs/agent-builder/memory) — set the default memory shape for new agents.
+- [AgentBuilderOptions reference](https://mastra.ai/reference/editor/agent-builder/agent-builder-options) — full property list.
+- [BuilderAgentDefaults reference](https://mastra.ai/reference/editor/agent-builder/builder-agent-defaults) — every field on `configuration.agent`.

package/.docs/docs/agent-builder/deploying.md

@@ -0,0 +1,121 @@
+# Deploying
+
+> **Note:** The Agent Builder is part of the Mastra Enterprise Edition. Production deployments require a valid EE license. [Contact sales](https://mastra.ai/contact) for more information.
+
+Production deployments swap the local primitives in the Quickstart for cloud-backed equivalents. The shape of the `Mastra` and `MastraEditor` config doesn't change — only the providers behind it.
+
+## What a production deployment needs
+
+1. **EE license** — a valid `MASTRA_EE_LICENSE` so the server will start with the Builder enabled.
+2. **Hosted storage** — a shared store for agents, skills, runs, and memory.
+3. **Shared workspace filesystem** — survives across instances; `local` is single-node only.
+4. **Cloud sandbox** — runs agent commands safely; `local` is unsafe in shared environments.
+5. **Auth and RBAC** — gates the Builder UI and `/agent-builder/*` routes.
+6. **Public base URL for channels** — Slack and other channel providers need a reachable URL.
+
+## EE license
+
+Set `MASTRA_EE_LICENSE` in the deployment environment. The server refuses to start when `builder.enabled` is truthy without a valid license. Treat the license key as a secret.
+
+## Storage
+
+Replace the file-backed LibSQL store with a hosted backend. LibSQL Cloud, PostgreSQL, and any other Mastra storage adapter all work.
+
+```typescript
+import { Mastra } from '@mastra/core/mastra'
+import { LibSQLStore } from '@mastra/libsql'
+
+new Mastra({
+  storage: new LibSQLStore({
+    url: process.env.DATABASE_URL!,
+    authToken: process.env.DATABASE_AUTH_TOKEN,
+  }),
+})
+```
+
+## Workspace filesystem and sandbox
+
+`local` filesystem works only on the node that owns the directory. For multi-instance deployments, register cloud filesystem and sandbox providers on `MastraEditor` and reference them by id in the inline workspace config.
+
+**npm**:
+
+```bash
+npm install @mastra/s3 @mastra/e2b
+```
+
+**pnpm**:
+
+```bash
+pnpm add @mastra/s3 @mastra/e2b
+```
+
+**Yarn**:
+
+```bash
+yarn add @mastra/s3 @mastra/e2b
+```
+
+**Bun**:
+
+```bash
+bun add @mastra/s3 @mastra/e2b
+```
+
+```typescript
+import { Mastra } from '@mastra/core/mastra'
+import { MastraEditor } from '@mastra/editor'
+import { s3FilesystemProvider } from '@mastra/s3'
+import { e2bSandboxProvider } from '@mastra/e2b'
+
+new Mastra({
+  editor: new MastraEditor({
+    filesystems: { [s3FilesystemProvider.id]: s3FilesystemProvider },
+    sandboxes: { [e2bSandboxProvider.id]: e2bSandboxProvider },
+    builder: {
+      enabled: true,
+      configuration: {
+        agent: {
+          workspace: {
+            type: 'inline',
+            config: {
+              name: 'builder-workspace',
+              filesystem: {
+                provider: s3FilesystemProvider.id,
+                config: {
+                  bucket: process.env.S3_BUCKET!,
+                  region: process.env.S3_REGION!,
+                },
+              },
+              sandbox: {
+                provider: e2bSandboxProvider.id,
+                config: { apiKey: process.env.E2B_API_KEY! },
+              },
+            },
+          },
+        },
+      },
+    },
+  }),
+})
+```
+
+`S3Filesystem` uses the default AWS credential chain (environment variables, `~/.aws` config, IAM roles, EC2 instance profile). For long-running deployments, use a credential provider function so credentials refresh automatically.
+
+`DockerSandbox` and `VercelSandbox` are alternative cloud sandbox providers — pick whichever matches your runtime.
+
+> **Warning:** A local sandbox can't run commands safely in a shared environment. Always register a cloud sandbox provider and reference it in the workspace config before deploying.
+
+## Auth and RBAC
+
+A production deployment without authentication exposes the Builder to the public internet. Register a `Mastra.server.auth` provider (for example, WorkOS or your own provider) and a `Mastra.server.rbac` provider to gate access.
+
+See [Access control](https://mastra.ai/docs/agent-builder/access-control) for the required role permissions and a WorkOS quickstart.
+
+## Public URL for channels
+
+Slack needs to reach your server through a public URL. Pass `baseUrl` to `SlackProvider` with the deployed URL (no trailing slash). See [Channels](https://mastra.ai/docs/agent-builder/channels) for the full setup.
+
+## Related
+
+- [Access control](https://mastra.ai/docs/agent-builder/access-control) — auth and RBAC setup.
+- [Channels](https://mastra.ai/docs/agent-builder/channels) — Slack `baseUrl` and channel-specific setup.

package/.docs/docs/agent-builder/memory.md

@@ -0,0 +1,65 @@
+# Memory
+
+> **Note:** The Agent Builder is part of the Mastra Enterprise Edition. Production deployments require a valid EE license. [Contact sales](https://mastra.ai/contact) for more information.
+
+The Agent Builder pins a default memory shape onto every new agent through `builder.configuration.agent.memory`. The default applies when an end user creates a new agent and doesn't override it.
+
+## Quickstart
+
+```typescript
+import { MastraEditor } from '@mastra/editor'
+
+new MastraEditor({
+  builder: {
+    enabled: true,
+    configuration: {
+      agent: {
+        memory: { observationalMemory: true },
+      },
+    },
+  },
+})
+```
+
+Observational memory lets the agent learn long-lived facts from past conversations. Storage on the `Mastra` instance is required — see the [Memory overview](https://mastra.ai/docs/memory/overview) for the prerequisites.
+
+## Observational memory model
+
+Observational memory runs an Observer and Reflector model on top of every conversation. The default model is `google/gemini-2.5-flash`, which requires a `GOOGLE_GENERATIVE_AI_API_KEY` environment variable in any environment where the Builder agent will run.
+
+To use a different model, set `observationalMemory.model` to any model ID supported by the Mastra model router (and provide the matching provider credentials):
+
+```typescript
+new MastraEditor({
+  builder: {
+    enabled: true,
+    configuration: {
+      agent: {
+        memory: {
+          observationalMemory: {
+            model: 'openai/gpt-5.4',
+          },
+        },
+      },
+    },
+  },
+})
+```
+
+The `model` field applies to both the Observer and Reflector. You can also override each one independently via `observation.model` and `reflection.model`. See the [SerializedMemoryConfig reference](https://mastra.ai/reference/memory/serialized-memory-config) for the full shape.
+
+## Storage and vector requirements
+
+Memory features layer on top of `Mastra.storage`:
+
+- **Message history** (`options.lastMessages`) requires storage.
+- **Observational memory** (`observationalMemory: true`) requires storage.
+- **Semantic recall** (`options.semanticRecall`) requires storage plus a registered vector adapter (`vector`) and an embedder (`embedder`).
+
+If a required adapter is missing, Mastra throws a descriptive error at agent run time. See [Semantic recall](https://mastra.ai/docs/memory/semantic-recall) for the full list of supported vector stores and embedders.
+
+## Related
+
+- [Memory overview](https://mastra.ai/docs/memory/overview) — concepts and core configuration.
+- [BuilderAgentDefaults reference](https://mastra.ai/reference/editor/agent-builder/builder-agent-defaults) — the full `memory` field schema.
+- [Configuration](https://mastra.ai/docs/agent-builder/configuration) — wire `memory` alongside the rest of the Builder config.

package/.docs/docs/agent-builder/model-policy.md

@@ -0,0 +1,48 @@
+# Model policy
+
+> **Note:** The Agent Builder is part of the Mastra Enterprise Edition. Production deployments require a valid EE license. [Contact sales](https://mastra.ai/contact) for more information.
+
+The model policy controls which providers and models Builder-created agents can use, which model is selected by default, and whether end users can change it. The policy lives at `builder.configuration.agent.models`.
+
+## Quickstart
+
+```typescript
+import { MastraEditor } from '@mastra/editor'
+
+new MastraEditor({
+  builder: {
+    enabled: true,
+    configuration: {
+      agent: {
+        models: {
+          allowed: [
+            { provider: 'openai', modelId: 'gpt-5.4-mini' },
+            { provider: 'openai', modelId: 'gpt-5.4' },
+            { provider: 'anthropic', modelId: 'claude-opus-4-7' },
+          ],
+        },
+      },
+    },
+  },
+})
+```
+
+This restricts the Builder's model picker to two OpenAI models and one Anthropic model. End users choose one when creating an agent.
+
+## Validation rules
+
+Mastra validates the model policy at server boot. Violations are surfaced as warnings through `getModelPolicyWarnings()`.
+
+- When `allowed` is empty or omitted, every registered model is available.
+- When `allowed` is non-empty, `default` (if set) must satisfy the allowlist. A `default` that fails this check is dropped and surfaced as a warning.
+- To hide the end-user model picker, set `features.agent.model: false` in [AgentBuilderOptions](https://mastra.ai/reference/editor/agent-builder/agent-builder-options). When the picker is hidden, provide a `default` so new agents resolve a model.
+
+Registered providers (`provider: 'openai'`, `provider: 'anthropic'`, and so on) can omit `modelId` to allow every model from that provider.
+
+See the [`builder.configuration.agent.models`](https://mastra.ai/reference/editor/agent-builder/builder-models) reference for every admin-writable field and validation rules.
+
+## Related
+
+- [Configuration](https://mastra.ai/docs/agent-builder/configuration) — wire the model policy into the broader Builder config.
+- [`builder.configuration.agent.models`](https://mastra.ai/reference/editor/agent-builder/builder-models) — full property list.
+- [Provider registry](https://github.com/mastra-ai/mastra/blob/main/packages/core/src/llm/model/provider-registry.json) — every model ID Mastra recognizes out of the box.