@mastra/mcp-docs-server 0.13.5-alpha.0 → 0.13.6

package/.docs/raw/workflows/input-data-mapping.mdx

@@ -12,78 +12,75 @@ Input data mapping allows explicit mapping of values for the inputs of the next
 - A constant value
 - The initial input of the workflow
 
-## Map
+## Mapping with `.map()`
 
 In this example the `output` from `step1` is transformed to match the `inputSchema` required for the `step2`. The value from `step1` is available using the `inputData` parameter of the `.map` function.
 
-```typescript {18} filename="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
+![Mapping with .map()](/image/workflows/workflows-data-mapping-map.jpg)
+
+```typescript {9} filename="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
 const step1 = createStep({...});
 const step2 = createStep({...});
 
-export const testWorkflow = createWorkflow({
-  id: "test-workflow",
-  description: 'Test workflow',
-  inputSchema: z.object({
-    input: z.number()
-  }),
-  outputSchema: z.object({
-    output: z.string()
-  })
-})
+export const testWorkflow = createWorkflow({...})
   .then(step1)
-  .map(({ inputData }) => {
+  .map(async ({ inputData }) => {
     const { value } = inputData;
     return {
-      output: `${value}`
+      output: `new ${value}`
     };
   })
   .then(step2)
   .commit();
 ```
 
-### inputData
+## Using `inputData`
 
 Use `inputData` to access the full output of the previous step:
 
-```typescript {2} showLineNumbers
+```typescript {3} filename="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
+  .then(step1)
   .map(({ inputData }) => {
-    const { value} = inputData;
-    ...
+    console.log(inputData);
   })
 ```
 
-### getStepResult
+## Using `getStepResult()`
 
 Use `getStepResult` to access the full output of a specific step by referencing the step's instance:
 
-```typescript {3} showLineNumbers
+```typescript {3} filename="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
   .then(step1)
-  .map(({ getStepResult }) => {
+  .map(async ({ getStepResult }) => {
     console.log(getStepResult(step1));
-    ...
   })
 ```
 
-### getInitData
+## Using `getInitData()`
 
 Use `getInitData` to access the initial input data provided to the workflow:
 
-```typescript {3} showLineNumbers
+```typescript {3} filename="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
   .then(step1)
-  .map(({ getInitData }) => {
+  .map(async ({ getInitData }) => {
       console.log(getInitData());
-    ...
   })
 ```
 
-## Renaming Outputs
+## Using `mapVariable()`
+
+To use `mapVariable` import the necessary function from the workflows module:
 
-### Step Outputs
+```typescript filename="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
+import { mapVariable } from "@mastra/core/workflows";
+```
+
+### Renaming step with `mapVariable()`
 
 You can rename step outputs using the object syntax in `.map()`. In the example below, the `value` output from `step1` is renamed to `details`:
 
-```typescript {3} showLineNumbers
-  .then(step)
+```typescript {3-6} filename="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
+  .then(step1)
   .map({
     details: mapVariable({
       step: step,
@@ -92,24 +89,15 @@ You can rename step outputs using the object syntax in `.map()`. In the example
   })
 ```
 
-### Workflow Outputs
+### Renaming workflows with `mapVariable()`
 
 You can rename workflow outputs by using **referential composition**. This involves passing the workflow instance as the `initData`.
 
-```typescript {12, 16} showLineNumbers
-export const testWorkflow = createWorkflow({
-  id: "test-workflow",
-  description: 'Test workflow',
-  inputSchema: z.object({
-    input: z.string()
-  }),
-  outputSchema: z.object({
-    output: z.string()
-  })
-});
+```typescript {6-9} filename="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
+export const testWorkflow = createWorkflow({...});
 
 testWorkflow
-  .then(cityCoordinatesStep)
+  .then(step1)
   .map({
     details: mapVariable({
       initData: testWorkflow,

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

@@ -5,12 +5,14 @@ description: "Workflows in Mastra help you orchestrate complex sequences of oper
 
 import { Steps } from "nextra/components";
 
-# Workflows Overview
+# 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 overview](/image/workflows/workflows-overview.jpg)
+
 You create workflows by:
 
 - Defining **steps** with `createStep`, specifying input/output schemas and business logic.
@@ -20,7 +22,7 @@ You create workflows by:
 This structure provides full type safety and runtime validation, ensuring data integrity across the entire workflow.
 
 
-## Getting Started
+## Getting started
 
 To use workflows, first import the necessary functions from the workflows module:
 
@@ -29,7 +31,7 @@ import { createWorkflow, createStep } from "@mastra/core/workflows";
 import { z } from "zod";
 ```
 
-### Create Step
+### Create step
 
 Steps are the building blocks of workflows. Create a step using `createStep`:
 
@@ -39,7 +41,7 @@ const step1 = createStep({...});
 
 > See [createStep](/reference/workflows/step) for more information.
 
-### Create Workflow
+### Create workflow
 
 Create a workflow using `createWorkflow` and complete it with `.commit()`.
 
@@ -65,7 +67,7 @@ export const testWorkflow = createWorkflow({
 
 > See [workflow](/reference/workflows/workflow) for more information.
 
-#### Composing Steps
+#### Composing steps
 
 Workflow steps can be composed and executed sequentially using `.then()`.
 
@@ -93,8 +95,7 @@ export const testWorkflow = createWorkflow({
 
 > Steps can be composed using a number of different methods. See [Control Flow](/docs/workflows/control-flow)  for more information.
 
-
-#### Cloning Steps
+#### Cloning steps
 
 Workflow steps can be cloned using `cloneStep()`, and used with any workflow method.
 
@@ -122,7 +123,7 @@ export const testWorkflow = createWorkflow({
   .commit();
 ```
 
-### Register Workflow
+### Register workflow
 
 Register a workflow using `workflows` in the main Mastra instance:
 
@@ -146,7 +147,7 @@ export const mastra = new Mastra({
 });
 ```
 
-### Run Workflow
+### Run workflow
 There are two ways to run and test workflows.
 
 <Steps>
@@ -170,7 +171,13 @@ const result = await run.start({
   }
 });
 
+// Dump the complete workflow result (includes status, steps and result)
 console.log(JSON.stringify(result, null, 2));
+
+// Get the workflow output value
+if (result.status === 'success') {
+  console.log(`output value: ${result.result.output}`);
+}
 ```
 > see [createRunAsync](/reference/workflows/create-run) and [start](/reference/workflows/start) for more information.
 
@@ -182,7 +189,7 @@ npx tsx src/test-workflow.ts
 
 </Steps>
 
-#### Run Workflow Results
+#### Run workflow results
 
 The result of running a workflow using either `start()` or `resume()` will look like one of the following, depending on the outcome.
 
@@ -250,7 +257,7 @@ The result of running a workflow using either `start()` or `resume()` will look
 ```
 - **error**: An optional field that includes the error message if the workflow fails
 
-### Stream Workflow
+### Stream workflow
 
 Similar to the run method shown above, workflows can also be streamed:
 
@@ -294,7 +301,7 @@ const result = await run.start({
 
 > See [watch](/reference/workflows/watch) for more information.
 
-## More Resources
+## More resources
 
 - The [Workflow Guide](../../guides/guide/ai-recruiter.mdx) in the Guides section is a tutorial that covers the main concepts.
 - [Parallel Steps workflow example](../../examples/workflows/parallel-steps.mdx)
@@ -303,4 +310,7 @@ const result = await run.start({
 - [Suspend and Resume workflow example](../../examples/workflows/human-in-the-loop.mdx)
 
 
+## Workflows (Legacy)
+
+For legacy workflow documentation, see [Workflows (Legacy)](/docs/workflows-legacy/overview).
 

package/.docs/raw/workflows/pausing-execution.mdx

@@ -16,7 +16,7 @@ You can pause execution using:
 
 When using any of these methods, the workflow status is set to `waiting` until execution resumes.
 
-## sleep
+## Pausing with `.sleep()`
 
 The `sleep()` method pauses execution between steps for a specified number of milliseconds.
 
@@ -34,7 +34,28 @@ export const testWorkflow = createWorkflow({...})
   .commit();
 ```
 
-## sleepUntil
+### Pausing with `.sleep(callback)`
+
+The `sleep()` method also accepts a callback that returns the number of milliseconds to pause. The callback receives `inputData`, allowing the delay to be computed dynamically.
+
+```typescript {9} filename="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
+import { createWorkflow, createStep } from "@mastra/core/workflows";
+import { z } from "zod";
+
+const step1 = createStep({...});
+const step2 = createStep({...});
+
+export const testWorkflow = createWorkflow({...})
+  .then(step1)
+  .sleep(async ({ inputData }) => {
+    const { delayInMs }  = inputData
+    return delayInMs;
+  })
+  .then(step2)
+  .commit();
+```
+
+## Pausing with `.sleepUntil()`
 
 The `sleepUntil()` method pauses execution between steps until a specified date.
 
@@ -52,12 +73,36 @@ export const testWorkflow = createWorkflow({...})
   .commit();
 ```
 
+### Pausing with `.sleepUntil(callback)`
+
+The `sleepUntil()` method also accepts a callback that returns a `Date` object. The callback receives `inputData`, allowing the target time to be computed dynamically.
+
+```typescript {9} filename="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
+import { createWorkflow, createStep } from "@mastra/core/workflows";
+import { z } from "zod";
+
+const step1 = createStep({...});
+const step2 = createStep({...});
+
+export const testWorkflow = createWorkflow({...})
+  .then(step1)
+  .sleepUntil(async ({ inputData }) => {
+    const { delayInMs }  = inputData
+    return new Date(Date.now() + delayInMs);
+  })
+  .then(step2)
+  .commit();
+```
+
+
 > `Date.now()` is evaluated when the workflow starts, not at the moment the `sleepUntil()` method is called.
 
-## waitForEvent
+## Pausing with `.waitForEvent()`
 
 The `waitForEvent()` method pauses execution until a specific event is received. Use `run.sendEvent()` to send the event. You must provide both the event name and the step to resume.
 
+![Pausing with .waitForEvent()](/image/workflows/workflows-sleep-events-waitforevent.jpg)
+
 ```typescript {10} filename="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
 import { createWorkflow, createStep } from "@mastra/core/workflows";
 import { z } from "zod";
@@ -72,7 +117,7 @@ export const testWorkflow = createWorkflow({...})
   .then(step3)
   .commit();
 ```
-## sendEvent
+## Sending an event with `.sendEvent()`
 
 The `.sendEvent()` method sends an event to the workflow. It accepts the event name and optional event data, which can be any JSON-serializable value.
 

package/.docs/raw/workflows/suspend-and-resume.mdx

@@ -7,7 +7,6 @@ description: "Suspend and resume in Mastra workflows allows you to pause executi
 
 Workflows can be paused at any step, with their current state persisted as a snapshot in storage. Execution can then be resumed from this saved snapshot when ready. Persisting the snapshot ensures the workflow state is maintained across sessions, deployments, and server restarts, essential for workflows that may remain suspended while awaiting external input or resources.
 
-
 Common scenarios for suspending workflows include:
 
 - Waiting for human approval or input
@@ -16,7 +15,7 @@ Common scenarios for suspending workflows include:
 - Rate limiting or throttling expensive operations
 - Handling event-driven processes with external triggers
 
-## Workflow Status
+## Workflow status types
 
 When running a workflow, its `status` can be one of the following:
 
@@ -25,11 +24,13 @@ When running a workflow, its `status` can be one of the following:
 - `success` - The workflow has completed
 - `failed` - The workflow has failed
 
-## Suspend
+## Suspending a workflow with `suspend()`
 
 When the state is `suspended`, you can identify any and all steps that have been suspended by looking at the `suspended` array of the workflow result output.
 
-```typescript {17} filename="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
+![Suspending a workflow with suspend()](/image/workflows/workflows-suspend-resume-suspend.jpg)
+
+```typescript {18} filename="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
 const step1 = createStep({
   id: "step-1",
   description: "Test suspend",
@@ -44,14 +45,14 @@ const step1 = createStep({
     city: z.string()
   }),
   execute: async ({ resumeData, suspend }) => {
-    if (!(resumeData ?? {}).city) {
+    const { city } = resumeData ?? {};
+
+    if (!city) {
       await suspend({});
       return { output: "" };
     }
 
-    return {
-      output: ""
-    };
+    return { output: "" };
   }
 });
 
@@ -62,11 +63,11 @@ export const testWorkflow = createWorkflow({})
 
 > See [Define Suspendable workflow](/examples/workflows/human-in-the-loop#define-suspendable-workflow) for more information.
 
-### Identifying Suspended steps
+### Identifying suspended steps
 
 To resume a suspended workflow, inspect the `suspended` array in the result to determine which step needs input:
 
-```typescript {15} filename="src/test-workflow.ts" showLineNumbers copy
+```typescript {15} filename="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
 import { mastra } from "./mastra";
 
 const run = await mastra.getWorkflow("testWorkflow").createRunAsync();
@@ -112,11 +113,11 @@ In this case, the logic resumes the first step listed in the `suspended` array.
 
 > See [Run Workflow Results](/workflows/overview#run-workflow-results) for more details.
 
-## Resume
+## Resuming a workflow with `resume()`
 
 A workflow can be resumed by calling `resume` and providing the required `resumeData`.
 
-```typescript {16-18} filename="src/test-workflow.ts" showLineNumbers copy
+```typescript {16-18} filename="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
 import { mastra } from "./mastra";
 
 const run = await mastra.getWorkflow("testWorkflow").createRunAsync();
@@ -141,11 +142,11 @@ if (result.status === "suspended") {
 }
 ```
 
-### Nested Workflow
+### Resuming nested workflows
 
 To resume a suspended nested workflow pass the workflow instance to the `step` parameter of the `resume` function.
 
-```typescript {3} filename="src/test-workflow.ts" showLineNumbers copy
+```typescript {33-34} filename="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
 const dowhileWorkflow = createWorkflow({
   id: 'dowhile-workflow',
   inputSchema: z.object({ value: z.number() }),
@@ -186,12 +187,12 @@ if (result.status === "suspended") {
 }
 ```
 
-## RuntimeContext
+## Using `RuntimeContext` with suspend/resume
 
 When using suspend/resume with `RuntimeContext`, you can create the instance yourself, and pass it to the `start` and `resume` functions.
 `RuntimeContext` is not automatically shared on a workflow run.
 
-```typescript {1,4,9,16} filename="src/test-workflow.ts" showLineNumbers copy
+```typescript {1,4,9,16} filename="src/mastra/workflows/test-workflow.tss" showLineNumbers copy
 import { RuntimeContext } from "@mastra/core/di";
 import { mastra } from "./mastra";
 

package/.docs/raw/workflows/using-with-agents-and-tools.mdx

@@ -11,14 +11,13 @@ Workflow steps are composable and typically run logic directly within the `execu
 - Abstracting complex or reusable logic into a dedicated tool.
 - Interacting with third-party APIs in a structured or reusable way.
 
-
 Workflows can use Mastra agents or tools directly as steps, for example: `createStep(testAgent)` or `createStep(testTool)`.
 
-## Agents
+## Using agents in workflows
 
 To include an agent in a workflow, define it in the usual way, then either add it directly to the workflow using `createStep(testAgent)` or, invoke it from within a step's `execute` function using `.generate()`.
 
-### Example Agent
+### Example agent
 
 This agent uses OpenAI to generate a fact about a city, country, and timezone.
 
@@ -34,7 +33,7 @@ export const testAgent = new Agent({
 });
 ```
 
-### Agents As Step
+### Adding an agent as a step
 
 In this example, `step1` uses the `testAgent` to generate an interesting fact about the country based on a given city.
 
@@ -43,6 +42,9 @@ The `.map` method transforms the workflow input into a `prompt` string compatibl
 The step is composed into the workflow using `.then()`, allowing it to receive the mapped input and return the agent's structured output. The workflow is finalized with `.commit()`.
 
 
+![Agent as step](/image/workflows/workflows-agent-tools-agent-step.jpg)
+
+
 ```typescript {3} filename="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
 import { testAgent } from "../agents/test-agent";
 
@@ -68,7 +70,7 @@ export const testWorkflow = createWorkflow({
   .commit();
 ```
 
-### Agent Generate
+### Calling an agent with `.generate()`
 
 In this example, the `step1` builds a prompt using the provided `input` and passes it to the `testAgent`, which returns a plain-text response containing facts about the city and its country.
 
@@ -107,11 +109,11 @@ export const testWorkflow = createWorkflow({...})
   .commit();
 ```
 
-## Tools
+## Using tools in workflows
 
 To use a tool within a workflow, define it in the usual way, then either add it directly to the workflow using `createStep(testTool)` or, invoke it from within a step's `execute` function using `.execute()`.
 
-### Example Tool
+### Example tool
 
 The example below uses the Open Meteo API to retrieve geolocation details for a city, returning its name, country, and timezone.
 
@@ -142,13 +144,14 @@ export const testTool = createTool({
 });
 ```
 
-
-### Tools as Step
+### Adding a tool as a step
 
 In this example, `step1` uses the `testTool`, which performs a geocoding lookup using the provided `city` and returns the resolved `country`.
 
 The step is added to the workflow using the sequential `.then()` method, allowing it to receive input from the workflow and return structured output. The workflow is finalized with `.commit()`.
 
+![Tool as step](/image/workflows/workflows-agent-tools-tool-step.jpg)
+
 ```typescript {1,3,6} filename="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
 import { testTool } from "../tools/test-tool";
 
@@ -159,7 +162,7 @@ export const testWorkflow = createWorkflow({...})
   .commit();
 ```
 
-### Tool Execute
+### Calling a tool with `.execute()`
 
 In this example, `step1` directly invokes `testTool` using its `.execute()` method. The tool performs a geocoding lookup with the provided `city` and returns the corresponding `country`.
 
@@ -201,7 +204,7 @@ export const testWorkflow = createWorkflow({...})
   .commit();
 ```
 
-## Workflow As Tool
+## Using workflows as tools
 
 In this example the `cityStringWorkflow` workflow has been added to the main Mastra instance.
 
@@ -255,7 +258,7 @@ export const cityCoordinatesTool = createTool({
 });
 ```
 
-## MCP Server
+## Exposing workflows with `MCPServer`
 
 You can convert your workflows into tools by passing them into an instance of a Mastra `MCPServer`. This allows any MCP-compatible client to access your workflow.
 
@@ -316,7 +319,7 @@ Run the client script to see your workflow tool.
 npx tsx src/test-mcp-client.ts
 ```
 
-## More Resources
+## More resources
 
 - [MCPServer reference documentation](/reference/tools/mcp-server).
 - [MCPClient reference documentation](/reference/tools/mcp-client).

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

@@ -5,6 +5,17 @@ description: "Workflows in Mastra help you orchestrate complex sequences of oper
 
 # Handling Complex LLM Operations with Workflows (Legacy)
 
+All the legacy workflow documentation is available on the links below.
+
+- [Steps](/docs/workflows-legacy/steps/)
+- [Control Flow](/docs/workflows-legacy/control-flow/)
+- [Variables](/docs/workflows-legacy/variables/)
+- [Suspend & Resume](/docs/workflows-legacy/suspend-and-resume/)
+- [Dynamic Workflows](/docs/workflows-legacy/dynamic-workflows/)
+- [Error Handling](/docs/workflows-legacy/error-handling/)
+- [Nested Workflows](/docs/workflows-legacy/nested-workflows/)
+- [Runtime/Dynamic Variables](/docs/workflows-legacy/runtime-variables/)
+
 Workflows in Mastra help you orchestrate complex sequences of operations with features like branching, parallel execution, resource suspension, and more.
 
 ## When to use workflows

package/LICENSE.md

@@ -1,46 +1,15 @@
-# Elastic License 2.0 (ELv2)
+# Apache License 2.0
 
-Copyright (c) 2025 Mastra AI, Inc.
+Copyright (c) 2025 Kepler Software, Inc.
 
-**Acceptance**
-By using the software, you agree to all of the terms and conditions below.
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
 
-**Copyright License**
-The licensor grants you a non-exclusive, royalty-free, worldwide, non-sublicensable, non-transferable license to use, copy, distribute, make available, and prepare derivative works of the software, in each case subject to the limitations and conditions below
+    http://www.apache.org/licenses/LICENSE-2.0
 
-**Limitations**
-You may not provide the software to third parties as a hosted or managed service, where the service provides users with access to any substantial set of the features or functionality of the software.
-
-You may not move, change, disable, or circumvent the license key functionality in the software, and you may not remove or obscure any functionality in the software that is protected by the license key.
-
-You may not alter, remove, or obscure any licensing, copyright, or other notices of the licensor in the software. Any use of the licensor’s trademarks is subject to applicable law.
-
-**Patents**
-The licensor grants you a license, under any patent claims the licensor can license, or becomes able to license, to make, have made, use, sell, offer for sale, import and have imported the software, in each case subject to the limitations and conditions in this license. This license does not cover any patent claims that you cause to be infringed by modifications or additions to the software. If you or your company make any written claim that the software infringes or contributes to infringement of any patent, your patent license for the software granted under these terms ends immediately. If your company makes such a claim, your patent license ends immediately for work on behalf of your company.
-
-**Notices**
-You must ensure that anyone who gets a copy of any part of the software from you also gets a copy of these terms.
-
-If you modify the software, you must include in any modified copies of the software prominent notices stating that you have modified the software.
-
-**No Other Rights**
-These terms do not imply any licenses other than those expressly granted in these terms.
-
-**Termination**
-If you use the software in violation of these terms, such use is not licensed, and your licenses will automatically terminate. If the licensor provides you with a notice of your violation, and you cease all violation of this license no later than 30 days after you receive that notice, your licenses will be reinstated retroactively. However, if you violate these terms after such reinstatement, any additional violation of these terms will cause your licenses to terminate automatically and permanently.
-
-**No Liability**
-As far as the law allows, the software comes as is, without any warranty or condition, and the licensor will not be liable to you for any damages arising out of these terms or the use or nature of the software, under any kind of legal claim.
-
-**Definitions**
-The _licensor_ is the entity offering these terms, and the _software_ is the software the licensor makes available under these terms, including any portion of it.
-
-_you_ refers to the individual or entity agreeing to these terms.
-
-_your company_ is any legal entity, sole proprietorship, or other kind of organization that you work for, plus all organizations that have control over, are under the control of, or are under common control with that organization. _control_ means ownership of substantially all the assets of an entity, or the power to direct its management and policies by vote, contract, or otherwise. Control can be direct or indirect.
-
-_your licenses_ are all the licenses granted to you for the software under these terms.
-
-_use_ means anything you do with the software requiring one of your licenses.
-
-_trademark_ means trademarks, service marks, and similar rights.
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.