@mastra/mcp-docs-server 1.2.13-alpha.0 → 1.2.13-alpha.11

package/.docs/docs/getting-started/file-based-agents.md

@@ -1,121 +0,0 @@
-> Discover all available pages from the documentation index: https://mastra.ai/llms.txt
-
-# File-based agents
-
-**Added in:** `@mastra/core@1.50.0`
-
-> **Beta:** This feature is in beta. Breaking changes may occur without a major version bump until the API is stable.
-
-File-based agents are an experimental, convention-based way to define [Mastra agents](https://mastra.ai/docs/agents/overview) and the primitives they use in files under `src/mastra/`, instead of registering them manually on your [`Mastra`](https://mastra.ai/reference/core/mastra-class) instance.
-
-This approach reduces glue code and makes the file system itself a direct representation of your [project structure](https://mastra.ai/reference/project-structure), so both you and your coding agent can understand it at a glance.
-
-You can build your entire project with file-based agents or combine this approach with agents and other primitives defined directly in code for incremental adoption.
-
-File-based agents have some limitations while in beta. They don't support every Mastra feature yet. Runtime configuration and wiring are usually better defined directly in code, along with any related primitives.
-
-> **Note:** All Mastra documentation currently shows agents and primitives defined directly in code. File-based agents use the same underlying concepts and APIs, so the guidance elsewhere in the docs still applies. As file-based agents mature, more examples may use this structure where appropriate.
-
-## Basic layout
-
-A small file-based agent looks like this:
-
-```text
-src/mastra/
-  agents/
-    weather/
-      config.ts
-      instructions.md
-      tools/
-        get-weather.ts
-      skills/
-        forecast-review.md
-```
-
-The main files in an agent directory are:
-
-- [`config.ts`](https://mastra.ai/reference/file-based-agents/config): Model selection and runtime options
-- [`instructions.md`](https://mastra.ai/reference/file-based-agents/instructions): The prompt that applies to every response
-- [`tools/`](https://mastra.ai/reference/file-based-agents/tools): Typed functions the model can call
-- [`skills/`](https://mastra.ai/reference/file-based-agents/skills): Reusable instructions
-
-You need to define `config.ts` and `instructions.md` at a minimum. Add optional files as needed. Learn more in the [add capabilities](#add-capabilities) section.
-
-## Quickstart
-
-Create a folder at `src/mastra/agents/weather`. Inside, add a `config.ts` and an `instructions.md` file with these contents:
-
-```typescript
-import { agentConfig } from '@mastra/core/agent'
-
-export default agentConfig({
-  model: 'openai/gpt-5.6-sol',
-})
-```
-
-```markdown
-You are a helpful weather assistant. Answer questions about current conditions and forecasts.
-```
-
-Start Mastra's development server with `mastra dev`. Inside Studio, you can now call the `weather` agent and ask it about the weather.
-
-## Add capabilities
-
-Map each primitive or feature to its file convention:
-
-| Primitive or feature                                                             | File convention                                                                           |
-| -------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------- |
-| [Agent config](https://mastra.ai/reference/file-based-agents/config)             | `src/mastra/agents/<agent-id>/config.ts`                                                  |
-| [Agent instructions](https://mastra.ai/reference/file-based-agents/instructions) | `src/mastra/agents/<agent-id>/instructions.md`                                            |
-| [Tools](https://mastra.ai/reference/file-based-agents/tools)                     | `src/mastra/agents/<agent-id>/tools/`                                                     |
-| [Skills](https://mastra.ai/reference/file-based-agents/skills)                   | `src/mastra/agents/<agent-id>/skills/`                                                    |
-| [Memory](https://mastra.ai/reference/file-based-agents/memory)                   | `src/mastra/agents/<agent-id>/memory.ts`                                                  |
-| [Workspace](https://mastra.ai/reference/file-based-agents/workspace)             | `src/mastra/agents/<agent-id>/workspace.ts` and `src/mastra/agents/<agent-id>/workspace/` |
-| [Processors](https://mastra.ai/reference/file-based-agents/processors)           | `src/mastra/agents/<agent-id>/processors/`                                                |
-| [Scorers](https://mastra.ai/reference/file-based-agents/scorers)                 | `src/mastra/agents/<agent-id>/scorers/`                                                   |
-| [Subagents](https://mastra.ai/reference/file-based-agents/subagents)             | `src/mastra/agents/<agent-id>/subagents/`                                                 |
-| [Workflows](https://mastra.ai/reference/file-based-agents/workflows)             | `src/mastra/workflows/`                                                                   |
-| [Storage](https://mastra.ai/reference/file-based-agents/storage)                 | `src/mastra/storage.ts`                                                                   |
-| [Observability](https://mastra.ai/reference/file-based-agents/observability)     | `src/mastra/observability.ts`                                                             |
-| [Logger](https://mastra.ai/reference/file-based-agents/logger)                   | `src/mastra/logger.ts`                                                                    |
-| [Server config](https://mastra.ai/reference/file-based-agents/server)            | `src/mastra/server.ts`                                                                    |
-| [Studio config](https://mastra.ai/reference/file-based-agents/studio)            | `src/mastra/studio.ts`                                                                    |
-| [Schedules](https://mastra.ai/docs/long-running-agents/schedules)                | Not yet file-based, create at runtime with `mastra.schedules.create()`                    |
-
-## Discovery lifecycle
-
-File-based primitives are discovered by the Mastra bundler under `mastra dev` and `mastra build`. During discovery, Mastra reads supported files under `src/mastra/`, imports TypeScript and JavaScript modules, reads markdown instructions and skills, copies workspace seed files, and registers the assembled primitives with your Mastra app.
-
-After discovery, a file-based agent runs as a normal [`Agent`](https://mastra.ai/reference/agents/agent). Calling it from the Agent API, Studio, workflows, or your application code uses the same runtime as a code-defined agent.
-
-Discovery is source-based and conservative.
-
-It skips symlinks, test files, and directories that aren't agent directories. Workflows and singleton project files are file-routed only when they have a default export.
-
-Start your app through the Mastra CLI so discovery runs:
-
-**npm**:
-
-```bash
-npx mastra dev
-```
-
-**pnpm**:
-
-```bash
-pnpm dlx mastra dev
-```
-
-**Yarn**:
-
-```bash
-yarn dlx mastra dev
-```
-
-**Bun**:
-
-```bash
-bun x mastra dev
-```
-
-If you import your `mastra` instance directly, `agents/<name>/` directories and the other conventions aren't discovered. When you consume Mastra as a library, register those primitives in code instead.

package/.docs/docs/mastra-platform/workspace.md

@@ -1,111 +0,0 @@
-> Discover all available pages from the documentation index: https://mastra.ai/llms.txt
-
-# Workspace
-
-A workspace gives an environment two things your agents can use at runtime:
-
-- A **bucket** for filesystem storage, exposed to your code as [`PlatformFilesystem`](https://mastra.ai/reference/workspace/platform-filesystem).
-- A **sandbox** for executing commands, exposed as [`PlatformSandbox`](https://mastra.ai/reference/workspace/platform-sandbox).
-
-Workspaces are provisioned per [environment](https://mastra.ai/docs/mastra-platform/environments), so `production` and `staging` each get their own bucket and sandbox. The platform manages provisioning, credentials, and lifecycle. Your deploy code only needs to construct the providers.
-
-## When workspaces are provisioned
-
-New projects have workspaces enabled by default. When you create an environment, the platform provisions a bucket for it automatically. The sandbox base image is warmed in the background so the first `PlatformSandbox` call starts quickly.
-
-Existing projects that haven't opted in show an **Enable workspaces** action in the Workspaces tab. Enabling provisions a bucket for every environment on the project.
-
-If provisioning fails for an environment, for example while Railway is under load, the Workspaces tab shows the failure and offers a retry. The environment itself is still created. Only the workspace is unavailable until you retry.
-
-## Use the workspace from your code
-
-Install the provider package:
-
-**npm**:
-
-```bash
-npm install @mastra/platform-workspace
-```
-
-**pnpm**:
-
-```bash
-pnpm add @mastra/platform-workspace
-```
-
-**Yarn**:
-
-```bash
-yarn add @mastra/platform-workspace
-```
-
-**Bun**:
-
-```bash
-bun add @mastra/platform-workspace
-```
-
-Compose the providers into a workspace and register it with Mastra:
-
-```typescript
-import { Workspace } from '@mastra/core/workspace'
-import { PlatformFilesystem, PlatformSandbox } from '@mastra/platform-workspace'
-
-export const workspace = new Workspace({
-  filesystem: new PlatformFilesystem(),
-  sandbox: new PlatformSandbox(),
-})
-```
-
-```typescript
-import { Mastra } from '@mastra/core'
-import { workspace } from './workspace'
-
-export const mastra = new Mastra({
-  workspace,
-})
-```
-
-`PlatformFilesystem` and `PlatformSandbox` read their credentials from environment variables the platform injects at deploy time, so you don't pass any options on the platform.
-
-## Injected environment variables
-
-Every deploy that runs on a platform environment with a workspace receives these variables:
-
-| Variable                      | Contents                                                                                                                                                 |
-| ----------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `MASTRA_PLATFORM_SECRET_KEY`  | Secret key scoped to the deploy. Used by the workspace providers to authenticate. `MASTRA_PLATFORM_ACCESS_TOKEN` is also injected as a deprecated alias. |
-| `MASTRA_PROJECT_ID`           | Project the deploy belongs to.                                                                                                                           |
-| `MASTRA_ENVIRONMENT_ID`       | Environment the deploy belongs to. Selects which sandbox pool the platform uses.                                                                         |
-| `MASTRA_PLATFORM_BUCKET_NAME` | Bucket name attached to the environment. Selects which bucket `PlatformFilesystem` reads and writes.                                                     |
-
-These names are reserved. If your project sets any of them explicitly, the platform-managed values take precedence.
-
-## Local development
-
-Reuse the same providers locally by putting the four variables in your `.env` file. Get the values from your project's Workspaces tab:
-
-```bash
-MASTRA_PLATFORM_SECRET_KEY=your-secret-key
-MASTRA_PROJECT_ID=your-project-id
-MASTRA_ENVIRONMENT_ID=your-environment-id
-MASTRA_PLATFORM_BUCKET_NAME=your-bucket-name
-```
-
-`PlatformFilesystem` and `PlatformSandbox` behave the same locally as on the platform, they connect to the same bucket and sandbox pool for that environment. Use a `staging` or `preview` environment's variables for local runs if you want to keep production data isolated.
-
-For a purely offline loop that never touches the platform, swap the providers for [`LocalFilesystem`](https://mastra.ai/reference/workspace/local-filesystem) and [`LocalSandbox`](https://mastra.ai/reference/workspace/local-sandbox) in a local build.
-
-## Inspect the workspace
-
-The Workspaces tab in your platform project shows, per environment:
-
-- Bucket status and its contents, with upload, download, and delete actions.
-- Recent sandbox sessions with their command, exit code, and duration.
-- Provisioning failures with a **Retry** action.
-
-## See also
-
-- [`PlatformFilesystem`](https://mastra.ai/reference/workspace/platform-filesystem): reference for the filesystem provider.
-- [`PlatformSandbox`](https://mastra.ai/reference/workspace/platform-sandbox): reference for the sandbox provider.
-- [Environments](https://mastra.ai/docs/mastra-platform/environments): how environments scope workspaces, variables, and databases.

package/.docs/docs/what-is-mastra.md

@@ -1,161 +0,0 @@
-> Discover all available pages from the documentation index: https://mastra.ai/llms.txt
-
-# What is Mastra?
-
-Mastra is an open-source TypeScript framework for building AI applications and autonomous AI systems. Use it for anything from an AI feature inside an existing product to long-running agents that run entire processes on their own, such as a software factory that plans, builds, reviews, and ships code.
-
-Mastra gives you everything you need to build an agent harness out of the box. It's built on established patterns, so you make fewer integration decisions and spend more time on your product. And, as you'd expect from an AI framework, it includes a [skill and CLI](https://mastra.ai/docs/getting-started/build-with-ai) that help your coding agent write accurate, up-to-date Mastra code.
-
-Run Mastra standalone or inside your existing web server, and call your agents from your own code, over HTTP using the [Mastra client](https://mastra.ai/docs/server/mastra-client), or from channels (for example, Slack).
-
-> **📹 Video:** [A quick tour of the Mastra platform](https://www.youtube.com/watch?v=NosES9aJxCc) shows how the pieces fit together.
-
-## Framework
-
-Mastra is batteries-included, but not all-or-nothing. A single agent can start small:
-
-```typescript
-import { Agent } from '@mastra/core/agent'
-import { searchDocs } from '../tools/search-docs'
-
-export const supportAgent = new Agent({
-  id: 'support-agent',
-  name: 'Support Agent',
-  instructions: 'Answer customer support questions clearly.',
-  model: 'openai/gpt-5.6-sol',
-  tools: { searchDocs },
-})
-```
-
-Then add the capabilities your agent needs:
-
-- **Act in real environments**: Use [workspaces](https://mastra.ai/docs/workspace/overview) so agents can read and write files, run commands, and work inside a sandbox.
-- **Bring the right context**: Use tools, [memory](https://mastra.ai/docs/memory/observational-memory), [skills](https://mastra.ai/docs/agents/skills), and domain knowledge so agents remember what matters and stay within the context window.
-- **Coordinate complex work**: Run typed [workflows](https://mastra.ai/docs/workflows/overview), [tasks](https://mastra.ai/docs/agents/using-tools), and [subagents](https://mastra.ai/docs/agents/supervisor-agents) when work needs multiple steps or parallel execution.
-- **Control the agent loop**: [Suspend](https://mastra.ai/docs/agents/agent-approval) for human approval, steer an in-flight loop with [signals](https://mastra.ai/docs/long-running-agents/signals), or queue input for the next turn.
-- **Meet users where they work**: Connect agents to Slack, Discord, GitHub, and other [channels](https://mastra.ai/docs/capabilities/channels/overview).
-- **Manage risk and cost**: Configure authentication, multi-tenant isolation, and [guardrails](https://mastra.ai/docs/agents/guardrails), including [`CostGuardProcessor`](https://mastra.ai/reference/processors/cost-guard-processor).
-
-See the left-hand sidebar for the full menu of features.
-
-## Studio
-
-![Agents page in Mastra Studio. A sidebar lists primitives like agents, workflows, and tools, a middle panel lists recent chats, and a chat panel shows the agent responding to a prompt with collapsible tool calls and a task list tracking progress. Below the chat is a message box with a model picker.](/assets/images/studio-agent-chat-e516834f26abd332aa54cbffa7553028.png)
-
-[Studio](https://mastra.ai/docs/studio/overview) is usually the first place you go after creating a Mastra app. It gives you a live environment for testing agents, inspecting runs, and iterating quickly.
-
-Studio isn't just for engineers. Deploy it and share it with your team, so collaborators can try an agent before it ships. With the [Editor](https://mastra.ai/docs/editor/overview) and [Agent Builder](https://mastra.ai/docs/agent-builder/overview), non-technical teammates can create and iterate on agents themselves, with every change versioned in code.
-
-## Observability and evals
-
-![Traces page in Mastra Studio. A table lists recent agent runs with timestamps and inputs. A details panel shows the selected trace as an expandable tree of model, tool, and workspace spans with per-span timings, plus actions to evaluate the trace or save it as a dataset item.](/assets/images/studio-traces-e061dbd62a9c7f2ac2d61ad172125be6.png)
-
-Mastra has built-in logs, traces, and metrics, so you can understand every run in development and production. See [Observability](https://mastra.ai/docs/observability/overview).
-
-Evals close the loop. Score outputs with rule-based or LLM-as-judge [scorers](https://mastra.ai/docs/evals/overview), live in production or offline in CI. Create datasets from real traces, run experiments, and compare versions. Because you own the code and the observability layer, you get a closed loop from trace to prompt edit to measurable improvement.
-
-## Long-running agents
-
-Some agents finish in a single request. Others run for hours or days, like a sales agent that watches for signups or an SRE agent that handles incidents. Mastra supports [long-running agents](https://mastra.ai/docs/long-running-agents/durable-agents) with these capabilities:
-
-- **Survive restarts and disconnects**: [Durable agents](https://mastra.ai/docs/long-running-agents/durable-agents) persist run state so work resumes and clients reconnect.
-- **Wake and steer agents mid-run**: Send [messages and signals](https://mastra.ai/docs/long-running-agents/signals) to wake an agent, add context, or queue input.
-- **Keep working toward a goal**: [Goals](https://mastra.ai/docs/long-running-agents/goals) persist an objective until it's met or the run budget is spent.
-- **Run work outside the request**: Use [schedules](https://mastra.ai/docs/long-running-agents/schedules) and [background tasks](https://mastra.ai/docs/long-running-agents/background-tasks) for recurring jobs, slow tools, and work that shouldn't block the agent loop.
-
-For long-running interactive applications, [AgentController](https://mastra.ai/docs/agent-controller/overview) manages threads, modes, tool approvals, and model switching. It powers [Mastra Code](https://code.mastra.ai/) and lets you build a Claude Code-style experience for your own domain.
-
-## Deployment
-
-Mastra is open source and infrastructure-neutral. The framework fits your stack instead of requiring your stack to fit one vendor. Choose from an ecosystem of model providers, databases, sandboxes, and observability platforms, and change providers without rewriting your application around proprietary infrastructure.
-
-When you're ready to deploy:
-
-- **[Mastra Server](https://mastra.ai/docs/mastra-platform/server)**: The quickest path to production. Mastra builds and hosts your application as an API server with a stable endpoint, environment variables, custom domains, and deploy history.
-- **Your infrastructure**: Use Mastra's [deployers for major platforms](https://mastra.ai/docs/deployment/overview), deploy a standard server to your preferred virtual machine, container, or platform as a service, or run Mastra inside an existing TypeScript application with a [server adapter](https://mastra.ai/docs/server/server-adapters).
-
-## Use cases
-
-Here are some of the ways you can use Mastra:
-
-<details>
-**Embed agents in your product**
-
-Add AI capabilities to your platform so your users can build or interact with agents.
-
-Used by [Replit](https://mastra.ai/blog/replitagent3), [Fireworks](https://mastra.ai/blog/fireworks-xml-prompting), [Medusa](https://mastra.ai/blog/medusa-ecommerce)
-
-</details>
-
-<details>
-**Customer-facing assistants**
-
-Build agents that handle inquiries, schedule appointments, send reminders, and answer questions via chat, WhatsApp, or voice.
-
-Used by [Vetnio](https://mastra.ai/blog/vetnio), [Lua](https://mastra.ai/blog/lua-scaling)
-
-Templates: [Docs Chatbot](https://mastra.ai/templates/docs-chatbot), [Slack Agent](https://mastra.ai/templates/slack-agent)
-
-</details>
-
-<details>
-**Internal copilots**
-
-Help employees work faster with AI that understands your domain—HR queries, clinical documentation, sales prep, or document generation.
-
-Used by [Factorial](https://mastra.ai/blog/factorial-case-study), [Counsel Health](https://mastra.ai/blog/counsel-health), [Cedar](https://mastra.ai/blog/cedar-case-study), [SoftBank](https://mastra.ai/blog/softbank-productivity-mastra-2025-08-20)
-
-Templates: [Chat with PDF](https://mastra.ai/templates/chat-with-pdf), [Google Sheet Analysis](https://mastra.ai/templates/google-sheets-analysis)
-
-</details>
-
-<details>
-**Data analysis agents**
-
-Let users query databases and dashboards in natural language. Connect to your data sources and return answers, charts, or reports.
-
-Used by [Index](https://mastra.ai/blog/index-case-study), [PLAID Japan](https://mastra.ai/blog/plaid-jpn-gcp-agents)
-
-Templates: [Chat with Database](https://mastra.ai/templates/text-to-sql), [CSV to Questions](https://mastra.ai/templates/csv-to-questions)
-
-</details>
-
-<details>
-**Content automation**
-
-Generate, transform, and manage structured content at scale—whether for a CMS, knowledge base, or documentation system.
-
-Used by [Sanity](https://mastra.ai/blog/sanity)
-
-Templates: [Chat with YouTube](https://mastra.ai/templates/chat-with-youtube), [Flash Cards from PDF](https://mastra.ai/templates/flash-cards-from-pdf)
-
-</details>
-
-<details>
-**DevOps & engineering automation**
-
-Automate deployments, debug production issues, manage infrastructure, and handle on-call workflows.
-
-Used by [StarSling](https://mastra.ai/blog/starsling)
-
-Templates: [GitHub PR Code Review](https://mastra.ai/templates/github-pr-code-review-agent), [Browser Agent](https://mastra.ai/templates/browsing-agent)
-
-</details>
-
-<details>
-**Sales & GTM workflows**
-
-Turn customer conversations into structured tasks, generate investment memos, or automate outreach sequences.
-
-Used by [Kestral](https://mastra.ai/blog/kestral), [Orange Collective](https://mastra.ai/blog/orange-collective-vc-operating-system), [WorkOS](https://mastra.ai/blog/workos-teaching-mastra)
-
-Templates: [Customer Feedback Summarization](https://mastra.ai/templates/customer-feedback-summarization)
-
-</details>
-
-Browse [templates](https://mastra.ai/templates) for working examples.
-
-## Next steps
-
-- [Get started](https://mastra.ai/docs)
-- [Agents overview](https://mastra.ai/docs/agents/overview)

package/.docs/reference/client-js/agent-builder.md

@@ -1,163 +0,0 @@
-> Discover all available pages from the documentation index: https://mastra.ai/llms.txt
-
-# Agent Builder API
-
-The Agent Builder API provides methods to interact with [Agent Builder](https://mastra.ai/docs/agent-builder/overview) actions on the server. Each action is a workflow exposed under `/agent-builder/:actionId/*`. The Builder must be enabled on the server via `MastraEditor.builder.enabled`, with a valid `MASTRA_EE_LICENSE` in production.
-
-## Getting all actions
-
-Retrieve a record of available Agent Builder actions:
-
-```typescript
-const actions = await mastraClient.getAgentBuilderActions()
-```
-
-Returns a `Record<string, WorkflowInfo>` keyed by action ID.
-
-## Working with a specific action
-
-Get an instance of a specific action by its ID:
-
-```typescript
-const action = mastraClient.getAgentBuilderAction('create-agent')
-```
-
-## Action methods
-
-### `details()`
-
-Retrieve metadata about an Agent Builder action:
-
-```typescript
-const info = await action.details()
-```
-
-### `createRun()`
-
-Create a new run for this action and receive a `runId`. Use the returned id with `startActionRun()`, `stream()`, `resume()`, or `observeStream()`.
-
-```typescript
-const { runId } = await action.createRun()
-```
-
-You can also pass an explicit `runId`:
-
-```typescript
-const { runId } = await action.createRun({ runId: 'my-run-id' })
-```
-
-### `startAsync()`
-
-Start the action and wait for completion. Returns the final `AgentBuilderActionResult` with `success`, `applied`, `branchName`, `message`, `validationResults`, `error`, `errors`, and `stepResults`.
-
-```typescript
-const result = await action.startAsync({
-  inputData: { agentName: 'support-bot' },
-})
-```
-
-Pass an existing `runId` as the second argument to start a previously created run:
-
-```typescript
-const { runId } = await action.createRun()
-const result = await action.startAsync({ inputData }, runId)
-```
-
-### `startActionRun()`
-
-Start an existing run without waiting for completion. Returns `{ message }`.
-
-```typescript
-const { runId } = await action.createRun()
-await action.startActionRun({ inputData }, runId)
-```
-
-### `stream()`
-
-Start an existing run and stream progress events as a `ReadableStream<{ type, payload }>`.
-
-```typescript
-const { runId } = await action.createRun()
-const stream = await action.stream({ inputData }, runId)
-
-for await (const event of stream) {
-  console.log(event.type, event.payload)
-}
-```
-
-### `resume()`
-
-Resume a suspended step on a run. Returns `{ message }`.
-
-```typescript
-await action.resume({ step: 'review', resumeData: { approved: true } }, runId)
-```
-
-### `resumeAsync()`
-
-Resume a suspended step and wait for completion. Returns an `AgentBuilderActionResult`.
-
-```typescript
-const result = await action.resumeAsync({ step: 'review', resumeData: { approved: true } }, runId)
-```
-
-### `resumeStream()`
-
-Resume a suspended step and stream subsequent events.
-
-```typescript
-const stream = await action.resumeStream({
-  runId,
-  step: 'review',
-  resumeData: { approved: true },
-})
-```
-
-### `observeStream()`
-
-Attach to an existing run, replaying cached events from the beginning, then continuing with live events. Use this to recover after a page refresh or hot reload.
-
-```typescript
-const stream = await action.observeStream({ runId })
-```
-
-### `observeStreamLegacy()`
-
-Same as `observeStream()` but uses the legacy streaming endpoint. Prefer `observeStream()` for new code.
-
-```typescript
-const stream = await action.observeStreamLegacy({ runId })
-```
-
-### `runs()`
-
-List runs for this action with optional filters.
-
-```typescript
-const runs = await action.runs({ page: 0, perPage: 20 })
-```
-
-Accepts `fromDate`, `toDate`, `page`, `perPage`, `resourceId`, and legacy `limit`/`offset`.
-
-### `runById()`
-
-Fetch a specific run by ID. Use `fields` to limit the returned payload and `withNestedWorkflows` to skip nested workflow data.
-
-```typescript
-const run = await action.runById(runId, {
-  fields: ['result', 'steps'],
-  withNestedWorkflows: false,
-})
-```
-
-### `cancelRun()`
-
-Cancel an in-flight run.
-
-```typescript
-await action.cancelRun(runId)
-```
-
-## Access control
-
-The `/agent-builder/*` routes are gated by the `agent-builder` permission resource. Calling clients need at minimum `agent-builder:read` and `agent-builder:execute`, plus any picker resources the action touches (`stored-agents`, `stored-skills`, `tools`, `workflows`, `memory`). See [Access control](https://mastra.ai/docs/agent-builder/access-control) for the full grant list.

package/.docs/reference/editor/agent-builder/agent-builder-options.md

@@ -1,76 +0,0 @@
-> Discover all available pages from the documentation index: https://mastra.ai/llms.txt
-
-# AgentBuilderOptions
-
-`AgentBuilderOptions` configures the Agent Builder. Pass it as `MastraEditor.builder` to enable the Builder UI, toggle visible surfaces, pin admin defaults, and opt into skill registries.
-
-See the [Configuration](https://mastra.ai/docs/agent-builder/configuration) page for concepts and worked examples.
-
-## Usage example
-
-```typescript
-import { MastraEditor } from '@mastra/editor'
-
-new MastraEditor({
-  builder: {
-    enabled: true,
-    features: {
-      agent: { browser: false },
-    },
-    configuration: {
-      agent: {
-        memory: { observationalMemory: true },
-        models: {
-          allowed: [
-            { provider: 'openai', modelId: 'gpt-5.4-mini' },
-            { provider: 'openai', modelId: 'gpt-5.4' },
-            { provider: 'anthropic', modelId: 'claude-opus-4-7' },
-          ],
-        },
-      },
-    },
-    registries: {
-      skillsSh: { enabled: true },
-    },
-  },
-})
-```
-
-## Properties
-
-**enabled** (`boolean`): Master switch. When false, the Builder UI is disabled and MastraEditor.resolveBuilder() returns undefined. (Default: `true`)
-
-**features** (`{ agent?: AgentFeatures }`): UI toggles. Each key on features.agent defaults to true when omitted.
-
-**features.agent.tools** (`boolean`): Show the tools tab in the agent editor.
-
-**features.agent.agents** (`boolean`): Show the sub-agents picker in the agent editor.
-
-**features.agent.workflows** (`boolean`): Show the workflows picker in the agent editor.
-
-**features.agent.skills** (`boolean`): Show the skills tab and library for the agent.
-
-**features.agent.memory** (`boolean`): Show the memory configuration in the agent editor.
-
-**features.agent.model** (`boolean`): Show the model picker in the agent editor. When false, the admin-pinned default model applies.
-
-**features.agent.browser** (`boolean`): Show the browser tab. Resolves to true only when a valid browser provider is registered on MastraEditor.browsers; otherwise it is downgraded to false and a warning is logged.
-
-**features.agent.avatarUpload** (`boolean`): Allow end users to upload an avatar for stored agents.
-
-**features.agent.favorites** (`boolean`): Show favorite agents and skills with per-user state and aggregate counts.
-
-**configuration** (`{ agent?: BuilderAgentDefaults }`): Admin-pinned defaults applied to every Builder-created agent. End users cannot override these values. See the BuilderAgentDefaults reference for the full schema.
-
-**registries** (`{ skillsSh?: { enabled: boolean } }`): Opt-in third-party skill registries. When no registry is enabled, the Builder hides registry browse UI.
-
-**registries.skillsSh** (`{ enabled: boolean }`): Enable the skills.sh registry. When enabled, the Builder shows registry browse UI for skills.sh skills.
-
-**registries.skillsSh.enabled** (`boolean`): Set to true to opt in. Defaults to false.
-
-## Related
-
-- [Configuration](https://mastra.ai/docs/agent-builder/configuration): Concept and worked examples.
-- [BuilderAgentDefaults](https://mastra.ai/reference/editor/agent-builder/builder-agent-defaults): Full schema for `configuration.agent`.
-- [builder.configuration.agent.models](https://mastra.ai/reference/editor/agent-builder/builder-models): Model allowlist and default model.
-- [MastraEditor class](https://mastra.ai/reference/editor/mastra-editor): The parent surface that hosts `builder`.