@mastra/mcp-docs-server 1.2.5-alpha.5 → 1.2.5-alpha.7

package/.docs/docs/agents/agent-approval.md

@@ -49,6 +49,8 @@ for await (const chunk of stream.fullStream) {
 ```
 
 > **Note:** Agent approval uses snapshots to capture request state. Configure a [storage provider](https://mastra.ai/docs/memory/storage) on your Mastra instance or you'll see a "snapshot not found" error.
+>
+> Snapshots for agent runs are minimal resume artifacts: they hold only what's needed to resume the suspended run and are deleted once the run finishes. Use [tracing](https://mastra.ai/docs/observability/overview) for the execution record and [memory](https://mastra.ai/docs/memory/overview) for the conversation history.
 
 ## How approval works
 

package/.docs/docs/long-running-agents/schedules.md

@@ -0,0 +1,227 @@
+> Discover all available pages from the documentation index: https://mastra.ai/llms.txt
+
+# Schedules
+
+**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.
+
+A schedule runs an agent on a cron cadence. On each fire, Mastra sends a prompt to the agent, either as a [signal](https://mastra.ai/docs/long-running-agents/signals) into a thread or as a threadless `agent.generate()` run. Use schedules for recurring agent work such as daily summaries, periodic checks, or scheduled nudges into a conversation.
+
+Schedules are persisted, so they survive restarts and redeploys. Manage them at runtime through `mastra.schedules`, the canonical create, read, update, and delete (CRUD) surface. The same surface also manages [workflow schedules](https://mastra.ai/docs/workflows/scheduled-workflows) — pass `workflowId` instead of `agentId` to schedule a workflow.
+
+## Prerequisites
+
+Schedules require a [storage](https://mastra.ai/docs/memory/storage) adapter that implements the schedules domain, for example `@mastra/libsql`. Without one, `mastra.schedules.create()` throws.
+
+## Quickstart
+
+The following schedule runs the `pinger` agent every hour. It has no thread, so each fire is an isolated `agent.generate()` run.
+
+```typescript
+import { Mastra } from '@mastra/core'
+import { Agent } from '@mastra/core/agent'
+import { LibSQLStore } from '@mastra/libsql'
+
+const pinger = new Agent({
+  id: 'pinger',
+  name: 'Pinger',
+  instructions: 'Report the current system status in one sentence.',
+  model: 'openai/gpt-5.5',
+})
+
+const mastra = new Mastra({
+  agents: { pinger },
+  storage: new LibSQLStore({ url: 'file:./mastra.db' }),
+})
+
+await mastra.schedules.create({
+  agentId: 'pinger',
+  cron: '0 * * * *',
+  prompt: 'Give me a status update.',
+})
+```
+
+Mastra starts the scheduler the first time a schedule is created, then fires the agent on the cron you specify.
+
+## Cadence
+
+Schedules fire on a cron expression. The `cron` field accepts a standard 5-, 6-, or 7-part cron expression, and it's validated when you create or update the schedule.
+
+Croner nicknames also work, for example `@hourly`, `@daily`, `@weekly`, `@monthly`, and `@midnight`. For day-and-time combinations, write the cron field directly:
+
+```typescript
+// Every weekday at 9am
+await mastra.schedules.create({
+  agentId: 'pinger',
+  cron: '0 9 * * 1-5',
+  prompt: 'Start-of-day check.',
+})
+```
+
+Set `timezone` to an IANA timezone, for example `America/New_York`, so fire times don't depend on the host's locale. When omitted, the cron resolves against the host's local timezone.
+
+For more readable cron construction, you can use a userland builder such as [`cron-time-generator`](https://www.npmjs.com/package/cron-time-generator) and pass its output to `cron`.
+
+## Threadless and threaded schedules
+
+An agent schedule fires in one of two modes, decided by whether you pass a `threadId`.
+
+### Threadless
+
+Without a `threadId`, each fire is an isolated `agent.generate()` run. Nothing is written to a conversation thread. This is the simplest mode and suits status checks, reports, and other work that doesn't need conversation context.
+
+### Threaded
+
+With a `threadId`, the schedule sends a [signal](https://mastra.ai/docs/long-running-agents/signals) into that thread, so the prompt joins the agent's conversation. Threaded schedules require a `resourceId` alongside the `threadId`.
+
+```typescript
+await mastra.schedules.create({
+  agentId: 'pinger',
+  cron: '0 9 * * *',
+  prompt: 'Summarize anything new since yesterday.',
+  threadId: 'thread-123',
+  resourceId: 'user-456',
+})
+```
+
+Threaded schedules accept extra fields that control how the signal behaves. They mirror the options [`agent.sendSignal`](https://mastra.ai/docs/long-running-agents/signals) accepts and stay JSON-serializable so they persist with the schedule.
+
+- `signalType`: the [signal type](https://mastra.ai/docs/long-running-agents/signals) to send, for example `notification` or `system-reminder`. Defaults to `notification`.
+- `tagName`: the XML tag the signal renders as. Defaults to `schedule`, so a fire surfaces to the agent as `<schedule>…</schedule>`.
+- `attributes`: values rendered onto the signal's XML tag.
+- `ifActive`: behavior when the thread is already streaming, as `{ behavior, attributes }`. `behavior` is one of `deliver`, `persist`, or `discard`.
+- `ifIdle`: behavior when the thread is idle, as `{ behavior, attributes, streamOptions }`. `behavior` is one of `wake`, `persist`, or `discard`. `streamOptions.requestContext` is applied to the woken run.
+
+These fields require a `threadId`. Passing them on a threadless schedule throws.
+
+```typescript
+await mastra.schedules.create({
+  agentId: 'pinger',
+  cron: '0 9 * * *',
+  prompt: 'Summarize anything new since yesterday.',
+  threadId: 'thread-123',
+  resourceId: 'user-456',
+  tagName: 'check-in', // renders as <check-in>…</check-in>
+  attributes: { source: 'cron' },
+  ifActive: { behavior: 'discard' }, // skip if the thread is mid-stream
+  ifIdle: {
+    behavior: 'wake', // wake the agent if the thread is idle
+    streamOptions: { requestContext: { locale: 'en-US' } },
+  },
+})
+```
+
+`providerOptions` are merged into the signal payload on every fire and apply to both threaded and threadless schedules.
+
+## Managing schedules
+
+Use `mastra.schedules` for all schedule operations. To scope to a single agent, pass `agentId` to `create` or `list`.
+
+```typescript
+// Create
+const schedule = await mastra.schedules.create({
+  agentId: 'pinger',
+  cron: '0 * * * *',
+  prompt: 'Status check.',
+})
+
+// Read
+await mastra.schedules.get(schedule.id)
+await mastra.schedules.list({ agentId: 'pinger' })
+
+// Update — changing cron or timezone recomputes the next fire time
+await mastra.schedules.update(schedule.id, { cron: '*/30 * * * *' })
+
+// Pause and resume
+await mastra.schedules.pause(schedule.id)
+await mastra.schedules.resume(schedule.id)
+
+// Fire once now, off-schedule
+await mastra.schedules.run(schedule.id)
+
+// Delete
+await mastra.schedules.delete(schedule.id)
+```
+
+A few rules worth knowing:
+
+- `pause` and `resume` are durable and idempotent. A paused schedule survives restarts, and `resume` recomputes the next fire time from now rather than firing backlogged runs.
+- `run` fires the schedule once immediately without affecting its cadence.
+- `list` filters by `agentId`, `workflowId`, `threadId`, `resourceId`, `name`, and `status`. Without a filter it returns every schedule, agent and workflow alike.
+
+### Workflow schedules
+
+The same service creates schedules that run a workflow instead of an agent. Pass `workflowId` and the workflow-shaped fields:
+
+```typescript
+await mastra.schedules.create({
+  workflowId: 'daily-report',
+  cron: '0 9 * * *',
+  inputData: { userId: 'system' },
+})
+```
+
+Workflow schedules created this way are independent of the declarative `schedule` field on `createWorkflow` — see [scheduled workflows](https://mastra.ai/docs/workflows/scheduled-workflows) for the declarative form and Studio views.
+
+### Custom IDs
+
+By default `create` generates a random `agent_<uuid>` id. Pass `id` to choose a stable one, for example when you want a predictable handle to look up, update, or delete later:
+
+```typescript
+await mastra.schedules.create({
+  id: 'nightly-summary',
+  agentId: 'pinger',
+  cron: '0 9 * * *',
+  prompt: 'Summarize anything new since yesterday.',
+})
+// stored as `agent_nightly-summary`
+```
+
+The id is normalized to `agent_<slug>`: the `agent_` prefix is added if missing and the rest is slugified. Workflow schedules normalize to `schedule_<slug>` instead. Creating a schedule with an id that already exists throws, so use `update` to change an existing one.
+
+### From the client
+
+The same operations are available from `@mastra/client-js` over the `/api/schedules` routes (`client.createSchedule`, `client.listSchedules`, `client.runSchedule`, and so on), so you can manage schedules from a separate process or a UI.
+
+## Lifecycle hooks
+
+Hooks let you run code at key points in an agent schedule's lifecycle, for example to compute fire-time parameters or react to the outcome. Configure them on the `Mastra` constructor under `schedules`. The hooks are a single flat bundle that runs for every agent's schedules; each hook context carries the firing `agentId`, so branch on it when you need per-agent behavior. Hooks live at the `Mastra` level so they apply to both code-defined and stored agents.
+
+```typescript
+const mastra = new Mastra({
+  agents: { pinger },
+  storage: new LibSQLStore({ url: 'file:./mastra.db' }),
+  schedules: {
+    prepare: async ({ agentId, schedule, trigger }) => {
+      // Return overrides, null to skip this fire, or undefined for defaults
+      return { prompt: `Status as of ${trigger.firedAt.toISOString()}` }
+    },
+    onFinish: async ({ agentId, outcome, runId }) => {
+      // Runs on any non-error, non-abort outcome
+    },
+    onError: async ({ agentId, phase, error }) => {
+      // Runs when prepare, the signal, or the agent run threw
+    },
+    onAbort: async ({ agentId, runId }) => {
+      // Runs when the run was aborted mid-stream
+    },
+  },
+})
+```
+
+The hooks are:
+
+- `prepare`: runs before the fire. Return an object to override fire-time parameters such as `prompt` or `threadId`, `null` to skip the fire, or `undefined` to use the stored defaults.
+- `onFinish`: runs once per trigger that reached a non-error, non-abort terminal state.
+- `onError`: runs when `prepare`, the signal, or the agent run threw.
+- `onAbort`: runs when the run was aborted mid-stream.
+
+Every hook context includes `agentId` (the agent the schedule fired for) alongside `schedule` and `trigger`.
+
+Hook exceptions are caught and logged. They never re-route the worker or trigger another hook.
+
+## Related
+
+- [Signals](https://mastra.ai/docs/long-running-agents/signals): the delivery mechanism behind threaded schedules.
+- [Scheduled workflows](https://mastra.ai/docs/workflows/scheduled-workflows): declare a cron schedule on a workflow definition.

package/.docs/docs/observability/feedback.md

@@ -0,0 +1,136 @@
+> Discover all available pages from the documentation index: https://mastra.ai/llms.txt
+
+# Feedback
+
+Feedback records capture human-in-the-loop signals such as thumbs, ratings, comments, and corrections. Use feedback when you need to attach user, QA, Studio, or system review data to a trace or span and query that data alongside other observability signals.
+
+Unlike metrics and scores, feedback is usually supplied by a person or review workflow. Numeric feedback values can be aggregated, grouped, charted over time, and queried for percentiles.
+
+## When to use feedback
+
+- Collect user satisfaction ratings for agent responses.
+- Store QA comments or corrections next to the trace they review.
+- Build dashboards for ratings by agent, environment, or experiment.
+
+## Add feedback
+
+Use `mastra.observability.addFeedback()` when you want to annotate a persisted trace or span from app code. The helper is optional on the observability entrypoint, so check that the active observability implementation supports it. See the [client SDK observability reference](https://mastra.ai/reference/client-js/observability) for all client methods.
+
+```typescript
+if (!mastra.observability.addFeedback) {
+  throw new Error('Feedback is not supported by the active observability implementation')
+}
+
+await mastra.observability.addFeedback({
+  traceId: 'trace-123',
+  spanId: 'span-456',
+  feedback: {
+    feedbackSource: 'user',
+    feedbackType: 'rating',
+    value: 1,
+    comment: 'The answer solved my issue.',
+  },
+})
+```
+
+## Create feedback
+
+Every `createFeedback()` requires `feedbackType` and `value`. Add `traceId` or `spanId` when the feedback should be anchored to a trace or a specific span. Use `feedbackSource` as optional string metadata, such as `user`, `qa`, `studio`, or `system`.
+
+For storage-level writes, include `timestamp` because the method writes directly to the store.
+
+```typescript
+const observability = await mastra.getStorage()!.getStore('observability')
+
+await observability!.createFeedback({
+  feedback: {
+    feedbackId: 'feedback-rating-1',
+    timestamp: new Date(),
+    traceId: 'trace-123',
+    spanId: 'span-456',
+    feedbackSource: 'user',
+    feedbackType: 'rating',
+    value: 1,
+    comment: 'The answer solved my issue.',
+    tags: ['production'],
+  },
+})
+
+await observability!.createFeedback({
+  feedback: {
+    feedbackId: 'feedback-comment-1',
+    timestamp: new Date(),
+    feedbackSource: 'qa',
+    feedbackType: 'comment',
+    value: 'Needs a citation before shipping.',
+    experimentId: 'support-agent-eval',
+  },
+})
+```
+
+## List feedback
+
+Use `listFeedback()` to page through raw records or poll with delta mode.
+
+```typescript
+const result = await observability!.listFeedback({
+  filters: {
+    feedbackType: 'rating',
+    feedbackSource: 'user',
+    timestamp: { start: new Date(Date.now() - 7 * 24 * 60 * 60 * 1000) },
+  },
+  pagination: { page: 0, perPage: 20 },
+  orderBy: { field: 'timestamp', direction: 'DESC' },
+})
+
+console.log(result.feedback, result.pagination?.hasMore)
+```
+
+Filters include target fields such as `traceId` and `spanId`, feedback fields such as `feedbackType`, `feedbackSource`, and `feedbackUserId`, and shared context fields such as `entityName`, `environment`, `experimentId`, and `tags`.
+
+```typescript
+await observability!.listFeedback({
+  filters: {
+    traceId: 'trace-123',
+    feedbackType: ['rating', 'thumbs'],
+    tags: ['production'],
+  },
+})
+```
+
+## Query feedback analytics
+
+OLAP feedback queries operate on numeric `value` fields. Use them for ratings, thumbs encoded as `1` and `-1`, numeric QA scores, or other numeric feedback types.
+
+```typescript
+const rating = await observability!.getFeedbackAggregate({
+  feedbackType: 'rating',
+  feedbackSource: 'user',
+  aggregation: 'avg',
+  comparePeriod: 'previous_day',
+})
+
+const byAgent = await observability!.getFeedbackBreakdown({
+  feedbackType: 'rating',
+  groupBy: ['entityName'],
+  aggregation: 'avg',
+  filters: { environment: 'production' },
+})
+
+const ratingsOverTime = await observability!.getFeedbackTimeSeries({
+  feedbackType: 'rating',
+  aggregation: 'avg',
+  interval: '1h',
+  groupBy: ['feedbackSource'],
+})
+```
+
+See the [feedback reference](https://mastra.ai/reference/observability/feedback) for all fields, filters, return types, and percentile query parameters.
+
+## Related
+
+- [Observability overview](https://mastra.ai/docs/observability/overview)
+- [Tracing overview](https://mastra.ai/docs/observability/tracing/overview)
+- [Metrics overview](https://mastra.ai/docs/observability/metrics/overview)
+- [Client SDK observability reference](https://mastra.ai/reference/client-js/observability)
+- [Feedback reference](https://mastra.ai/reference/observability/feedback)

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

@@ -2,13 +2,14 @@
 
 # Observability overview
 
-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 three complementary signals that work together to help you understand what your application is doing and why.
+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, and metrics.
-- [**Storage**](https://mastra.ai/docs/observability/storage): Choose storage backends for persisted traces, logs, and metrics aggregation.
+- [**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.
 - [**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 duration, token usage, and cost data from traces automatically, with no additional instrumentation required.
+- [**Feedback**](https://mastra.ai/docs/observability/feedback): Stores ratings, comments, corrections, and other review signals linked to traces and spans.
 - [**Integrations**](https://mastra.ai/docs/observability/integrations/overview): Choose exporters, bridges, and span processors for Studio, hosted, or external observability workflows.
 
 ## When to use observability
@@ -27,7 +28,9 @@ Metrics are derived from traces automatically. When a span ends, Mastra extracts
 
 Logs are correlated to traces automatically. Every `logger.info()`, `logger.warn()`, or `logger.error()` call within a traced context is tagged with the current trace and span IDs. You can navigate from a log entry directly to the trace that produced it.
 
-All three signals share correlation IDs (trace ID, span ID, entity type, entity name), so you can jump between a metric spike, the traces behind it, and the logs within those traces.
+Feedback records human review signals such as ratings, comments, and corrections. Feedback can be linked to traces and spans, then queried with the same observability store used for metrics.
+
+These signals share correlation IDs (trace ID, span ID, entity type, entity name), so you can jump between a metric spike, the traces behind it, logs within those traces, and related feedback.
 
 ## Quickstart
 
@@ -114,6 +117,7 @@ Not all storage backends support every signal. Traces work with most backends, b
 - [Tracing](https://mastra.ai/docs/observability/tracing/overview)
 - [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)

package/.docs/docs/workflows/scheduled-workflows.md

@@ -74,8 +74,8 @@ Fields:
 Pass an array to fire the same workflow on multiple cadences. Each entry needs a unique stable `id`:
 
 ```typescript
-const heartbeat = createWorkflow({
-  id: 'heartbeat',
+const statusCheck = createWorkflow({
+  id: 'status-check',
   schedule: [
     { id: 'morning', cron: '0 9 * * *', inputData: { window: 'morning' } },
     { id: 'evening', cron: '0 18 * * *', inputData: { window: 'evening' } },
@@ -137,7 +137,7 @@ A few rules worth knowing:
 - Resume recomputes `nextFireAt` from now. A schedule paused for a week doesn't fire seven backlogged runs the moment you resume it. It fires on the next regular cron tick.
 - The only way to unpause is `resumeSchedule` (or the **Resume** button in Studio). Editing the workflow's `schedule` config doesn't unpause a paused row.
 - Pause and resume are idempotent. Calling pause on an already-paused schedule is a no-op.
-- This is an operational override, not a way to author schedules. Creating, deleting, and editing schedules still happens in code via the `schedule` field on `createWorkflow`.
+- This is an operational override, not a way to author schedules. Declarative schedules are created, deleted, and edited in code via the `schedule` field on `createWorkflow`. To create schedules imperatively at runtime instead, use the unified [`mastra.schedules`](https://mastra.ai/docs/long-running-agents/schedules) service with a `workflowId`.
 
 The underlying HTTP routes are `POST /api/schedules/:scheduleId/pause` and `POST /api/schedules/:scheduleId/resume`. Both require the `schedules:write` permission.
 
@@ -180,4 +180,5 @@ Manage Inngest schedules from the [Inngest dashboard](https://www.inngest.com/do
 ## Related
 
 - [Workflow overview](https://mastra.ai/docs/workflows/overview)
-- [Suspend and resume](https://mastra.ai/docs/workflows/suspend-and-resume)
+- [Suspend and resume](https://mastra.ai/docs/workflows/suspend-and-resume)
+- [Agent schedules](https://mastra.ai/docs/long-running-agents/schedules): run an agent, rather than a workflow, on a cron schedule, and manage both kinds at runtime through `mastra.schedules`.

package/.docs/guides/build-your-ui/openui.md

@@ -10,7 +10,7 @@ OpenUI connects to Mastra through the [AG-UI protocol](https://docs.ag-ui.com).
 
 ## Integration guide
 
-Embed Mastra in your Next.js API route and connect an OpenUI `<FullScreen />` chat surface to it through the AG-UI protocol.
+Embed Mastra in your Next.js API route and connect an OpenUI `<AgentInterface />` chat surface to it through the AG-UI protocol.
 
 1. Scaffold a new OpenUI app:
 
@@ -184,33 +184,25 @@ Embed Mastra in your Next.js API route and connect an OpenUI `<FullScreen />` ch
    }
    ```
 
-4. Wire the OpenUI `<FullScreen />` chat surface to the route. Set `streamProtocol` to `agUIAdapter()` so OpenUI knows to parse AG-UI events.
+4. Wire the OpenUI `<AgentInterface />` chat surface to the route. Build an `llm` adapter with `fetchLLM()` and set `streamAdapter` to `agUIAdapter()` so OpenUI knows to parse AG-UI events.
 
    ```tsx
    'use client'
 
    import '@openuidev/react-ui/components.css'
 
-   import { agUIAdapter } from '@openuidev/react-headless'
-   import { FullScreen } from '@openuidev/react-ui'
+   import { AgentInterface, agUIAdapter, fetchLLM } from '@openuidev/react-ui'
    import { openuiChatLibrary } from '@openuidev/react-ui/genui-lib'
 
+   const llm = fetchLLM({
+     url: '/api/chat',
+     streamAdapter: agUIAdapter(),
+   })
+
    export default function Page() {
      return (
        <div className="relative h-screen w-screen overflow-hidden">
-         <FullScreen
-           processMessage={async ({ messages, threadId, abortController }) => {
-             return fetch('/api/chat', {
-               method: 'POST',
-               headers: { 'Content-Type': 'application/json' },
-               body: JSON.stringify({ messages, threadId }),
-               signal: abortController.signal,
-             })
-           }}
-           streamProtocol={agUIAdapter()}
-           componentLibrary={openuiChatLibrary}
-           agentName="OpenUI + Mastra Chat"
-         />
+         <AgentInterface llm={llm} componentLibrary={openuiChatLibrary} />
        </div>
      )
    }
@@ -251,7 +243,7 @@ Embed Mastra in your Next.js API route and connect an OpenUI `<FullScreen />` ch
 OpenUI consumes the [AG-UI protocol](https://docs.ag-ui.com), a transport-agnostic stream of typed events for AI agents. `@ag-ui/mastra` translates a Mastra `Agent` into this protocol:
 
 - The server calls `agent.run({ messages, threadId, runId, ... })` and serializes each emitted event as an SSE message.
-- The client passes `streamProtocol={agUIAdapter()}` to `<FullScreen />`, which parses the SSE stream into the internal events that drive OpenUI Lang rendering.
+- The client passes `fetchLLM({ streamAdapter: agUIAdapter() })` to `<AgentInterface />`, which parses the SSE stream into the internal events that drive OpenUI Lang rendering.
 
 `threadId` ties a conversation together across requests, and `runId` identifies a single execution. Generate a fresh `runId` per request and persist `threadId` on the client.
 
@@ -266,11 +258,11 @@ OpenUI generates UI from a component library. The library defines which componen
 - `openuiChatLibrary`: components for chat interfaces (cards, forms, tables, charts).
 - `openuiDashboardLibrary`: components for dashboards and data-heavy surfaces.
 
-Pass the library to `<FullScreen componentLibrary={...} />` to make its components available to the model.
+Pass the library to `<AgentInterface componentLibrary={...} />` to make its components available to the model.
 
 ### Customizing the library
 
-To restrict or extend the output, define your own library in `src/library.ts` and export a subset of components. Pass that library to `<FullScreen />` and regenerate the system prompt whenever the library changes:
+To restrict or extend the output, define your own library in `src/library.ts` and export a subset of components. Pass that library to `<AgentInterface />` and regenerate the system prompt whenever the library changes:
 
 **npm**:
 

package/.docs/models/environment-variables.md

@@ -65,6 +65,7 @@ List of required environment variables for each model provider and gateway suppo
 | [LLM Gateway](https://mastra.ai/models/providers/llmgateway)                                   | `llmgateway/*`             | `LLMGATEWAY_API_KEY`                                                                                  |
 | [LLMTR](https://mastra.ai/models/providers/llmtr)                                              | `llmtr/*`                  | `LLMTR_API_KEY`                                                                                       |
 | [LMStudio](https://mastra.ai/models/providers/lmstudio)                                        | `lmstudio/*`               | `LMSTUDIO_API_KEY`                                                                                    |
+| [LongCat](https://mastra.ai/models/providers/longcat)                                          | `longcat/*`                | `LONGCAT_API_KEY`                                                                                     |
 | [LucidQuery](https://mastra.ai/models/providers/lucidquery)                                    | `lucidquery/*`             | `LUCIDQUERY_API_KEY`                                                                                  |
 | [Meganova](https://mastra.ai/models/providers/meganova)                                        | `meganova/*`               | `MEGANOVA_API_KEY`                                                                                    |
 | [MiniMax (minimax.io)](https://mastra.ai/models/providers/minimax)                             | `minimax/*`                | `MINIMAX_API_KEY`                                                                                     |

package/.docs/models/gateways/vercel.md

@@ -74,11 +74,11 @@ ANTHROPIC_API_KEY=ant-...
 | `amazon/nova-micro`                      |
 | `amazon/nova-pro`                        |
 | `amazon/titan-embed-text-v2`             |
+| `anthropic/claude-3-haiku`               |
 | `anthropic/claude-3.5-haiku`             |
 | `anthropic/claude-fable-5`               |
 | `anthropic/claude-haiku-4.5`             |
 | `anthropic/claude-opus-4`                |
-| `anthropic/claude-opus-4.1`              |
 | `anthropic/claude-opus-4.5`              |
 | `anthropic/claude-opus-4.6`              |
 | `anthropic/claude-opus-4.7`              |

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 4545 models from 139 providers through a single API.
+Mastra provides a unified interface for working with LLMs across multiple providers, giving you access to 4555 models from 140 providers through a single API.
 
 ## Features
 

package/.docs/models/providers/anthropic.md

@@ -2,7 +2,7 @@
 
 # ![Anthropic logo](https://models.dev/logos/anthropic.svg)Anthropic
 
-Access 18 Anthropic models through Mastra's model router. Authentication is handled automatically using the `ANTHROPIC_API_KEY` environment variable.
+Access 12 Anthropic models through Mastra's model router. Authentication is handled automatically using the `ANTHROPIC_API_KEY` environment variable.
 
 Learn more in the [Anthropic documentation](https://docs.anthropic.com/en/docs/about-claude/models).
 
@@ -37,19 +37,13 @@ for await (const chunk of stream) {
 | `anthropic/claude-fable-5`             | 1.0M    |       |           |       |       |       | $10        | $50         |
 | `anthropic/claude-haiku-4-5`           | 200K    |       |           |       |       |       | $1         | $5          |
 | `anthropic/claude-haiku-4-5-20251001`  | 200K    |       |           |       |       |       | $1         | $5          |
-| `anthropic/claude-opus-4-0`            | 200K    |       |           |       |       |       | $15        | $75         |
-| `anthropic/claude-opus-4-1`            | 200K    |       |           |       |       |       | $15        | $75         |
-| `anthropic/claude-opus-4-1-20250805`   | 200K    |       |           |       |       |       | $15        | $75         |
-| `anthropic/claude-opus-4-20250514`     | 200K    |       |           |       |       |       | $15        | $75         |
 | `anthropic/claude-opus-4-5`            | 200K    |       |           |       |       |       | $5         | $25         |
 | `anthropic/claude-opus-4-5-20251101`   | 200K    |       |           |       |       |       | $5         | $25         |
 | `anthropic/claude-opus-4-6`            | 1.0M    |       |           |       |       |       | $5         | $25         |
 | `anthropic/claude-opus-4-7`            | 1.0M    |       |           |       |       |       | $5         | $25         |
 | `anthropic/claude-opus-4-8`            | 1.0M    |       |           |       |       |       | $5         | $25         |
-| `anthropic/claude-sonnet-4-0`          | 200K    |       |           |       |       |       | $3         | $15         |
-| `anthropic/claude-sonnet-4-20250514`   | 200K    |       |           |       |       |       | $3         | $15         |
-| `anthropic/claude-sonnet-4-5`          | 200K    |       |           |       |       |       | $3         | $15         |
-| `anthropic/claude-sonnet-4-5-20250929` | 200K    |       |           |       |       |       | $3         | $15         |
+| `anthropic/claude-sonnet-4-5`          | 1.0M    |       |           |       |       |       | $3         | $15         |
+| `anthropic/claude-sonnet-4-5-20250929` | 1.0M    |       |           |       |       |       | $3         | $15         |
 | `anthropic/claude-sonnet-4-6`          | 1.0M    |       |           |       |       |       | $3         | $15         |
 | `anthropic/claude-sonnet-5`            | 1.0M    |       |           |       |       |       | $2         | $10         |
 

package/.docs/models/providers/deepinfra.md

@@ -2,7 +2,7 @@
 
 # ![Deep Infra logo](https://models.dev/logos/deepinfra.svg)Deep Infra
 
-Access 27 Deep Infra models through Mastra's model router. Authentication is handled automatically using the `DEEPINFRA_API_KEY` environment variable.
+Access 40 Deep Infra models through Mastra's model router. Authentication is handled automatically using the `DEEPINFRA_API_KEY` environment variable.
 
 Learn more in the [Deep Infra documentation](https://deepinfra.com/models).
 
@@ -36,7 +36,7 @@ for await (const chunk of stream) {
 | ------------------------------------------------------------- | ------- | ----- | --------- | ----- | ----- | ----- | ---------- | ----------- |
 | `deepinfra/deepseek-ai/DeepSeek-R1-0528`                      | 164K    |       |           |       |       |       | $0.50      | $2          |
 | `deepinfra/deepseek-ai/DeepSeek-V3.2`                         | 164K    |       |           |       |       |       | $0.26      | $0.38       |
-| `deepinfra/deepseek-ai/DeepSeek-V4-Flash`                     | 1.0M    |       |           |       |       |       | $0.10      | $0.20       |
+| `deepinfra/deepseek-ai/DeepSeek-V4-Flash`                     | 1.0M    |       |           |       |       |       | $0.09      | $0.18       |
 | `deepinfra/deepseek-ai/DeepSeek-V4-Pro`                       | 1.0M    |       |           |       |       |       | $1         | $3          |
 | `deepinfra/google/gemma-4-26B-A4B-it`                         | 262K    |       |           |       |       |       | $0.07      | $0.34       |
 | `deepinfra/google/gemma-4-31B-it`                             | 262K    |       |           |       |       |       | $0.13      | $0.38       |
@@ -44,15 +44,28 @@ for await (const chunk of stream) {
 | `deepinfra/meta-llama/Llama-4-Maverick-17B-128E-Instruct-FP8` | 1.0M    |       |           |       |       |       | $0.15      | $0.60       |
 | `deepinfra/meta-llama/Llama-4-Scout-17B-16E-Instruct`         | 328K    |       |           |       |       |       | $0.10      | $0.30       |
 | `deepinfra/MiniMaxAI/MiniMax-M2.5`                            | 197K    |       |           |       |       |       | $0.15      | $1          |
+| `deepinfra/MiniMaxAI/MiniMax-M2.7`                            | 197K    |       |           |       |       |       | $0.25      | $1          |
+| `deepinfra/MiniMaxAI/MiniMax-M3`                              | 524K    |       |           |       |       |       | $0.30      | $1          |
 | `deepinfra/moonshotai/Kimi-K2.5`                              | 262K    |       |           |       |       |       | $0.45      | $2          |
 | `deepinfra/moonshotai/Kimi-K2.6`                              | 262K    |       |           |       |       |       | $0.75      | $4          |
 | `deepinfra/moonshotai/Kimi-K2.7-Code`                         | 262K    |       |           |       |       |       | $0.74      | $4          |
-| `deepinfra/openai/gpt-oss-120b`                               | 131K    |       |           |       |       |       | $0.04      | $0.19       |
+| `deepinfra/nvidia/Llama-3.3-Nemotron-Super-49B-v1.5`          | 131K    |       |           |       |       |       | $0.40      | $0.40       |
+| `deepinfra/nvidia/Nemotron-3-Nano-30B-A3B`                    | 262K    |       |           |       |       |       | $0.05      | $0.20       |
+| `deepinfra/nvidia/Nemotron-3-Nano-Omni-30B-A3B-Reasoning`     | 262K    |       |           |       |       |       | $0.20      | $0.80       |
+| `deepinfra/openai/gpt-oss-120b`                               | 131K    |       |           |       |       |       | $0.04      | $0.17       |
 | `deepinfra/openai/gpt-oss-20b`                                | 131K    |       |           |       |       |       | $0.03      | $0.14       |
+| `deepinfra/Qwen/Qwen3-32B`                                    | 41K     |       |           |       |       |       | $0.08      | $0.28       |
 | `deepinfra/Qwen/Qwen3-Coder-480B-A35B-Instruct-Turbo`         | 262K    |       |           |       |       |       | $0.30      | $1          |
+| `deepinfra/Qwen/Qwen3-Max`                                    | 256K    |       |           |       |       |       | $1         | $6          |
+| `deepinfra/Qwen/Qwen3-Next-80B-A3B-Instruct`                  | 262K    |       |           |       |       |       | $0.09      | $1          |
+| `deepinfra/Qwen/Qwen3.5-122B-A10B`                            | 16K     |       |           |       |       |       | $0.29      | $2          |
+| `deepinfra/Qwen/Qwen3.5-27B`                                  | 262K    |       |           |       |       |       | $0.26      | $3          |
 | `deepinfra/Qwen/Qwen3.5-35B-A3B`                              | 262K    |       |           |       |       |       | $0.14      | $1          |
 | `deepinfra/Qwen/Qwen3.5-397B-A17B`                            | 262K    |       |           |       |       |       | $0.45      | $3          |
+| `deepinfra/Qwen/Qwen3.5-9B`                                   | 262K    |       |           |       |       |       | $0.10      | $0.15       |
+| `deepinfra/Qwen/Qwen3.6-27B`                                  | 262K    |       |           |       |       |       | $0.32      | $3          |
 | `deepinfra/Qwen/Qwen3.6-35B-A3B`                              | 262K    |       |           |       |       |       | $0.15      | $0.95       |
+| `deepinfra/Qwen/Qwen3.7-Max`                                  | 256K    |       |           |       |       |       | $3         | $8          |
 | `deepinfra/XiaomiMiMo/MiMo-V2.5`                              | 262K    |       |           |       |       |       | $0.40      | $2          |
 | `deepinfra/XiaomiMiMo/MiMo-V2.5-Pro`                          | 1.0M    |       |           |       |       |       | $1         | $3          |
 | `deepinfra/zai-org/GLM-4.6`                                   | 203K    |       |           |       |       |       | $0.43      | $2          |
@@ -60,7 +73,7 @@ for await (const chunk of stream) {
 | `deepinfra/zai-org/GLM-4.7-Flash`                             | 203K    |       |           |       |       |       | $0.06      | $0.40       |
 | `deepinfra/zai-org/GLM-5`                                     | 203K    |       |           |       |       |       | $0.60      | $2          |
 | `deepinfra/zai-org/GLM-5.1`                                   | 203K    |       |           |       |       |       | $1         | $4          |
-| `deepinfra/zai-org/GLM-5.2`                                   | 1.0M    |       |           |       |       |       | $0.95      | $3          |
+| `deepinfra/zai-org/GLM-5.2`                                   | 1.0M    |       |           |       |       |       | $0.93      | $3          |
 
 ## Advanced configuration