@mastra/mcp-docs-server 0.13.11-alpha.0 → 0.13.11-alpha.2

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

@@ -1,45 +1,19 @@
 ---
-title: "Reference: Workflow.execute() | Building Workflows | Mastra Docs"
-description: Documentation for the `.execute()` method in workflows, which executes a step with input data and returns the output.
+title: "Reference: Workflow.execute() | Workflows | Mastra Docs"
+description: Documentation for the `Workflow.execute()` method in workflows, which executes a workflow directly and returns the output.
 ---
 
 # Workflow.execute()
 
-The `.execute()` method executes a step with input data and returns the output, allowing you to process data within a workflow.
+The `.execute()` method executes a workflow directly and returns the output, allowing you to run a workflow without creating a separate run instance.
 
-## Usage
+## Usage example
 
-```typescript
-const inputSchema = z.object({
-  inputValue: z.string(),
-});
-
-const myStep = createStep({
-  id: "my-step",
-  description: "Does something useful",
-  inputSchema,
-  outputSchema: z.object({
-    outputValue: z.string(),
-  }),
-  resumeSchema: z.object({
-    resumeValue: z.string(),
-  }),
-  suspendSchema: z.object({
-    suspendValue: z.string(),
-  }),
-  execute: async ({
-    inputData,
-    mastra,
-    getStepResult,
-    getInitData,
-    runtimeContext,
-  }) => {
-    const otherStepOutput = getStepResult(step2);
-    const initData = getInitData<typeof inputSchema>(); // typed as the input schema variable (zod schema)
-    return {
-      outputValue: `Processed: ${inputData.inputValue}, ${initData.startValue} (runtimeContextValue: ${runtimeContext.get("runtimeContextValue")})`,
-    };
-  },
+```typescript showLineNumbers copy
+await workflow.execute({
+  inputData: {
+    value: "hello world"
+  }
 });
 ```
 
@@ -48,77 +22,93 @@ const myStep = createStep({
 <PropertiesTable
   content={[
     {
-      name: "params",
-      type: "object",
-      description: "Configuration object for executing the step",
+      name: "inputData",
+      type: "z.infer<TInput>",
+      description: "Input data that matches the workflow's input schema",
       isOptional: false,
+    },
+    {
+      name: "resumeData",
+      type: "any",
+      description: "Data for resuming a suspended workflow",
+      isOptional: true,
+    },
+    {
+      name: "suspend",
+      type: "(suspendPayload: any) => Promise<any>",
+      description: "Function to suspend workflow execution",
+      isOptional: false,
+    },
+    {
+      name: "resume",
+      type: "object",
+      description: "Configuration for resuming workflow execution",
+      isOptional: true,
       properties: [
         {
-          name: "inputData",
-          type: "z.infer<TInput>",
-          description: "Input data matching the step's input schema",
+          name: "steps",
+          type: "string[]",
+          description: "Steps to resume",
           isOptional: false,
         },
         {
-          name: "resumeData",
-          type: "ResumeSchema",
-          description: "Data for resuming a suspended step",
-          isOptional: true,
-        },
-        {
-          name: "suspend",
-          type: "(suspendPayload: any) => Promise<void>",
-          description: "Function to suspend step execution",
+          name: "resumePayload",
+          type: "any",
+          description: "Payload data for resuming",
           isOptional: false,
         },
         {
-          name: "resume",
-          type: "object",
-          description: "Configuration for resuming execution",
+          name: "runId",
+          type: "string",
+          description: "ID of the run to resume",
           isOptional: true,
-          properties: [
-            {
-              name: "steps",
-              type: "string[]",
-              description: "Steps to resume",
-              isOptional: false,
-            },
-            {
-              name: "resumePayload",
-              type: "any",
-              description: "Payload data for resuming",
-              isOptional: false,
-            },
-            {
-              name: "runId",
-              type: "string",
-              description: "ID of the run to resume",
-              isOptional: true,
-            },
-          ],
-        },
-        {
-          name: "emitter",
-          type: "object",
-          description: "Event emitter object",
-          isOptional: false,
-          properties: [
-            {
-              name: "emit",
-              type: "(event: string, data: any) => void",
-              description: "Function to emit events",
-              isOptional: false,
-            },
-          ],
         },
+      ],
+    },
+    {
+      name: "emitter",
+      type: "object",
+      description: "Event emitter object for workflow events",
+      isOptional: false,
+      properties: [
         {
-          name: "mastra",
-          type: "Mastra",
-          description: "Mastra instance",
+          name: "emit",
+          type: "(event: string, data: any) => void",
+          description: "Function to emit events",
           isOptional: false,
         },
       ],
     },
+    {
+      name: "mastra",
+      type: "Mastra",
+      description: "Mastra instance",
+      isOptional: false,
+    },
+    {
+      name: "runtimeContext",
+      type: "RuntimeContext",
+      description: "Runtime context data to use during workflow execution",
+      isOptional: true,
+    },
+    {
+      name: "abort",
+      type: "() => any",
+      description: "Function to abort workflow execution",
+      isOptional: false,
+    },
+    {
+      name: "abortSignal",
+      type: "AbortSignal",
+      description: "Abort signal for workflow execution",
+      isOptional: false,
+    },
+    {
+      name: "runCount",
+      type: "number",
+      description: "Number of times the workflow has been run",
+      isOptional: true,
+    },
   ]}
 />
 
@@ -129,11 +119,13 @@ const myStep = createStep({
     {
       name: "result",
       type: "Promise<z.infer<TOutput>>",
-      description: "A promise that resolves to the output of the executed step",
+      description: "A promise that resolves to the output of the executed workflow",
     },
   ]}
 />
 
 ## Related
 
+- [Workflow.createRunAsync()](./create-run.mdx) - Alternative method for creating workflow runs
+- [WorkflowRun.start()](./start.mdx) - Starting workflow execution
 - [Running workflows](../../docs/workflows/overview.mdx#running-workflows)

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

@@ -1,16 +1,16 @@
 ---
-title: "Reference: Workflow.foreach() | Building Workflows | Mastra Docs"
-description: Documentation for the `.foreach()` method in workflows, which creates a loop that executes a step for each item in an array.
+title: "Reference: Workflow.foreach() | Workflows | Mastra Docs"
+description: Documentation for the `Workflow.foreach()` method in workflows, which creates a loop that executes a step for each item in an array.
 ---
 
 # Workflow.foreach()
 
 The `.foreach()` method creates a loop that executes a step for each item in an array.
 
-## Usage
+## Usage example
 
-```typescript
-workflow.foreach(stepOne, { concurrency: 2 });
+```typescript copy
+workflow.foreach(step1, { concurrency: 2 });
 ```
 
 ## Parameters

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

@@ -1,62 +1,16 @@
 ---
-title: "Reference: Workflow.map() | Building Workflows | Mastra Docs"
-description: Documentation for the `.map()` method in workflows, which maps output data from a previous step to the input of a subsequent step.
+title: "Reference: Workflow.map() | Workflows | Mastra Docs"
+description: Documentation for the `Workflow.map()` method in workflows, which maps output data from a previous step to the input of a subsequent step.
 ---
 
 # Workflow.map()
 
 The `.map()` method maps output data from a previous step to the input of a subsequent step, allowing you to transform data between steps.
 
-## Usage
+## Usage example
 
-```typescript
-const step1 = createStep({
-  id: "step1",
-  inputSchema: z.object({
-    inputValue: z.string(),
-  }),
-  outputSchema: z.object({
-    outputValue: z.string(),
-  }),
-  execute: async ({ inputData }) => {
-    return { outputValue: inputData.inputValue };
-  },
-});
-
-const step2 = createStep({
-  id: "step2",
-  inputSchema: z.object({
-    unexpectedName: z.string(),
-  }),
-  outputSchema: z.object({
-    result: z.string(),
-  }),
-  execute: async ({ inputData }) => {
-    return { result: inputData.unexpectedName };
-  },
-});
-
-const workflow = createWorkflow({
-  id: "my-workflow",
-  steps: [step1, step2],
-  inputSchema: z.object({
-    inputValue: z.string(),
-  }),
-  outputSchema: z.object({
-    result: z.string(),
-  }),
-});
-
-workflow
-  .then(step1)
-  .map({
-    unexpectedName: {
-      step: step1,
-      path: "outputValue",
-    },
-  })
-  .then(step2)
-  .commit();
+```typescript copy
+workflow.map(async ({ inputData }) => `${inputData.value} - map`
 ```
 
 ## Parameters
@@ -64,49 +18,10 @@ workflow
 <PropertiesTable
   content={[
     {
-      name: "mappingConfig",
-      type: "object",
-      description:
-        "Configuration object that defines how data should be mapped between workflow steps, either as a mapping object or a mapping function",
+      name: "mappingFunction",
+      type: "(params: { inputData: any }) => any",
+      description: "Function that transforms input data and returns the mapped result",
       isOptional: false,
-      properties: [
-        {
-          name: "step",
-          type: "Step | Step[]",
-          description: "The step(s) to map output from",
-          isOptional: true,
-        },
-        {
-          name: "path",
-          type: "string",
-          description: "Path to the output value in the step result",
-          isOptional: true,
-        },
-        {
-          name: "value",
-          type: "any",
-          description: "Static value to map",
-          isOptional: true,
-        },
-        {
-          name: "schema",
-          type: "ZodType",
-          description: "Schema for validating the mapped value",
-          isOptional: true,
-        },
-        {
-          name: "initData",
-          type: "Step",
-          description: "Step containing initial workflow data to map from",
-          isOptional: true,
-        },
-        {
-          name: "runtimeContextPath",
-          type: "string",
-          description: "Path to value in runtime context",
-          isOptional: true,
-        },
-      ],
     },
   ]}
 />

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

@@ -1,16 +1,16 @@
 ---
-title: "Reference: Workflow.parallel() | Building Workflows | Mastra Docs"
-description: Documentation for the `.parallel()` method in workflows, which executes multiple steps in parallel.
+title: "Reference: Workflow.parallel() | Workflows | Mastra Docs"
+description: Documentation for the `Workflow.parallel()` method in workflows, which executes multiple steps in parallel.
 ---
 
 # Workflow.parallel()
 
 The `.parallel()` method executes multiple steps in parallel.
 
-## Usage
+## Usage example
 
-```typescript
-workflow.parallel([stepOne, stepTwo]);
+```typescript copy
+workflow.parallel([step1, step2]);
 ```
 
 ## Parameters

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

@@ -1,65 +1,52 @@
 ---
-title: "Reference: Workflow.resume() | Building Workflows | Mastra Docs"
-description: Documentation for the `.resume()` method in workflows, which resumes a suspended workflow run with new data.
+title: "Reference: WorkflowRun.resume() | Workflows | Mastra Docs"
+description: Documentation for the `WorkflowRun.resume()` method in workflows, which resumes a suspended workflow run with new data.
 ---
 
-# Workflow.resume()
+# WorkflowRun.resume()
 
 The `.resume()` method resumes a suspended workflow run with new data, allowing you to continue execution from a specific step.
 
-## Usage
+## Usage example
 
-```typescript
-const run = await counterWorkflow.createRunAsync();
-const result = await run.start({ inputData: { startValue: 0 } });
+```typescript showLineNumbers copy
+const run = await workflow.createRunAsync();
+
+const result = await run.start({ inputData: { value: "initial data" } });
 
 if (result.status === "suspended") {
   const resumedResults = await run.resume({
-    resumeData: { newValue: 0 },
+    resumeData: { value: "resume data" }
   });
 }
 ```
-
-
-For more advanced scenarios where you need to specify the exact step to resume:
-
-```typescript
-await run.resume({
-  step: result.suspended[0], // Explicitly choose which step to resume
-  resumeData: { newValue: 0 },
-});
-```
-> **Note**: When exactly one step is suspended, you can omit the `step` parameter and the workflow will automatically resume that step. For workflows with multiple suspended steps, you must explicitly specify which step to resume.
-
 ## Parameters
 
 <PropertiesTable
   content={[
     {
-      name: "params",
-      type: "object",
-      description: "Configuration object for resuming the workflow run",
-      isOptional: false,
-      properties: [
-        {
-          name: "resumeData",
-          type: "ResumeSchema",
-          description: "Data for resuming the suspended step",
-          isOptional: true,
-        },
-        {
-          name: "step",
-          type: "Step | Step[] | string | string[]",
-          description: "The step(s) to resume execution from. When omitted, the workflow will automatically resume the suspended step if exactly one step is suspended. Throws an error if multiple steps are suspended and no step is specified.",
-          isOptional: true,
-        },
-        {
-          name: "runtimeContext",
-          type: "RuntimeContext",
-          description: "Runtime context data to use when resuming",
-          isOptional: true,
-        },
-      ],
+      name: "resumeData",
+      type: "z.infer<TResumeSchema>",
+      description: "Data for resuming the suspended step",
+      isOptional: true,
+    },
+    {
+      name: "step",
+      type: "Step<string, any, any, TResumeSchema, any, TEngineType> | [...Step<string, any, any, any, any, TEngineType>[], Step<string, any, any, TResumeSchema, any, TEngineType>] | string | string[]",
+      description: "The step(s) to resume execution from. Can be a Step instance, array of Steps, step ID string, or array of step ID strings",
+      isOptional: true,
+    },
+    {
+      name: "runtimeContext",
+      type: "RuntimeContext",
+      description: "Runtime context data to use when resuming",
+      isOptional: true,
+    },
+    {
+      name: "runCount",
+      type: "number",
+      description: "Optional run count for nested workflow execution",
+      isOptional: true,
     },
   ]}
 />
@@ -69,14 +56,25 @@ await run.resume({
 <PropertiesTable
   content={[
     {
-      name: "resumedResults",
+      name: "result",
       type: "Promise<WorkflowResult<TOutput, TSteps>>",
-      description:
-        "A promise that resolves to the result of the resumed workflow run",
+      description: "A promise that resolves to the workflow execution result containing step outputs and status",
     },
   ]}
 />
 
+## Extended usage example
+
+```typescript showLineNumbers copy
+if (result.status === "suspended") {
+  const resumedResults = await run.resume({
+    step: result.suspended[0],
+    resumeData: { value: "resume data" }
+  });
+}
+```
+> **Note**: When exactly one step is suspended, you can omit the `step` parameter and the workflow will automatically resume that step. For workflows with multiple suspended steps, you must explicitly specify which step to resume.
+
 ## Related
 
 - [Suspend and resume](../../docs/workflows/suspend-and-resume.mdx)

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

@@ -1,16 +1,16 @@
 ---
-title: "Reference: Workflow.sendEvent() | Building Workflows | Mastra Docs"
-description: Documentation for the `.sendEvent()` method in workflows, which resumes execution when an event is sent.
+title: "Reference: Workflow.sendEvent() | Workflows | Mastra Docs"
+description: Documentation for the `Workflow.sendEvent()` method in workflows, which resumes execution when an event is sent.
 ---
 
 # Workflow.sendEvent()
 
 The `.sendEvent()` resumes execution when an event is sent.
 
-## Usage
+## Usage example
 
-```typescript
-workflow.sendEvent('my-event-name', step1);
+```typescript copy
+workflow.sendEvent('event-name', step1);
 ```
 
 ## Parameters

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

@@ -1,16 +1,16 @@
 ---
-title: "Reference: Workflow.sleep() | Building Workflows | Mastra Docs"
-description: Documentation for the `.sleep()` method in workflows, which pauses execution for a specified number of milliseconds.
+title: "Reference: Workflow.sleep() | Workflows | Mastra Docs"
+description: Documentation for the `Workflow.sleep()` method in workflows, which pauses execution for a specified number of milliseconds.
 ---
 
 # Workflow.sleep()
 
 The `.sleep()` method pauses execution for a specified number of milliseconds.
 
-## Usage
+## Usage example
 
-```typescript
-workflow.sleep(1000);
+```typescript copy
+workflow.sleep(5000);
 ```
 
 ## Parameters

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

@@ -1,16 +1,16 @@
 ---
-title: "Reference: Workflow.sleepUntil() | Building Workflows | Mastra Docs"
-description: Documentation for the `.sleepUntil()` method in workflows, which pauses execution until a specified date.
+title: "Reference: Workflow.sleepUntil() | Workflows | Mastra Docs"
+description: Documentation for the `Workflow.sleepUntil()` method in workflows, which pauses execution until a specified date.
 ---
 
 # Workflow.sleepUntil()
 
 The `.sleepUntil()` method pauses execution until a specified date.
 
-## Usage
+## Usage example
 
-```typescript
-workflow.sleepUntil(new Date(Date.now() + 1000));
+```typescript copy
+workflow.sleepUntil(new Date(Date.now() + 5000));
 ```
 
 ## Parameters
@@ -18,9 +18,9 @@ workflow.sleepUntil(new Date(Date.now() + 1000));
 <PropertiesTable
   content={[
     {
-      name: "date",
-      type: "Date",
-      description: "The date until which to pause execution",
+      name: "dateOrCallback",
+      type: "Date | ((params: ExecuteFunctionParams) => Promise<Date>)",
+      description: "Either a Date object or a callback function that returns a Date. The callback receives execution context and can compute the target time dynamically based on input data.",
       isOptional: false,
     },
   ]}
@@ -38,6 +38,14 @@ workflow.sleepUntil(new Date(Date.now() + 1000));
   ]}
 />
 
+## Extended usage example
+
+```typescript showLineNumbers copy
+workflow.sleepUntil(async ({ inputData }) => {
+  return new Date(Date.now() + inputData.value);
+});
+```
+
 ## Related
 
 - [Sleep & Events](../../docs/workflows/pausing-execution.mdx)