@mastra/mcp-docs-server 1.2.13 → 1.2.14-alpha.3

package/.docs/docs/observability/integrations/exporters/confident-ai.md

@@ -0,0 +1,140 @@
+> Discover all available pages from the documentation index: https://mastra.ai/llms.txt
+
+# Confident AI exporter
+
+[Confident AI](https://www.confident-ai.com/) is an LLM observability and evaluation platform for teams to build reliable AI applications in both development and production.
+
+The `@mastra/deepeval` package sends your Mastra traces to Confident AI, where you can run metrics against them and track quality over time. It builds on [DeepEval](https://www.confident-ai.com/docs), the open-source evaluation SDK behind the platform.
+
+## Installation
+
+**npm**:
+
+```bash
+npm install @mastra/deepeval@latest
+```
+
+**pnpm**:
+
+```bash
+pnpm add @mastra/deepeval@latest
+```
+
+**Yarn**:
+
+```bash
+yarn add @mastra/deepeval@latest
+```
+
+**Bun**:
+
+```bash
+bun add @mastra/deepeval@latest
+```
+
+## Configuration
+
+### Prerequisites
+
+1. **Confident AI account**: Sign up at [confident-ai.com](https://www.confident-ai.com/)
+2. **API key**: Generate one in your Confident AI project settings
+3. **Environment variables**: Set your credentials:
+
+```bash
+CONFIDENT_API_KEY=confident_proj_xxxxxxxxxxxxx
+
+# Optional
+CONFIDENT_TRACE_ENVIRONMENT=production  # Defaults to "development"
+```
+
+### Zero-Config Setup
+
+With environment variables set, use the exporter with no configuration:
+
+```typescript
+import { Mastra } from '@mastra/core'
+import { Observability } from '@mastra/observability'
+import { DeepEvalExporter } from '@mastra/deepeval'
+
+export const mastra = new Mastra({
+  observability: new Observability({
+    configs: {
+      deepeval: {
+        serviceName: 'my-service',
+        exporters: [new DeepEvalExporter()],
+      },
+    },
+  }),
+})
+```
+
+### Explicit Configuration
+
+You can also pass credentials directly (takes precedence over environment variables):
+
+```typescript
+import { Mastra } from '@mastra/core'
+import { Observability } from '@mastra/observability'
+import { DeepEvalExporter } from '@mastra/deepeval'
+
+export const mastra = new Mastra({
+  observability: new Observability({
+    configs: {
+      deepeval: {
+        serviceName: 'my-service',
+        exporters: [
+          new DeepEvalExporter({
+            apiKey: process.env.CONFIDENT_API_KEY,
+            environment: 'production',
+          }),
+        ],
+      },
+    },
+  }),
+})
+```
+
+### Metric collections
+
+Confident AI evaluates incoming traces against metric collections defined in your project. Attach them at the trace level or per span type. Trace-level metrics run against the whole trace, and per-type metrics run against matching spans.
+
+```typescript
+new DeepEvalExporter({
+  metricCollection: 'trace-metrics', // trace-level
+  llmMetricCollection: 'llm-metrics', // applied to LLM spans
+  agentMetricCollection: 'agent-metrics', // applied to agent spans
+  toolMetricCollectionMap: {
+    search: 'search-tool-metrics', // applied to the "search" tool
+  },
+})
+```
+
+### Complete Configuration
+
+```typescript
+new DeepEvalExporter({
+  apiKey: process.env.CONFIDENT_API_KEY,
+  environment: 'production', // Default: "development"
+  name: 'my-trace', // Default: the Mastra serviceName
+  tags: ['production'],
+  metadata: { team: 'growth' },
+})
+```
+
+## Span type mapping
+
+Mastra spans map to the span types shown in Confident AI:
+
+| Mastra span type                                                       | Confident AI span type |
+| ---------------------------------------------------------------------- | ---------------------- |
+| `AGENT_RUN`, `WORKFLOW_RUN`                                            | `AGENT`                |
+| `MODEL_GENERATION`                                                     | `LLM`                  |
+| `TOOL_CALL`, `MCP_TOOL_CALL`, `PROVIDER_TOOL_CALL`, `CLIENT_TOOL_CALL` | `TOOL`                 |
+| `RAG_EMBEDDING`, `RAG_VECTOR_OPERATION`                                | `RETRIEVER`            |
+| All other exported span types                                          | `CUSTOM`               |
+
+## Related
+
+- [Tracing Overview](https://mastra.ai/docs/observability/tracing/overview)
+- [DeepEvalExporter reference](https://mastra.ai/reference/observability/tracing/exporters/confident-ai)
+- [Confident AI documentation](https://www.confident-ai.com/docs)

package/.docs/docs/observability/integrations/overview.md

@@ -41,7 +41,7 @@ Processors transform or redact spans before export:
 
 ## Next steps
 
-- [Configuration](https://mastra.ai/docs/observability/config)
+- [Configuration](https://mastra.ai/docs/observability/overview)
 - [Tracing](https://mastra.ai/docs/observability/tracing/overview)
 - [Mastra Storage](https://mastra.ai/docs/observability/integrations/exporters/mastra-storage)
 - [OpenTelemetry bridge](https://mastra.ai/docs/observability/integrations/bridges/otel)

package/.docs/docs/observability/overview.md

@@ -4,8 +4,8 @@
 
 Mastra's observability system gives you visibility into every agent run, workflow step, tool call, and model interaction. Agent behavior depends on model responses, prompts, tools, memory, and workflow state, so observability helps you inspect runtime decisions from day one. It captures complementary signals that work together to help you understand what your application is doing and why.
 
-- [**Configuration**](https://mastra.ai/docs/observability/config): Configure observability once for traces, logs, metrics, and feedback.
-- [**Storage**](https://mastra.ai/docs/observability/storage): Choose storage backends for persisted traces, logs, metrics aggregation, and feedback queries.
+- [**Configuration**](#configuration): Configure observability once for traces, logs, metrics, and feedback.
+- [**Storage**](#storage): Choose storage backends for persisted traces, logs, metrics aggregation, and feedback queries.
 - [**Tracing**](https://mastra.ai/docs/observability/tracing/overview): Records every operation as a hierarchical timeline of spans, capturing inputs, outputs, token usage, and timing.
 - [**Logging**](https://mastra.ai/docs/observability/logging): Forwards structured log entries from your application and Mastra internals to observability storage, correlated to traces automatically.
 - [**Metrics**](https://mastra.ai/docs/observability/metrics/overview): Extracts trace usage and cost data. No additional instrumentation is required.
@@ -96,21 +96,137 @@ export const mastra = new Mastra({
         spanOutputProcessors: [
           new SensitiveDataFilter(), // Redacts sensitive data like passwords, tokens, keys
         ],
+        logging: {
+          enabled: true,
+          level: 'info',
+        },
       },
     },
   }),
 })
 ```
 
-It enables tracing, log forwarding, and metrics. Mastra also supports external tracing providers like Langfuse, Datadog, and any OpenTelemetry-compatible platform. Use [Configuration](https://mastra.ai/docs/observability/config), [Storage](https://mastra.ai/docs/observability/storage), and [Integrations overview](https://mastra.ai/docs/observability/integrations/overview) to set up observability.
+It enables tracing, log forwarding, and metrics. Mastra also supports external tracing providers like Langfuse, Datadog, and any OpenTelemetry-compatible platform. See [Maintaining Studio access](#maintaining-studio-access) to keep Mastra Studio access while sending data to an external provider.
 
-## Mastra platform
+## Configuration
 
-For hosted traces, logs, and metrics across projects and deploys, see [Observability on Mastra platform](https://mastra.ai/docs/mastra-platform/observability).
+Observability is configured once on your Mastra instance and applies across traces, logs, and metrics.
+
+### Basic config
+
+An observability config usually contains:
+
+- `serviceName`: The service identifier attached to exported observability data.
+- `exporters`: One or more destinations for traces, logs, and derived metrics.
+- `spanOutputProcessors`: Transformations that run before spans are exported.
+- `logging`: Log forwarding settings for observability storage.
+
+For destinations and processors, see [Integrations overview](https://mastra.ai/docs/observability/integrations/overview).
+
+### Maintaining Studio access
+
+When you add external exporters, keep `MastraStorageExporter` for Studio observability and/or `MastraPlatformExporter` for hosted Mastra platform observability.
+
+The following example shows only the observability config. Configure storage separately.
+
+```ts
+import { Observability, MastraStorageExporter, MastraPlatformExporter } from '@mastra/observability'
+import { ArizeExporter } from '@mastra/arize'
+
+export const observability = new Observability({
+  configs: {
+    production: {
+      serviceName: 'my-service',
+      exporters: [
+        new ArizeExporter({
+          endpoint: process.env.PHOENIX_COLLECTOR_ENDPOINT,
+          apiKey: process.env.PHOENIX_API_KEY,
+        }),
+        new MastraStorageExporter(),
+        new MastraPlatformExporter(),
+      ],
+    },
+  },
+})
+```
+
+### Flushing in serverless environments
+
+In serverless environments, flush observability exporters before the runtime pauses or exits:
+
+```ts
+await mastra.observability.flush()
+```
+
+Use external storage in serverless environments instead of local file storage. See [Storage](#storage) for storage selection and routing.
+
+### Multi-config setup
+
+Use multiple configs when different environments or request types need different exporters or sampling behavior. Select the active config at runtime with `configSelector`.
+
+```ts
+import { Mastra } from '@mastra/core'
+import { Observability, MastraStorageExporter } from '@mastra/observability'
+import { LangfuseExporter } from '@mastra/langfuse'
+
+const storageExporter = new MastraStorageExporter()
+const langfuseExporter = new LangfuseExporter()
+
+export const mastra = new Mastra({
+  observability: new Observability({
+    configs: {
+      development: {
+        serviceName: 'my-service-dev',
+        exporters: [storageExporter],
+      },
+      production: {
+        serviceName: 'my-service-prod',
+        exporters: [storageExporter, langfuseExporter],
+      },
+    },
+    configSelector: () => process.env.NODE_ENV || 'development',
+  }),
+})
+```
+
+For trace sampling, see [Tracing](https://mastra.ai/docs/observability/tracing/overview).
 
 ## Storage
 
-Not all storage backends support every signal. Traces work with most backends, but metrics and logs require an OLAP-capable store like DuckDB (development) or ClickHouse (production). For setup guidance, see [Storage](https://mastra.ai/docs/observability/storage).
+Storage determines which observability signals persist, which queries are available, and whether metrics aggregation works. Use a dedicated observability store instead of your primary application store.
+
+### Signal support
+
+Storage support depends on the signal and workload. `MastraStorageExporter` can persist traces to ClickHouse, PostgreSQL, MSSQL, MongoDB, and LibSQL. Metrics require an analytics-capable store:
+
+- DuckDB: Recommended for local testing and development.
+- ClickHouse: Recommended for high-volume production observability.
+- `PostgresStoreVNext`: Supports metrics when the observability domain is enabled. Always provide a time range to avoid full partition scans.
+- Mastra platform: Use `MastraPlatformExporter` for hosted observability without managing the backend yourself.
+
+For the complete provider list and supported tracing strategies, see [Mastra Storage exporter](https://mastra.ai/docs/observability/integrations/exporters/mastra-storage). Use composite storage to route the `observability` domain separately when your primary store doesn't support observability or when the workload needs independent scaling.
+
+### Local development
+
+For local development, use:
+
+- `LibSQLStore` for primary application storage
+- `DuckDBStore` for the `observability` domain
+- `MastraStorageExporter` for local Studio access
+
+### Production deployment
+
+Observability traffic is usually more write-heavy than the rest of the application. In production:
+
+- Use `MastraStorageExporter` with ClickHouse for the `observability` domain when you keep observability in your own storage.
+- Use `MastraPlatformExporter` for hosted Mastra platform observability instead of managing the backend yourself.
+- Use composite storage when observability needs a different backend or scaling policy from your primary application data.
+
+For backend compatibility details and exporter batching behavior, see [Mastra Storage exporter](https://mastra.ai/docs/observability/integrations/exporters/mastra-storage).
+
+## Mastra platform
+
+For hosted traces, logs, and metrics across projects and deploys, see [Observability on Mastra platform](https://mastra.ai/docs/mastra-platform/observability).
 
 ## Next steps
 
@@ -118,8 +234,6 @@ Not all storage backends support every signal. Traces work with most backends, b
 - [Logging](https://mastra.ai/docs/observability/logging)
 - [Metrics](https://mastra.ai/docs/observability/metrics/overview)
 - [Feedback](https://mastra.ai/docs/observability/feedback)
-- [Configuration](https://mastra.ai/docs/observability/config)
-- [Storage](https://mastra.ai/docs/observability/storage)
 - [Integrations overview](https://mastra.ai/docs/observability/integrations/overview)
 - [Mastra Studio](https://mastra.ai/docs/studio/observability)
 - [Automatic metrics reference](https://mastra.ai/reference/observability/metrics/automatic-metrics)

package/.docs/docs/observability/tracing/overview.md

@@ -19,8 +19,8 @@ This page focuses on trace-specific concepts: span hierarchy, sampling, metadata
 
 To get started with tracing, configure observability in your Mastra instance and run an agent or workflow. You can configure behavior through the following features:
 
-- [Configuration](https://mastra.ai/docs/observability/config): Base observability config and multiple configs, plus serverless flushing
-- [Storage](https://mastra.ai/docs/observability/storage): Storage routing for traces, logs, and metrics
+- [Configuration](https://mastra.ai/docs/observability/overview): Base observability config and multiple configs, plus serverless flushing
+- [Storage](https://mastra.ai/docs/observability/overview): Storage routing for traces, logs, and metrics
 - [Integrations overview](https://mastra.ai/docs/observability/integrations/overview): Exporters, bridges, and processors
 
 ## Sampling strategies

package/.docs/docs/server/mastra-client.md

@@ -73,7 +73,7 @@ The Mastra Client SDK exposes all resources served by the Mastra Server.
 
 Use `upsertStoredWorkflow()` to create or replace a persisted workflow definition. A successful upsert validates the complete definition, registers it with the running Mastra instance, and makes it available through the standard workflow execution API.
 
-The following example creates a mapping workflow, reads the stored definition, runs it, and then deletes it:
+The following example shows the full lifecycle of a mapping workflow, from creation and inspection through execution and deletion:
 
 ```typescript
 import { MastraClient } from '@mastra/client-js'

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

@@ -4,6 +4,8 @@
 
 Server adapters let you run Mastra with your own HTTP server instead of the Hono server generated by `mastra build`. They provide more control over the server setup, including custom middleware ordering, authentication, logging, and deployment configuration. You can still integrate Mastra into any Node.js application without changing how agents or workflows execute.
 
+> **Warning:** Server adapters use the `mastra` instance you pass them and don't run file-based discovery. Register agents on that instance in code. To use file-based agents, run Mastra as a separate server with `mastra dev` or `mastra build`.
+
 ## When to use server adapters
 
 - You want Mastra’s endpoints added automatically to an existing application

package/.docs/docs/storage/overview.md

@@ -184,7 +184,7 @@ export const mastra = new Mastra({
 })
 ```
 
-You can also route `observability` to a dedicated analytics backend. See [observability storage](https://mastra.ai/docs/observability/storage) for an observability-specific example.
+You can also route `observability` to a dedicated analytics backend. See the [observability quickstart](https://mastra.ai/docs/observability/overview) for an observability-specific example.
 
 ## Supported providers
 
@@ -211,4 +211,4 @@ Each provider page includes installation instructions, configuration parameters,
 - [Storage retention](https://mastra.ai/reference/storage/retention)
 - [Storage schemas](https://mastra.ai/reference/storage/overview)
 - [Memory](https://mastra.ai/docs/memory/overview)
-- [Observability storage](https://mastra.ai/docs/observability/storage)
+- [Observability storage](https://mastra.ai/docs/observability/overview)

package/.docs/guides/build-your-ui/copilotkit/channels.md

@@ -2,70 +2,69 @@
 
 # CopilotKit channels
 
-The same Mastra agent that powers your in-app copilot can also run as a bot in messaging platforms. CopilotKit's bot layer connects your agent to Slack, Discord, Telegram, WhatsApp, and Microsoft Teams, with threads, tool calls, and human-in-the-loop approvals handled in the channel.
+The same Mastra agent that powers your in-app copilot can also run as a bot in messaging platforms. CopilotKit's Channels SDK connects your agent to Slack and other messaging platforms, with threads, tool calls, rich interactive messages, and human-in-the-loop approvals handled natively in the channel.
 
-> **Info:** The full setup lives in the [CopilotKit bot documentation](https://docs.copilotkit.ai/slack). This page shows how it fits together with a Mastra agent.
+> **Info:** Full platform setup lives in the [CopilotKit Channels documentation](https://docs.copilotkit.ai/slack/mastra). This page shows how Channels fit together with a Mastra agent.
 
 ## How it fits together
 
-Your Mastra agent stays where it's, exposed through `registerCopilotKit()` as described in [CopilotKit overview](https://mastra.ai/guides/build-your-ui/copilotkit/overview). The bot is a separate process built with `@copilotkit/bot`: you attach one or more platform adapters and point the bot at your agent. `createBot` takes an array of adapters, so a single bot can serve several platforms at once.
+Your Mastra agent stays where it's deployed, exposed over AG-UI through `registerCopilotKit()` (see [CopilotKit overview](https://mastra.ai/guides/build-your-ui/copilotkit/overview)). A channel is a separate long-running process built with `@copilotkit/channels`: you attach one or more platform adapters and point the channel at your agent. `createChannel` takes an array of adapters, so a single process can serve several platforms at once.
 
-```typescript
-import { createBot } from '@copilotkit/bot'
-import { slack } from '@copilotkit/bot-slack'
-
-const bot = createBot({
-  adapters: [
-    slack({
-      botToken: process.env.SLACK_BOT_TOKEN!,
-      appToken: process.env.SLACK_APP_TOKEN!,
-    }),
-  ],
-  // Point the bot at your agent.
-  agent: threadId => {
-    // ...connect to your CopilotKit runtime / Mastra agent
-  },
-})
-
-bot.onMention(async ({ thread }) => {
-  await thread.runAgent()
-})
-
-await bot.start()
-```
-
-Rich messages are written as JSX and rendered to each platform's native message format (Block Kit on Slack, for example), so an interactive card degrades gracefully where a platform has no equivalent.
-
-## Slack
-
-The [Slack quickstart](https://docs.copilotkit.ai/slack) takes you from zero to a bot you can `@`-mention in a channel, then adds an interactive button card. Slack runs over Socket Mode, which opens an outbound WebSocket to Slack, so no public URL or tunnel is required during development.
-
-Install the packages:
+Install the SDK (batteries-included, every adapter):
 
 **npm**:
 
 ```bash
-npm install @copilotkit/bot @copilotkit/bot-ui @copilotkit/bot-slack
+npm install @copilotkit/channels
 ```
 
 **pnpm**:
 
 ```bash
-pnpm add @copilotkit/bot @copilotkit/bot-ui @copilotkit/bot-slack
+pnpm add @copilotkit/channels
 ```
 
 **Yarn**:
 
 ```bash
-yarn add @copilotkit/bot @copilotkit/bot-ui @copilotkit/bot-slack
+yarn add @copilotkit/channels
 ```
 
 **Bun**:
 
 ```bash
-bun add @copilotkit/bot @copilotkit/bot-ui @copilotkit/bot-slack
+bun add @copilotkit/channels
 ```
 
+```typescript
+import { createChannel, Message, Section } from '@copilotkit/channels'
+import { slack } from '@copilotkit/channels/slack'
+import { mastraAgent } from './agent' // your AG-UI Mastra agent
+
+const channel = createChannel({
+  // Point the channel at your Mastra agent (an AbstractAgent, or a per-thread factory).
+  agent: mastraAgent,
+  adapters: [
+    slack({
+      botToken: process.env.SLACK_BOT_TOKEN!,
+      appToken: process.env.SLACK_APP_TOKEN!,
+    }),
+  ],
+})
+
+channel.onMention(async ({ thread }) => {
+  await thread.runAgent()
+})
+
+await channel.start()
+```
+
+The agent receives ordinary AG-UI input and emits ordinary AG-UI events; the platform mechanics stay behind the adapter, so the same Mastra agent runs unchanged across every channel. Rich messages are written as JSX and rendered to each platform's native format (Block Kit on Slack, for example), so an interactive card degrades gracefully where a platform has no equivalent.
+
+## Slack
+
+The [Slack quickstart](https://docs.copilotkit.ai/slack/mastra) takes you from zero to a bot you can `@`-mention in a channel, then adds an interactive button card. Slack runs over Socket Mode, which opens an outbound WebSocket to Slack, so no public URL or tunnel is required during development.
+
 Set the Slack credentials in your environment:
 
 - `SLACK_BOT_TOKEN`: Bot User OAuth token (`xoxb-...`)
@@ -73,4 +72,15 @@ Set the Slack credentials in your environment:
 
 ## Other platforms
 
-The bot adapters share one `@copilotkit/bot` API and differ only in what each platform natively supports. For Discord, Telegram, WhatsApp, and Microsoft Teams, set the relevant platform credentials and add the matching adapter to the `adapters` array. See the [CopilotKit bot documentation](https://docs.copilotkit.ai/slack) for platform-specific setup.
+The Channels SDK isn't limited to Slack. Other platforms like Microsoft Teams run through the same `@copilotkit/channels` API: add the matching adapter to the `adapters` array and the rest of your agent code stays the same. See the [CopilotKit Channels documentation](https://docs.copilotkit.ai/slack/mastra) for the current platform list and per-platform setup.
+
+## Message pipeline and architecture
+
+Managed channels keep a deliberate credential split, which matters when your Mastra agent uses separate model keys and tools:
+
+- **You keep** the agent logic, model credentials, tools, and the channel process.
+- **CopilotKit Intelligence holds** the platform credentials, message delivery, registration, health, and reconnects.
+
+A turn begins when a user messages the app. Intelligence receives the platform event, and the gateway delivers the turn to your running channel process. Your Mastra agent runs and renders a reply. Intelligence then returns the reply as native platform content. Platform credentials never enter the agent process, and enterprise Intelligence can be self-hosted for data residency.
+
+> **Note:** By default, interactive actions live in memory and reset on restart. Back the channel with a durable action and state store (Redis or Postgres) so buttons and per-thread state survive restarts and span multiple instances.

package/.docs/guides/concepts/multi-agent-systems.md

@@ -44,7 +44,7 @@ A supervisor pattern keeps one lead agent in control for the full task. The supe
 
 Use this pattern when the task is open-ended and the full sequence isn't known in advance. For example, a research task may require different lines of inquiry based on what earlier steps uncover. A supervisor can adapt as the task unfolds. The tradeoff is that the supervisor becomes the main coordination point. That makes the pattern flexible, but it also means the result depends heavily on good delegation behavior and clear subagent boundaries.
 
-In Mastra, this pattern maps directly to [supervisor agents](https://mastra.ai/docs/agents/supervisor-agents). A supervisor agent defines subagents on the `agents` property and uses `stream()` or `generate()` to coordinate them. Mastra also provides delegation hooks, message filtering, and memory isolation to help control this pattern.
+In Mastra, this pattern maps directly to [supervisor agents](https://mastra.ai/docs/capabilities/subagents). A supervisor agent defines subagents on the `agents` property and uses `stream()` or `generate()` to coordinate them. Mastra also provides delegation hooks, message filtering, and memory isolation to help control this pattern.
 
 > **Tip:** Follow the [supervisor agents tutorial](https://mastra.ai/guides/guide/research-coordinator) for a step-by-step guide.
 
@@ -60,12 +60,12 @@ Mastra doesn't provide a dedicated council primitive. In Mastra, implement this
 
 These patterns differ mainly in how they distribute control:
 
-| Pattern           | Who stays in control | Use when                                         | Tradeoff                                                 | Mastra implementation                                                |
-| ----------------- | -------------------- | ------------------------------------------------ | -------------------------------------------------------- | -------------------------------------------------------------------- |
-| Handoffs          | Current specialist   | Ownership should move between specialists        | Context transfer becomes more important                  | Agents with workflows and memory                                     |
-| Workflows         | Execution graph      | The path is known in advance                     | Less adaptive when the task changes                      | [Workflows](https://mastra.ai/docs/workflows/overview)               |
-| Supervisor agents | One lead agent       | Delegation must adapt during execution           | Results depend on good coordination and clear boundaries | [Supervisor agents](https://mastra.ai/docs/agents/supervisor-agents) |
-| Council           | Final synthesis step | The task needs multiple independent perspectives | Higher cost and latency                                  | Agents with workflow parallelism                                     |
+| Pattern           | Who stays in control | Use when                                         | Tradeoff                                                 | Mastra implementation                                              |
+| ----------------- | -------------------- | ------------------------------------------------ | -------------------------------------------------------- | ------------------------------------------------------------------ |
+| Handoffs          | Current specialist   | Ownership should move between specialists        | Context transfer becomes more important                  | Agents with workflows and memory                                   |
+| Workflows         | Execution graph      | The path is known in advance                     | Less adaptive when the task changes                      | [Workflows](https://mastra.ai/docs/workflows/overview)             |
+| Supervisor agents | One lead agent       | Delegation must adapt during execution           | Results depend on good coordination and clear boundaries | [Supervisor agents](https://mastra.ai/docs/capabilities/subagents) |
+| Council           | Final synthesis step | The task needs multiple independent perspectives | Higher cost and latency                                  | Agents with workflow parallelism                                   |
 
 In practice, these patterns are often combined:
 

package/.docs/guides/guide/coding-agent.md

@@ -191,7 +191,7 @@ export async function createCodingAgentSession() {
 }
 ```
 
-This example uses one mode and disables the controller's additional built-in tools so the introductory UI can focus on workspace execution. The simplified setup is intended for this tutorial. In a production application, enable the built-in tools your product needs and implement their UI flows: interactive tools such as `ask_user` and `submit_plan` suspend until your interface resumes them, while task and subagent tools have their own lifecycle events. See [tool approvals and suspensions](https://mastra.ai/docs/agent-controller/tool-approvals).
+This example uses one mode and disables the controller's additional built-in tools so the introductory UI can focus on workspace execution. The simplified setup is intended for this tutorial. In a production application, enable the built-in tools your product needs and implement their UI flows: interactive tools such as `ask_user` and `submit_plan` suspend until your interface resumes them, while task and subagent tools have their own lifecycle events. See [tool approvals and suspensions](https://mastra.ai/docs/harness/agent-controller).
 
 The example also omits storage, so the conversation lasts only for the current process. You can add storage later when you want to resume sessions.
 
@@ -387,6 +387,6 @@ Learn more:
 
 - [`createCodingAgent()` reference](https://mastra.ai/reference/coding-agent/create-coding-agent)
 - [`buildBasePrompt()` reference](https://mastra.ai/reference/coding-agent/build-base-prompt)
-- [AgentController overview](https://mastra.ai/docs/agent-controller/overview)
+- [AgentController overview](https://mastra.ai/docs/harness/agent-controller)
 - [`AgentController` reference](https://mastra.ai/reference/agent-controller/agent-controller-class)
 - [Workspace overview](https://mastra.ai/docs/workspace/overview)

package/.docs/guides/guide/research-coordinator.md

@@ -414,5 +414,5 @@ You can extend this research coordinator to:
 
 Learn more:
 
-- [Supervisor Agents](https://mastra.ai/docs/agents/supervisor-agents)
+- [Supervisor Agents](https://mastra.ai/docs/capabilities/subagents)
 - [Agent.stream() Reference](https://mastra.ai/reference/streaming/agents/stream)

package/.docs/guides/migrations/network-to-supervisor.md

@@ -255,7 +255,7 @@ const stream = await supervisorAgent.stream('Research AI in education', {
 
 ## See also
 
-- [Supervisor Agents](https://mastra.ai/docs/agents/supervisor-agents)
+- [Supervisor Agents](https://mastra.ai/docs/capabilities/subagents)
 - [Agent Networks](https://mastra.ai/docs/agents/networks)
 - [Agent.stream() Reference](https://mastra.ai/reference/streaming/agents/stream)
 - [Agent.generate() Reference](https://mastra.ai/reference/agents/generate)

package/.docs/models/index.md

@@ -2,7 +2,7 @@
 
 # Model Providers
 
-Mastra provides a unified interface for working with LLMs across multiple providers, giving you access to 5288 models from 168 providers through a single API.
+Mastra provides a unified interface for working with LLMs across multiple providers, giving you access to 5290 models from 168 providers through a single API.
 
 ## Features
 

package/.docs/models/providers/cortecs.md

@@ -2,7 +2,7 @@
 
 # ![Cortecs logo](https://models.dev/logos/cortecs.svg)Cortecs
 
-Access 58 Cortecs models through Mastra's model router. Authentication is handled automatically using the `CORTECS_API_KEY` environment variable.
+Access 59 Cortecs models through Mastra's model router. Authentication is handled automatically using the `CORTECS_API_KEY` environment variable.
 
 Learn more in the [Cortecs documentation](https://cortecs.ai).
 
@@ -49,6 +49,7 @@ for await (const chunk of stream) {
 | `cortecs/deepseek-v3-0324`               | 128K    |       |           |       |       |       | $0.55      | $2          |
 | `cortecs/deepseek-v3.2`                  | 164K    |       |           |       |       |       | $0.27      | $0.44       |
 | `cortecs/deepseek-v4-flash`              | 1.0M    |       |           |       |       |       | $0.13      | $0.27       |
+| `cortecs/deepseek-v4-flash-0731`         | 1.0M    |       |           |       |       |       | $0.26      | $0.31       |
 | `cortecs/deepseek-v4-pro`                | 1.0M    |       |           |       |       |       | $2         | $3          |
 | `cortecs/devstral-2512`                  | 262K    |       |           |       |       |       | —          | —           |
 | `cortecs/gemini-2.5-pro`                 | 1.0M    |       |           |       |       |       | $2         | $11         |