@mastra/mcp-docs-server 1.2.12 → 1.2.13-alpha.1

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

@@ -104,6 +104,78 @@ A tool's own `requireApproval` setting takes precedence over the function above.
 
 > **Note:** Function-based `requireToolApproval` is only available on regular `stream()` / `generate()` calls. Durable agents and stored agents persist their options, and a function can't be serialized, so they accept only a boolean. If you pass a function in those contexts it falls back to requiring approval for every tool call.
 
+#### Bind approval to the exact tool arguments
+
+For sensitive tools, bind the approval to the exact tool name and arguments that were shown to the reviewer. If those arguments drift before execution, the tool shouldn't run under the old approval.
+
+The `tool-call-approval` chunk already includes `toolName`, `toolCallId`, and `args`. You can fingerprint those fields when the approval request is shown. The example below uses a simple JSON string as the fingerprint, but in production you should use a stable hash of the tool name and arguments:
+
+```typescript
+import { Agent } from '@mastra/core/agent'
+
+// For your production usecase, build a stable hash of the tool name and args
+function actionFingerprint(toolName: string, args: unknown) {
+  const payload = JSON.stringify({ toolName, args })
+  return `fingerprint-${payload}`
+}
+
+const sensitiveTools = new Set(['issue_refund', 'delete_record'])
+const approvedFingerprints = new Set<string>()
+
+export const approvalBoundAgent = new Agent({
+  id: 'approval-bound-agent',
+  name: 'Approval Bound Agent',
+  model: 'openai/gpt-5.6-sol',
+  tools: { issueRefundTool, deleteRecordTool },
+  hooks: {
+    beforeToolCall: ({ toolName, input }) => {
+      if (!sensitiveTools.has(toolName)) return
+
+      const fingerprint = actionFingerprint(toolName, input)
+      if (!approvedFingerprints.delete(fingerprint)) {
+        return {
+          proceed: false,
+          output: `Tool call blocked: approval did not match ${toolName} arguments.`,
+        }
+      }
+    },
+  },
+})
+```
+
+```typescript
+const stream = await approvalBoundAgent.stream('Refund order ord-1042', {
+  requireToolApproval: ({ toolName }) => sensitiveTools.has(toolName),
+})
+
+async function consumeApprovalStream(currentStream: typeof stream) {
+  for await (const chunk of currentStream.fullStream) {
+    if (chunk.type === 'tool-call-approval') {
+      const { toolName, toolCallId, args } = chunk.payload
+      const fingerprint = actionFingerprint(toolName, args)
+
+      // Present toolName, args, and fingerprint to your approval UI.
+      const approved = await showApprovalDialog({ toolName, args, fingerprint })
+
+      const nextStream = approved
+        ? await approveReviewedToolCall(currentStream.runId, toolCallId, fingerprint)
+        : await approvalBoundAgent.declineToolCall({ runId: currentStream.runId, toolCallId })
+
+      await consumeApprovalStream(nextStream)
+    }
+  }
+}
+
+async function approveReviewedToolCall(runId: string, toolCallId: string, fingerprint: string) {
+  approvedFingerprints.add(fingerprint)
+  return approvalBoundAgent.approveToolCall({ runId, toolCallId })
+}
+
+await consumeApprovalStream(stream)
+```
+
+In production, store the approved fingerprint in durable storage scoped to the user, run, tool call, and policy version. The `Set` above is intentionally small so the boundary is easy to see: the approval is consumed once, and only for the same canonical tool arguments that were reviewed.
+
 ### Runtime suspension with `suspend()`
 
 A tool can also pause _during_ its `execute` function by calling `suspend()`. This is useful when the tool starts running and then discovers it needs additional user input or confirmation before it can finish.

package/.docs/docs/agents/using-tools.md

@@ -65,31 +65,6 @@ export const weatherAgent = new Agent({
 })
 ```
 
-## Use provider web search
-
-Import `webSearchTool` from `@mastra/core/tools` when you want the model provider to run its native web search tool. The tool has no local `execute` function. Mastra resolves it at run time from the active model, then passes the provider-managed tool to the model.
-
-```typescript
-import { Agent } from '@mastra/core/agent'
-import { webSearchTool } from '@mastra/core/tools'
-
-export const researchAgent = new Agent({
-  id: 'research-agent',
-  name: 'Research Agent',
-  instructions: `
-    You are a helpful research assistant.
-    Use web search when you need current information.`,
-  model: 'openai/gpt-5.6-sol',
-  tools: {
-    webSearch: webSearchTool,
-  },
-})
-```
-
-`webSearchTool` supports OpenAI, Anthropic, Google Gemini, and xAI models. If Mastra can't infer one of those providers from the active model, the agent run fails with a `MastraError`.
-
-Only the `webSearchTool` value triggers provider web search. Custom tools with the names `webSearch` or `web_search` stay unchanged.
-
 ## Define schemas
 
 You can define the tool's `inputSchema` and `outputSchema` with any library that supports [Standard JSON Schema](https://standardschema.dev/json-schema). This includes libraries like [Zod](https://zod.dev/), [Valibot](https://valibot.dev/), and [ArkType](https://arktype.io/).
@@ -494,14 +469,38 @@ Note that for subagents, you'll see two different identifiers in stream response
 
 Mastra includes agent-agnostic built-in tools in `@mastra/core/tools` that add interactive and organizational capabilities to any agent.
 
-| Tool            | Purpose                                           |
-| --------------- | ------------------------------------------------- |
-| `ask_user`      | Ask the user a question and wait for their answer |
-| `submit_plan`   | Submit a plan file for user approval              |
-| `task_write`    | Create or replace a structured task list          |
-| `task_update`   | Update one tracked task by ID                     |
-| `task_complete` | Mark one tracked task completed                   |
-| `task_check`    | Check task list completion status                 |
+| Tool            | Purpose                                              |
+| --------------- | ---------------------------------------------------- |
+| `ask_user`      | Ask the user a question and wait for their answer    |
+| `submit_plan`   | Submit a plan file for user approval                 |
+| `task_write`    | Create or replace a structured task list             |
+| `task_update`   | Update one tracked task by ID                        |
+| `task_complete` | Mark one tracked task completed                      |
+| `task_check`    | Check task list completion status                    |
+| `webSearchTool` | Run provider-native web search with the active model |
+
+### Use provider web search
+
+Import `webSearchTool` from `@mastra/core/tools` when you want the model provider to run its native web search tool. Mastra resolves it at run time from the active model, then passes the provider-managed tool to the model.
+
+```typescript
+import { Agent } from '@mastra/core/agent'
+import { webSearchTool } from '@mastra/core/tools'
+
+export const researchAgent = new Agent({
+  id: 'research-agent',
+  name: 'Research Agent',
+  instructions: 'Use web search when you need current information.',
+  model: 'openai/gpt-5.6-sol',
+  tools: {
+    search: webSearchTool,
+  },
+})
+```
+
+`webSearchTool` supports OpenAI, Anthropic, Google Gemini, and xAI models. If Mastra can't infer one of those providers from the active model, the agent run fails with a `MastraError`.
+
+The `search` key is only the agent-local tool name. Use any key. The `webSearchTool` value tells Mastra to use provider web search.
 
 ### Ask the user a question
 

package/.docs/docs/evals/datasets/running-experiments.md

@@ -133,7 +133,7 @@ Visit the [Scorers overview](https://mastra.ai/docs/evals/overview) for details
 
 ## Tool mocks
 
-When an experiment runs an agent that calls side-effecting tools, you can make the run deterministic by attaching static tool mocks to individual dataset items. During the experiment, a mocked tool returns its declared output instead of executing. Tools that have no mock on the item run live.
+When an experiment runs an agent that calls side-effecting tools, you can make the run deterministic by attaching static tool mocks to individual dataset items. During the experiment, a mocked tool returns its declared output instead of executing. By default, tools that have no mock on the item run live.
 
 Mocks live on the dataset item, so they version with the row and travel with the test case. Each mock declares a tool name, the arguments it expects, and the output to return:
 
@@ -152,6 +152,29 @@ await dataset.addItem({
 
 Tool mocks are supported for `agent` targets only.
 
+### Block undeclared tools
+
+Set `unmockedToolPolicy: 'deny'` on an experiment to block every tool call that doesn't have a mock. This is useful when a live call could cause side effects:
+
+```typescript
+const summary = await dataset.startExperiment({
+  targetType: 'agent',
+  targetId: 'weather-agent',
+  unmockedToolPolicy: 'deny',
+})
+```
+
+The default policy is `'allow'`. You can override the experiment policy on an individual stored or inline item:
+
+```typescript
+await dataset.addItem({
+  input: 'What is the weather in Seattle?',
+  unmockedToolPolicy: 'allow',
+})
+```
+
+The item value takes precedence over the experiment value. A denied call fails with `TOOL_MOCK_NOT_DECLARED` before the tool executes. The failure isn't retried or added to `liveCalls`.
+
 ### Matching and consumption
 
 Arguments are matched strictly: object key order is ignored and array order is substantial, plus there is no type coercion. A mock is served only when the agent calls the tool with arguments that deep-equal the mock's `args`.
@@ -175,14 +198,15 @@ This is useful when a tool's arguments are noisy or generated by the model. The
 
 ### Failures
 
-A mocked tool call fails the item when the arguments don't match or all matching mocks have been consumed:
+A tool call fails the item when it violates the mock configuration:
 
 - `TOOL_MOCK_MISMATCH`: the tool was called with arguments that no mock matches.
 - `TOOL_MOCK_EXHAUSTED`: every matching mock has already been consumed.
+- `TOOL_MOCK_NOT_DECLARED`: the tool has no mock and the effective `unmockedToolPolicy` is `'deny'`.
 
-When a mocked tool is mis-called, the agent run is aborted immediately, so the model can't go on to call any further tools, including unmocked, side-effecting tools that would otherwise run live. These failures are deterministic, so they're not retried. Mocks that are declared but never used don't fail the item, they're reported as unconsumed.
+On any of these failures, the agent run is aborted immediately, so the model can't go on to call any further tools, including unmocked, side-effecting tools that would otherwise run live. These failures are deterministic, so they're not retried. Mocks that are declared but never used don't fail the item, they're reported as unconsumed.
 
-While an item has mocks, the agent's tools execute sequentially so repeated `(toolName, args)` mocks are consumed in the provider's call order. This serialization applies only to items that declare mocks.
+While mock interception is active, the agent's tools execute sequentially so repeated `(toolName, args)` mocks are consumed in the provider's call order. Interception is active when the item declares mocks or its effective `unmockedToolPolicy` is `'deny'`.
 
 ### Diagnostics
 
@@ -195,8 +219,8 @@ for (const item of summary.results) {
 
   console.log(report.served) // mocks matched and returned
   console.log(report.unconsumed) // mocks declared but never used
-  console.log(report.liveCalls) // unmocked tools that ran live
-  console.log(report.failure) // the mismatch/exhausted failure, if any
+  console.log(report.liveCalls) // undeclared tools allowed to run live
+  console.log(report.failure) // the first deterministic mock failure, if any
 }
 ```
 
@@ -205,7 +229,7 @@ In [Studio](https://mastra.ai/docs/studio/overview), edit a dataset item to auth
 ### Limitations
 
 - **No tool span for mocked calls.** A mocked call returns its output before the tool executes, so it doesn't create a tool span. Trajectory scorers backed by stored traces may therefore not see mocked tool calls. Trajectory extraction that falls back to the agent's message output still sees them, so trajectory scoring can differ depending on your observability configuration.
-- **Storage support.** Tool mocks and tool mock reports are persisted by the LibSQL, PostgreSQL, MongoDB, and Spanner adapters. The MySQL adapter doesn't support them and rejects writes that carry tool mocks or a tool mock report so the feature never silently runs tools live.
+- **Storage support.** Tool mocks and tool mock reports are persisted by the LibSQL, PostgreSQL, MongoDB, and Spanner adapters. The MySQL adapter doesn't support them and rejects writes that carry tool mocks or a tool mock report. All dataset storage adapters persist `unmockedToolPolicy`.
 
 ## Async experiments
 

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

@@ -56,6 +56,7 @@ List of required environment variables for each model provider and gateway suppo
 | [GitHub Models](https://mastra.ai/models/providers/github-models)                              | `github-models/*`          | `GITHUB_TOKEN`                                                                                        |
 | [GMI Cloud](https://mastra.ai/models/providers/gmicloud)                                       | `gmicloud/*`               | `GMICLOUD_API_KEY`                                                                                    |
 | [Google](https://mastra.ai/models/providers/google)                                            | `google/*`                 | `GOOGLE_API_KEY`, `GOOGLE_GENERATIVE_AI_API_KEY`                                                      |
+| [GreenPT](https://mastra.ai/models/providers/greenpt)                                          | `greenpt/*`                | `GREENPT_API_KEY`                                                                                     |
 | [Groq](https://mastra.ai/models/providers/groq)                                                | `groq/*`                   | `GROQ_API_KEY`                                                                                        |
 | [Helicone](https://mastra.ai/models/providers/helicone)                                        | `helicone/*`               | `HELICONE_API_KEY`                                                                                    |
 | [Hetzner](https://mastra.ai/models/providers/hetzner)                                          | `hetzner/*`                | `HETZNER_API_KEY`                                                                                     |

package/.docs/models/index.md

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

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

@@ -2,7 +2,7 @@
 
 # ![Cortecs logo](https://models.dev/logos/cortecs.svg)Cortecs
 
-Access 57 Cortecs models through Mastra's model router. Authentication is handled automatically using the `CORTECS_API_KEY` environment variable.
+Access 58 Cortecs models through Mastra's model router. Authentication is handled automatically using the `CORTECS_API_KEY` environment variable.
 
 Learn more in the [Cortecs documentation](https://cortecs.ai).
 
@@ -72,6 +72,7 @@ for await (const chunk of stream) {
 | `cortecs/kimi-k2.5`                      | 256K    |       |           |       |       |       | $0.55      | $3          |
 | `cortecs/kimi-k2.6`                      | 256K    |       |           |       |       |       | $0.81      | $4          |
 | `cortecs/kimi-k2.7-code`                 | 262K    |       |           |       |       |       | $1         | $5          |
+| `cortecs/kimi-k3`                        | 1.0M    |       |           |       |       |       | $3         | $15         |
 | `cortecs/llama-3.1-405b-instruct`        | 128K    |       |           |       |       |       | —          | —           |
 | `cortecs/llama-3.3-70b-instruct`         | 131K    |       |           |       |       |       | $0.09      | $0.28       |
 | `cortecs/llama-4-maverick`               | 1.0M    |       |           |       |       |       | $0.12      | $0.60       |

package/.docs/models/providers/greenpt.md

@@ -0,0 +1,98 @@
+> Discover all available pages from the documentation index: https://mastra.ai/llms.txt
+
+# ![GreenPT logo](https://models.dev/logos/greenpt.svg)GreenPT
+
+Access 26 GreenPT models through Mastra's model router. Authentication is handled automatically using the `GREENPT_API_KEY` environment variable.
+
+Learn more in the [GreenPT documentation](https://docs.greenpt.ai).
+
+```bash
+GREENPT_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: "greenpt/devstral-2-123b-instruct-2512"
+});
+
+// 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 [GreenPT documentation](https://docs.greenpt.ai) for details.
+
+## Models
+
+| Model                                         | Context | Tools | Reasoning | Image | Audio | Video | Input $/1M | Output $/1M |
+| --------------------------------------------- | ------- | ----- | --------- | ----- | ----- | ----- | ---------- | ----------- |
+| `greenpt/devstral-2-123b-instruct-2512`       | 200K    |       |           |       |       |       | $0.57      | $3          |
+| `greenpt/gemma-3-27b-it`                      | 40K     |       |           |       |       |       | $0.34      | $0.68       |
+| `greenpt/gemma4`                              | 262K    |       |           |       |       |       | $0.57      | $2          |
+| `greenpt/glm-5.1`                             | 200K    |       |           |       |       |       | $2         | $6          |
+| `greenpt/glm-5.2`                             | 1.0M    |       |           |       |       |       | $1         | $5          |
+| `greenpt/gpt-oss-120b`                        | 131K    |       |           |       |       |       | $0.23      | $0.80       |
+| `greenpt/green-l`                             | 128K    |       |           |       |       |       | $0.28      | $0.91       |
+| `greenpt/green-l-raw`                         | 128K    |       |           |       |       |       | $0.28      | $0.91       |
+| `greenpt/green-r`                             | 131K    |       |           |       |       |       | $0.40      | $1          |
+| `greenpt/green-r-raw`                         | 131K    |       |           |       |       |       | $0.40      | $1          |
+| `greenpt/green-s`                             | —       |       |           |       |       |       | $0.00      | —           |
+| `greenpt/green-s-pro`                         | —       |       |           |       |       |       | $0.00      | —           |
+| `greenpt/holo2-30b-a3b`                       | 22K     |       |           |       |       |       | $0.40      | $0.97       |
+| `greenpt/kimi-k2.6`                           | 262K    |       |           |       |       |       | $0.83      | $4          |
+| `greenpt/kimi-k2.6-fast`                      | 262K    |       |           |       |       |       | $2         | $9          |
+| `greenpt/kimi-k2.7-code`                      | 262K    |       |           |       |       |       | $0.94      | $4          |
+| `greenpt/llama-3.3-70b-instruct`              | 100K    |       |           |       |       |       | $1         | $1          |
+| `greenpt/minimax-m2.5`                        | 205K    |       |           |       |       |       | $0.19      | $1          |
+| `greenpt/mistral-medium-3.5-128b`             | 262K    |       |           |       |       |       | $2         | $10         |
+| `greenpt/mistral-small-3.2-24b-instruct-2506` | 128K    |       |           |       |       |       | $0.23      | $0.46       |
+| `greenpt/pixtral-12b-2409`                    | 128K    |       |           |       |       |       | $0.28      | $0.28       |
+| `greenpt/qwen3-235b-a22b-instruct-2507`       | 262K    |       |           |       |       |       | $1         | $3          |
+| `greenpt/qwen3-coder-30b-a3b-instruct`        | 128K    |       |           |       |       |       | $0.28      | $1          |
+| `greenpt/qwen3.5-397b-a17b`                   | 262K    |       |           |       |       |       | $0.80      | $5          |
+| `greenpt/qwen3.6-35b-a3b`                     | 262K    |       |           |       |       |       | $0.34      | $2          |
+| `greenpt/voxtral-small-24b-2507`              | 33K     |       |           |       |       |       | $0.23      | $0.51       |
+
+## Advanced configuration
+
+### Custom headers
+
+```typescript
+const agent = new Agent({
+  id: "custom-agent",
+  name: "custom-agent",
+  model: {
+    url: "https://api.greenpt.ai/v1",
+    id: "greenpt/devstral-2-123b-instruct-2512",
+    apiKey: process.env.GREENPT_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
+      ? "greenpt/voxtral-small-24b-2507"
+      : "greenpt/devstral-2-123b-instruct-2512";
+  }
+});
+```

package/.docs/models/providers.md

@@ -58,6 +58,7 @@ Direct access to individual AI model providers. Each provider offers unique mode
 - [FrogBot](https://mastra.ai/models/providers/frogbot)
 - [GitHub Models](https://mastra.ai/models/providers/github-models)
 - [GMI Cloud](https://mastra.ai/models/providers/gmicloud)
+- [GreenPT](https://mastra.ai/models/providers/greenpt)
 - [Helicone](https://mastra.ai/models/providers/helicone)
 - [Hetzner](https://mastra.ai/models/providers/hetzner)
 - [HPC-AI](https://mastra.ai/models/providers/hpc-ai)

package/.docs/reference/datasets/startExperiment.md

@@ -77,6 +77,8 @@ console.log(`Status: ${summary2.status}`)
 
 **maxRetries** (`number`): Maximum retries per item on failure. Defaults to 0 (no retries). Abort errors are never retried.
 
+**unmockedToolPolicy** (`'allow' | 'deny'`): Controls undeclared agent tool calls. allow executes them live. deny fails the item with TOOL\_MOCK\_NOT\_DECLARED before execution. An item-level value overrides this experiment default. (Default: `'allow'`)
+
 ## Returns
 
 **result** (`Promise<ExperimentSummary>`): Summary of the completed experiment.

package/.docs/reference/processors/regex-filter-processor.md

@@ -53,14 +53,12 @@ const agent = new Agent({
   id: 'my-agent',
   name: 'my-agent',
   model: 'openai/gpt-5-nano',
-  processors: {
-    input: [
-      new RegexFilterProcessor({
-        presets: ['pii', 'secrets'],
-        strategy: 'block',
-      }),
-    ],
-  },
+  inputProcessors: [
+    new RegexFilterProcessor({
+      presets: ['pii', 'secrets'],
+      strategy: 'block',
+    }),
+  ],
 })
 ```
 
@@ -80,6 +78,8 @@ const agent = new Agent({
 
 **phase** (`'input' | 'output' | 'all'`): Phases to apply the filter. 'input' filters input messages. 'output' filters output stream and result. 'all' filters both. (Default: `'all'`)
 
+**includeRedactedValues** (`boolean`): Include the text that was redacted in each report entry. Off by default, because the values are the data the processor removes. (Default: `false`)
+
 ## Returns
 
 **id** (`'regex-filter'`): Processor identifier.
@@ -106,4 +106,76 @@ When the `block` strategy is active (default), `RegexFilterProcessor` throws a `
 | --------- | ------------------------------------------------ | ---------------------------------------------- |
 | `pii`     | Emails, phone numbers, SSNs, credit card numbers | `[EMAIL]`, `[PHONE]`, `[SSN]`, `[CREDIT_CARD]` |
 | `secrets` | API keys, bearer tokens, AWS access keys         | `[API_KEY]`, `[BEARER_TOKEN]`, `[AWS_KEY]`     |
-| `urls`    | HTTP/HTTPS URLs                                  | `[URL]`                                        |
+| `urls`    | HTTP/HTTPS URLs                                  | `[URL]`                                        |
+
+## Redaction behavior
+
+Every rule is matched independently, so two rules can claim text that overlaps. A card number written without separators matches both `phone` and `credit-card`, for example. Overlapping matches are combined into a single region and replaced once, using the replacement of the longest match.
+
+```typescript
+const filter = new RegexFilterProcessor({
+  presets: ['pii'],
+  strategy: 'redact',
+})
+
+// "Charge 4111111111111111 today" becomes "Charge [CREDIT_CARD] today"
+```
+
+A replacement string can reference capture groups with `$1` or `$&`. Those references resolve for a single match whose pattern also matches the matched text on its own. In a combined region, or for a rule anchored on its surroundings with a lookbehind or lookahead, the replacement string is inserted as written. The region is redacted either way.
+
+## Redaction reporting
+
+The `redact` strategy rewrites text in place, so nothing downstream can tell what changed. Assign `onViolation` to record it. The processor calls it once per redacted message, message part, or stream chunk, and offsets are relative to that piece of text. Async callbacks are awaited, and errors are caught so an unavailable audit sink cannot fail the request.
+
+```typescript
+import { RegexFilterProcessor, type RegexRedactionDetail } from '@mastra/core/processors'
+
+const filter = new RegexFilterProcessor({
+  presets: ['pii'],
+  strategy: 'redact',
+})
+
+filter.onViolation = async ({ detail }) => {
+  const redaction = detail as RegexRedactionDetail
+
+  for (const entry of redaction.redactions) {
+    await auditLog.write({
+      phase: redaction.phase,
+      messageId: redaction.messageId,
+      rule: entry.rule,
+      offset: entry.index,
+      length: entry.length,
+    })
+  }
+}
+```
+
+The callback is awaited, including in `processOutputStream`, where it runs for every chunk that contains a match. Keep the callback fast, or hand the work to a queue, so a slow audit sink doesn't stall a streaming response. With no callback attached, the `redact` path stays synchronous.
+
+The `block` strategy reports through the same callback. There the processor runner invokes it when it catches the `TripWire`, so `detail` holds the tripwire metadata described under [Error behavior](#error-behavior) rather than the shape below.
+
+`detail` for a redaction is a `RegexRedactionDetail`:
+
+**strategy** (`'redact'`): Distinguishes a redaction report from the block strategy payload.
+
+**phase** (`'processInput' | 'processOutputStream' | 'processOutputResult'`): Processor method that applied the redactions.
+
+**messageId** (`string`): Id of the message the text came from. Absent for stream chunks.
+
+**partIndex** (`number`): Index of the redacted part in the message's parts array, which also contains non-text parts. Absent for string content and stream chunks.
+
+**redactions** (`RegexRedaction[]`): Redactions in the order they appear in the text.
+
+**redactions.rule** (`string`): Name of the rule whose replacement was used.
+
+**redactions.index** (`number`): Start offset of the redacted span in the text.
+
+**redactions.length** (`number`): Length of the redacted span.
+
+**redactions.replacement** (`string`): Text that replaced the span.
+
+**redactions.overlappingRules** (`string[]`): Names of all rules that matched this span, set only when more than one overlapped.
+
+**redactions.value** (`string`): The text that was redacted. Set only when includeRedactedValues is enabled.
+
+Values are left out by default. An audit trail that copies the data it protects widens the exposure it was added to narrow. Set `includeRedactedValues` only when the destination is as protected as the original, and note that the `block` strategy also withholds matched text from its `TripWire` metadata for the same reason.

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # @mastra/mcp-docs-server
 
+## 1.2.13-alpha.1
+
+### Patch Changes
+
+- Updated dependencies [[`7f4e26d`](https://github.com/mastra-ai/mastra/commit/7f4e26dd57bd9b23c278ea21235ab823a3810a6c), [`b582f7f`](https://github.com/mastra-ai/mastra/commit/b582f7fa2f9c1f87d19efc63d344fbe5dda2608c), [`b582f7f`](https://github.com/mastra-ai/mastra/commit/b582f7fa2f9c1f87d19efc63d344fbe5dda2608c)]:
+  - @mastra/core@1.56.0-alpha.0
+
 ## 1.2.12
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/mcp-docs-server",
-  "version": "1.2.12",
+  "version": "1.2.13-alpha.1",
   "description": "MCP server for accessing Mastra.ai documentation, changelogs, and news.",
   "type": "module",
   "main": "dist/index.js",
@@ -28,8 +28,8 @@
     "jsdom": "^26.1.0",
     "local-pkg": "^1.1.2",
     "zod": "^4.4.3",
-    "@mastra/mcp": "^1.15.0",
-    "@mastra/core": "1.55.0"
+    "@mastra/core": "1.56.0-alpha.0",
+    "@mastra/mcp": "^1.15.0"
   },
   "devDependencies": {
     "@hono/node-server": "^1.19.14",
@@ -47,7 +47,7 @@
     "vitest": "4.1.10",
     "@internal/lint": "0.0.119",
     "@internal/types-builder": "0.0.94",
-    "@mastra/core": "1.55.0"
+    "@mastra/core": "1.56.0-alpha.0"
   },
   "homepage": "https://mastra.ai",
   "repository": {