@mastra/mcp-docs-server 0.13.27 → 0.13.28-alpha.2

package/.docs/raw/reference/streaming/agents/MastraModelOutput.mdx

@@ -6,11 +6,7 @@ description: "Complete reference for MastraModelOutput - the stream object retur
 import { Callout } from "nextra/components";
 import { PropertiesTable } from "@/components/properties-table";
 
-# MastraModelOutput (Experimental)
-
-<Callout type="important">
-  <strong className="block">Experimental API: </strong>This type is part of the experimental `.stream()` method. The API may change as we refine the feature based on feedback.
-</Callout>
+# MastraModelOutput
 
 The `MastraModelOutput` class is returned by [.stream()](./stream.mdx) and provides both streaming and promise-based access to model outputs. It supports structured output generation, tool calls, reasoning, and comprehensive usage tracking.
 

package/.docs/raw/reference/streaming/workflows/resumeStreamVNext.mdx

@@ -88,7 +88,7 @@ if (result.status === "suspended") {
     },
     {
       name: "stream.result",
-      type: "Promise<WorkflowResult<TOutput, TSteps>>",
+      type: "Promise<WorkflowResult<TState, TOutput, TSteps>>",
       description: "A promise that resolves to the final workflow result",
     },
     {

package/.docs/raw/reference/streaming/workflows/stream.mdx

@@ -81,7 +81,7 @@ const stream = await run.stream({
     },
     {
       name: "getWorkflowState",
-      type: "() => Promise<WorkflowResult<TOutput, TSteps>>",
+      type: "() => Promise<WorkflowResult<TState, TOutput, TSteps>>",
       description: "A function that returns a promise resolving to the final workflow result",
     },
     {

package/.docs/raw/reference/streaming/workflows/streamVNext.mdx

@@ -96,7 +96,7 @@ const stream = run.streamVNext({
     },
     {
       name: "stream.result",
-      type: "Promise<WorkflowResult<TOutput, TSteps>>",
+      type: "Promise<WorkflowResult<TState, TOutput, TSteps>>",
       description: "A promise that resolves to the final workflow result",
     },
     {

package/.docs/raw/reference/workflows/run-methods/resume.mdx

@@ -80,6 +80,22 @@ if (result.status === "suspended") {
         }
       ]
     },
+    {
+      name: "outputOptions",
+      type: "OutputOptions",
+      isOptional: true,
+      description: "Options for AI tracing configuration.",
+      properties: [
+        {
+          parameters: [{
+            name: "includeState",
+            type: "boolean",
+            isOptional: true,
+            description: "Whether to include the workflow run state in the result."
+          }]
+        }
+      ]
+    },
   ]}
 />
 
@@ -89,7 +105,7 @@ if (result.status === "suspended") {
   content={[
     {
       name: "result",
-      type: "Promise<WorkflowResult<TOutput, TSteps>>",
+      type: "Promise<WorkflowResult<TState, TOutput, TSteps>>",
       description: "A promise that resolves to the workflow execution result containing step outputs and status",
     },
     {

package/.docs/raw/reference/workflows/run-methods/start.mdx

@@ -73,6 +73,22 @@ const result = await run.start({
         }
       ]
     },
+    {
+      name: "outputOptions",
+      type: "OutputOptions",
+      isOptional: true,
+      description: "Options for AI tracing configuration.",
+      properties: [
+        {
+          parameters: [{
+            name: "includeState",
+            type: "boolean",
+            isOptional: true,
+            description: "Whether to include the workflow run state in the result."
+          }]
+        }
+      ]
+    },
   ]}
 />
 
@@ -82,7 +98,7 @@ const result = await run.start({
   content={[
     {
       name: "result",
-      type: "Promise<WorkflowResult<TOutput, TSteps>>",
+      type: "Promise<WorkflowResult<TState, TOutput, TSteps>>",
       description: "A promise that resolves to the workflow execution result containing step outputs and status",
     },
     {

package/.docs/raw/reference/workflows/step.mdx

@@ -72,6 +72,12 @@ const step1 = createStep({
       description: "Optional Zod schema for suspending the step",
       required: false,
     },
+    {
+      name: "stateSchema",
+      type: "z.ZodObject<any>",
+      description: "Optional Zod schema for the step state. Automatically injected when using Mastra's state system. The stateSchema must be a subset of the workflow's stateSchema. If not specified, type is 'any'.",
+      required: false,
+    },
     {
       name: "execute",
       type: "(params: ExecuteParams) => Promise<any>",
@@ -117,6 +123,11 @@ const step1 = createStep({
       type: "() => Promise<void>",
       description: "Function to pause workflow execution",
     },
+    {
+      name: "setState",
+      type: "(state: z.infer<TState>) => void",
+      description: "Function to set the state of the workflow. Inject via reducer-like pattern, such as 'setState({ ...state, ...newState })'",
+    },
     {
       name: "runId",
       type: "string",

package/.docs/raw/reference/workflows/workflow.mdx

@@ -42,7 +42,13 @@ export const workflow = createWorkflow({
       name: "outputSchema",
       type: "z.ZodType<any>",
       description: "Zod schema defining the output structure for the workflow",
-    }
+    },
+    {
+      name: "stateSchema",
+      type: "z.ZodObject<any>",
+      description: "Optional Zod schema for the workflow state. Automatically injected when using Mastra's state system. If not specified, type is 'any'.",
+      isOptional: true,
+    },
   ]}
 />
 

package/.docs/raw/server-db/local-dev-playground.mdx

@@ -118,7 +118,7 @@ Key features:
 
 The local development server exposes a set of REST API routes via the [Mastra Server](/docs/deployment/server-deployment), allowing you to test and interact with your agents and workflows before deployment.
 
-For a full overview of available API routes, including agents, tools, and workflows, see the [Routes reference](/reference/cli/dev#routes).
+For a full overview of available API routes, including agents, tools, and workflows, visit [http://localhost:4111/swagger-ui](http://localhost:4111/swagger-ui) during `mastra dev`.
 
 ## OpenAPI Specification
 

package/.docs/raw/workflows/overview.mdx

@@ -1,18 +1,32 @@
 ---
 title: "Handling Complex LLM Operations | Workflows | Mastra"
-description: "Workflows in Mastra help you orchestrate complex sequences of operations with features like branching, parallel execution, resource suspension, and more."
+description: "Workflows in Mastra help you orchestrate complex sequences of tasks with features like branching, parallel execution, resource suspension, and more."
 ---
 
 import { Steps } from "nextra/components";
 
 # Workflows overview
 
-Workflows let you define and orchestrate complex sequences of tasks as **typed steps** connected by data flows. Each step has clearly defined inputs and outputs validated by Zod schemas.
-
-A workflow manages execution order, dependencies, branching, parallelism, and error handling — enabling you to build robust, reusable processes. Steps can be nested or cloned to compose larger workflows.
+Workflows allow you to define and manage complex sequences of tasks by connecting them with clear, structured processes. Unlike a single agent, which operates independently, workflows enable you to orchestrate multiple steps with specific logic, tools, and external services. This approach provides more control and predictability, ensuring consistent results by allowing you to determine what tasks are performed and when they are completed.
 
 ![Workflows overview](/image/workflows/workflows-overview.jpg)
 
+## When to use a workflow
+
+For example, you might want to perform a sequence of tasks:
+
+1. Handle a user question like “Can I return my last order?”
+2. Fetch user-specific data from a database using their `user_id`.
+3. Check return eligibility via an external API or business logic.
+4. Make a conditional decision (e.g. approve, deny, escalate) based on the data.
+5. Generate a tailored response based on the outcome.
+
+Each of these tasks is created as a **step** in a workflow, giving you fine-grained control over data flow, execution order, and side effects.
+
+> **📹 Watch**:  → An introduction to workflows, and how they compare to agents [YouTube (7 minutes)](https://youtu.be/0jg2g3sNvgw)
+
+## Building workflows
+
 You create workflows by:
 
 - Defining **steps** with `createStep`, specifying input/output schemas and business logic.
@@ -21,7 +35,10 @@ You create workflows by:
 
 This structure provides full type safety and runtime validation, ensuring data integrity across the entire workflow.
 
-> **📹 Watch**:  → An introduction to workflows, and how they compare to agents [YouTube (7 minutes)](https://youtu.be/0jg2g3sNvgw)
+### Visual testing
+
+Use the [Playground](../server-db/local-dev-playground.mdx#workflows) to visualize workflow execution in real time. It shows which steps are running, completed, or suspended.
+
 
 ## Getting started
 

package/CHANGELOG.md

@@ -1,5 +1,29 @@
 # @mastra/mcp-docs-server
 
+## 0.13.28-alpha.2
+
+### Patch Changes
+
+- Updated dependencies [[`ee9108f`](https://github.com/mastra-ai/mastra/commit/ee9108fa29bb8368fc23df158c9f0645b2d7b65c)]:
+  - @mastra/core@0.20.1-alpha.2
+
+## 0.13.28-alpha.1
+
+### Patch Changes
+
+- Mutable shared workflow run state ([#8545](https://github.com/mastra-ai/mastra/pull/8545))
+
+- Updated dependencies [[`c621613`](https://github.com/mastra-ai/mastra/commit/c621613069173c69eb2c3ef19a5308894c6549f0), [`12b1189`](https://github.com/mastra-ai/mastra/commit/12b118942445e4de0dd916c593e33ec78dc3bc73), [`4783b30`](https://github.com/mastra-ai/mastra/commit/4783b3063efea887825514b783ba27f67912c26d), [`076b092`](https://github.com/mastra-ai/mastra/commit/076b0924902ff0f49d5712d2df24c4cca683713f), [`2aee9e7`](https://github.com/mastra-ai/mastra/commit/2aee9e7d188b8b256a4ddc203ccefb366b4867fa), [`c582906`](https://github.com/mastra-ai/mastra/commit/c5829065a346260f96c4beb8af131b94804ae3ad), [`fa2eb96`](https://github.com/mastra-ai/mastra/commit/fa2eb96af16c7d433891a73932764960d3235c1d), [`4783b30`](https://github.com/mastra-ai/mastra/commit/4783b3063efea887825514b783ba27f67912c26d), [`a739d0c`](https://github.com/mastra-ai/mastra/commit/a739d0c8b37cd89569e04a6ca0827083c6167e19), [`603e927`](https://github.com/mastra-ai/mastra/commit/603e9279db8bf8a46caf83881c6b7389ccffff7e), [`cd45982`](https://github.com/mastra-ai/mastra/commit/cd4598291cda128a88738734ae6cbef076ebdebd), [`874f74d`](https://github.com/mastra-ai/mastra/commit/874f74da4b1acf6517f18132d035612c3ecc394a), [`0baf2ba`](https://github.com/mastra-ai/mastra/commit/0baf2bab8420277072ef1f95df5ea7b0a2f61fe7), [`26e968d`](https://github.com/mastra-ai/mastra/commit/26e968db2171ded9e4d47aa1b4f19e1e771158d0), [`cbd3fb6`](https://github.com/mastra-ai/mastra/commit/cbd3fb65adb03a7c0df193cb998aed5ac56675ee)]:
+  - @mastra/core@0.20.1-alpha.1
+  - @mastra/mcp@0.13.4-alpha.0
+
+## 0.13.28-alpha.0
+
+### Patch Changes
+
+- Updated dependencies [[`10e633a`](https://github.com/mastra-ai/mastra/commit/10e633a07d333466d9734c97acfc3dbf757ad2d0)]:
+  - @mastra/core@0.20.1-alpha.0
+
 ## 0.13.27
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/mcp-docs-server",
-  "version": "0.13.27",
+  "version": "0.13.28-alpha.2",
   "description": "MCP server for accessing Mastra.ai documentation, changelogs, and news.",
   "type": "module",
   "main": "dist/index.js",
@@ -33,8 +33,8 @@
     "uuid": "^11.1.0",
     "zod": "^3.25.76",
     "zod-to-json-schema": "^3.24.6",
-    "@mastra/core": "0.20.0",
-    "@mastra/mcp": "^0.13.3"
+    "@mastra/core": "0.20.1-alpha.2",
+    "@mastra/mcp": "^0.13.4-alpha.0"
   },
   "devDependencies": {
     "@hono/node-server": "^1.19.5",
@@ -49,8 +49,8 @@
     "tsx": "^4.19.4",
     "typescript": "^5.8.3",
     "vitest": "^3.2.4",
-    "@internal/lint": "0.0.45",
-    "@mastra/core": "0.20.0"
+    "@internal/lint": "0.0.46",
+    "@mastra/core": "0.20.1-alpha.2"
   },
   "homepage": "https://mastra.ai",
   "repository": {

package/.docs/raw/agents/input-processors.mdx

@@ -1,284 +0,0 @@
----
-title: "Input Processors"
-description: "Learn how to use input processors to intercept and modify agent messages before they reach the language model."
----
-
-# Input Processors
-
-Input Processors allow you to intercept, modify, validate, or filter messages _before_ they are sent to the language model. This is useful for implementing guardrails, content moderation, message transformation, and security controls.
-
-Processors operate on the messages in your conversation thread. They can modify, filter, or validate content, and even abort the request entirely if certain conditions are met.
-
-## Built-in Processors
-
-Mastra provides several built-in processors for common use cases:
-
-### `UnicodeNormalizer`
-
-This processor normalizes Unicode text to ensure consistent formatting and remove potentially problematic characters.
-
-```typescript copy showLineNumbers {9-11}
-import { Agent } from "@mastra/core/agent";
-import { UnicodeNormalizer } from "@mastra/core/processors";
-import { openai } from "@ai-sdk/openai";
-
-const agent = new Agent({
-  name: 'normalized-agent',
-  instructions: 'You are a helpful assistant',
-  model: openai("gpt-4o"),
-  inputProcessors: [
-    new UnicodeNormalizer({
-      stripControlChars: true,
-      collapseWhitespace: true,
-    }),
-  ],
-});
-```
-
-Available options:
-- `stripControlChars`: Remove control characters (default: false)
-- `preserveEmojis`: Keep emojis intact (default: true)
-- `collapseWhitespace`: Collapse multiple spaces/newlines (default: true)
-- `trim`: Remove leading/trailing whitespace (default: true)
-
-### `ModerationProcessor`
-
-This processor provides content moderation using an LLM to detect inappropriate content across multiple categories.
-
-```typescript copy showLineNumbers {5-13}
-import { ModerationProcessor } from "@mastra/core/processors";
-
-const agent = new Agent({
-  inputProcessors: [
-    new ModerationProcessor({
-      model: openai("gpt-4.1-nano"), // Use a fast, cost-effective model
-      threshold: 0.7, // Confidence threshold for flagging
-      strategy: 'block', // Block flagged content
-      categories: ['hate', 'harassment', 'violence'], // Custom categories
-    }),
-  ],
-});
-```
-
-Available options:
-- `model`: Language model for moderation analysis (required)
-- `categories`: Array of categories to check (default: ['hate','hate/threatening','harassment','harassment/threatening','self-harm','self-harm/intent','self-harm/instructions','sexual','sexual/minors','violence','violence/graphic'])
-- `threshold`: Confidence threshold for flagging (0-1, default: 0.5)
-- `strategy`: Action when content is flagged (default: 'block')
-- `customInstructions`: Custom instructions for the moderation agent
-
-Strategies available:
-- `block`: Reject the request with an error (default)
-- `warn`: Log warning but allow content through
-- `filter`: Remove flagged messages but continue processing
-
-### `PromptInjectionDetector`
-
-This processor detects and prevents prompt injection attacks, jailbreaks, and system manipulation attempts.
-
-```typescript copy showLineNumbers {5-12}
-import { PromptInjectionDetector } from "@mastra/core/processors";
-
-const agent = new Agent({
-  inputProcessors: [
-    new PromptInjectionDetector({
-      model: openai("gpt-4.1-nano"),
-      threshold: 0.8, // Higher threshold for fewer false positives
-      strategy: 'rewrite', // Attempt to neutralize while preserving intent
-      detectionTypes: ['injection', 'jailbreak', 'system-override'],
-    }),
-  ],
-});
-```
-
-Available options:
-- `model`: Language model for injection detection (required)
-- `detectionTypes`: Array of injection types to detect (default: ['injection', 'jailbreak', 'system-override'])
-- `threshold`: Confidence threshold for flagging (0-1, default: 0.7)
-- `strategy`: Action when injection is detected (default: 'block')
-- `instructions`: Custom detection instructions for the agent
-- `includeScores`: Whether to include confidence scores in logs (default: false)
-
-Strategies available:
-- `block`: Reject the request (default)
-- `warn`: Log warning but allow through
-- `filter`: Remove flagged messages
-- `rewrite`: Attempt to neutralize the injection while preserving legitimate intent
-
-### `PIIDetector`
-
-This processor detects and optionally redacts personally identifiable information (PII) from messages.
-
-```typescript copy showLineNumbers {5-14}
-import { PIIDetector } from "@mastra/core/processors";
-
-const agent = new Agent({
-  inputProcessors: [
-    new PIIDetector({
-      model: openai("gpt-4.1-nano"),
-      threshold: 0.6,
-      strategy: 'redact', // Automatically redact detected PII
-      detectionTypes: ['email', 'phone', 'credit-card', 'ssn', 'api-key', 'crypto-wallet', 'iban'],
-      redactionMethod: 'mask', // Preserve format while masking
-      preserveFormat: true, // Keep original structure in redacted values
-      includeDetections: true, // Log details for compliance auditing
-    }),
-  ],
-});
-```
-
-Available options:
-- `model`: Language model for PII detection (required)
-- `detectionTypes`: Array of PII types to detect (default: ['email', 'phone', 'credit-card', 'ssn', 'api-key', 'ip-address', 'name', 'address', 'date-of-birth', 'url', 'uuid', 'crypto-wallet', 'iban'])
-- `threshold`: Confidence threshold for flagging (0-1, default: 0.6)
-- `strategy`: Action when PII is detected (default: 'block')
-- `redactionMethod`: How to redact PII ('mask', 'hash', 'remove', 'placeholder', default: 'mask')
-- `preserveFormat`: Maintain PII structure during redaction (default: true)
-- `includeDetections`: Include detection details in logs for compliance (default: false)
-- `instructions`: Custom detection instructions for the agent
-
-Strategies available:
-- `block`: Reject requests containing PII (default)
-- `warn`: Log warning but allow through
-- `filter`: Remove messages containing PII
-- `redact`: Replace PII with placeholder values
-
-### `LanguageDetector`
-
-This processor detects the language of incoming messages and can automatically translate them to a target language.
-
-```typescript copy showLineNumbers {5-12}
-import { LanguageDetector } from "@mastra/core/processors";
-
-const agent = new Agent({
-  inputProcessors: [
-    new LanguageDetector({
-      model: openai("gpt-4o-mini"),
-      targetLanguages: ['English', 'en'], // Accept English content
-      strategy: 'translate', // Auto-translate non-English content
-      threshold: 0.8, // High confidence threshold
-    }),
-  ],
-});
-```
-
-Available options:
-- `model`: Language model for detection and translation (required)
-- `targetLanguages`: Array of target languages (language names or ISO codes)
-- `threshold`: Confidence threshold for language detection (0-1, default: 0.7)
-- `strategy`: Action when non-target language is detected (default: 'detect')
-- `preserveOriginal`: Keep original content in metadata (default: true)
-- `instructions`: Custom detection instructions for the agent
-
-Strategies available:
-- `detect`: Only detect language, don't translate (default)
-- `translate`: Automatically translate to target language
-- `block`: Reject content not in target language
-- `warn`: Log warning but allow content through
-
-## Applying Multiple Processors
-
-You can chain multiple processors. They execute sequentially in the order they appear in the `inputProcessors` array. The output of one processor becomes the input for the next.
-
-**Order matters!** Generally, it's best practice to place text normalization first, security checks next, and content modification last.
-
-```typescript copy showLineNumbers {9-18}
-import { Agent } from "@mastra/core/agent";
-import {
-  UnicodeNormalizer,
-  ModerationProcessor,
-  PromptInjectionDetector,
-  PIIDetector
-} from "@mastra/core/processors";
-
-const secureAgent = new Agent({
-  inputProcessors: [
-    // 1. Normalize text first
-    new UnicodeNormalizer({ stripControlChars: true }),
-    // 2. Check for security threats
-    new PromptInjectionDetector({ model: openai("gpt-4.1-nano") }),
-    // 3. Moderate content
-    new ModerationProcessor({ model: openai("gpt-4.1-nano") }),
-    // 4. Handle PII last
-    new PIIDetector({ model: openai("gpt-4.1-nano"), strategy: 'redact' }),
-  ],
-});
-```
-
-## Creating Custom Processors
-
-You can create custom processors by implementing the `Processor` interface. A Processor can be used for input processing when it implements the `processInput` method.
-
-```typescript copy showLineNumbers {5,10-33,39}
-import type { Processor } from "@mastra/core/processors";
-import type { MastraMessageV2 } from "@mastra/core/agent/message-list";
-import { TripWire } from "@mastra/core/agent";
-
-class MessageLengthLimiter implements Processor {
-  readonly name = 'message-length-limiter';
-
-  constructor(private maxLength: number = 1000) {}
-
-  processInput({ messages, abort }: {
-    messages: MastraMessageV2[];
-    abort: (reason?: string) => never
-  }): MastraMessageV2[] {
-    // Check total message length
-    try {
-      const totalLength = messages.reduce((sum, msg) => {
-        return sum + msg.content.parts
-          .filter(part => part.type === 'text')
-          .reduce((partSum, part) => partSum + (part as any).text.length, 0);
-      }, 0);
-
-      if (totalLength > this.maxLength) {
-        abort(`Message too long: ${totalLength} characters (max: ${this.maxLength})`); // throws a TripWire error
-      }
-    } catch (error) {
-      if (error instanceof TripWire) {
-        throw error; // Re-throw tripwire errors
-      }
-      throw new Error(`Length validation failed: ${error instanceof Error ? error.message : 'Unknown error'}`); // application level throw a standard error
-    }
-
-    return messages;
-  }
-}
-
-// Use the custom processor
-const agent = new Agent({
-  inputProcessors: [
-    new MessageLengthLimiter(2000), // Limit to 2000 characters
-  ],
-});
-```
-
-When creating custom processors:
-- Always return the `messages` array (potentially modified)
-- Use `abort(reason)` to terminate processing early. Abort is used to simulate blocking a message. errors thrown with `abort` will be an instance of TripWire. For code/application level errors, throw standard errors.
-- Mutate the input messages directly, make sure to mutate both the parts and content of a message.
-- Keep processors focused on a single responsibility
-- If using an agent inside your processor, use a fast model, limit the size of the response from it as much as possible (every token slows down the response exponentially), and make the system prompt as concise as possible, these are both latency bottlenecks.
-
-## Integration with Agent Methods
-
-Input processors work with the `generate()` and `stream()` methods. The entire processor pipeline completes before the agent begins generating or streaming a response.
-
-```typescript copy showLineNumbers
-// Processors run before generate()
-const result = await agent.generate('Hello');
-
-// Processors also run before stream()
-const stream = await agent.stream('Hello');
-for await (const chunk of stream) {
-  console.log(chunk);
-}
-```
-
-If any processor calls `abort()`, the request terminates immediately and subsequent processors are not executed. The agent returns a 200 response with details (`result.tripwireReason`) about why the request was blocked.
-
-## Output Processors
-
-While input processors handle user messages before they reach the language model, **output processors** handle the LLM's responses after generation but before they're returned to the user. This is useful for response validation, content filtering, and safety controls on LLM-generated content.
-
-See the [Output Processors documentation](/docs/agents/output-processors) for details on processing LLM responses.