@mastra/mcp-docs-server 0.13.38 → 0.13.39-alpha.0

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

@@ -16,7 +16,7 @@ Workflows let you define complex sequences of tasks using clear, structured step
 
 Use workflows for tasks that are clearly defined upfront and involve multiple steps with a specific execution order. They give you fine-grained control over how data flows and transforms between steps, and which primitives are called at each stage.
 
-> **📹 Watch**: → An introduction to workflows, and how they compare to agents [YouTube (7 minutes)](https://youtu.be/0jg2g3sNvgw)
+> **📹 Watch**:  → An introduction to workflows, and how they compare to agents [YouTube (7 minutes)](https://youtu.be/0jg2g3sNvgw)
 
 ## Core principles
 
@@ -38,18 +38,18 @@ import { createStep } from "@mastra/core/workflows";
 const step1 = createStep({
   id: "step-1",
   inputSchema: z.object({
-    message: z.string(),
+    message: z.string()
   }),
   outputSchema: z.object({
-    formatted: z.string(),
+    formatted: z.string()
   }),
   execute: async ({ inputData }) => {
     const { message } = inputData;
 
     return {
-      formatted: message.toUpperCase(),
+      formatted: message.toUpperCase()
     };
-  },
+  }
 });
 ```
 
@@ -57,7 +57,7 @@ const step1 = createStep({
 
 ### Using agents and tools
 
-Workflow steps can also call registered agents or import and execute tools directly, visit the [Agents and Tools](./agents-and-tools) page for more information.
+Workflow steps can also call registered agents or import and execute tools directly, visit the [Using Tools](/docs/agents/using-tools) page for more information.
 
 ## Creating a workflow
 
@@ -80,55 +80,123 @@ export const testWorkflow = createWorkflow({
 })
   .then(step1)
   .commit();
-
 ```
 
 > See the [Workflow Class](/reference/workflows/workflow) for a full list of configuration options.
 
 ### Understanding control flow
 
-Workflows can be composed using a number of different methods. The method you choose determines how each step's schema should be structured. Visit the [Control Flow](./control-flow) page for more information.
+Workflows can be composed using a number of different methods. The method you choose determines how each step's schema should be structured. Visit the [Control Flow](/docs/workflows/control-flow) page for more information.
 
-#### Composing workflow steps
+## Workflow state
 
-When using `.then()`, steps run sequentially. Each step’s `inputSchema` must match the `outputSchema` of the previous step. The final step’s `outputSchema` should match the workflow’s `outputSchema` to ensure end-to-end type safety.
+Workflow state lets you share values across steps without passing them through every step’s inputSchema and outputSchema. All state values are defined in the workflow’s stateSchema, but each step only declares the values it needs. To set initial values, use initialState when running the workflow.
 
-```typescript {4,7,14,17,24,27} title="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
+```typescript title="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
 const step1 = createStep({
-  //...
-  inputSchema: z.object({
-    message: z.string(),
-  }),
-  outputSchema: z.object({
-    formatted: z.string(),
+  // ...
+  stateSchema: z.object({
+    processedItems: z.array(z.string()),
   }),
+  execute: async ({ inputData, state, setState }) => {
+    const { message } = inputData;
+    const { processedItems } = state;
+
+    setState({
+      ...state,
+      processedItems: [...processedItems, "item-1", "item-2"],
+    });
+
+    return {
+      formatted: message.toUpperCase(),
+    };
+  },
 });
 
 const step2 = createStep({
   // ...
-  inputSchema: z.object({
-    formatted: z.string(),
-  }),
-  outputSchema: z.object({
-    emphasized: z.string(),
+  stateSchema: z.object({
+    metadata: z.object({
+      processedBy: z.string(),
+    }),
   }),
+  execute: async ({ inputData, state }) => {
+    const { formatted } = inputData;
+    const { metadata } = state;
+
+    return {
+      emphasized: `${formatted}!! ${metadata.processedBy}`,
+    };
+  },
 });
 
 export const testWorkflow = createWorkflow({
   // ...
+  stateSchema: z.object({
+    processedItems: z.array(z.string()),
+    metadata: z.object({
+      processedBy: z.string(),
+    }),
+  }),
+})
+  .then(step1)
+  .then(step2)
+  .commit();
+```
+
+## Workflows as steps
+
+Use a workflow as a step to reuse its logic within a larger composition. Input and output follow the same schema rules described in [Core principles](/docs/workflows/control-flow).
+
+```typescript {26} title="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
+const step1 = createStep({...});
+const step2 = createStep({...});
+
+const childWorkflow = createWorkflow({
+  id: "child-workflow",
   inputSchema: z.object({
-    message: z.string(),
+    message: z.string()
   }),
   outputSchema: z.object({
-    emphasized: z.string(),
-  }),
+    emphasized: z.string()
+  })
 })
   .then(step1)
   .then(step2)
   .commit();
+
+export const testWorkflow = createWorkflow({
+  id: "test-workflow",
+  inputSchema: z.object({
+    message: z.string()
+  }),
+  outputSchema: z.object({
+    emphasized: z.string()
+  })
+})
+  .then(childWorkflow)
+  .commit();
+```
+
+### Cloning a workflow
+
+Clone a workflow using `cloneWorkflow()` when you want to reuse its logic but track it separately under a new ID. Each clone runs independently and appears as a distinct workflow in logs and observability tools.
+
+```typescript {6} title="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
+import { cloneWorkflow } from "@mastra/core/workflows";
+
+const step1 = createStep({...});
+
+const parentWorkflow = createWorkflow({...})
+const clonedWorkflow = cloneWorkflow(parentWorkflow, { id: "cloned-workflow" });
+
+export const testWorkflow = createWorkflow({...})
+  .then(step1)
+  .then(clonedWorkflow)
+  .commit();
 ```
 
-### Registering a workflow
+## Registering a workflow
 
 Register your workflow in the Mastra instance to make it available throughout your application. Once registered, it can be called from agents or tools and has access to shared resources such as logging and observability features:
 
@@ -149,22 +217,16 @@ You can run workflows from agents, tools, the Mastra Client, or the command line
 ```typescript showLineNumbers copy
 const testWorkflow = mastra.getWorkflow("testWorkflow");
 ```
-
 :::info
-
 `mastra.getWorkflow()` is preferred over a direct import, since it provides access to the Mastra instance configuration (logger, telemetry, storage, registered agents, and vector stores).
-
 :::
 
-> See [Running Workflows](/examples/workflows_legacy/creating-a-workflow) for more information.
-
 ## Running workflows
 
 Workflows can be run in two modes: start waits for all steps to complete before returning, and stream emits events during execution. Choose the approach that fits your use case: start when you only need the final result, and stream when you want to monitor progress or trigger actions as steps complete.
 
 <Tabs>
   <TabItem value="start" label="Start">
-
 Create a workflow run instance using `createRunAsync()`, then call `.start()` with `inputData` matching the workflow's `inputSchema`. The workflow executes all steps and returns the final result.
 
 ```typescript showLineNumbers copy
@@ -172,16 +234,14 @@ const run = await testWorkflow.createRunAsync();
 
 const result = await run.start({
   inputData: {
-    message: "Hello world",
-  },
+    message: "Hello world"
+  }
 });
 
 console.log(result);
 ```
-
   </TabItem>
   <TabItem value="stream" label="Stream">
-
 Create a workflow run instance using `.createRunAsync()`, then call `.stream()` with `inputData` matching the workflow's `inputSchema`. The workflow emits events as each step executes, which you can iterate over to track progress.
 
 ```typescript showLineNumbers copy
@@ -189,15 +249,14 @@ const run = await testWorkflow.createRunAsync();
 
 const result = await run.stream({
   inputData: {
-    message: "Hello world",
-  },
+    message: "Hello world"
+  }
 });
 
 for await (const chunk of result.stream) {
   console.log(chunk);
 }
 ```
-
   </TabItem>
 </Tabs>
 
@@ -217,7 +276,7 @@ The workflow output includes the full execution lifecycle, showing the input and
       },
       "output": {
         "formatted": "HELLO WORLD"
-      }
+      },
     },
     "step-2": {
       "status": "success",
@@ -226,7 +285,7 @@ The workflow output includes the full execution lifecycle, showing the input and
       },
       "output": {
         "emphasized": "HELLO WORLD!!!"
-      }
+      },
     }
   },
   "input": {
@@ -252,28 +311,21 @@ const step1 = createStep({
   execute: async ({ runtimeContext }) => {
     const userTier = runtimeContext.get("user-tier") as UserTier["user-tier"];
 
-    const maxResults = userTier === "enterprise" ? 1000 : 50;
+    const maxResults = userTier === "enterprise"
+      ? 1000
+      : 50;
 
     return { maxResults };
-  },
+  }
 });
 ```
 
 > See [Runtime Context](/docs/server-db/runtime-context) for more information.
 
-## Testing with Mastra Playground
+## Testing with Studio
 
-Use the Mastra [Playground](/docs/getting-started/studio) to easily run workflows with different inputs, visualize the execution lifecycle, see the inputs and outputs for each step, and inspect each part of the workflow in more detail.
+Use [Studio](/docs/getting-started/studio) to easily run workflows with different inputs, visualize the execution lifecycle, see the inputs and outputs for each step, and inspect each part of the workflow in more detail.
 
 ## Related
 
 For a closer look at workflows, see our [Workflow Guide](/guides/guide/ai-recruiter), which walks through the core concepts with a practical example.
-
-- [Parallel Steps workflow example](/examples/workflows_legacy/parallel-steps)
-- [Conditional Branching workflow example](/examples/workflows_legacy/conditional-branching)
-- [Inngest workflow example](/examples/workflows/inngest-workflow)
-- [Suspend and Resume workflow example](/examples/workflows_legacy/human-in-the-loop)
-
-## Workflows (Legacy)
-
-For legacy workflow documentation, see [Workflows (Legacy)](../workflows-legacy/overview).

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

@@ -5,15 +5,7 @@ description: "Suspend and resume in Mastra workflows allows you to pause executi
 
 # Suspend & Resume
 
-Workflows can be paused at any step, with their current state persisted as a [snapshot](./snapshots) 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
-- Pausing until external API resources become available
-- Collecting additional data needed for later steps
-- Rate limiting or throttling expensive operations
-- Handling event-driven processes with external triggers
+Workflows can be paused at any step to collect additional data, wait for API callbacks, throttle expensive operations, or wait for [Human in the Loop](./human-in-the-loop) input. When a workflow is suspended, its current state can be persisted as a [snapshot](./snapshots) and later resumed from the same point. Snapshots are stored in the configured storage system and persist across deployments and application restarts.
 
 > **New to suspend and resume?** Watch these official video tutorials:
 >

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # @mastra/mcp-docs-server
 
+## 0.13.39-alpha.0
+
+### Patch Changes
+
+- update peerdeps ([`5ca1cca`](https://github.com/mastra-ai/mastra/commit/5ca1ccac61ffa7141e6d9fa8f22d3ad4d03bf5dc))
+
+- Updated dependencies [[`5ca1cca`](https://github.com/mastra-ai/mastra/commit/5ca1ccac61ffa7141e6d9fa8f22d3ad4d03bf5dc), [`6d7e90d`](https://github.com/mastra-ai/mastra/commit/6d7e90db09713e6250f4d6c3d3cff1b4740e50f9), [`f78b908`](https://github.com/mastra-ai/mastra/commit/f78b9080e11af765969b36b4a619761056030840), [`23c2614`](https://github.com/mastra-ai/mastra/commit/23c26140fdbf04b8c59e8d7d52106d67dad962ec), [`e365eda`](https://github.com/mastra-ai/mastra/commit/e365eda45795b43707310531cac1e2ce4e5a0712)]:
+  - @mastra/mcp@0.14.2-alpha.0
+  - @mastra/core@0.24.0-alpha.0
+
 ## 0.13.38
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/mcp-docs-server",
-  "version": "0.13.38",
+  "version": "0.13.39-alpha.0",
   "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/mcp": "^0.14.1",
-    "@mastra/core": "0.23.3"
+    "@mastra/core": "0.24.0-alpha.0",
+    "@mastra/mcp": "^0.14.2-alpha.0"
   },
   "devDependencies": {
     "@hono/node-server": "^1.19.5",
@@ -50,7 +50,7 @@
     "typescript": "^5.8.3",
     "vitest": "^3.2.4",
     "@internal/lint": "0.0.57",
-    "@mastra/core": "0.23.3"
+    "@mastra/core": "0.24.0-alpha.0"
   },
   "homepage": "https://mastra.ai",
   "repository": {

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

@@ -1,107 +0,0 @@
----
-title: "Input Data Mapping | Workflows | Mastra Docs"
-description: "Learn how to use workflow input mapping to create more dynamic data flows in your Mastra workflows."
----
-
-# Input Data Mapping
-
-Input data mapping allows explicit mapping of values for the inputs of the next step. These values can come from a number of sources:
-
-- The outputs of a previous step
-- The runtime context
-- A constant value
-- The initial input of the workflow
-
-## 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.
-
-![Mapping with .map()](/img/workflows/workflows-data-mapping-map.jpg)
-
-```typescript {9} title="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
-const step1 = createStep({...});
-const step2 = createStep({...});
-
-export const testWorkflow = createWorkflow({...})
-  .then(step1)
-  .map(async ({ inputData }) => {
-    const { value } = inputData;
-    return {
-      output: `new ${value}`
-    };
-  })
-  .then(step2)
-  .commit();
-```
-
-## Using `inputData`
-
-Use `inputData` to access the full output of the previous step:
-
-```typescript {3} title="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
-  .then(step1)
-  .map(({ inputData }) => {
-    console.log(inputData);
-  })
-```
-
-## Using `getStepResult()`
-
-Use `getStepResult` to access the full output of a specific step by referencing the step's instance:
-
-```typescript {3} title="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
-  .then(step1)
-  .map(async ({ getStepResult }) => {
-    console.log(getStepResult(step1));
-  })
-```
-
-## Using `getInitData()`
-
-Use `getInitData` to access the initial input data provided to the workflow:
-
-```typescript {3} title="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
-  .then(step1)
-  .map(async ({ getInitData }) => {
-      console.log(getInitData());
-  })
-```
-
-## Using `mapVariable()`
-
-To use `mapVariable` import the necessary function from the workflows module:
-
-```typescript title="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-6} title="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
-  .then(step1)
-  .map({
-    details: mapVariable({
-      step: step,
-      path: "value"
-    })
-  })
-```
-
-### Renaming workflows with `mapVariable()`
-
-You can rename workflow outputs by using **referential composition**. This involves passing the workflow instance as the `initData`.
-
-```typescript {6-9} title="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
-export const testWorkflow = createWorkflow({...});
-
-testWorkflow
-  .then(step1)
-  .map({
-    details: mapVariable({
-      initData: testWorkflow,
-      path: "value"
-    })
-  })
-```