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

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

@@ -1,21 +1,20 @@
 ---
-title: "Reference: Workflow.start() | Building Workflows | Mastra Docs"
-description: Documentation for the `.start()` method in workflows, which starts a workflow run with input data.
+title: "Reference: WorkflowRun.start() | Workflows | Mastra Docs"
+description: Documentation for the `WorkflowRun.start()` method in workflows, which starts a workflow run with input data.
 ---
 
-# Workflow.start()
+# WorkflowRun.start()
 
 The `.start()` method starts a workflow run with input data, allowing you to execute the workflow from the beginning.
 
-## Usage
+## Usage example
 
-```typescript
-const run = await myWorkflow.createRunAsync();
+```typescript showLineNumbers copy
+const run = await workflow.createRunAsync();
 
-// Start the workflow with input data
 const result = await run.start({
   inputData: {
-    startValue: "initial data",
+    value: "initial data",
   },
 });
 ```
@@ -25,24 +24,22 @@ const result = await run.start({
 <PropertiesTable
   content={[
     {
-      name: "params",
-      type: "object",
-      description: "Configuration object for starting the workflow run",
-      isOptional: false,
-      properties: [
-        {
-          name: "inputData",
-          type: "z.infer<TInput>",
-          description: "Input data matching the workflow's input schema",
-          isOptional: true,
-        },
-        {
-          name: "runtimeContext",
-          type: "RuntimeContext",
-          description: "Runtime context data to use when starting the workflow",
-          isOptional: true,
-        },
-      ],
+      name: "inputData",
+      type: "z.infer<TInput>",
+      description: "Input data that matches the workflow's input schema",
+      isOptional: true,
+    },
+    {
+      name: "runtimeContext",
+      type: "RuntimeContext",
+      description: "Runtime context data to use during workflow execution",
+      isOptional: true,
+    },
+    {
+      name: "writableStream",
+      type: "WritableStream<ChunkType>",
+      description: "Optional writable stream for streaming workflow output",
+      isOptional: true,
     },
   ]}
 />
@@ -54,11 +51,29 @@ const result = await run.start({
     {
       name: "result",
       type: "Promise<WorkflowResult<TOutput, TSteps>>",
-      description: "A promise that resolves to the result of the workflow run",
+      description: "A promise that resolves to the workflow execution result containing step outputs and status",
     },
   ]}
 />
 
+## Extended usage example
+
+```typescript showLineNumbers copy
+import { RuntimeContext } from "@mastra/core/runtime-context";
+
+const run = await workflow.createRunAsync();
+
+const runtimeContext = new RuntimeContext();
+runtimeContext.set("variable", false);
+
+const result = await run.start({
+  inputData: {
+    value: "initial data"
+  },
+  runtimeContext
+});
+```
+
 ## Related
 
 - [Running workflows](../../docs/workflows/overview.mdx#running-workflows)

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

@@ -1,48 +1,34 @@
 ---
-title: "Reference: Step | Building Workflows | Mastra Docs"
-description: Documentation for the Step class, which defines individual units of work within a workflow.
+title: "Reference: Step Class | Workflows | Mastra Docs"
+description: Documentation for the Step class in Mastra, which defines individual units of work within a workflow.
 ---
 
-# Step
+# Step Class
 
 The Step class defines individual units of work within a workflow, encapsulating execution logic, data validation, and input/output handling.
 It can take either a tool or an agent as a parameter to automatically create a step from them.
 
-## Usage
+## Usage example
 
-```typescript
-import { createStep } from "@mastra/core/workflows";
+```typescript filename="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
+import { createWorkflow, createStep } from "@mastra/core/workflows";
 import { z } from "zod";
 
-const processOrder = createStep({
-  id: "processOrder",
+const step1 = createStep({
+  id: "step-1",
+  description: "passes value from input to output",
   inputSchema: z.object({
-    orderId: z.string(),
-    userId: z.string(),
+    value: z.number()
   }),
   outputSchema: z.object({
-    status: z.string(),
-    orderId: z.string(),
+    value: z.number()
   }),
-  resumeSchema: z.object({
-    orderId: z.string(),
-  }),
-  suspendSchema: z.object({}),
-  execute: async ({
-    inputData,
-    mastra,
-    getStepResult,
-    getInitData,
-    suspend,
-    runtimeContext,
-    runCount
-    runId,
-  }) => {
+  execute: async ({ inputData }) => {
+    const { value } = inputData;
     return {
-      status: "processed",
-      orderId: inputData.orderId,
+      value
     };
-  },
+  }
 });
 ```
 

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

@@ -1,234 +1,84 @@
 ---
-title: "Reference: Workflow.stream() | Building Workflows | Mastra Docs"
-description: Documentation for the `.stream()` method in workflows, which allows you to monitor the execution of a workflow run as a stream.
+title: "Reference: WorkflowRun.stream() | Workflows | Mastra Docs"
+description: Documentation for the `WorkflowRun.stream()` method in workflows, which allows you to monitor the execution of a workflow run as a stream.
 ---
 
-# Run.stream()
+# WorkflowRun.stream()
 
 The `.stream()` method allows you to monitor the execution of a workflow run, providing real-time updates on the status of steps.
 
-## Usage
+## Usage example
 
-```typescript
-const run = await myWorkflow.createRunAsync();
+```typescript showLineNumbers copy
+const run = await workflow.createRunAsync();
 
-// Add a stream to monitor execution
-const result = run.stream({ inputData: {...} });
-
-
-for (const chunk of stream) {
-  // do something with the chunk
-}
+const stream = await run.stream({
+  inputData: {
+    value: "initial data",
+  },
+});
 ```
 
-## Messages
+## Parameters
 
 <PropertiesTable
   content={[
     {
-      name: "start",
-      type: "object",
-      description: "The workflow starts",
-      isOptional: false,
-      properties: [
-        {
-          type: "object",
-          parameters: [
-            {
-              name: "example",
-              type: "{ type: 'start', payload: { runId: '1' } }",
-              description: "Example message structure",
-              isOptional: false,
-            },
-          ],
-        },
-      ],
-    },
-    {
-      name: "step-start",
-      type: "object",
-      description: "The start of a step",
-      isOptional: false,
-      properties: [
-        {
-          type: "object",
-          parameters: [
-            {
-              name: "example",
-              type: "{ type: 'step-start', payload: { id: 'fetch-weather' } }",
-              description: "Example message structure",
-              isOptional: false,
-            },
-          ],
-        },
-      ],
-    },
-    {
-      name: "tool-call",
-      type: "object",
-      description: "A tool call has started",
-      isOptional: false,
-      properties: [
-        {
-          type: "object",
-          parameters: [
-            {
-              name: "example",
-              type: "{ type: 'tool-call', toolCallId: 'weatherAgent', toolName: 'Weather Agent', args: { prompt: 'Based on the following weather forecast for New York, suggest appropriate activities:...' } }",
-              description: "Example message structure",
-              isOptional: false,
-            },
-          ],
-        },
-      ],
-    },
-    {
-      name: "tool-call-streaming-start",
-      type: "object",
-      description: "A tool call/agent has started",
-      isOptional: false,
-      properties: [
-        {
-          type: "object",
-          parameters: [
-            {
-              name: "example",
-              type: "{ type: 'tool-call-streaming-start', toolCallId: 'weatherAgent', toolName: 'Weather Agent', args: { prompt: 'Based on the following weather forecast for New York, suggest appropriate activities:...' } }",
-              description: "Example message structure",
-              isOptional: false,
-            },
-          ],
-        },
-      ],
+      name: "inputData",
+      type: "z.infer<TInput>",
+      description: "Input data that matches the workflow's input schema",
+      isOptional: true,
     },
     {
-      name: "tool-call-delta",
-      type: "object",
-      description: "The delta of the tool output",
-      isOptional: false,
-      properties: [
-        {
-          type: "object",
-          parameters: [
-            {
-              name: "example",
-              type: "{ type: 'tool-call-delta', toolCallId: 'weatherAgent', toolName: 'Weather Agent', args: { prompt: 'Based on the following weather forecast for New York, suggest appropriate activities:\\n' + '            [\\n' + '  {\\n' + '    \"date\": \"2025-05-16\",\\n' + '    \"maxTemp\": 22.2,\\n' + '    \"minTemp\": 16,\\n' + '    \"precipitationChance\": 5,\\n' + '    \"condition\": \"Dense drizzle\",\\n' + '    \"location\": \"New York\"\\n' + '  },\\n' + '            ' }, argsTextDelta: '📅' }",
-              description: "Example message structure",
-              isOptional: false,
-            },
-          ],
-        },
-      ],
-    },
-    {
-      name: "step-result",
-      type: "object",
-      description: "The result of a step",
-      isOptional: false,
-      properties: [
-        {
-          type: "object",
-          parameters: [
-            {
-              name: "example",
-              type: "{ type: 'step-result', payload: { id: 'Weather Agent', status: 'success', output: [Object] } }",
-              description: "Example message structure",
-              isOptional: false,
-            },
-          ],
-        },
-      ],
-    },
-    {
-      name: "step-finish",
-      type: "object",
-      description: "The end of a step",
-      isOptional: false,
-      properties: [
-        {
-          type: "object",
-          parameters: [
-            {
-              name: "example",
-              type: "{ type: 'step-finish', payload: { id: 'Weather Agent', metadata: {} } }",
-              description: "Example message structure",
-              isOptional: false,
-            },
-          ],
-        },
-      ],
-    },
-    {
-      name: "finish",
-      type: "object",
-      description: "The end of the workflow",
-      isOptional: false,
-      properties: [
-        {
-          type: "object",
-          parameters: [
-            {
-              name: "example",
-              type: "{ type: 'finish', payload: { runId: '1' } }",
-              description: "Example message structure",
-              isOptional: false,
-            },
-          ],
-        },
-      ],
+      name: "runtimeContext",
+      type: "RuntimeContext",
+      description: "Runtime context data to use during workflow execution",
+      isOptional: true,
     },
   ]}
 />
 
-## Parameters
+## Returns
 
 <PropertiesTable
   content={[
     {
-      name: "params",
-      type: "object",
-      description: "Configuration object for starting the workflow run",
-      isOptional: false,
-      properties: [
-        {
-          name: "inputData",
-          type: "z.infer<TInput>",
-          parameters: [
-            {
-              name: "z.infer<TInput>",
-              type: "inputData",
-              description:
-                "Runtime context data to use when starting the workflow",
-              isOptional: true,
-            },
-          ],
-        },
-        {
-          name: "runtimeContext",
-          type: "RuntimeContext",
-          parameters: [
-            {
-              name: "runtimeContext",
-              type: "RuntimeContext",
-              description:
-                "Runtime context data to use when starting the workflow",
-              isOptional: true,
-            },
-          ],
-        },
-      ],
+      name: "stream",
+      type: "ReadableStream<StreamEvent>",
+      description: "A readable stream that emits workflow execution events in real-time",
     },
-  ]}
-/>
-
-## Returns
-
-<PropertiesTable
-  content={[
     {
-      name: "result",
-      type: "Promise<WorkflowResult<TOutput, TSteps>>",
-      description: "A stream that pipes each step to the stream",
+      name: "getWorkflowState",
+      type: "() => Promise<WorkflowResult<TOutput, TSteps>>",
+      description: "A function that returns a promise resolving to the final workflow result",
     },
   ]}
 />
+
+## Extended usage example
+
+```typescript showLineNumbers copy
+const { getWorkflowState } = await run.stream({
+  inputData: {
+    value: "initial data"
+  }
+});
+
+const result = await getWorkflowState();
+```
+
+## Stream Events
+
+The stream emits various event types during workflow execution. Each event has a `type` field and a `payload` containing relevant data:
+
+- **`start`**: Workflow execution begins
+- **`step-start`**: A step begins execution
+- **`tool-call`**: A tool call is initiated
+- **`tool-call-streaming-start`**: Tool call streaming begins
+- **`tool-call-delta`**: Incremental tool output updates
+- **`step-result`**: A step completes with results
+- **`step-finish`**: A step finishes execution
+- **`finish`**: Workflow execution completes
+
+
+