@mastra/mcp-docs-server 1.1.35-alpha.5 → 1.1.35-alpha.8

package/.docs/docs/agents/processors.md

@@ -211,6 +211,22 @@ The method receives the current `stepNumber`, `model`, `tools`, `toolChoice`, `m
 
 See the [`Processor` reference](https://mastra.ai/reference/processors/processor-interface) for all available arguments and return types.
 
+### Rewrite the LLM request before the provider call
+
+Use `processLLMRequest()` when you need to rewrite the final prompt that Mastra sends to the model. This hook runs after Mastra converts the `MessageList` into the provider-facing prompt format (`LanguageModelV2Prompt`) and immediately before the provider call.
+
+Use the message-based hooks for conversation changes:
+
+- `processInput()`: Change the conversation once before the agentic loop starts.
+- `processInputStep()`: Change messages or step configuration before each LLM call.
+- `processLLMRequest()`: Change only the outbound prompt for the current provider call.
+
+Changes returned from `processLLMRequest()` are transient. They don't persist back to `MessageList`, memory, UI history, or future provider calls. This makes the hook a good fit for provider compatibility rewrites, role/content normalization, or other model-specific prompt changes that shouldn't alter stored conversation history.
+
+The method receives `prompt`, `model`, `stepNumber`, `steps`, `state`, and the shared processor context. Calling `abort()` from `processLLMRequest()` emits the normal tripwire response and stops the call.
+
+See the [`Processor` reference](https://mastra.ai/reference/processors/processor-interface) for all available arguments and return types.
+
 ### Use the `prepareStep()` callback
 
 The `prepareStep()` callback on `generate()` or `stream()` is a shorthand for `processInputStep()`. Internally, Mastra wraps it in a processor that calls your function at each step. It accepts the same arguments and return type as `processInputStep()`, but doesn't require creating a class:
@@ -317,7 +333,7 @@ For more on retry behavior, see [Retry mechanism](#retry-mechanism) in Advanced
 
 ### Persist data across chunks and steps
 
-Output methods receive a `state` object that persists for the lifetime of one request. State is keyed by the processor's `id`, so each processor sees only its own data, and it is shared between `processOutputStream`, `processOutputStep`, and `processOutputResult`. A new state object is created for every new `agent.generate()` or `agent.stream()` call.
+Output methods receive a `state` object that persists for the lifetime of one request. State is keyed by the processor's `id`, so each processor sees only its own data, and it's shared between `processOutputStream`, `processOutputStep`, and `processOutputResult`. A new state object is created for every new `agent.generate()` or `agent.stream()` call.
 
 ```typescript
 import type { Processor } from '@mastra/core/processors'
@@ -383,6 +399,14 @@ Enables dynamic tool discovery for agents with large tool libraries. Instead of
 
 See the [`ToolSearchProcessor` reference](https://mastra.ai/reference/processors/tool-search-processor) for configuration options and usage examples.
 
+### `ProviderHistoryCompat`
+
+Handles provider-specific history incompatibilities when agents reuse messages across model providers. It can rewrite the outbound LLM request before the provider call, or recover from known provider API errors and retry.
+
+Add `ProviderHistoryCompat` explicitly when you need provider history compatibility rules, reactive API error recovery, custom compatibility rules, or predictable processor ordering.
+
+See the [`ProviderHistoryCompat` reference](https://mastra.ai/reference/processors/provider-history-compat) for setup, built-in rules, and custom rule options.
+
 ## Advanced patterns
 
 ### Ensure a final response with `maxSteps`
@@ -494,7 +518,7 @@ for await (const chunk of stream.fullStream) {
 
 Custom chunk types must use the `data-` prefix (e.g., `data-moderation-update`, `data-status`).
 
-By default, `processOutputStream()` skips `data-*` chunks so it does not accidentally operate on tool telemetry or other processors' output. To inspect, modify, or block these chunks in a processor, set `processDataParts = true` on that processor:
+By default, `processOutputStream()` skips `data-*` chunks so it doesn't accidentally operate on tool telemetry or other processors' output. To inspect, modify, or block these chunks in a processor, set `processDataParts = true` on that processor:
 
 ```typescript
 class ModerationCollector implements Processor {

package/.docs/guides/guide/web-search.md

@@ -17,7 +17,7 @@ Some LLM providers include built-in web search capabilities that can be used dir
 
 1. Install dependencies
 
-   **Open AI**:
+   **OpenAI**:
 
    **npm**:
 
@@ -119,7 +119,7 @@ Some LLM providers include built-in web search capabilities that can be used dir
 
 2. Create a new file `src/mastra/agents/searchAgent.ts` and define your agent:
 
-   **Open AI**:
+   **OpenAI**:
 
    ```ts
    import { Agent } from '@mastra/core/agent'
@@ -128,7 +128,7 @@ Some LLM providers include built-in web search capabilities that can be used dir
      id: 'search-agent',
      name: 'Search Agent',
      instructions: 'You are a search agent that can search the web for information.',
-     model: 'openai/gpt-5.4',
+     model: 'openai/gpt-5.5',
    })
    ```
 
@@ -147,7 +147,7 @@ Some LLM providers include built-in web search capabilities that can be used dir
 
 3. Setup the tool:
 
-   **Open AI**:
+   **OpenAI**:
 
    ```ts
    import { openai } from '@ai-sdk/openai'
@@ -157,7 +157,7 @@ Some LLM providers include built-in web search capabilities that can be used dir
      id: 'search-agent',
      name: 'Search Agent',
      instructions: 'You are a search agent that can search the web for information.',
-     model: 'openai/gpt-5.4',
+     model: 'openai/gpt-5.5',
      tools: {
        webSearch: openai.tools.webSearch(),
      },
@@ -241,7 +241,7 @@ For more control over search behavior, you can integrate external search APIs as
      id: 'search-agent',
      name: 'Search Agent',
      instructions: 'You are a search agent that can search the web for information.',
-     model: 'openai/gpt-5.4',
+     model: 'openai/gpt-5.5',
    })
    ```
 
@@ -293,7 +293,7 @@ For more control over search behavior, you can integrate external search APIs as
      id: 'search-agent',
      name: 'Search Agent',
      instructions: 'You are a search agent that can search the web for information.',
-     model: 'openai/gpt-5.4',
+     model: 'openai/gpt-5.5',
      tools: {
        webSearch,
      },

package/.docs/models/gateways/azure-openai.md

@@ -13,7 +13,7 @@ const agent = new Agent({
   id: "my-agent",
   name: "My Agent",
   instructions: "You are a helpful assistant",
-  model: "azure-openai/my-gpt4-deployment"  // Use your Azure deployment name (autocompleted in dev mode)
+  model: "azure-openai/my-gpt-5-4-deployment"  // Use your Azure deployment name (autocompleted in dev mode)
 });
 
 // Generate a response
@@ -34,9 +34,9 @@ Azure model IDs follow this pattern: `azure-openai/your-deployment-name`
 
 The deployment name is **specific to your Azure account** and chosen when you create a deployment in Azure Portal. Common examples:
 
-- `azure-openai/my-gpt4-deployment`
-- `azure-openai/production-gpt-35-turbo`
-- `azure-openai/staging-gpt-4o`
+- `azure-openai/my-gpt-5-4-deployment`
+- `azure-openai/production-gpt-5-4`
+- `azure-openai/staging-gpt-5-4-mini`
 
 ## Setup
 
@@ -44,7 +44,7 @@ Create deployments in [Azure OpenAI Studio](https://oai.azure.com/). The resourc
 
 ## Configuration
 
-Instantiate the gateway and pass it to Mastra. Three configuration modes are available.
+Instantiate the gateway and pass it to Mastra. The common configuration modes are shown below.
 
 ### Static Deployments
 
@@ -59,7 +59,7 @@ export const mastra = new Mastra({
     new AzureOpenAIGateway({
       resourceName: "my-openai-resource",
       apiKey: process.env.AZURE_API_KEY!,
-      deployments: ["gpt-4-prod", "gpt-35-turbo-dev"],
+      deployments: ["gpt-5-4-prod", "gpt-5-4-mini-dev"],
     }),
   ],
 });
@@ -111,7 +111,7 @@ export const mastra = new Mastra({
         type: "entraId",
         credential: new DefaultAzureCredential(),
       },
-      deployments: ["gpt-4-prod", "gpt-35-turbo-dev"],
+      deployments: ["gpt-5-4-prod", "gpt-5-4-mini-dev"],
     }),
   ],
 });
@@ -145,23 +145,94 @@ export const mastra = new Mastra({
 });
 ```
 
+### Azure Responses API
+
+Azure OpenAI supports the Responses API through the `v1` API path used by the AI SDK Azure provider. Set `useResponsesAPI: true` when your Azure resource and deployment support that route. The gateway then uses `apiVersion: "v1"` and `useDeploymentBasedUrls: false` by default.
+
+```typescript
+import { Mastra } from "@mastra/core";
+import { AzureOpenAIGateway } from "@mastra/core/llm";
+
+export const mastra = new Mastra({
+  gateways: [
+    new AzureOpenAIGateway({
+      resourceName: "my-openai-resource",
+      apiKey: process.env.AZURE_API_KEY!,
+      useResponsesAPI: true,
+      deployments: ["my-gpt-5-4-deployment"],
+    }),
+  ],
+});
+```
+
+Keep `useResponsesAPI` omitted or set it to `false` for the existing Azure chat completions route. That path keeps `apiVersion: "2024-04-01-preview"` and deployment-based URLs by default for compatibility.
+
+You can still configure `apiVersion` and `useDeploymentBasedUrls` directly. For example, set `useDeploymentBasedUrls: false` to use the Azure `v1` URL shape with the chat model constructor; the gateway defaults `apiVersion` to `"v1"` for that route. Passing `apiVersion: "v1"` by itself keeps the existing deployment-based URL default for compatibility.
+
+Do not combine `useResponsesAPI: true` with `useDeploymentBasedUrls: true`; the gateway rejects that configuration because Responses API support uses the Azure `v1` route.
+
+Use `apiVersion: "v1"` for the GA `v1` route. Microsoft currently exposes preview `v1` features through feature-specific headers, such as `"aoai-evals": "preview"`, or through preview/alpha API paths. The gateway still accepts `apiVersion: "preview"` with `useDeploymentBasedUrls: false` for Azure provider configurations that require the preview query value. Date-based API versions are only for the legacy deployment-based route, so the gateway rejects them when `useResponsesAPI` is `true` or `useDeploymentBasedUrls` is `false`.
+
+The same API key and Microsoft Entra ID authentication modes work with the `v1` route.
+
+### Azure Responses WebSocket transport
+
+Azure OpenAI also supports WebSocket mode on the Responses API. Use it for agent or tool loops with many model-tool round trips. Keep the standard HTTP transport for single-shot requests and short conversations.
+
+WebSocket transport requires `useResponsesAPI: true`, because Azure exposes it on the `v1` Responses path. Then opt in per stream request with `providerOptions.azure.transport: "websocket"`.
+
+```typescript
+import { Agent } from "@mastra/core/agent";
+
+const agent = new Agent({
+  id: "azure-ws-agent",
+  name: "Azure WebSocket Agent",
+  instructions: "Use tools when they are useful.",
+  model: "azure-openai/my-gpt-5-4-deployment",
+});
+
+const stream = await agent.stream("Find and improve the slow function.", {
+  providerOptions: {
+    azure: {
+      transport: "websocket",
+      store: false,
+      websocket: {
+        closeOnFinish: false,
+      },
+    },
+  },
+});
+
+for await (const chunk of stream.textStream) {
+  process.stdout.write(chunk);
+}
+
+stream.transport?.close();
+```
+
+Set `closeOnFinish: false` when you want to keep the socket open across follow-up turns. Azure keeps one response chain in connection-local memory, so continuing from the most recent `previous_response_id` can reduce continuation latency. The connection runs one response at a time and does not multiplex parallel runs.
+
+Do not send overlapping follow-up requests with `previous_response_id` on the same WebSocket transport. Mastra rejects overlapping continuation requests because Azure only keeps one in-flight response per connection. Wait for the active stream to finish before continuing the response chain.
+
 ## Configuration Reference
 
-| Option                      | Type              | Required | Description                                                           |
-| --------------------------- | ----------------- | -------- | --------------------------------------------------------------------- |
-| `resourceName`              | `string`          | Yes      | Azure OpenAI resource name                                            |
-| `apiKey`                    | `string`          | Yes\*    | API key from "Keys and Endpoint"                                      |
-| `authentication`            | `object`          | No       | Microsoft Entra ID authentication                                     |
-| `authentication.type`       | `"entraId"`       | Yes\*    | Authentication mode                                                   |
-| `authentication.credential` | `TokenCredential` | Yes\*    | Azure SDK-compatible credential for `entraId` authentication mode     |
-| `authentication.scope`      | `string`          | No       | Token scope (default: `https://cognitiveservices.azure.com/.default`) |
-| `apiVersion`                | `string`          | No       | API version (default: `2024-04-01-preview`)                           |
-| `deployments`               | `string[]`        | No       | Deployment names for static mode                                      |
-| `management`                | `object`          | No       | Management API credentials                                            |
-| `management.tenantId`       | `string`          | Yes\*    | Azure AD tenant ID                                                    |
-| `management.clientId`       | `string`          | Yes\*    | Service Principal client ID                                           |
-| `management.clientSecret`   | `string`          | Yes\*    | Service Principal secret                                              |
-| `management.subscriptionId` | `string`          | Yes\*    | Azure subscription ID                                                 |
-| `management.resourceGroup`  | `string`          | Yes\*    | Resource group name                                                   |
+| Option                      | Type              | Required | Description                                                                                                                  |
+| --------------------------- | ----------------- | -------- | ---------------------------------------------------------------------------------------------------------------------------- |
+| `resourceName`              | `string`          | Yes      | Azure OpenAI resource name                                                                                                   |
+| `apiKey`                    | `string`          | Yes\*    | API key from "Keys and Endpoint"                                                                                             |
+| `authentication`            | `object`          | No       | Microsoft Entra ID authentication                                                                                            |
+| `authentication.type`       | `"entraId"`       | Yes\*    | Authentication mode                                                                                                          |
+| `authentication.credential` | `TokenCredential` | Yes\*    | Azure SDK-compatible credential for `entraId` authentication mode                                                            |
+| `authentication.scope`      | `string`          | No       | Token scope (default: `https://cognitiveservices.azure.com/.default`)                                                        |
+| `apiVersion`                | `string`          | No       | API version (default: `2024-04-01-preview`, or `v1` when `useResponsesAPI` is `true` or `useDeploymentBasedUrls` is `false`) |
+| `useResponsesAPI`           | `boolean`         | No       | Resolve deployments through the Azure OpenAI Responses API (default: `false`)                                                |
+| `useDeploymentBasedUrls`    | `boolean`         | No       | Use Azure deployment-based URLs (default: `true`, or `false` when `useResponsesAPI` is `true`)                               |
+| `deployments`               | `string[]`        | No       | Deployment names for static mode                                                                                             |
+| `management`                | `object`          | No       | Management API credentials                                                                                                   |
+| `management.tenantId`       | `string`          | Yes\*    | Azure AD tenant ID                                                                                                           |
+| `management.clientId`       | `string`          | Yes\*    | Service Principal client ID                                                                                                  |
+| `management.clientSecret`   | `string`          | Yes\*    | Service Principal secret                                                                                                     |
+| `management.subscriptionId` | `string`          | Yes\*    | Azure subscription ID                                                                                                        |
+| `management.resourceGroup`  | `string`          | Yes\*    | Resource group name                                                                                                          |
 
 \* Provide either `apiKey` or `authentication.type: "entraId"`. Management fields are required if `management` is provided.

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

package/.docs/models/providers/kiro.md

@@ -0,0 +1,110 @@
+# ![Kiro logo](https://models.dev/logos/kiro.svg)Kiro
+
+Access 12 Kiro models through Mastra's model router. Authentication is handled automatically using the `KIRO_API_KEY` environment variable.
+
+Learn more in the [Kiro documentation](https://kiro.dev).
+
+```bash
+KIRO_API_KEY=your-api-key
+```
+
+```typescript
+import { Agent } from "@mastra/core/agent";
+
+const agent = new Agent({
+  id: "my-agent",
+  name: "My Agent",
+  instructions: "You are a helpful assistant",
+  model: "kiro/auto"
+});
+
+// Generate a response
+const response = await agent.generate("Hello!");
+
+// Stream a response
+const stream = await agent.stream("Tell me a story");
+for await (const chunk of stream) {
+  console.log(chunk);
+}
+```
+
+> **Info:** Mastra uses the OpenAI-compatible `/chat/completions` endpoint. Some provider-specific features may not be available. Check the [Kiro documentation](https://kiro.dev) for details.
+
+## Models
+
+| Model                    | Context | Tools | Reasoning | Image | Audio | Video | Input $/1M | Output $/1M |
+| ------------------------ | ------- | ----- | --------- | ----- | ----- | ----- | ---------- | ----------- |
+| `kiro/auto`              | 1.0M    |       |           |       |       |       | —          | —           |
+| `kiro/claude-haiku-4.5`  | 200K    |       |           |       |       |       | —          | —           |
+| `kiro/claude-opus-4.5`   | 200K    |       |           |       |       |       | —          | —           |
+| `kiro/claude-opus-4.6`   | 1.0M    |       |           |       |       |       | —          | —           |
+| `kiro/claude-opus-4.7`   | 1.0M    |       |           |       |       |       | —          | —           |
+| `kiro/claude-sonnet-4`   | 200K    |       |           |       |       |       | —          | —           |
+| `kiro/claude-sonnet-4.5` | 200K    |       |           |       |       |       | —          | —           |
+| `kiro/claude-sonnet-4.6` | 1.0M    |       |           |       |       |       | —          | —           |
+| `kiro/deepseek-3.2`      | 164K    |       |           |       |       |       | —          | —           |
+| `kiro/minimax-m2.1`      | 196K    |       |           |       |       |       | —          | —           |
+| `kiro/minimax-m2.5`      | 196K    |       |           |       |       |       | —          | —           |
+| `kiro/qwen3-coder-next`  | 256K    |       |           |       |       |       | —          | —           |
+
+## Advanced configuration
+
+### Custom headers
+
+```typescript
+const agent = new Agent({
+  id: "custom-agent",
+  name: "custom-agent",
+  model: {
+    url: "https://q.us-east-1.amazonaws.com",
+    id: "kiro/auto",
+    apiKey: process.env.KIRO_API_KEY,
+    headers: {
+      "X-Custom-Header": "value"
+    }
+  }
+});
+```
+
+### Dynamic model selection
+
+```typescript
+const agent = new Agent({
+  id: "dynamic-agent",
+  name: "Dynamic Agent",
+  model: ({ requestContext }) => {
+    const useAdvanced = requestContext.task === "complex";
+    return useAdvanced
+      ? "kiro/qwen3-coder-next"
+      : "kiro/auto";
+  }
+});
+```
+
+## Direct provider installation
+
+This provider can also be installed directly as a standalone package, which can be used instead of the Mastra model router string. View the [package documentation](https://www.npmjs.com/package/kiro-acp-ai-provider) for more details.
+
+**npm**:
+
+```bash
+npm install kiro-acp-ai-provider
+```
+
+**pnpm**:
+
+```bash
+pnpm add kiro-acp-ai-provider
+```
+
+**Yarn**:
+
+```bash
+yarn add kiro-acp-ai-provider
+```
+
+**Bun**:
+
+```bash
+bun add kiro-acp-ai-provider
+```

package/.docs/models/providers/llmgateway.md

@@ -153,7 +153,7 @@ for await (const chunk of stream) {
 | `llmgateway/llama-4-maverick-17b-instruct`         | 8K      |       |           |       |       |       | $0.24      | $0.97       |
 | `llmgateway/llama-4-scout`                         | 33K     |       |           |       |       |       | $0.18      | $0.59       |
 | `llmgateway/llama-4-scout-17b-instruct`            | 8K      |       |           |       |       |       | $0.17      | $0.66       |
-| `llmgateway/mimo-v2-flash`                         | 256K    |       |           |       |       |       | $0.10      | $0.30       |
+| `llmgateway/mimo-v2-flash`                         | 262K    |       |           |       |       |       | $0.10      | $0.30       |
 | `llmgateway/minimax-m2`                            | 197K    |       |           |       |       |       | $0.30      | $1          |
 | `llmgateway/minimax-m2.1`                          | 205K    |       |           |       |       |       | $0.30      | $1          |
 | `llmgateway/minimax-m2.1-lightning`                | 197K    |       |           |       |       |       | $0.12      | $0.48       |

package/.docs/models/providers/opencode-go.md

@@ -1,6 +1,6 @@
 # ![OpenCode Go logo](https://models.dev/logos/opencode-go.svg)OpenCode Go
 
-Access 14 OpenCode Go models through Mastra's model router. Authentication is handled automatically using the `OPENCODE_API_KEY` environment variable.
+Access 12 OpenCode Go models through Mastra's model router. Authentication is handled automatically using the `OPENCODE_API_KEY` environment variable.
 
 Learn more in the [OpenCode Go documentation](https://opencode.ai/docs/zen).
 
@@ -40,8 +40,6 @@ for await (const chunk of stream) {
 | `opencode-go/glm-5.1`           | 203K    |       |           |       |       |       | $1         | $4          |
 | `opencode-go/kimi-k2.5`         | 262K    |       |           |       |       |       | $0.60      | $3          |
 | `opencode-go/kimi-k2.6`         | 262K    |       |           |       |       |       | $0.95      | $4          |
-| `opencode-go/mimo-v2-omni`      | 262K    |       |           |       |       |       | $0.40      | $2          |
-| `opencode-go/mimo-v2-pro`       | 1.0M    |       |           |       |       |       | $1         | $3          |
 | `opencode-go/mimo-v2.5`         | 1.0M    |       |           |       |       |       | $0.40      | $2          |
 | `opencode-go/mimo-v2.5-pro`     | 1.0M    |       |           |       |       |       | $1         | $3          |
 | `opencode-go/minimax-m2.5`      | 205K    |       |           |       |       |       | $0.30      | $1          |

package/.docs/models/providers/qiniu-ai.md

@@ -81,7 +81,7 @@ for await (const chunk of stream) {
 | `qiniu-ai/kling-v2-6`                               | 100.0M  |       |           |       |       |       | —          | —           |
 | `qiniu-ai/meituan/longcat-flash-chat`               | 131K    |       |           |       |       |       | —          | —           |
 | `qiniu-ai/meituan/longcat-flash-lite`               | 256K    |       |           |       |       |       | —          | —           |
-| `qiniu-ai/mimo-v2-flash`                            | 256K    |       |           |       |       |       | —          | —           |
+| `qiniu-ai/mimo-v2-flash`                            | 256K    |       |           |       |       |       | $0.10      | $0.30       |
 | `qiniu-ai/MiniMax-M1`                               | 1.0M    |       |           |       |       |       | —          | —           |
 | `qiniu-ai/minimax/minimax-m2`                       | 200K    |       |           |       |       |       | —          | —           |
 | `qiniu-ai/minimax/minimax-m2.1`                     | 205K    |       |           |       |       |       | —          | —           |
@@ -120,7 +120,7 @@ for await (const chunk of stream) {
 | `qiniu-ai/x-ai/grok-4.1-fast-non-reasoning`         | 2.0M    |       |           |       |       |       | —          | —           |
 | `qiniu-ai/x-ai/grok-4.1-fast-reasoning`             | 20.0M   |       |           |       |       |       | —          | —           |
 | `qiniu-ai/x-ai/grok-code-fast-1`                    | 256K    |       |           |       |       |       | —          | —           |
-| `qiniu-ai/xiaomi/mimo-v2-flash`                     | 256K    |       |           |       |       |       | —          | —           |
+| `qiniu-ai/xiaomi/mimo-v2-flash`                     | 256K    |       |           |       |       |       | $0.10      | $0.30       |
 | `qiniu-ai/z-ai/autoglm-phone-9b`                    | 13K     |       |           |       |       |       | —          | —           |
 | `qiniu-ai/z-ai/glm-4.6`                             | 200K    |       |           |       |       |       | —          | —           |
 | `qiniu-ai/z-ai/glm-4.7`                             | 200K    |       |           |       |       |       | —          | —           |

package/.docs/models/providers/xiaomi.md

@@ -34,8 +34,8 @@ for await (const chunk of stream) {
 
 | Model                  | Context | Tools | Reasoning | Image | Audio | Video | Input $/1M | Output $/1M |
 | ---------------------- | ------- | ----- | --------- | ----- | ----- | ----- | ---------- | ----------- |
-| `xiaomi/mimo-v2-flash` | 256K    |       |           |       |       |       | $0.10      | $0.30       |
-| `xiaomi/mimo-v2-omni`  | 256K    |       |           |       |       |       | $0.40      | $2          |
+| `xiaomi/mimo-v2-flash` | 262K    |       |           |       |       |       | $0.10      | $0.30       |
+| `xiaomi/mimo-v2-omni`  | 262K    |       |           |       |       |       | $0.40      | $2          |
 | `xiaomi/mimo-v2-pro`   | 1.0M    |       |           |       |       |       | $1         | $3          |
 | `xiaomi/mimo-v2.5`     | 1.0M    |       |           |       |       |       | $0.40      | $2          |
 | `xiaomi/mimo-v2.5-pro` | 1.0M    |       |           |       |       |       | $1         | $3          |

package/.docs/models/providers/zenmux.md

@@ -114,7 +114,7 @@ for await (const chunk of stream) {
 | `zenmux/x-ai/grok-code-fast-1`                | 256K    |       |           |       |       |       | $0.20      | $2          |
 | `zenmux/xiaomi/mimo-v2-flash`                 | 262K    |       |           |       |       |       | $0.10      | $0.30       |
 | `zenmux/xiaomi/mimo-v2-omni`                  | 265K    |       |           |       |       |       | $0.40      | $2          |
-| `zenmux/xiaomi/mimo-v2-pro`                   | 1.0M    |       |           |       |       |       | $2         | $5          |
+| `zenmux/xiaomi/mimo-v2-pro`                   | 1.0M    |       |           |       |       |       | $1         | $3          |
 | `zenmux/xiaomi/mimo-v2.5`                     | 1.0M    |       |           |       |       |       | $0.40      | $2          |
 | `zenmux/xiaomi/mimo-v2.5-pro`                 | 1.0M    |       |           |       |       |       | $1         | $3          |
 | `zenmux/z-ai/glm-4.5`                         | 128K    |       |           |       |       |       | $0.35      | $2          |

package/.docs/models/providers.md

@@ -45,6 +45,7 @@ Direct access to individual AI model providers. Each provider offers unique mode
 - [Jiekou.AI](https://mastra.ai/models/providers/jiekou)
 - [Kilo Gateway](https://mastra.ai/models/providers/kilo)
 - [Kimi For Coding](https://mastra.ai/models/providers/kimi-for-coding)
+- [Kiro](https://mastra.ai/models/providers/kiro)
 - [KUAE Cloud Coding Plan](https://mastra.ai/models/providers/kuae-cloud-coding-plan)
 - [Llama](https://mastra.ai/models/providers/llama)
 - [LLM Gateway](https://mastra.ai/models/providers/llmgateway)

package/.docs/reference/cli/mastra.md

@@ -550,6 +550,470 @@ See the [Storage migration guide](https://mastra.ai/guides/migrations/upgrade-to
 
 It accepts [common flags](#common-flags).
 
+## `mastra api`
+
+Calls a Mastra runtime server with JSON input and JSON output. Use it for local development servers, deployed Mastra Platform projects, or self-hosted Mastra servers.
+
+```bash
+mastra api agent list --pretty
+mastra api agent run weather-agent '{"messages":"What is the weather in London?"}'
+mastra api tool execute get-weather '{"location":"San Francisco"}'
+```
+
+Use `mastra api <resource> <action> --help` to see examples for a command.
+
+### Output
+
+Success responses are written to `stdout` as JSON. Single-resource commands return:
+
+```json
+{ "data": {} }
+```
+
+List commands return a `data` array and pagination metadata:
+
+```json
+{ "data": [], "page": { "total": 0, "page": 0, "perPage": 0, "hasMore": false } }
+```
+
+Errors are written to `stderr` as JSON and return a non-zero exit code:
+
+```json
+{
+  "error": {
+    "code": "SERVER_UNREACHABLE",
+    "message": "Could not connect to target server",
+    "details": {}
+  }
+}
+```
+
+### Target resolution
+
+The command resolves the target server in this order:
+
+1. `--url <url>` for an explicit remote or self-hosted server.
+2. `http://localhost:4111` for a local `mastra dev` server.
+3. `.mastra-project.json` for a Mastra Platform project.
+
+Automatic platform auth is only used when the CLI resolves a Mastra Platform target from `.mastra-project.json`. Localhost targets and explicit `--url` targets do not receive automatic credentials. Headers passed with `--header` are sent to any target, including localhost.
+
+### Flags
+
+#### `--url <url>`
+
+Target a specific Mastra server URL.
+
+```bash
+mastra api --url https://example.com agent list
+```
+
+#### `--header <"Key: Value">`
+
+Send a custom HTTP header. Repeat the flag to send multiple headers.
+
+```bash
+mastra api --url https://example.com --header "Authorization: Bearer $TOKEN" agent list
+```
+
+#### `--timeout <ms>`
+
+Set the request timeout in milliseconds. Defaults to `30000`. Workflow run start and resume commands default to `120000`.
+
+#### `--pretty`
+
+Pretty-print JSON output. Defaults to `false`.
+
+#### `--schema`
+
+Print the CLI-oriented request schema for a command that accepts JSON input. The schema comes from the target server's route contracts and includes the command shape, positionals, examples, request schemas, and response shape.
+
+`--schema` is available on leaf commands that accept JSON input. It is not available as a top-level `mastra api` flag.
+
+```bash
+mastra api agent run --schema
+mastra api tool execute --schema
+```
+
+### Input model
+
+Commands that accept input take one inline JSON argument. Do not pass file paths or stdin.
+
+```bash
+mastra api workflow run start data-pipeline '{"inputData":{"source":"s3://bucket/data.csv"}}'
+```
+
+Use positional arguments for stable IDs and JSON for filters or payloads. For routes that require both query parameters and a request body, pass one JSON object. The CLI splits the input according to the server route schema.
+
+```bash
+mastra api thread create '{"agentId":"weather-agent","resourceId":"user_123","threadId":"thread_abc123","title":"Support conversation"}'
+```
+
+List commands accept `page` and `perPage` in the JSON input when the target route supports pagination:
+
+```bash
+mastra api score list '{"page":0,"perPage":50}'
+```
+
+### Get command-specific help
+
+Each `mastra api` leaf command includes command-specific examples in its help output. Use `--help` on the exact command you want to call:
+
+```bash
+mastra api agent run --help
+mastra api tool execute --help
+mastra api memory current update --help
+mastra api workflow run resume --help
+```
+
+Use `--schema` on commands that accept JSON input to inspect the request shape returned by the target server:
+
+```bash
+mastra api agent run --schema
+mastra api thread create --schema
+mastra api score create --schema
+```
+
+Some commands have important runtime requirements. For example, `mastra api memory current update` requires working memory to be enabled for the memory instance, and `mastra api workflow run resume` only works for suspended workflow runs.
+
+### Commands
+
+#### `mastra api agent list`
+
+Lists the agents registered on the target server. Pass optional JSON input for route-supported filters.
+
+```bash
+mastra api agent list [input]
+```
+
+#### `mastra api agent get`
+
+Gets metadata for one registered agent.
+
+```bash
+mastra api agent get <agentId>
+```
+
+#### `mastra api agent run`
+
+Runs an agent with JSON input. Use command help to see examples for text prompts, chat messages, and memory thread options.
+
+```bash
+mastra api agent run <agentId> <input>
+```
+
+#### `mastra api workflow list`
+
+Lists workflows registered on the target server. Pass optional JSON input for route-supported filters.
+
+```bash
+mastra api workflow list [input]
+```
+
+#### `mastra api workflow get`
+
+Gets metadata for one registered workflow.
+
+```bash
+mastra api workflow get <workflowId>
+```
+
+#### `mastra api workflow run start`
+
+Starts a workflow run with JSON input. Workflow start commands use a longer default timeout than most commands because runs can take longer to complete.
+
+```bash
+mastra api workflow run start <workflowId> <input>
+```
+
+#### `mastra api workflow run list`
+
+Lists runs for a workflow. Pass optional JSON input for route-supported filters or pagination.
+
+```bash
+mastra api workflow run list <workflowId> [input]
+```
+
+#### `mastra api workflow run get`
+
+Gets one workflow run by ID.
+
+```bash
+mastra api workflow run get <workflowId> <runId>
+```
+
+#### `mastra api workflow run resume`
+
+Resumes a suspended workflow run with JSON input. The run must be in a suspended state.
+
+```bash
+mastra api workflow run resume <workflowId> <runId> <input>
+```
+
+#### `mastra api workflow run cancel`
+
+Cancels a workflow run.
+
+```bash
+mastra api workflow run cancel <workflowId> <runId>
+```
+
+#### `mastra api tool list`
+
+Lists tools registered on the target server. Pass optional JSON input for route-supported filters.
+
+```bash
+mastra api tool list [input]
+```
+
+#### `mastra api tool get`
+
+Gets metadata and schemas for one tool.
+
+```bash
+mastra api tool get <toolId>
+```
+
+#### `mastra api tool execute`
+
+Executes a tool with JSON input. Raw tool input is wrapped as the route `data` field unless you pass an explicit `data` object.
+
+```bash
+mastra api tool execute <toolId> <input>
+```
+
+#### `mastra api mcp list`
+
+Lists Model Context Protocol (MCP) servers registered on the target server. Pass optional JSON input for route-supported filters.
+
+```bash
+mastra api mcp list [input]
+```
+
+#### `mastra api mcp get`
+
+Gets metadata for one MCP server.
+
+```bash
+mastra api mcp get <id>
+```
+
+#### `mastra api mcp tool list`
+
+Lists tools exposed by an MCP server. Pass optional JSON input for route-supported filters.
+
+```bash
+mastra api mcp tool list <serverId> [input]
+```
+
+#### `mastra api mcp tool get`
+
+Gets metadata and schemas for one MCP tool.
+
+```bash
+mastra api mcp tool get <serverId> <toolId>
+```
+
+#### `mastra api mcp tool execute`
+
+Executes an MCP tool with JSON input. Raw tool input is wrapped as the route `data` field unless you pass an explicit `data` object.
+
+```bash
+mastra api mcp tool execute <serverId> <toolId> <input>
+```
+
+#### `mastra api thread list`
+
+Lists memory threads. Pass optional JSON input for route-supported filters.
+
+```bash
+mastra api thread list [input]
+```
+
+#### `mastra api thread get`
+
+Gets one memory thread by ID.
+
+```bash
+mastra api thread get <threadId>
+```
+
+#### `mastra api thread create`
+
+Creates a memory thread. Pass one JSON input object; the CLI splits fields such as `agentId` into query parameters when required by the server route.
+
+```bash
+mastra api thread create <input>
+```
+
+#### `mastra api thread update`
+
+Updates a memory thread. Pass one JSON input object for fields such as `agentId`, `resourceId`, `title`, or `metadata`.
+
+```bash
+mastra api thread update <threadId> <input>
+```
+
+#### `mastra api thread delete`
+
+Deletes a memory thread. Pass JSON input for route-required query parameters such as `agentId` and `resourceId`.
+
+```bash
+mastra api thread delete <threadId> <input>
+```
+
+#### `mastra api thread messages`
+
+Lists messages for a memory thread. Pass optional JSON input for route-supported filters or pagination.
+
+```bash
+mastra api thread messages <threadId> [input]
+```
+
+#### `mastra api memory search`
+
+Searches long-term memory. Use `--help` or `--schema` to inspect required fields such as `agentId`, `resourceId`, and `searchQuery`.
+
+```bash
+mastra api memory search <input>
+```
+
+#### `mastra api memory current get`
+
+Reads current working memory for a thread.
+
+```bash
+mastra api memory current get <input>
+```
+
+#### `mastra api memory current update`
+
+Updates current working memory for a thread. Working memory must be enabled for the memory instance.
+
+```bash
+mastra api memory current update <input>
+```
+
+#### `mastra api memory status`
+
+Gets memory status for an agent and optional thread or resource context.
+
+```bash
+mastra api memory status <input>
+```
+
+#### `mastra api trace list`
+
+Lists observability traces. Pass optional JSON input for route-supported filters or pagination.
+
+```bash
+mastra api trace list [input]
+```
+
+#### `mastra api trace get`
+
+Gets one observability trace by ID.
+
+```bash
+mastra api trace get <traceId>
+```
+
+#### `mastra api log list`
+
+Lists observability logs. Pass optional JSON input for route-supported filters or pagination.
+
+```bash
+mastra api log list [input]
+```
+
+#### `mastra api score create`
+
+Creates an observability score. The input uses the server score body shape; inspect it with `--schema`.
+
+```bash
+mastra api score create <input>
+```
+
+#### `mastra api score list`
+
+Lists observability scores. Pass optional JSON input for filters such as run ID or pagination.
+
+```bash
+mastra api score list [input]
+```
+
+#### `mastra api score get`
+
+Gets one observability score by ID.
+
+```bash
+mastra api score get <scoreId>
+```
+
+#### `mastra api dataset list`
+
+Lists datasets. Pass optional JSON input for route-supported filters or pagination.
+
+```bash
+mastra api dataset list [input]
+```
+
+#### `mastra api dataset get`
+
+Gets one dataset by ID.
+
+```bash
+mastra api dataset get <datasetId>
+```
+
+#### `mastra api dataset create`
+
+Creates a dataset with JSON input.
+
+```bash
+mastra api dataset create <input>
+```
+
+#### `mastra api dataset items`
+
+Lists items in a dataset. Pass optional JSON input for route-supported filters or pagination.
+
+```bash
+mastra api dataset items <datasetId> [input]
+```
+
+#### `mastra api experiment list`
+
+Lists experiments for a dataset. Pass optional JSON input for route-supported filters or pagination.
+
+```bash
+mastra api experiment list <datasetId> [input]
+```
+
+#### `mastra api experiment get`
+
+Gets one experiment by ID.
+
+```bash
+mastra api experiment get <datasetId> <experimentId>
+```
+
+#### `mastra api experiment run`
+
+Starts an experiment for a dataset with JSON input.
+
+```bash
+mastra api experiment run <datasetId> <input>
+```
+
+#### `mastra api experiment results`
+
+Lists results for an experiment. Pass optional JSON input for route-supported filters or pagination.
+
+```bash
+mastra api experiment results <datasetId> <experimentId> [input]
+```
+
 ## Common flags
 
 ### `--dir`

package/.docs/reference/index.md

@@ -168,6 +168,7 @@ The Reference section provides documentation of Mastra's API, including paramete
 - [PrefillErrorHandler](https://mastra.ai/reference/processors/prefill-error-handler)
 - [Processor Interface](https://mastra.ai/reference/processors/processor-interface)
 - [PromptInjectionDetector](https://mastra.ai/reference/processors/prompt-injection-detector)
+- [ProviderHistoryCompat](https://mastra.ai/reference/processors/provider-history-compat)
 - [RegexFilterProcessor](https://mastra.ai/reference/processors/regex-filter-processor)
 - [SemanticRecall](https://mastra.ai/reference/processors/semantic-recall-processor)
 - [SkillSearchProcessor](https://mastra.ai/reference/processors/skill-search-processor)

package/.docs/reference/processors/processor-interface.md

@@ -4,7 +4,7 @@ The `Processor` interface defines the contract for all processors in Mastra. Pro
 
 ## When processor methods run
 
-The six processor methods run at different points in the agent execution lifecycle:
+The seven processor methods run at different points in the agent execution lifecycle:
 
 ```text
 ┌─────────────────────────────────────────────────────────────────┐
@@ -26,6 +26,11 @@ The six processor methods run at different points in the agent execution lifecyc
 │  │  └──────────┬──────────┘                                │    │
 │  │             │                                           │    │
 │  │             ▼                                           │    │
+│  │  ┌─────────────────────┐                                │    │
+│  │  │  processLLMRequest   │  ← Runs before provider call   │    │
+│  │  └──────────┬──────────┘                                │    │
+│  │             │                                           │    │
+│  │             ▼                                           │    │
 │  │       LLM Execution ──── API Error? ──┐                │    │
 │  │             │                          │                │    │
 │  │             │              ┌───────────────────┐        │    │
@@ -59,14 +64,15 @@ The six processor methods run at different points in the agent execution lifecyc
 └─────────────────────────────────────────────────────────────────┘
 ```
 
-| Method                | When it runs                                           | Use case                                                                      |
-| --------------------- | ------------------------------------------------------ | ----------------------------------------------------------------------------- |
-| `processInput`        | Once at the start, before the agentic loop             | Validate/transform initial user input, add context                            |
-| `processInputStep`    | At each step of the agentic loop, before each LLM call | Transform messages between steps, handle tool results                         |
-| `processAPIError`     | When an LLM API call fails                             | Inspect API rejections, optionally mutate state/messages, and request a retry |
-| `processOutputStream` | On each streaming chunk during LLM response            | Filter/modify streaming content, detect patterns in real-time                 |
-| `processOutputStep`   | After each LLM response, before tool execution         | Validate output quality, implement guardrails with retry                      |
-| `processOutputResult` | Once after generation completes                        | Post-process final response, log results                                      |
+| Method                | When it runs                                           | Use case                                                                                     |
+| --------------------- | ------------------------------------------------------ | -------------------------------------------------------------------------------------------- |
+| `processInput`        | Once at the start, before the agentic loop             | Validate/transform initial user input, add context                                           |
+| `processInputStep`    | At each step of the agentic loop, before each LLM call | Transform messages between steps, handle tool results                                        |
+| `processLLMRequest`   | After LLM request conversion, before the provider call | Rewrite the outbound `LanguageModelV2Prompt` for the current call without persisting changes |
+| `processAPIError`     | When an LLM API call fails                             | Inspect API rejections, optionally mutate state/messages, and request a retry                |
+| `processOutputStream` | On each streaming chunk during LLM response            | Filter/modify streaming content, detect patterns in real-time                                |
+| `processOutputStep`   | After each LLM response, before tool execution         | Validate output quality, implement guardrails with retry                                     |
+| `processOutputResult` | Once after generation completes                        | Post-process final response, log results                                                     |
 
 ## Interface definition
 
@@ -97,6 +103,10 @@ interface Processor<TId extends string = string, TTripwireMetadata = unknown> {
     | void
     | undefined
 
+  processLLMRequest?(
+    args: ProcessLLMRequestArgs<TTripwireMetadata>,
+  ): Promise<ProcessLLMRequestResult> | ProcessLLMRequestResult
+
   processAPIError?(
     args: ProcessAPIErrorArgs<TTripwireMetadata>,
   ): Promise<ProcessAPIErrorResult | void> | ProcessAPIErrorResult | void
@@ -243,9 +253,10 @@ processInputStep?<TTripwireMetadata = unknown>(
 1. `processInput` (once at start)
 2. `processInputStep` from inputProcessors (at each step, before LLM call)
 3. `prepareStep` callback (runs as part of the processInputStep pipeline, after inputProcessors)
-4. LLM execution
-5. Tool execution (if needed)
-6. Repeat from step 2 if tools were called
+4. `processLLMRequest` from inputProcessors (after prompt conversion, before the provider call)
+5. LLM execution
+6. Tool execution (if needed)
+7. Repeat from step 2 if tools were called
 
 #### `ProcessInputStepArgs`
 
@@ -339,6 +350,57 @@ System messages are **reset to their original values** at the start of each step
 
 ***
 
+### `processLLMRequest`
+
+Processes the final LLM request after Mastra converts the `MessageList` into `LanguageModelV2Prompt` and before the provider call. Use this method for transient, model-aware rewrites that should affect only the current outbound request.
+
+Returned prompt changes are forwarded to the model for the current call only. They are not persisted back to `MessageList`, memory, UI history, or later provider calls.
+
+```typescript
+processLLMRequest?(
+  args: ProcessLLMRequestArgs,
+): Promise<ProcessLLMRequestResult> | ProcessLLMRequestResult;
+```
+
+#### `ProcessLLMRequestArgs`
+
+**prompt** (`LanguageModelV2Prompt`): The LLM request prompt that will be sent to the provider for this call.
+
+**model** (`MastraLanguageModel`): The resolved model that will receive the prompt. Use this to scope provider-specific rewrites.
+
+**stepNumber** (`number`): Current step number (0-indexed). Step 0 is the initial LLM call.
+
+**steps** (`StepResult[]`): Results from previous steps, including text, toolCalls, and toolResults.
+
+**state** (`Record<string, unknown>`): Per-processor state that persists across all method calls within this request.
+
+**abort** (`(reason?: string, options?: { retry?: boolean; metadata?: unknown }) => never`): Function to abort processing. Throws a TripWire error that stops execution and emits a \`tripwire\` chunk.
+
+**retryCount** (`number`): Current retry attempt count from \`ProcessorContext\`. Starts at \`0\`; use to cap processor-triggered retries.
+
+**requestContext** (`RequestContext`): Request-scoped context with execution metadata.
+
+**tracingContext** (`TracingContext`): Tracing context for observability.
+
+**writer** (`ProcessorStreamWriter`): Stream writer for emitting custom data chunks during streaming. Use \`writer.custom()\` to send transient UI signals.
+
+**abortSignal** (`AbortSignal`): Signal for cancelling the operation.
+
+#### Return value
+
+`processLLMRequest` returns `ProcessLLMRequestResult`, which is `{ prompt?: LanguageModelV2Prompt } | undefined | void`.
+
+- Return `{ prompt }` to replace the outbound prompt for the current provider call.
+- Return `undefined` or `void` to forward the original prompt unchanged.
+
+#### Use cases
+
+- Removing or reshaping provider-specific prompt parts before a model call
+- Normalizing roles or content to match a provider's input requirements
+- Adapting tool result formats when switching providers mid-loop
+
+***
+
 ### `processAPIError`
 
 Handles LLM API rejection errors before they surface as final errors. This runs when the API call fails with a non-retryable error (such as a 400 or 422 status code). Unlike `processOutputStep` which runs after successful responses, this runs when the API rejects the request.

package/.docs/reference/processors/provider-history-compat.md

@@ -0,0 +1,132 @@
+# ProviderHistoryCompat
+
+The `ProviderHistoryCompat` processor handles provider-specific history incompatibilities. It can rewrite the outbound language model prompt before a provider call, or react to API errors and retry with repaired message history.
+
+Use it when an agent may switch between model providers, reuse message history across providers, or call a provider that rejects fields emitted by another provider.
+
+## Usage example
+
+Add `ProviderHistoryCompat` to `inputProcessors` when you want all built-in compatibility rules available for an agent:
+
+```typescript
+import { Agent } from '@mastra/core/agent'
+import { ProviderHistoryCompat } from '@mastra/core/processors'
+
+export const agent = new Agent({
+  name: 'my-agent',
+  instructions: 'You are a helpful assistant.',
+  model: 'anthropic/claude-sonnet-4-5',
+  inputProcessors: [new ProviderHistoryCompat()],
+})
+```
+
+Mastra agents don't add this processor automatically. Add it explicitly when you need provider history compatibility rules, reactive API error recovery, custom rules, or predictable processor ordering.
+
+## Constructor parameters
+
+**opts** (`{ additionalRules?: CompatRule[] }`): Configuration options for provider history compatibility rules.
+
+**opts.additionalRules** (`CompatRule[]`): Custom compatibility rules to run after the built-in rules. Rules can rewrite the outbound prompt or repair persisted messages after matching an API error.
+
+## Properties
+
+**id** (`'provider-history-compat'`): Processor identifier.
+
+**name** (`'Provider History Compat'`): Processor display name.
+
+**processLLMRequest** (`(args: ProcessLLMRequestArgs) => ProcessLLMRequestResult`): Runs preemptive compatibility rules against the converted LanguageModelV2Prompt immediately before the provider call. Returned prompt changes are transient and are not persisted to memory or message history.
+
+**processAPIError** (`(args: ProcessAPIErrorArgs) => Promise<ProcessAPIErrorResult | void>`): Runs reactive compatibility rules when a provider rejects the request. Matching rules can mutate the message list and return retry: true on the first retry attempt.
+
+## Built-in rules
+
+`ProviderHistoryCompat` includes these built-in compatibility rules:
+
+| Rule                                        | Provider  | Timing                      | Behavior                                                                                                                          |
+| ------------------------------------------- | --------- | --------------------------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| `anthropic-tool-id-format`                  | Anthropic | Reactive API error recovery | Rewrites tool call IDs that contain characters outside `[a-zA-Z0-9_-]` and retries the request.                                   |
+| `cerebras-strip-reasoning-content`          | Cerebras  | Preemptive prompt rewrite   | Removes assistant `reasoning` parts from the outbound prompt so they're not serialized as unsupported `reasoning_content` fields. |
+| `anthropic-strip-foreign-reasoning-content` | Anthropic | Preemptive prompt rewrite   | Removes non-Anthropic assistant `reasoning` parts from the outbound prompt. Anthropic-native thinking history is preserved.       |
+
+Preemptive rules run through `processLLMRequest` after Mastra converts messages to the model prompt format and before the prompt is sent to the provider. These rewrites affect only the current provider call.
+
+Reactive rules run through `processAPIError` after a provider rejection. They can update the persisted `messageList` and request a retry.
+
+## `CompatRule`
+
+A `CompatRule` defines one provider history compatibility fix:
+
+```typescript
+import type { CompatRule } from '@mastra/core/processors'
+
+const removeUnsupportedPromptParts: CompatRule = {
+  name: 'remove-unsupported-prompt-parts',
+  applyToPrompt({ prompt, model }) {
+    // Return a modified LanguageModelV2Prompt, or undefined to leave it unchanged.
+    return undefined
+  },
+}
+```
+
+**name** (`string`): Human-readable rule identifier for logs and debugging.
+
+**errorPatterns** (`RegExp[]`): Patterns matched against provider API error messages and response bodies. Required for reactive rules that implement fix.
+
+**fix** (`(messages: MastraDBMessage[]) => boolean`): Reactive fix that mutates persisted database messages after a matching API error. Return true when the rule changed messages and the request should retry.
+
+**applyToPrompt** (`(args: { prompt: LanguageModelV2Prompt; model: unknown }) => LanguageModelV2Prompt | undefined`): Preemptive fix that rewrites the outbound prompt for the current provider call. Return undefined when no prompt change is needed.
+
+## Custom rules
+
+Pass custom rules through `additionalRules`. Custom rules run after the built-in rules:
+
+```typescript
+import { Agent } from '@mastra/core/agent'
+import { ProviderHistoryCompat, type CompatRule } from '@mastra/core/processors'
+
+const stripUnsupportedAssistantMetadata: CompatRule = {
+  name: 'strip-unsupported-assistant-metadata',
+  applyToPrompt({ prompt, model }) {
+    if (typeof model !== 'string' || !model.startsWith('example-provider/')) {
+      return undefined
+    }
+
+    let changed = false
+    const nextPrompt = prompt.map(message => {
+      if (message.role !== 'assistant' || typeof message.content === 'string') {
+        return message
+      }
+
+      const nextContent = message.content.map(part => {
+        if (!('providerOptions' in part)) return part
+        changed = true
+        const { providerOptions: _providerOptions, ...rest } = part
+        return rest
+      })
+
+      return { ...message, content: nextContent }
+    })
+
+    return changed ? nextPrompt : undefined
+  },
+}
+
+export const agent = new Agent({
+  name: 'custom-provider-agent',
+  instructions: 'You are a helpful assistant.',
+  model: 'example-provider/model',
+  inputProcessors: [
+    new ProviderHistoryCompat({
+      additionalRules: [stripUnsupportedAssistantMetadata],
+    }),
+  ],
+})
+```
+
+Use `applyToPrompt` for provider-specific rewrites that shouldn't be saved to memory. Use `fix` with `errorPatterns` when the provider rejects persisted message history and the repaired history should be reused on future turns.
+
+## Related
+
+- [Processor interface](https://mastra.ai/reference/processors/processor-interface)
+- [Processors](https://mastra.ai/docs/agents/processors)
+- [PrefillErrorHandler](https://mastra.ai/reference/processors/prefill-error-handler)

package/.docs/reference/streaming/agents/stream.md

@@ -333,9 +333,9 @@ await agent.stream('message for agent', {
 })
 ```
 
-## OpenAI WebSocket transport
+## Responses WebSocket transport
 
-Opt into OpenAI Responses WebSocket streaming via `providerOptions.openai.transport`. This only applies to streaming calls and is currently supported for direct OpenAI models (for example, `openai/gpt-5.4`). If WebSocket streaming is unavailable, Mastra falls back to HTTP streaming. By default, Mastra closes the WebSocket when the stream finishes.
+Opt into Responses WebSocket streaming with provider options. This only applies to streaming calls and is supported for direct OpenAI models and Azure OpenAI Responses deployments. If WebSocket streaming is unavailable, Mastra falls back to HTTP streaming. By default, Mastra closes the WebSocket when the stream finishes.
 
 ```ts
 const stream = await agent.stream('Hello', {
@@ -351,6 +351,20 @@ const stream = await agent.stream('Hello', {
 })
 ```
 
+For Azure OpenAI, configure the gateway with `useResponsesAPI: true`, then use `providerOptions.azure.transport`.
+
+```ts
+const stream = await agent.stream('Hello', {
+  providerOptions: {
+    azure: {
+      transport: 'websocket',
+      store: false,
+      websocket: { closeOnFinish: true },
+    },
+  },
+})
+```
+
 To keep the connection open after the stream finishes, set `closeOnFinish: false` and close it manually.
 
 ```ts
@@ -367,6 +381,8 @@ const stream = await agent.stream('Hello', {
 stream.transport?.close()
 ```
 
+Responses WebSocket connections run one response at a time. Mastra rejects overlapping continuation requests that include `previous_response_id` on the same WebSocket transport. Wait for the active stream to finish before sending the next turn in the response chain.
+
 ## Related
 
 - [Generating responses](https://mastra.ai/docs/agents/overview)

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # @mastra/mcp-docs-server
 
+## 1.1.35-alpha.7
+
+### Patch Changes
+
+- Updated dependencies [[`087e413`](https://github.com/mastra-ai/mastra/commit/087e4133e5d6efa36619e9556c16750e4179c047), [`087e413`](https://github.com/mastra-ai/mastra/commit/087e4133e5d6efa36619e9556c16750e4179c047), [`087e413`](https://github.com/mastra-ai/mastra/commit/087e4133e5d6efa36619e9556c16750e4179c047)]:
+  - @mastra/core@1.33.0-alpha.3
+
+## 1.1.35-alpha.6
+
+### Patch Changes
+
+- Updated dependencies [[`d1fdbd0`](https://github.com/mastra-ai/mastra/commit/d1fdbd012add5623cb7e6b7f882b605ab358bbb4), [`d91ebe2`](https://github.com/mastra-ai/mastra/commit/d91ebe28ee065d8f2ed6df741c3c07f58d359529)]:
+  - @mastra/core@1.33.0-alpha.2
+
 ## 1.1.35-alpha.4
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/mcp-docs-server",
-  "version": "1.1.35-alpha.5",
+  "version": "1.1.35-alpha.8",
   "description": "MCP server for accessing Mastra.ai documentation, changelogs, and news.",
   "type": "module",
   "main": "dist/index.js",
@@ -29,7 +29,7 @@
     "jsdom": "^26.1.0",
     "local-pkg": "^1.1.2",
     "zod": "^4.3.6",
-    "@mastra/core": "1.33.0-alpha.1",
+    "@mastra/core": "1.33.0-alpha.3",
     "@mastra/mcp": "^1.7.0"
   },
   "devDependencies": {
@@ -48,7 +48,7 @@
     "vitest": "4.1.5",
     "@internal/lint": "0.0.92",
     "@internal/types-builder": "0.0.67",
-    "@mastra/core": "1.33.0-alpha.1"
+    "@mastra/core": "1.33.0-alpha.3"
   },
   "homepage": "https://mastra.ai",
   "repository": {