@mastra/mcp-docs-server 1.2.17-alpha.18 → 1.2.17-alpha.20

package/.docs/docs/deployment/cloud-providers.md

@@ -21,5 +21,6 @@ The following pages show you how to deploy Mastra to specific cloud providers.
 - [Inngest](https://mastra.ai/integrations/deploy/inngest)
 - [Kubernetes](https://mastra.ai/integrations/deploy/kubernetes)
 - [Netlify](https://mastra.ai/integrations/deploy/netlify)
+- [Render](https://mastra.ai/integrations/deploy/render)
 - [Temporal](https://mastra.ai/integrations/deploy/temporal)
 - [Vercel](https://mastra.ai/integrations/deploy/vercel)

package/.docs/docs/deployment/overview.md

@@ -52,6 +52,7 @@ Use this option for auto-scaling, minimal infrastructure management, or when you
 - [Inngest](https://mastra.ai/integrations/deploy/inngest)
 - [Kubernetes](https://mastra.ai/integrations/deploy/kubernetes)
 - [Netlify](https://mastra.ai/integrations/deploy/netlify)
+- [Render](https://mastra.ai/integrations/deploy/render)
 - [Temporal](https://mastra.ai/integrations/deploy/temporal)
 - [Vercel](https://mastra.ai/integrations/deploy/vercel)
 

package/.docs/docs/sandbox/overview.md

@@ -111,6 +111,7 @@ Use a remote or container backend when commands need a stronger boundary from th
 - [AgentCore](https://mastra.ai/integrations/sandboxes/agentcore)
 - [Apple Container](https://mastra.ai/integrations/sandboxes/apple-container)
 - [Blaxel](https://mastra.ai/integrations/sandboxes/blaxel)
+- [Cloudflare Sandbox](https://mastra.ai/integrations/sandboxes/cloudflare-sandbox)
 - [Daytona](https://mastra.ai/integrations/sandboxes/daytona)
 - [Docker](https://mastra.ai/integrations/sandboxes/docker)
 - [E2B](https://mastra.ai/integrations/sandboxes/e2b)

package/.docs/docs/storage.md

@@ -200,6 +200,7 @@ Each provider page includes installation instructions, configuration parameters,
 - [Google Cloud Spanner](https://mastra.ai/integrations/databases/spanner)
 - [LanceDB](https://mastra.ai/integrations/databases/lancedb)
 - [libSQL](https://mastra.ai/integrations/databases/libsql)
+- [Mastra](https://mastra.ai/docs/mastra-platform/database)
 - [MongoDB](https://mastra.ai/integrations/databases/mongodb)
 - [MSSQL](https://mastra.ai/integrations/databases/mssql)
 - [Neon Postgres](https://mastra.ai/integrations/databases/neon)

package/.docs/docs/workflows/control-flow.md

@@ -17,8 +17,6 @@ Each step connects to the next in the workflow through defined schemas that keep
 
 Use `.then()` to run steps in order, allowing each step to access the result of the step before it.
 
-![Chaining steps with .then()](/assets/images/workflows-control-flow-then-bde5e0fbefe5c64c19a8c3471c0e8439.jpg)
-
 ```typescript
 const step1 = createStep({
   inputSchema: z.object({
@@ -55,8 +53,6 @@ export const testWorkflow = createWorkflow({
 
 Use `.parallel()` to run steps simultaneously. All parallel steps must complete before the workflow continues to the next step. Each step's `id` is used when defining a following step's `inputSchema` and becomes the key on the `inputData` object used to access the previous step's values. The outputs of parallel steps can then be referenced or combined by a following step.
 
-![Concurrent steps with .parallel()](/assets/images/workflows-control-flow-parallel-8e7fe60f1c4daa510431b37c973f6f8d.jpg)
-
 ```typescript
 const step1 = createStep({
   id: 'step-1',

package/.docs/docs/workflows/human-in-the-loop.md

@@ -8,8 +8,6 @@ Some workflows need to pause for human input before continuing. When a workflow
 
 Human-in-the-loop (HITL) input works much like [pausing a workflow](https://mastra.ai/docs/workflows/suspend-and-resume) using `suspend()`. The key difference is that when human input is required, you can return `suspend()` with a payload that provides context or guidance to the user on how to continue.
 
-![Pausing a workflow with suspend()](/assets/images/workflows-suspend-4540783670f918109ac35beaf4db914b.jpg)
-
 ```typescript
 import { createWorkflow, createStep } from '@mastra/core/workflows'
 import { z } from 'zod'
@@ -93,8 +91,6 @@ The data returned by the step can include a reason and help the user understand
 
 As with [restarting a workflow](https://mastra.ai/docs/workflows/suspend-and-resume), use `resume()` with `resumeData` to continue a workflow after receiving input from a human. The workflow resumes from the step where it was paused.
 
-![Restarting a workflow with resume()](/assets/images/workflows-resume-1e54b4d0c753ff79571f6d6b05109a60.jpg)
-
 ```typescript
 const workflow = mastra.getWorkflow('testWorkflow')
 const run = await workflow.createRun()

package/.docs/docs/workflows/suspend-and-resume.md

@@ -11,8 +11,6 @@ Use `suspend()` to pause workflow execution at a specific step. You can define a
 - If the condition isn’t met, the workflow pauses and returns `suspend()`.
 - If the condition is met, the workflow continues with the remaining logic in the step.
 
-![Pausing a workflow with suspend()](/assets/images/workflows-suspend-4540783670f918109ac35beaf4db914b.jpg)
-
 ```typescript
 const step1 = createStep({
   id: 'step-1',
@@ -56,8 +54,6 @@ export const testWorkflow = createWorkflow({
 
 Use `resume()` to restart a suspended workflow from the step where it paused. Pass `resumeData` matching the step's `resumeSchema` to satisfy the suspend condition and continue execution.
 
-![Restarting a workflow with resume()](/assets/images/workflows-resume-1e54b4d0c753ff79571f6d6b05109a60.jpg)
-
 ```typescript
 import { step1 } from './workflows/test-workflow'
 

package/.docs/integrations/deploy/render.md

@@ -0,0 +1,389 @@
+> Discover all available pages from the documentation index: https://mastra.ai/llms.txt
+
+# Render
+
+Deploy Mastra applications on [Render](https://render.com/). Host the Mastra API as a [web service](https://render.com/docs/web-services), or use [Render Workflows](https://render.com/docs/workflows) for long-running tasks with independent retry policies.
+
+Choose the deployment path that fits your application:
+
+- **Mastra API**: Deploy Mastra's [server](https://mastra.ai/docs/server/overview) as a web service with a public endpoint. The [Web Services guide](https://render.com/docs/web-services) explains how to deploy custom code or a supported [server adapter](https://mastra.ai/docs/server/server-adapters).
+- **Mastra workflow**: Run an entire Mastra workflow within one task. Render controls the outer run, while Mastra manages its steps and state. See [Defining Workflow Tasks](https://render.com/docs/workflows-defining) for configuration details.
+- **Distributed agent operations**: Give each operation its own compute plan, timeout, and retry policy. Render Workflows handles the execution queue and provides run observability.
+
+This guide builds an editorial pipeline that reviews a draft from three perspectives in parallel, then passes the feedback to an editor agent. Use the links above if you want to deploy a Mastra API or execute an entire Mastra workflow as one task.
+
+## How Render Workflows integrates with Mastra
+
+Mastra supplies the agents and application logic, while Render Workflows defines the execution boundaries. A typical pipeline has three layers:
+
+1. A parent task coordinates the run.
+2. Child tasks invoke Mastra agents for focused work.
+3. A final task combines the results.
+
+Calling one task from another creates a chained run in a separate instance, with its own compute plan, timeout, and retry policy.
+
+## Setup
+
+Create an empty Mastra project named `render-workflows`:
+
+**npm**:
+
+```bash
+npm create mastra@latest render-workflows -- --empty
+```
+
+**pnpm**:
+
+```bash
+pnpm create mastra render-workflows --empty
+```
+
+**Yarn**:
+
+```bash
+yarn create mastra render-workflows --empty
+```
+
+**Bun**:
+
+```bash
+bunx create-mastra render-workflows --empty
+```
+
+Install two additional dependencies:
+
+**npm**:
+
+```bash
+npm install @renderinc/sdk tsx
+```
+
+**pnpm**:
+
+```bash
+pnpm add @renderinc/sdk tsx
+```
+
+**Yarn**:
+
+```bash
+yarn add @renderinc/sdk tsx
+```
+
+**Bun**:
+
+```bash
+bun add @renderinc/sdk tsx
+```
+
+Add your API key to an `.env` file. This example uses OpenAI, but any supported [model provider](https://mastra.ai/models) works.
+
+```text
+OPENAI_API_KEY=your_openai_api_key
+```
+
+Install the [Render CLI](https://render.com/docs/cli) to run workflow commands from your terminal.
+
+## Distributed agent pipeline
+
+### Create the agents
+
+In `src/mastra`, create an `agents` directory with `reviewer-agent.ts` and `editor-agent.ts`. Define both agents:
+
+```ts
+import { Agent } from '@mastra/core/agent'
+
+export const reviewerAgent = new Agent({
+  id: 'reviewer-agent',
+  name: 'Reviewer Agent',
+  model: 'openai/gpt-5.6-sol',
+  instructions: `
+    Review the supplied draft only from the requested perspective.
+    Identify concrete problems and recommend specific changes.
+    Do not rewrite the full draft.
+  `,
+})
+```
+
+```ts
+import { Agent } from '@mastra/core/agent'
+
+export const editorAgent = new Agent({
+  id: 'editor-agent',
+  name: 'Editor Agent',
+  model: 'openai/gpt-5.6-sol',
+  instructions: `
+    Revise the supplied draft using the reviewers' feedback.
+    Return the complete revised draft and nothing else.
+    Preserve accurate details and do not introduce unsupported claims.
+  `,
+})
+```
+
+### Configure the Mastra instance
+
+Add both agents to the Mastra instance in `src/mastra/index.ts`:
+
+```ts
+import { Mastra } from '@mastra/core/mastra'
+import { editorAgent } from './agents/editor-agent.js'
+import { reviewerAgent } from './agents/reviewer-agent.js'
+
+export const mastra = new Mastra({
+  agents: {
+    editorAgent,
+    reviewerAgent,
+  },
+})
+```
+
+### Create the tasks
+
+In `src`, create a `tasks` directory with `review-task.ts`, `revision-task.ts`, and `editorial-task.ts`.
+
+#### Review task
+
+The reviewer agent handles one area of focus. Its compute plan, five-minute timeout, and retry policy apply only to that analysis. A temporary model-provider failure can trigger another attempt without restarting the other reviewers.
+
+```typescript
+import { task } from '@renderinc/sdk/workflows'
+import { mastra } from '../mastra/index.js'
+
+type Review = {
+  focus: string
+  feedback: string
+}
+
+export const reviewDraft = task(
+  {
+    name: 'review_draft',
+    plan: 'starter',
+    timeoutSeconds: 300,
+    retry: {
+      maxRetries: 2,
+      waitDurationMs: 1_000,
+      backoffScaling: 2,
+    },
+  },
+  async function reviewDraft(draft: string, focus: string): Promise<Review> {
+    const reviewer = mastra.getAgentById('reviewer-agent')
+    const response = await reviewer.generate(`
+      Review this draft for ${focus}.
+      Draft: ${draft}
+    `)
+    if (!response.text) {
+      throw new Error(`The ${focus} review returned no text`)
+    }
+    return {
+      focus,
+      feedback: response.text,
+    }
+  },
+)
+```
+
+#### Revision task
+
+This task combines the feedback and produces a revised draft. It uses a larger compute plan and a longer timeout than each reviewer.
+
+```typescript
+import { task } from '@renderinc/sdk/workflows'
+import { mastra } from '../mastra/index.js'
+
+type Review = {
+  focus: string
+  feedback: string
+}
+
+export const reviseDraft = task(
+  {
+    name: 'revise_draft',
+    plan: 'standard',
+    timeoutSeconds: 600,
+    retry: {
+      maxRetries: 2,
+      waitDurationMs: 1_000,
+      backoffScaling: 2,
+    },
+  },
+  async function reviseDraft(draft: string, reviews: Review[]): Promise<{ draft: string }> {
+    const editor = mastra.getAgentById('editor-agent')
+    const response = await editor.generate(`
+      Revise the draft using the review feedback.
+      Draft: ${draft}
+      Reviews: ${JSON.stringify(reviews, null, 2)}
+    `)
+    if (!response.text) {
+      throw new Error('The editor returned no text')
+    }
+    return {
+      draft: response.text,
+    }
+  },
+)
+```
+
+#### Editorial task
+
+The parent dispatches three reviews in parallel with `Promise.all()`, then sends their combined feedback to the revision step. Retries are disabled at this level because each child defines its own policy. If you enable orchestration retries, ensure that another attempt can't duplicate external side effects or other non-idempotent work.
+
+```typescript
+import { task } from '@renderinc/sdk/workflows'
+import { reviewDraft } from './review-task.js'
+import { reviseDraft } from './revision-task.js'
+
+export const editorialPipeline = task(
+  {
+    name: 'editorial_pipeline',
+    plan: 'starter',
+    timeoutSeconds: 1_200,
+    retry: {
+      maxRetries: 0,
+      waitDurationMs: 1_000,
+      backoffScaling: 2,
+    },
+  },
+  async function editorialPipeline(draft: string): Promise<{ draft: string }> {
+    const focuses = ['technical clarity', 'structure and flow', 'reader usefulness']
+    const reviews = await Promise.all(focuses.map(focus => reviewDraft(draft, focus)))
+    return reviseDraft(draft, reviews)
+  },
+)
+```
+
+### Set up the entry point
+
+Create `src/index.ts` and import the editorial task:
+
+```ts
+import './tasks/editorial-task.js'
+```
+
+In `package.json`, add scripts to build the TypeScript project and run the workflow:
+
+```json
+{
+  "scripts": {
+    "build": "tsc",
+    "dev:workflows": "tsx src/index.ts",
+    "start:workflows": "node dist/index.js"
+  }
+}
+```
+
+Configure `tsconfig.json` for the build:
+
+```json
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "rootDir": "src",
+    "outDir": "dist",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true
+  },
+  "include": ["src/**/*"]
+}
+```
+
+Build the project. The command compiles the JavaScript files into `dist`.
+
+**npm**:
+
+```bash
+npm run build
+```
+
+**pnpm**:
+
+```bash
+pnpm run build
+```
+
+**Yarn**:
+
+```bash
+yarn build
+```
+
+**Bun**:
+
+```bash
+bun run build
+```
+
+## Run the pipeline
+
+### Locally
+
+Start the local development server with the Render CLI:
+
+```bash
+render workflows dev -- npm run dev:workflows
+```
+
+The server lists the registered tasks:
+
+```bash
+➜ render workflows dev -- npm run dev:workflows
+Workflow server listening on port 8120
+Loaded environment variables from .env
+3 tasks found in npm run dev:workflows
+  • editorial_pipeline
+  • review_draft
+  • revise_draft
+
+To browse and run tasks, open another terminal and run:
+  render workflows tasks list --local
+```
+
+In another terminal, confirm that the tasks are available:
+
+```bash
+render workflows tasks list --local
+```
+
+The command displays each task's name, ID, and creation time. Press `Ctrl+C`, then start the editorial pipeline from the same terminal:
+
+```bash
+render workflows tasks runs start editorial_pipeline \
+  --local \
+  --input='["Render Workflows runs long-running tasks outside the request lifecycle."]'
+```
+
+The development server records the parent run, three parallel reviews, and the final revision.
+
+### Production
+
+Create a workflow service from the current repository:
+
+```bash
+render workflows create \
+  --name mastra-workflows \
+  --repo . \
+  --runtime node \
+  --build-command "npm install && npm run build" \
+  --run-command "npm run start:workflows"
+```
+
+Add `OPENAI_API_KEY`, or the key for your chosen model provider, to the service's environment variables.
+
+After deployment, start a production run. If needed, replace `mastra-workflows/editorial_pipeline` with the task slug shown in the Render Dashboard.
+
+```bash
+render workflows tasks start mastra-workflows/editorial_pipeline \
+  --input='["Render Workflows runs long-running tasks outside the request lifecycle."]'
+```
+
+Open the workflow service in the Render Dashboard to inspect each task run, attempt, result, and log stream.
+
+## Related
+
+- [Render Workflows documentation](https://render.com/docs/workflows)
+- [Defining Render workflow tasks](https://render.com/docs/workflows-defining)
+- [Triggering task runs](https://render.com/docs/workflows-running)
+- [Render Workflows TypeScript SDK](https://render.com/docs/workflows-sdk-typescript)
+- [Render Workflows limits and pricing](https://render.com/docs/workflows-limits)

package/.docs/integrations/sandboxes/cloudflare-sandbox.md

@@ -0,0 +1,118 @@
+> Discover all available pages from the documentation index: https://mastra.ai/llms.txt
+
+# Cloudflare Sandbox
+
+`CloudflareSandbox` executes commands and manages files in a remote [Cloudflare Sandbox](https://developers.cloudflare.com/sandbox/) through the [Sandbox Bridge HTTP API](https://developers.cloudflare.com/sandbox/bridge/http-api/).
+
+> **Warning:** Deploy and secure a [Sandbox Bridge Worker](https://developers.cloudflare.com/sandbox/bridge/) before using this provider. The bridge can create and delete sandboxes, execute commands, and write files on behalf of its callers.
+
+## Installation
+
+**npm**:
+
+```bash
+npm install @mastra/cloudflare-sandbox
+```
+
+**pnpm**:
+
+```bash
+pnpm add @mastra/cloudflare-sandbox
+```
+
+**Yarn**:
+
+```bash
+yarn add @mastra/cloudflare-sandbox
+```
+
+**Bun**:
+
+```bash
+bun add @mastra/cloudflare-sandbox
+```
+
+## Usage
+
+Add `CloudflareSandbox` to a workspace and assign it to an agent:
+
+```typescript
+import { Agent } from '@mastra/core/agent'
+import { Workspace } from '@mastra/core/workspace'
+import { CloudflareSandbox } from '@mastra/cloudflare-sandbox'
+
+const workspace = new Workspace({
+  sandbox: new CloudflareSandbox({
+    baseUrl: process.env.CLOUDFLARE_SANDBOX_BRIDGE_URL!,
+    apiToken: process.env.CLOUDFLARE_SANDBOX_API_KEY,
+    workingDirectory: '/workspace',
+    commandTimeout: 300_000,
+  }),
+})
+
+export const agent = new Agent({
+  id: 'dev-agent',
+  name: 'Development agent',
+  instructions: 'You are a helpful development assistant.',
+  model: 'anthropic/claude-sonnet-4-6',
+  workspace,
+})
+```
+
+The provider creates a remote sandbox when the workspace starts. Pass `sandboxId` to reconnect to an existing sandbox instead.
+
+## Execute commands
+
+Pass command arguments, environment variables, a working directory, and streaming callbacks through `executeCommand()`. The provider sends the command as an `argv` array, so the bridge handles shell escaping:
+
+```typescript
+const result = await workspace.sandbox?.executeCommand?.('npm', ['test'], {
+  cwd: '/workspace/project',
+  env: {
+    NODE_ENV: 'test',
+  },
+  onStdout: chunk => process.stdout.write(chunk),
+  onStderr: chunk => process.stderr.write(chunk),
+})
+```
+
+## Write files
+
+Relative paths are resolved under `/workspace`. Absolute paths must also resolve within `/workspace`. Each file is sent as its own bridge request, and the bridge caps a single file at 32 MiB.
+
+```typescript
+await workspace.sandbox?.writeFiles?.([
+  { path: 'src/index.ts', content: "console.log('hello')\n" },
+  { path: '/workspace/package.json', content: JSON.stringify({ type: 'module' }) },
+])
+```
+
+## Constructor parameters
+
+**baseUrl** (`string`): URL of the deployed Cloudflare Sandbox Bridge Worker.
+
+**apiToken** (`string`): Bearer token matching the Worker's SANDBOX\_API\_KEY secret.
+
+**sandboxId** (`string`): Existing Cloudflare sandbox ID to reconnect to instead of creating a sandbox.
+
+**id** (`string`): Stable Mastra identifier. Defaults to a generated UUID-based value.
+
+**name** (`string`): Human-readable sandbox name. (Default: `Cloudflare Sandbox`)
+
+**env** (`Record<string, string>`): Environment variables applied to every command.
+
+**workingDirectory** (`string`): Working directory applied to every command.
+
+**commandTimeout** (`number`): Default command timeout in milliseconds. (Default: `300000`)
+
+**instructions** (`string | ((options) => string)`): Custom instructions returned by getInstructions().
+
+## Lifecycle behavior
+
+- `start()`: Reconnects to `sandboxId` or creates a remote sandbox.
+- `stop()`: Detaches the Mastra lifecycle without deleting the remote sandbox because the bridge doesn't expose a suspend operation.
+- `destroy()`: Deletes the remote sandbox.
+
+## Limitations
+
+The provider supports command execution, streamed output, and file writes. It doesn't currently expose the bridge's bucket mounts, sessions, PTY terminals, or workspace persistence routes, and it doesn't support background process management, stdin, snapshots, or port URLs.

package/.docs/integrations.md

@@ -36,6 +36,7 @@
 - [AgentCore](https://mastra.ai/integrations/sandboxes/agentcore)
 - [Apple Container](https://mastra.ai/integrations/sandboxes/apple-container)
 - [Blaxel](https://mastra.ai/integrations/sandboxes/blaxel)
+- [Cloudflare Sandbox](https://mastra.ai/integrations/sandboxes/cloudflare-sandbox)
 - [Daytona](https://mastra.ai/integrations/sandboxes/daytona)
 - [Docker](https://mastra.ai/integrations/sandboxes/docker)
 - [E2B](https://mastra.ai/integrations/sandboxes/e2b)
@@ -54,6 +55,7 @@
 - [Laminar](https://mastra.ai/integrations/observability/laminar)
 - [Langfuse](https://mastra.ai/integrations/observability/langfuse)
 - [LangSmith](https://mastra.ai/integrations/observability/langsmith)
+- [Mastra](https://mastra.ai/docs/mastra-platform/observability)
 - [OpenTelemetry](https://mastra.ai/integrations/observability/opentelemetry)
 - [PostHog](https://mastra.ai/integrations/observability/posthog)
 - [Sentry](https://mastra.ai/integrations/observability/sentry)
@@ -70,6 +72,7 @@
 - [Google Cloud Spanner](https://mastra.ai/integrations/databases/spanner)
 - [LanceDB](https://mastra.ai/integrations/databases/lancedb)
 - [libSQL](https://mastra.ai/integrations/databases/libsql)
+- [Mastra](https://mastra.ai/docs/mastra-platform/database)
 - [MongoDB](https://mastra.ai/integrations/databases/mongodb)
 - [MSSQL](https://mastra.ai/integrations/databases/mssql)
 - [Neon Postgres](https://mastra.ai/integrations/databases/neon)
@@ -90,6 +93,7 @@
 - [Kubernetes](https://mastra.ai/integrations/deploy/kubernetes)
 - [Mastra](https://mastra.ai/docs/mastra-platform/deploy)
 - [Netlify](https://mastra.ai/integrations/deploy/netlify)
+- [Render](https://mastra.ai/integrations/deploy/render)
 - [Temporal](https://mastra.ai/integrations/deploy/temporal)
 - [Vercel](https://mastra.ai/integrations/deploy/vercel)
 

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

@@ -90,7 +90,6 @@ List of required environment variables for each model provider and gateway suppo
 | [LucidQuery](https://mastra.ai/models/providers/lucidquery)                                    | `lucidquery/*`             | `LUCIDQUERY_API_KEY`                                                                                  |
 | [Lynkr](https://mastra.ai/models/providers/lynkr)                                              | `lynkr/*`                  | `LYNKR_API_KEY`                                                                                       |
 | [Meganova](https://mastra.ai/models/providers/meganova)                                        | `meganova/*`               | `MEGANOVA_API_KEY`                                                                                    |
-| [Merge Gateway](https://mastra.ai/models/providers/merge-gateway)                              | `merge-gateway/*`          | `MERGE_GATEWAY_API_KEY`                                                                               |
 | [Meta](https://mastra.ai/models/providers/meta)                                                | `meta/*`                   | `META_MODEL_API_KEY`                                                                                  |
 | [MiniMax (minimax.io)](https://mastra.ai/models/providers/minimax)                             | `minimax/*`                | `MINIMAX_API_KEY`                                                                                     |
 | [MiniMax (minimaxi.com)](https://mastra.ai/models/providers/minimax-cn)                        | `minimax-cn/*`             | `MINIMAX_API_KEY`                                                                                     |
@@ -136,7 +135,7 @@ List of required environment variables for each model provider and gateway suppo
 | [Sarvam AI](https://mastra.ai/models/providers/sarvam)                                         | `sarvam/*`                 | `SARVAM_API_KEY`                                                                                      |
 | [Scaleway](https://mastra.ai/models/providers/scaleway)                                        | `scaleway/*`               | `SCALEWAY_API_KEY`                                                                                    |
 | [SCNet Token Plan](https://mastra.ai/models/providers/scnet-token-plan)                        | `scnet-token-plan/*`       | `SCNET_API_KEY`                                                                                       |
-| [SCX.ai](https://mastra.ai/models/providers/scx)                                               | `scx/*`                    | `SCX_API_KEY`                                                                                         |
+| [SCX.ai](https://mastra.ai/models/providers/scx-ai)                                            | `scx-ai/*`                 | `SCX_API_KEY`                                                                                         |
 | [SiliconFlow](https://mastra.ai/models/providers/siliconflow)                                  | `siliconflow/*`            | `SILICONFLOW_API_KEY`                                                                                 |
 | [SiliconFlow (China)](https://mastra.ai/models/providers/siliconflow-cn)                       | `siliconflow-cn/*`         | `SILICONFLOW_CN_API_KEY`                                                                              |
 | [Snowflake Cortex](https://mastra.ai/models/providers/snowflake-cortex)                        | `snowflake-cortex/*`       | `SNOWFLAKE_ACCOUNT`, `SNOWFLAKE_CORTEX_PAT`                                                           |
@@ -180,6 +179,7 @@ List of required environment variables for each model provider and gateway suppo
 | [Zhipu AI Coding Plan](https://mastra.ai/models/providers/zhipuai-coding-plan)                 | `zhipuai-coding-plan/*`    | `ZHIPU_API_KEY`                                                                                       |
 | [Azure OpenAI](https://mastra.ai/models/gateways/azure-openai) (Gateway)                       | `azure-openai/*`           | `AZURE_API_KEY`, `AZURE_TENANT_ID`, `AZURE_CLIENT_ID`, `AZURE_CLIENT_SECRET`, `AZURE_SUBSCRIPTION_ID` |
 | [Mastra](https://mastra.ai/models/gateways/mastra) (Gateway)                                   | `mastra/*`                 | `MASTRA_GATEWAY_API_KEY`                                                                              |
+| [Merge Gateway](https://mastra.ai/models/gateways/merge-gateway) (Gateway)                     | `merge-gateway/*`          | `MERGE_GATEWAY_API_KEY`                                                                               |
 | [Neon](https://mastra.ai/models/gateways/neon) (Gateway)                                       | `neon/*`                   | `NEON_AI_GATEWAY_BASE_URL`, `NEON_AI_GATEWAY_TOKEN`                                                   |
 | [Netlify](https://mastra.ai/models/gateways/netlify) (Gateway)                                 | `netlify/*`                | `NETLIFY_TOKEN`, `NETLIFY_SITE_ID`                                                                    |
 | [OpenRouter](https://mastra.ai/models/gateways/openrouter) (Gateway)                           | `openrouter/*`             | `OPENROUTER_API_KEY`                                                                                  |