@mastra/mcp-docs-server 0.0.0-studio-deploy-20260403185613 → 0.0.0-studio-deploy-20260403235642

package/.docs/docs/agents/channels.md

@@ -0,0 +1,170 @@
+# Channels
+
+**Added in:** `@mastra/core@1.22.0`
+
+Channels connect your agents to messaging platforms like Slack, Discord, and Telegram. When a user sends a message on a platform, the agent receives it, processes it through the normal agent pipeline, and streams the response back to the conversation.
+
+## When to use channels
+
+Use channels when you want your agent to:
+
+- Respond to messages in Slack workspaces, Discord servers, or Telegram chats
+- Handle both direct messages and mentions in group conversations
+
+## Quickstart
+
+Configure channels directly on your agent using adapters from the [Chat SDK](https://chat-sdk.dev/adapters):
+
+```typescript
+import { Agent } from '@mastra/core/agent'
+import { createSlackAdapter } from '@chat-adapter/slack'
+
+export const supportAgent = new Agent({
+  id: 'support-agent',
+  name: 'Support Agent',
+  instructions: 'You are a helpful support assistant.',
+  model: 'openai/gpt-5.4',
+  channels: {
+    adapters: {
+      slack: createSlackAdapter(),
+    },
+  },
+})
+```
+
+Register the agent in your Mastra instance with storage so channel state persists across restarts:
+
+```typescript
+import { Mastra } from '@mastra/core'
+import { LibSQLStore } from '@mastra/libsql'
+import { supportAgent } from './agents/support-agent'
+
+export const mastra = new Mastra({
+  agents: { supportAgent },
+  storage: new LibSQLStore({
+    url: process.env.DATABASE_URL,
+  }),
+})
+```
+
+Each adapter reads credentials from environment variables by default.
+
+## Platform setup
+
+Each platform requires credentials and event configuration. See the Chat SDK adapter docs for full setup: [Slack](https://chat-sdk.dev/adapters/slack), [Discord](https://chat-sdk.dev/adapters/discord), [Telegram](https://chat-sdk.dev/adapters/telegram).
+
+Mastra generates a webhook route for each platform at:
+
+```text
+/api/agents/{agentId}/channels/{platform}/webhook
+```
+
+For example: `/api/agents/support-agent/channels/slack/webhook`
+
+Point your platform's webhook or interactions URL to this path.
+
+### Local development
+
+Platform webhooks need a public URL to reach your local server. Use a tunnel to expose `localhost:4111`:
+
+```bash
+# ngrok
+ngrok http 4111
+
+# cloudflared
+cloudflared tunnel --url http://localhost:4111
+```
+
+Copy the generated URL and use it as the base for your webhook paths (e.g. `https://abc123.ngrok.io/api/agents/support-agent/channels/slack/webhook`).
+
+## Thread context
+
+When a user mentions the agent mid-conversation in a channel thread, the agent may not have prior context. By default, Mastra fetches the last 10 messages from the platform on the first mention.
+
+1. On the **first mention** in a thread, the agent fetches recent messages from the platform.
+2. These messages are prepended to the user's message as conversation context.
+3. After responding, the agent subscribes to the thread and has full history via Mastra's memory.
+4. Subsequent messages in that thread do **not** re-fetch from the platform.
+
+Set `threadContext: { maxMessages: 0 }` to disable this behavior. This only applies to non-DM threads.
+
+## Tool approval
+
+Tools with `requireApproval: true` render as interactive cards with Approve and Deny buttons:
+
+```typescript
+import { createTool } from '@mastra/core/tools'
+import { z } from 'zod'
+
+const deleteFile = createTool({
+  id: 'delete-file',
+  description: 'Delete a file from the system',
+  inputSchema: z.object({
+    path: z.string().describe('Path to the file to delete'),
+  }),
+  requireApproval: true,
+  execute: async ({ path }) => {
+    await fs.unlink(path)
+    return { deleted: path }
+  },
+})
+```
+
+When the agent calls this tool, users see a card with the tool name, arguments, and Approve/Deny buttons. The tool only executes after approval.
+
+Set `cards: false` on an adapter to render tool calls as plain text instead of interactive cards. When cards are disabled and a tool requires approval, the agent uses `autoResumeSuspendedTools` to let the LLM decide based on the conversation context.
+
+## Multi-user awareness
+
+In group conversations, Mastra automatically prefixes each message with the sender's name and platform ID so the agent can distinguish between speakers:
+
+```text
+[Alice (@U123ABC)]: Can you help me with this?
+[Bob (@U456DEF)]: I have a question too.
+```
+
+## Multimodal content
+
+Models like Gemini can natively process images, video, and audio. Combine `inlineMedia` and `inlineLinks` to let users share rich content with your agent across platforms:
+
+```typescript
+import { Agent } from '@mastra/core/agent'
+import { createDiscordAdapter } from '@chat-adapter/discord'
+import { google } from '@ai-sdk/google'
+
+export const visionAgent = new Agent({
+  name: 'Vision Agent',
+  instructions: 'You can see images, watch videos, and listen to audio.',
+  model: google('gemini-3.1-flash-image-preview'),
+  channels: {
+    adapters: {
+      discord: createDiscordAdapter(),
+    },
+    inlineMedia: ['image/*', 'video/*', 'audio/*'],
+    inlineLinks: [
+      // Gemini treats YouTube URLs as native video file parts
+      { match: 'youtube.com', mimeType: 'video/*' },
+      { match: 'youtu.be', mimeType: 'video/*' },
+      'imgur.com', // HEAD-check imgur links; inline as file part if mimeType matches inlineMedia
+    ],
+  },
+})
+```
+
+With this configuration:
+
+- A user uploads a screenshot and the agent describes what it sees
+- A user uploads an `.mp4` clip and the agent summarizes the video
+- A user pastes a YouTube link and the agent watches and discusses the video
+- A user pastes an imgur link and the agent sees the image directly
+
+By default, only images are sent inline (`inlineMedia: ['image/*']`). Unsupported types are described as text summaries so the agent knows about the file without crashing models that reject them.
+
+> **Note:** See [Channels reference](https://mastra.ai/reference/agents/channels) for all `inlineMedia` patterns and [inlineLinks reference](https://mastra.ai/reference/agents/channels) for domain matching, HEAD detection, and forced mime types.
+
+## Related
+
+- [Agent overview](https://mastra.ai/docs/agents/overview)
+- [Tool approval](https://mastra.ai/docs/agents/agent-approval)
+- [Channels reference](https://mastra.ai/reference/agents/channels)
+- [Chat SDK adapters](https://chat-sdk.dev/adapters)

package/.docs/docs/agents/overview.md

@@ -87,6 +87,7 @@ Once your agent is running, use this table to find the right page for what you w
 | Keep your agent safe                                           | [Guardrails](https://mastra.ai/docs/agents/guardrails)                 |
 | Swap instructions or models based on request context           | [Dynamic configuration](https://mastra.ai/docs/server/request-context) |
 | Add speech-to-text or text-to-speech                           | [Voice](https://mastra.ai/docs/agents/adding-voice)                    |
+| Connect to Slack, Discord, or Telegram                         | [Channels](https://mastra.ai/docs/agents/channels)                     |
 
 ## Multi-agent systems
 

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

@@ -1,35 +1,61 @@
 # Observability overview
 
-Mastra provides observability features for AI applications. Monitor LLM operations, trace agent decisions, and debug complex workflows with tools that understand AI-specific patterns.
+Mastra's observability system gives you visibility into every agent run, workflow step, tool call, and model interaction. It captures three complementary signals that work together to help you understand what your application is doing and why.
 
-## Key features
+- [**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.
 
-### Tracing
+## When to use observability
 
-Specialized tracing for AI operations that captures:
+- Debug unexpected agent behavior by inspecting the full decision path, tool calls, and model responses.
+- Monitor latency across agents, workflows, and tools to identify bottlenecks.
+- Track token consumption and estimated cost over time to control spending.
+- Diagnose workflow failures by tracing execution through each step.
+- Compare agent performance before and after prompt or model changes.
 
-- **Model interactions**: Token usage, latency, prompts, and completions
-- **Agent execution**: Decision paths, tool calls, and memory operations
-- **Workflow steps**: Branching logic, parallel execution, and step outputs
-- **Automatic instrumentation**: Tracing with decorators
+## How the pieces fit together
 
-### Logging
+Tracing is the foundation. When observability is configured, every agent run, workflow execution, tool call, and model interaction produces a [span](https://opentelemetry.io/docs/concepts/signals/traces/#spans). Spans are organized into traces that show the full request lifecycle as a hierarchical timeline.
 
-All logger calls from your application and Mastra's internal components are automatically forwarded to observability storage when observability is configured. You can [control the log level and disable forwarding](https://mastra.ai/docs/observability/logging) independently from your console logger.
+Metrics are derived from traces automatically. When a span ends, Mastra extracts duration, token counts, and cost estimates without any extra code. These metrics power the dashboards in [Studio](https://mastra.ai/docs/studio/observability).
 
-## Storage requirements
+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.
 
-The `DefaultExporter` persists traces to your configured storage backend. Not all storage providers support observability—for the full list, see [Storage Provider Support](https://mastra.ai/docs/observability/tracing/exporters/default).
+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.
 
-For production environments with high traffic, we recommend using **ClickHouse** for the observability domain via [composite storage](https://mastra.ai/reference/storage/composite). See [Production Recommendations](https://mastra.ai/docs/observability/tracing/exporters/default) for details.
+## Get started
 
-## Quickstart
+Install `@mastra/observability` and a storage backend:
 
-Configure Observability in your Mastra instance:
+**npm**:
+
+```bash
+npm install @mastra/observability @mastra/libsql @mastra/duckdb
+```
+
+**pnpm**:
+
+```bash
+pnpm add @mastra/observability @mastra/libsql @mastra/duckdb
+```
+
+**Yarn**:
+
+```bash
+yarn add @mastra/observability @mastra/libsql @mastra/duckdb
+```
+
+**Bun**:
+
+```bash
+bun add @mastra/observability @mastra/libsql @mastra/duckdb
+```
+
+Then configure observability in your Mastra instance. The following example uses composite storage to route observability data to DuckDB (which supports metrics aggregation) while keeping everything else in LibSQL:
 
 ```ts
 import { Mastra } from '@mastra/core/mastra'
-import { PinoLogger } from '@mastra/loggers'
 import { LibSQLStore } from '@mastra/libsql'
 import { DuckDBStore } from '@mastra/duckdb'
 import { MastraCompositeStore } from '@mastra/core/storage'
@@ -41,7 +67,6 @@ import {
 } from '@mastra/observability'
 
 export const mastra = new Mastra({
-  logger: new PinoLogger(),
   storage: new MastraCompositeStore({
     id: 'composite-storage',
     default: new LibSQLStore({
@@ -60,9 +85,6 @@ export const mastra = new Mastra({
           new DefaultExporter(), // Persists traces to storage for Mastra Studio
           new CloudExporter(), // Sends traces to Mastra Cloud (if MASTRA_CLOUD_ACCESS_TOKEN is set)
         ],
-        logging: {
-          level: 'info', // Minimum log level forwarded to storage (default: 'debug')
-        },
         spanOutputProcessors: [
           new SensitiveDataFilter(), // Redacts sensitive data like passwords, tokens, keys
         ],
@@ -72,14 +94,18 @@ export const mastra = new Mastra({
 })
 ```
 
-> **Serverless environments:** The `file:./mastra.db` storage URL uses the local filesystem, which doesn't work in serverless environments like Vercel, AWS Lambda, or Cloudflare Workers. For serverless deployments, use external storage. See the [Vercel deployment guide](https://mastra.ai/guides/deployment/vercel) for a complete example.
+This enables tracing, log forwarding, and metrics. Mastra also supports external tracing providers like Langfuse, Datadog, and any OpenTelemetry-compatible platform. See [Tracing](https://mastra.ai/docs/observability/tracing/overview) for configuration details.
+
+## Storage
 
-With this basic setup, you will see Traces and Logs in both Studio and in Mastra Cloud.
+Not all storage backends support every signal. Traces and logs work with most backends, but metrics require an OLAP-capable store like DuckDB (development) or ClickHouse (production). For the full compatibility list, see [storage provider support](https://mastra.ai/docs/observability/tracing/exporters/default).
 
-We also support various external tracing providers like MLflow, Langfuse, Braintrust, and any OpenTelemetry-compatible platform (Datadog, New Relic, SigNoz, etc.). See more about this in the [Tracing](https://mastra.ai/docs/observability/tracing/overview) documentation.
+For production environments with high traffic, use composite storage to route the observability domain to a dedicated backend. See [production recommendations](https://mastra.ai/docs/observability/tracing/exporters/default) for details.
 
-## What's next?
+## Next steps
 
-- **[Set up Tracing](https://mastra.ai/docs/observability/tracing/overview)**: Configure tracing for your application
-- **[Configure Logging](https://mastra.ai/docs/observability/logging)**: Add structured logging
-- **[API Reference](https://mastra.ai/reference/observability/tracing/instances)**: Detailed configuration options
+- [Tracing](https://mastra.ai/docs/observability/tracing/overview)
+- [Logging](https://mastra.ai/docs/observability/logging)
+- [Metrics](https://mastra.ai/docs/observability/metrics/overview)
+- [Mastra Studio](https://mastra.ai/docs/studio/observability)
+- [Automatic metrics reference](https://mastra.ai/reference/observability/metrics/automatic-metrics)

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

@@ -4,7 +4,7 @@ The Mastra Client SDK provides a concise and type-safe interface for interacting
 
 ## Prerequisites
 
-To ensure smooth local development, make sure you have:
+Before you start local development, have:
 
 - Node.js `v22.13.0` or later
 - TypeScript `v4.7` or higher (if using TypeScript)
@@ -54,15 +54,17 @@ export const mastraClient = new MastraClient({
 
 ## Core APIs
 
-The Mastra Client SDK exposes all resources served by the Mastra Server
+The Mastra Client SDK exposes all resources served by the Mastra Server.
 
 - **[Agents](https://mastra.ai/reference/client-js/agents)**: Generate responses and stream conversations.
 - **[Memory](https://mastra.ai/reference/client-js/memory)**: Manage conversation threads and message history.
 - **[Tools](https://mastra.ai/reference/client-js/tools)**: Executed and managed tools.
 - **[Workflows](https://mastra.ai/reference/client-js/workflows)**: Trigger workflows and track their execution.
 - **[Vectors](https://mastra.ai/reference/client-js/vectors)**: Use vector embeddings for semantic search.
+- **[Responses](https://mastra.ai/reference/client-js/responses)**: Call the OpenAI Responses API through Mastra agents. This API is currently experimental.
+- **[Conversations](https://mastra.ai/reference/client-js/conversations)**: Work with OpenAI Responses API conversations and their stored item history. This API is currently experimental.
 - **[Logs](https://mastra.ai/reference/client-js/logs)**: View logs and debug system behavior.
-- **[Telemetry](https://mastra.ai/reference/client-js/telemetry)**: Monitor app performance and trace activity.
+- **[Telemetry](https://mastra.ai/reference/client-js/telemetry)**: View app performance and trace activity.
 
 ## Generating responses
 
@@ -133,7 +135,7 @@ export const mastraClient = new MastraClient({
 
 ## Credentials and session cookies
 
-**Authenticate Mastra API calls with session cookies** when your UI and Mastra API are not on the same origin—different host, subdomain, or port (for example Mastra Studio on one port and a custom server on another). Add **`credentials: 'include'`** to `MastraClient` so each request carries the cookies the user already has after sign-in. Skip this and you will often get **`401`** responses from Mastra even though login succeeded in the browser.
+**Authenticate Mastra API calls with session cookies** when your UI and Mastra API aren't on the same origin—different host, subdomain, or port (for example Mastra Studio on one port and a custom server on another). Add **`credentials: 'include'`** to `MastraClient` so each request carries the cookies the user already has after sign-in. Skip this and you will often get **`401`** responses from Mastra even though login succeeded in the browser.
 
 ```typescript
 import { MastraClient } from '@mastra/client-js'
@@ -146,7 +148,7 @@ export const mastraClient = new MastraClient({
 
 **Allow credentialed cross-origin requests on your server**—see [CORS: requests with credentials](https://developer.mozilla.org/en-US/docs/Web/HTTP/Guides/CORS#requests_with_credentials). You need a concrete `Access-Control-Allow-Origin` (not `*`) and `Access-Control-Allow-Credentials: true`, or the browser will block the call before it reaches Mastra.
 
-**Using `@mastra/react`?** Wrap your app with `MastraReactProvider`, set `baseUrl` and `apiPrefix` to match your server, and rely on the default `credentials: 'include'`. Change `credentials` only when you deliberately want `same-origin` or `omit` behavior.
+**Using `@mastra/react`?** Wrap your app with `MastraReactProvider`, set `baseUrl` and `apiPrefix` to match your server, and rely on the default `credentials: 'include'`. Change `credentials` only when you want `same-origin` or `omit` behavior.
 
 ## Adding request cancelling
 
@@ -219,7 +221,7 @@ const handleClientTool = async () => {
 }
 ```
 
-### Client tool's agent
+### Client tool agent
 
 This is a standard Mastra [agent](https://mastra.ai/docs/agents/overview) configured to return hex color codes, intended to work with the browser-based client tool defined above.
 
@@ -236,9 +238,9 @@ export const colorAgent = new Agent({
 })
 ```
 
-## Server-side environments
+## Use MastraClient on the server
 
-You can also use `MastraClient` in server-side environments such as API routes, serverless functions or actions. The usage will broadly remain the same but you may need to recreate the response to your client:
+You can also use `MastraClient` in server-side environments such as API routes, serverless functions, or actions. The usage remains the same, but you may need to recreate the response for your client:
 
 ```typescript
 export async function action() {
@@ -252,7 +254,7 @@ export async function action() {
 
 ## Best practices
 
-1. **Error Handling**: Implement proper [error handling](https://mastra.ai/reference/client-js/error-handling) for development scenarios.
+1. **Error Handling**: Use [error handling](https://mastra.ai/reference/client-js/error-handling) for development scenarios.
 2. **Environment Variables**: Use environment variables for configuration.
 3. **Debugging**: Enable detailed [logging](https://mastra.ai/reference/client-js/logs) when needed.
-4. **Performance**: Monitor application performance, [telemetry](https://mastra.ai/reference/client-js/telemetry) and traces.
+4. **Performance**: Track application performance, [telemetry](https://mastra.ai/reference/client-js/telemetry), and traces.

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

@@ -12,7 +12,7 @@ The server provides:
 
 - API endpoints for all registered agents and workflows
 - Custom API routes and middleware
-- Authentication with multiple providers
+- Authentication across providers
 - Request context for dynamic configuration
 - Stream data redaction for secure responses
 
@@ -51,6 +51,18 @@ To explore the API interactively, visit the Swagger UI at <http://localhost:4111
 
 > **Note:** The OpenAPI and Swagger endpoints are disabled in production by default. To enable them, set [`server.build.openAPIDocs`](https://mastra.ai/reference/configuration) and [`server.build.swaggerUI`](https://mastra.ai/reference/configuration) to `true` respectively.
 
+## OpenAI Responses API
+
+Mastra exposes OpenAI-compatible Responses and Conversations routes. These routes are agent-backed adapters over Mastra agents, memory, and storage, so requests run through the selected Mastra agent instead of acting as a raw provider proxy.
+
+These APIs are currently experimental.
+
+Use `agent_id` to select the Mastra agent that should handle the request. Initial requests target an agent directly, and stored follow-up turns can continue with `previous_response_id`. You can also pass `model` to override the agent's configured model for a single request. If you omit `model`, Mastra uses the model already configured on the agent.
+
+The Responses routes support streaming, function calling (tools), stored continuations with `previous_response_id`, conversation threads through `conversation_id`, provider-specific passthrough with `providerOptions`, and JSON output through `text.format`.
+
+For the full request and response contract, see the [Responses API reference](https://mastra.ai/reference/client-js/responses) and [Conversations API reference](https://mastra.ai/reference/client-js/conversations). For the complete list of HTTP routes, see [server routes](https://mastra.ai/reference/server/routes).
+
 ## Stream data redaction
 
 When streaming agent responses, the HTTP layer redacts system prompts, tool definitions, API keys, and similar data from each chunk before sending it to clients. This is enabled by default.

package/.docs/docs/studio/observability.md

@@ -4,6 +4,7 @@ Studio includes these observability views:
 
 - **Metrics** for aggregate performance data
 - **Traces** for individual request inspection
+- **Logs** for browsing internal and application logs
 
 All require an [observability storage backend](#quickstart) to be configured.
 
@@ -21,6 +22,12 @@ When you run an agent or workflow, the Observability tab displays traces that hi
 
 Tracing filters out low-level framework details so your traces stay focused and readable. Visit the [tracing overview](https://mastra.ai/docs/observability/tracing/overview) for more details.
 
+## Logs
+
+Browse internal Mastra logs forwarded to your observability storage. Logs provide full-text search (across message content, entity names, and trace IDs), date presets (last 24 hours to 30 days), and multi-select filters for level, entity type, and entity name. Selecting a log opens a detail panel showing the full message, structured data, and metadata. If the log is correlated with a trace, you can navigate directly to the trace and span timeline.
+
+Log forwarding is enabled by default when you configure observability. See [logging](https://mastra.ai/docs/observability/logging) for level configuration, query examples, and customization details.
+
 ## Quickstart
 
 For detailed instructions, follow the [observability instructions](https://mastra.ai/docs/observability/overview). To get up and running quickly, add the `@mastra/observability` package to your project and configure it with [LibSQL](https://mastra.ai/reference/storage/libsql) and [DuckDB](https://mastra.ai/reference/vectors/duckdb) for a local development setup that supports both traces and metrics.
@@ -95,4 +102,5 @@ export const mastra = new Mastra({
 
 - [Observability overview](https://mastra.ai/docs/observability/overview)
 - [Metrics overview](https://mastra.ai/docs/observability/metrics/overview)
-- [Tracing overview](https://mastra.ai/docs/observability/tracing/overview)
+- [Tracing overview](https://mastra.ai/docs/observability/tracing/overview)
+- [Logging](https://mastra.ai/docs/observability/logging)

package/.docs/docs/studio/overview.md

@@ -124,4 +124,4 @@ Mastra also supports HTTPS development through the [`--https`](https://mastra.ai
 
 - Learn how to [deploy Studio](https://mastra.ai/docs/studio/deployment) for production use.
 - Add [authentication](https://mastra.ai/docs/studio/auth) to control access to your deployed Studio.
-- Explore [Studio observability](https://mastra.ai/docs/studio/observability) to monitor agent performance and gain insights through metrics, logs, and traces.
+- Explore [Studio observability](https://mastra.ai/docs/studio/observability) to monitor agent performance through metrics, traces, and logs.

package/.docs/guides/guide/firecrawl.md

@@ -0,0 +1,152 @@
+# Web scraping with Firecrawl
+
+Firecrawl is a web data API that turns websites into clean markdown or structured JSON. In this guide, you will wire Firecrawl into Mastra tools so your agents and workflows can search and scrape live web data on demand.
+
+## Prerequisites
+
+- Node.js `v22.13.0` or later installed
+- A Firecrawl API key (get one at <https://firecrawl.dev>)
+- An API key from a supported [Model Provider](https://mastra.ai/models)
+- An existing Mastra project (Follow the [installation guide](https://mastra.ai/guides/getting-started/quickstart) to set up a new project)
+
+## Installation
+
+Install the Firecrawl SDK:
+
+**npm**:
+
+```bash
+npm install @mendable/firecrawl-js
+```
+
+**pnpm**:
+
+```bash
+pnpm add @mendable/firecrawl-js
+```
+
+**Yarn**:
+
+```bash
+yarn add @mendable/firecrawl-js
+```
+
+**Bun**:
+
+```bash
+bun add @mendable/firecrawl-js
+```
+
+## Configure environment variables
+
+Create a `.env` file in your project root:
+
+```bash
+FIRECRAWL_API_KEY=fc-your-api-key
+# Optional: FIRECRAWL_API_URL=http://localhost:3002
+```
+
+## Build the Firecrawl tools
+
+Create a tool file that exposes Firecrawl search and scrape to Mastra.
+
+1. Create `src/mastra/tools/firecrawl.ts` and set up Firecrawl:
+
+   ```ts
+   import Firecrawl from '@mendable/firecrawl-js'
+   import { createTool } from '@mastra/core/tools'
+   import { z } from 'zod'
+
+   const firecrawl = new Firecrawl({ apiKey: process.env.FIRECRAWL_API_KEY! })
+
+   export const firecrawlSearch = createTool({
+     id: 'firecrawl-search',
+     description: 'Search the web and return top results.',
+     inputSchema: z.object({ query: z.string().min(1) }),
+     outputSchema: z.object({
+       results: z.array(
+         z.object({
+           title: z.string().nullable(),
+           url: z.string(),
+         }),
+       ),
+     }),
+     execute: async ({ query }) => {
+       const results = await firecrawl.search(query, { limit: 3 })
+       return {
+         results: (results.web ?? []).map(item => ({
+           title: item.title ?? null,
+           url: item.url,
+         })),
+       }
+     },
+   })
+
+   export const firecrawlScrape = createTool({
+     id: 'firecrawl-scrape',
+     description: 'Scrape a URL and return markdown content.',
+     inputSchema: z.object({ url: z.string().url() }),
+     outputSchema: z.object({ markdown: z.string() }),
+     execute: async ({ url }) => {
+       const result = await firecrawl.scrape(url, {
+         formats: ['markdown'],
+         onlyMainContent: true,
+       })
+       return { markdown: result.markdown ?? '' }
+     },
+   })
+   ```
+
+2. Create a new agent at `src/mastra/agents/web-agent.ts`:
+
+   ```ts
+   import { Agent } from '@mastra/core/agent'
+   import { firecrawlSearch, firecrawlScrape } from '../tools/firecrawl'
+
+   export const webAgent = new Agent({
+     id: 'web-agent',
+     name: 'Web Agent',
+     instructions: 'Use Firecrawl tools to search and scrape web pages, then summarize the results.',
+     model: 'openai/gpt-5.4',
+     tools: { firecrawlSearch, firecrawlScrape },
+   })
+   ```
+
+3. Register the newly created agent in `src/mastra/index.ts` on your Mastra instance:
+
+   ```ts
+   import { Mastra } from '@mastra/core'
+   import { webAgent } from './agents/web-agent'
+
+   export const mastra = new Mastra({
+     agents: { webAgent },
+   })
+   ```
+
+## Test in Studio
+
+Run the dev server and open [Studio](https://mastra.ai/docs/studio/overview):
+
+```bash
+mastra dev
+```
+
+In Studio, open the **Web Agent** and try:
+
+- "Find the latest Mastra changelog and summarize the last release."
+- "Search for Firecrawl pricing and extract the plan tiers."
+
+## Self-hosted Firecrawl
+
+If you run Firecrawl locally, set `FIRECRAWL_API_URL` or pass `apiUrl` in the client:
+
+```ts
+const firecrawl = new Firecrawl({
+  apiKey: process.env.FIRECRAWL_API_KEY!,
+  apiUrl: process.env.FIRECRAWL_API_URL,
+})
+```
+
+## Related
+
+- [Firecrawl documentation](https://docs.firecrawl.dev)

package/.docs/models/gateways/openrouter.md

@@ -1,6 +1,6 @@
 # ![OpenRouter logo](https://models.dev/logos/openrouter.svg)OpenRouter
 
-OpenRouter aggregates models from multiple providers with enhanced features like rate limiting and failover. Access 166 models through Mastra's model router.
+OpenRouter aggregates models from multiple providers with enhanced features like rate limiting and failover. Access 168 models through Mastra's model router.
 
 Learn more in the [OpenRouter documentation](https://openrouter.ai/models).
 
@@ -173,6 +173,7 @@ ANTHROPIC_API_KEY=ant-...
 | `qwen/qwen3.5-397b-a17b`                                        |
 | `qwen/qwen3.5-plus-02-15`                                       |
 | `qwen/qwen3.6-plus-preview:free`                                |
+| `qwen/qwen3.6-plus:free`                                        |
 | `sourceful/riverflow-v2-fast-preview`                           |
 | `sourceful/riverflow-v2-max-preview`                            |
 | `sourceful/riverflow-v2-standard-preview`                       |
@@ -199,4 +200,5 @@ ANTHROPIC_API_KEY=ant-...
 | `z-ai/glm-4.6:exacto`                                           |
 | `z-ai/glm-4.7`                                                  |
 | `z-ai/glm-4.7-flash`                                            |
-| `z-ai/glm-5`                                                    |
+| `z-ai/glm-5`                                                    |
+| `z-ai/glm-5-turbo`                                              |

package/.docs/models/index.md

@@ -1,6 +1,6 @@
 # Model Providers
 
-Mastra provides a unified interface for working with LLMs across multiple providers, giving you access to 3566 models from 94 providers through a single API.
+Mastra provides a unified interface for working with LLMs across multiple providers, giving you access to 3581 models from 95 providers through a single API.
 
 ## Features
 

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

@@ -1,6 +1,6 @@
 # ![Anthropic logo](https://models.dev/logos/anthropic.svg)Anthropic
 
-Access 23 Anthropic models through Mastra's model router. Authentication is handled automatically using the `ANTHROPIC_API_KEY` environment variable.
+Access 22 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,7 +37,6 @@ for await (const chunk of stream) {
 | `anthropic/claude-3-5-sonnet-20240620` | 200K    |       |           |       |       |       | $3         | $15         |
 | `anthropic/claude-3-5-sonnet-20241022` | 200K    |       |           |       |       |       | $3         | $15         |
 | `anthropic/claude-3-7-sonnet-20250219` | 200K    |       |           |       |       |       | $3         | $15         |
-| `anthropic/claude-3-7-sonnet-latest`   | 200K    |       |           |       |       |       | $3         | $15         |
 | `anthropic/claude-3-haiku-20240307`    | 200K    |       |           |       |       |       | $0.25      | $1          |
 | `anthropic/claude-3-opus-20240229`     | 200K    |       |           |       |       |       | $15        | $75         |
 | `anthropic/claude-3-sonnet-20240229`   | 200K    |       |           |       |       |       | $3         | $15         |