@mastra/mcp-docs-server 1.0.0-beta.11 → 1.0.0-beta.14

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

@@ -9,15 +9,14 @@ Workflow steps can call agents to leverage LLM reasoning or call tools for type-
 
 ## Using agents in workflows
 
-Use agents in workflow steps when you need reasoning, language generation, or other LLM-based tasks. Call from a step's `execute` function for more control over the agent call (e.g., track conversation history or return structured output). Compose agents as steps when you don't need to modify how the agent is invoked.
+Use agents in workflow steps when you need reasoning, language generation, or other LLM-based tasks. Call from a step's `execute` function for more control over the agent call (e.g., track message history or return structured output). Compose agents as steps when you don't need to modify how the agent is invoked.
 
 ### Calling agents
 
 Call agents inside a step's `execute` function using `.generate()` or `.stream()`. This lets you modify the agent call and handle the response before passing it to the next step.
 
-```typescript {7-12} title="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
+```typescript {6-14} title="src/mastra/workflows/test-workflow.ts"
 const step1 = createStep({
-  // ...
   execute: async ({ inputData, mastra }) => {
     const { message } = inputData;
 
@@ -45,13 +44,12 @@ Compose an agent as a step using `createStep()` when you don't need to modify th
 
 ![Agent as step](/img/workflows/workflows-agent-tools-agent-step.jpg)
 
-```typescript {1,3,8-13} title="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
+```typescript {1,3,7-12} title="src/mastra/workflows/test-workflow.ts"
 import { testAgent } from "../agents/test-agent";
 
 const step1 = createStep(testAgent);
 
 export const testWorkflow = createWorkflow({
-  // ...
 })
   .map(async ({ inputData }) => {
     const { message } = inputData;
@@ -64,7 +62,11 @@ export const testWorkflow = createWorkflow({
   .commit();
 ```
 
-> See [Input Data Mapping](./input-data-mapping) for more information.
+:::info
+
+Visit [Input Data Mapping](./input-data-mapping) for more information.
+
+:::
 
 When no `structuredOutput` option is provided, Mastra agents use a default schema that expects a `prompt` string as input and returns a `text` string as output:
 
@@ -83,7 +85,7 @@ When no `structuredOutput` option is provided, Mastra agents use a default schem
 
 When you need the agent to return structured data instead of plain text, pass the `structuredOutput` option to `createStep()`. The step's output schema will match your provided schema, enabling type-safe chaining to subsequent steps.
 
-```typescript {1-6,8-10} title="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
+```typescript {1-6,8-10} title="src/mastra/workflows/test-workflow.ts"
 const articleSchema = z.object({
   title: z.string(),
   summary: z.string(),
@@ -104,9 +106,7 @@ const processStep = createStep({
   }),
 });
 
-export const testWorkflow = createWorkflow({
-  // ...
-})
+export const testWorkflow = createWorkflow({})
   .map(async ({ inputData }) => ({
     prompt: `Generate an article about: ${inputData.topic}`,
   }))
@@ -117,7 +117,11 @@ export const testWorkflow = createWorkflow({
 
 The `structuredOutput.schema` option accepts any Zod schema. The agent will generate output conforming to this schema, and the step's `outputSchema` will be automatically set to match.
 
-> See [Structured Output](/docs/v1/agents/structured-output) for more options like error handling strategies and streaming with structured output.
+:::info
+
+Visit [Structured Output](/docs/v1/agents/structured-output) for more options like error handling strategies and streaming with structured output.
+
+:::
 
 ## Using tools in workflows
 
@@ -127,11 +131,10 @@ Use tools in workflow steps to leverage existing tool logic. Call from a step's
 
 Call tools inside a step's `execute` function using `.execute()`. This gives you more control over the tool's input context, or process its response before passing it to the next step.
 
-```typescript {8-13,16} title="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
+```typescript {7-12} title="src/mastra/workflows/test-workflow.ts"
 import { testTool } from "../tools/test-tool";
 
 const step2 = createStep({
-  // ...
   execute: async ({ inputData, requestContext }) => {
     const { formatted } = inputData;
 
@@ -149,7 +152,11 @@ const step2 = createStep({
 });
 ```
 
-> See [Calling Tools](/docs/v1/workflows/agents-and-tools#calling-tools) for more examples.
+:::info
+
+Visit [Calling Tools](/docs/v1/workflows/agents-and-tools#calling-tools) for more examples.
+
+:::
 
 ### Tools as steps
 
@@ -157,14 +164,12 @@ Compose a tool as a step using `createStep()` when the previous step's output ma
 
 ![Tool as step](/img/workflows/workflows-agent-tools-tool-step.jpg)
 
-```typescript {1,3,9-14} title="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
+```typescript {1,3,7-12} title="src/mastra/workflows/test-workflow.ts"
 import { testTool } from "../tools/test-tool";
 
 const step2 = createStep(testTool);
 
-export const testWorkflow = createWorkflow({
-  // ...
-})
+export const testWorkflow = createWorkflow({})
   .then(step1)
   .map(async ({ inputData }) => {
     const { formatted } = inputData;
@@ -176,7 +181,11 @@ export const testWorkflow = createWorkflow({
   .commit();
 ```
 
-> See [Input Data Mapping](./input-data-mapping) for more information.
+:::info
+
+Visit [Input Data Mapping](./input-data-mapping) for more information.
+
+:::
 
 ## Related
 

package/.docs/raw/workflows/control-flow.mdx

@@ -22,9 +22,8 @@ Use `.then()` to run steps in order, allowing each step to access the result of
 
 ![Chaining steps with .then()](/img/workflows/workflows-control-flow-then.jpg)
 
-```typescript {30-31} title="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
+```typescript {27-28} title="src/mastra/workflows/test-workflow.ts"
 const step1 = createStep({
-  //...
   inputSchema: z.object({
     message: z.string()
   }),
@@ -34,7 +33,6 @@ const step1 = createStep({
 });
 
 const step2 = createStep({
-  // ...
   inputSchema: z.object({
     formatted: z.string()
   }),
@@ -44,7 +42,6 @@ const step2 = createStep({
 });
 
 export const testWorkflow = createWorkflow({
-  // ...
   inputSchema: z.object({
     message: z.string()
   }),
@@ -63,15 +60,13 @@ Use `.parallel()` to run steps at the same time. All parallel steps must complet
 
 ![Concurrent steps with .parallel()](/img/workflows/workflows-control-flow-parallel.jpg)
 
-```typescript {42} title="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
+```typescript {39} title="src/mastra/workflows/test-workflow.ts"
 const step1 = createStep({
   id: "step-1",
-  // ...
 });
 
 const step2 = createStep({
   id: "step-2",
-  // ...
 });
 
 const step3 = createStep({
@@ -97,7 +92,6 @@ const step3 = createStep({
 });
 
 export const testWorkflow = createWorkflow({
-  // ...
   inputSchema: z.object({
     message: z.string()
   }),
@@ -116,7 +110,7 @@ export const testWorkflow = createWorkflow({
 
 When steps run in parallel, the output is an object where each key is the step's `id` and the value is that step's output. This allows you to access each parallel step's result independently.
 
-```typescript title="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
+```typescript title="src/mastra/workflows/test-workflow.ts"
 const step1 = createStep({
   id: "format-step",
   inputSchema: z.object({ message: z.string() }),
@@ -176,7 +170,11 @@ export const testWorkflow = createWorkflow({
 - The next step receives an object containing all parallel step outputs
 - You must define the `inputSchema` of the following step to match this structure
 
-> See [Choosing the right pattern](#choosing-the-right-pattern) to understand when to use `.parallel()` vs `.foreach()`.
+:::info
+
+Visit [Choosing the right pattern](#choosing-the-right-pattern) to understand when to use `.parallel()` vs `.foreach()`.
+
+:::
 
 ## Conditional logic with `.branch()`
 
@@ -184,11 +182,10 @@ Use `.branch()` to choose which step to run based on a condition. All steps in a
 
 ![Conditional branching with .branch()](/img/workflows/workflows-control-flow-branch.jpg)
 
-```typescript {33-36} title="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
+```typescript {30-33} title="src/mastra/workflows/test-workflow.ts"
 const step1 = createStep({...})
 
 const stepA = createStep({
-  // ...
   inputSchema: z.object({
     value: z.number()
   }),
@@ -198,7 +195,6 @@ const stepA = createStep({
 });
 
 const stepB = createStep({
-  // ...
   inputSchema: z.object({
     value: z.number()
   }),
@@ -208,7 +204,6 @@ const stepB = createStep({
 });
 
 export const testWorkflow = createWorkflow({
-  // ...
   inputSchema: z.object({
     value: z.number()
   }),
@@ -228,7 +223,7 @@ export const testWorkflow = createWorkflow({
 
 When using conditional branching, only one branch executes based on which condition evaluates to `true` first. The output structure is similar to `.parallel()`, where the result is keyed by the executed step's `id`.
 
-```typescript title="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
+```typescript title="src/mastra/workflows/test-workflow.ts"
 const step1 = createStep({
   id: "initial-step",
   inputSchema: z.object({ value: z.number() }),
@@ -309,7 +304,7 @@ When using `.then()`, `.parallel()`, or `.branch()`, it is sometimes necessary t
 
 ![Mapping with .map()](/img/workflows/workflows-data-mapping-map.jpg)
 
-```typescript {9} title="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
+```typescript {9} title="src/mastra/workflows/test-workflow.ts"
 const step1 = createStep({...});
 const step2 = createStep({...});
 
@@ -337,7 +332,7 @@ The `.map()` method provides additional helper functions for more complex mappin
 
 When working with `.parallel()` or `.branch()` outputs, you can use `.map()` to transform the data structure before passing it to the next step. This is especially useful when you need to flatten or restructure the output.
 
-```typescript title="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
+```typescript title="src/mastra/workflows/test-workflow.ts"
 export const testWorkflow = createWorkflow({...})
   .parallel([step1, step2])
   .map(async ({ inputData }) => {
@@ -352,7 +347,7 @@ export const testWorkflow = createWorkflow({...})
 
 You can also use the helper functions provided by `.map()`:
 
-```typescript title="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
+```typescript title="src/mastra/workflows/test-workflow.ts"
 export const testWorkflow = createWorkflow({...})
   .branch([
     [condition1, stepA],
@@ -380,11 +375,10 @@ Use `.dountil()` to run a step repeatedly until a condition becomes true.
 
 ![Repeating with .dountil()](/img/workflows/workflows-control-flow-dountil.jpg)
 
-```typescript {17} title="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
+```typescript {14} title="src/mastra/workflows/test-workflow.ts"
 const step1 = createStep({...});
 
 const step2 = createStep({
-  // ...
   execute: async ({ inputData }) => {
     const { number } = inputData;
     return {
@@ -393,9 +387,7 @@ const step2 = createStep({
   }
 });
 
-export const testWorkflow = createWorkflow({
-  // ...
-})
+export const testWorkflow = createWorkflow({})
   .then(step1)
   .dountil(step2, async ({ inputData: { number } }) => number > 10)
   .commit();
@@ -407,11 +399,10 @@ Use `.dowhile()` to run a step repeatedly while a condition remains true.
 
 ![Repeating with .dowhile()](/img/workflows/workflows-control-flow-dowhile.jpg)
 
-```typescript {17} title="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
+```typescript {14} title="src/mastra/workflows/test-workflow.ts"
 const step1 = createStep({...});
 
 const step2 = createStep({
-  // ...
   execute: async ({ inputData }) => {
     const { number } = inputData;
     return {
@@ -420,9 +411,7 @@ const step2 = createStep({
   }
 });
 
-export const testWorkflow = createWorkflow({
-  // ...
-})
+export const testWorkflow = createWorkflow({})
   .then(step1)
   .dowhile(step2, async ({ inputData: { number } }) => number < 10)
   .commit();
@@ -434,9 +423,8 @@ Use `.foreach()` to run the same step for each item in an array. The input must
 
 ![Repeating with .foreach()](/img/workflows/workflows-control-flow-foreach.jpg)
 
-```typescript {17} title="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
+```typescript {15} title="src/mastra/workflows/test-workflow.ts"
 const step1 = createStep({
-  // ...
   inputSchema: z.string(),
   outputSchema: z.string(),
   execute: async ({ inputData }) => {
@@ -447,7 +435,6 @@ const step1 = createStep({
 const step2 = createStep({...});
 
 export const testWorkflow = createWorkflow({
-  // ...
   inputSchema: z.array(z.string()),
   outputSchema: z.array(z.string())
 })
@@ -460,7 +447,7 @@ export const testWorkflow = createWorkflow({
 
 The `.foreach()` method always returns an array containing the output of each iteration. The order of outputs matches the order of inputs.
 
-```typescript title="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
+```typescript title="src/mastra/workflows/test-workflow.ts"
 const addTenStep = createStep({
   id: "add-ten",
   inputSchema: z.object({ value: z.number() }),
@@ -486,7 +473,7 @@ export const testWorkflow = createWorkflow({
 
 Use `concurrency` to control the number of array items processed at the same time. The default is `1`, which runs steps sequentially. Increasing the value allows `.foreach()` to process multiple items simultaneously.
 
-```typescript title="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
+```typescript title="src/mastra/workflows/test-workflow.ts"
 const step1 = createStep({...})
 
 export const testWorkflow = createWorkflow({...})
@@ -498,7 +485,7 @@ export const testWorkflow = createWorkflow({...})
 
 Since `.foreach()` outputs an array, you can use `.then()` or `.map()` to aggregate or transform the results. The step following `.foreach()` receives the entire array as its input.
 
-```typescript title="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
+```typescript title="src/mastra/workflows/test-workflow.ts"
 const processItemStep = createStep({
   id: "process-item",
   inputSchema: z.object({ value: z.number() }),
@@ -535,7 +522,7 @@ export const testWorkflow = createWorkflow({
 
 You can also use `.map()` to transform the array output:
 
-```typescript title="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
+```typescript title="src/mastra/workflows/test-workflow.ts"
 export const testWorkflow = createWorkflow({...})
   .foreach(processItemStep)
   .map(async ({ inputData }) => ({
@@ -551,7 +538,7 @@ export const testWorkflow = createWorkflow({...})
 
 When you chain `.foreach()` calls, each operates on the array output of the previous step. This is useful when each item in your array needs to be transformed by multiple steps in sequence.
 
-```typescript title="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
+```typescript title="src/mastra/workflows/test-workflow.ts"
 const chunkStep = createStep({
   id: "chunk",
   // Takes a document, returns an array of chunks
@@ -589,7 +576,7 @@ For processing multiple documents where each produces multiple chunks, you have
 
 **Option 1: Process all documents in a single step with batching control**
 
-```typescript title="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
+```typescript title="src/mastra/workflows/test-workflow.ts"
 const downloadAndChunkStep = createStep({
   id: "download-and-chunk",
   inputSchema: z.array(z.string()),  // Array of URLs
@@ -614,7 +601,7 @@ export const multiDocWorkflow = createWorkflow({...})
 
 **Option 2: Use foreach for documents, aggregate chunks, then foreach for embeddings**
 
-```typescript title="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
+```typescript title="src/mastra/workflows/test-workflow.ts"
 const downloadStep = createStep({
   id: "download",
   inputSchema: z.string(),  // Single URL
@@ -660,7 +647,7 @@ export const multiDocWorkflow = createWorkflow({
 
 The step after `.foreach()` only executes after all iterations complete. If you need to run multiple sequential operations per item, use a nested workflow instead of chaining multiple `.foreach()` calls. This keeps all operations for each item together and makes the data flow clearer.
 
-```typescript title="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
+```typescript title="src/mastra/workflows/test-workflow.ts"
 // Define a workflow that processes a single document
 const processDocumentWorkflow = createWorkflow({
   id: "process-document",
@@ -820,7 +807,7 @@ Loop conditions can be implemented in different ways depending on how you want t
 
 Use `iterationCount` to limit how many times a loop runs. If the count exceeds your threshold, throw an error to fail the step and stop the workflow.
 
-```typescript title="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
+```typescript title="src/mastra/workflows/test-workflow.ts"
 const step1 = createStep({...});
 
 export const testWorkflow = createWorkflow({...})

package/.docs/raw/workflows/error-handling.mdx

@@ -5,20 +5,180 @@ description: "Learn how to handle errors in Mastra workflows using step retries,
 
 # Error Handling
 
-Mastra provides a built-in retry mechanism for workflows or steps that fail due to transient errors. This is particularly useful for steps that interact with external services or resources that might experience temporary unavailability.
+Mastra workflows support error handling through result status checks after execution, retry policies for transient failures, and lifecycle callbacks for centralized error logging or alerting.
+
+## Handling workflow results
+
+When you run a workflow, the result object contains the status and any errors that occurred.
+
+### Checking the result status
+
+```typescript title="src/run-workflow.ts"
+import { mastra } from "./mastra";
+
+const workflow = mastra.getWorkflow("myWorkflow");
+const run = await workflow.createRun();
+const result = await run.start({ inputData: { value: "test" } });
+
+switch (result.status) {
+  case 'success':
+    console.log('Workflow completed:', result.result);
+    break;
+  case 'failed':
+    console.error('Workflow failed:', result.error);
+    break;
+  case 'suspended':
+    console.log('Workflow suspended, waiting for resume');
+    break;
+}
+```
+
+### Result object structure
+
+The result object contains:
+
+- `status` - The workflow status: `'success'`, `'failed'`, `'suspended'`, or `'tripwire'`
+- `result` - The workflow output (when status is `'success'`)
+- `error` - Error details (when status is `'failed'`)
+- `steps` - Individual step results with their status and output
+
+### Accessing step results
+
+You can inspect individual step results to understand where a failure occurred:
+
+```typescript title="src/run-workflow.ts"
+const result = await run.start({ inputData: { value: "test" } });
+
+if (result.status === 'failed') {
+  // Find which step failed
+  for (const [stepId, stepResult] of Object.entries(result.steps)) {
+    if (stepResult.status === 'failed') {
+      console.error(`Step ${stepId} failed:`, stepResult.error);
+    }
+  }
+}
+```
+
+## Lifecycle callbacks
+
+For scenarios where you need to handle workflow completion without awaiting the result—such as background jobs, fire-and-forget workflows, or centralized logging—you can use lifecycle callbacks.
+
+### onFinish
+
+Called when a workflow completes with any status (success, failed, suspended, or tripwire):
+
+```typescript {8-15} title="src/mastra/workflows/order-workflow.ts"
+import { createWorkflow } from "@mastra/core/workflows";
+import { z } from "zod";
+
+const orderWorkflow = createWorkflow({
+  id: 'order-processing',
+  inputSchema: z.object({ orderId: z.string() }),
+  outputSchema: z.object({ orderId: z.string(), status: z.string() }),
+  options: {
+    onFinish: async (result) => {
+      await db.updateOrderStatus(result.result?.orderId, result.status);
+      await analytics.track('workflow_completed', {
+        workflowId: 'order-processing',
+        status: result.status,
+      });
+    },
+  },
+});
+```
+
+The `onFinish` callback receives:
+
+- `status` - The workflow status
+- `result` - The workflow output (on success)
+- `error` - Error details (on failure)
+- `steps` - Individual step results
+- `tripwire` - Tripwire info (if status is `'tripwire'`)
+
+### onError
+
+Called only when a workflow fails (status is `'failed'` or `'tripwire'`):
+
+```typescript {8-14} title="src/mastra/workflows/payment-workflow.ts"
+import { createWorkflow } from "@mastra/core/workflows";
+import { z } from "zod";
+
+const paymentWorkflow = createWorkflow({
+  id: 'payment-processing',
+  inputSchema: z.object({ amount: z.number() }),
+  outputSchema: z.object({ transactionId: z.string() }),
+  options: {
+    onError: async (errorInfo) => {
+      await alertService.notify({
+        channel: 'payments-alerts',
+        message: `Payment workflow failed: ${errorInfo.error?.message}`,
+      });
+      await errorTracker.capture(errorInfo.error);
+    },
+  },
+});
+```
+
+The `onError` callback receives:
+
+- `status` - Either `'failed'` or `'tripwire'`
+- `error` - Error details
+- `steps` - Individual step results
+- `tripwire` - Tripwire info (if status is `'tripwire'`)
+
+### Using both callbacks
+
+You can use both callbacks together:
+
+```typescript {8-16} title="src/mastra/workflows/pipeline-workflow.ts"
+import { createWorkflow } from "@mastra/core/workflows";
+import { z } from "zod";
+
+const pipelineWorkflow = createWorkflow({
+  id: 'data-pipeline',
+  inputSchema: z.object({ source: z.string() }),
+  outputSchema: z.object({ recordsProcessed: z.number() }),
+  options: {
+    onFinish: async (result) => {
+      // Always log completion
+      await logger.info('Pipeline completed', { status: result.status });
+    },
+    onError: async (errorInfo) => {
+      // Alert on failures
+      await pagerDuty.alert('Data pipeline failed', errorInfo.error);
+    },
+  },
+});
+```
+
+### Error handling in callbacks
+
+Errors thrown inside callbacks are caught and logged—they will not affect the workflow result or cause it to fail. This ensures that callback issues don't break your workflows in production.
+
+```typescript
+options: {
+  onFinish: async (result) => {
+    // If this throws, it's logged but the workflow result is unchanged
+    await externalService.notify(result);
+  },
+}
+```
+
+## Retries
+
+Mastra has a retry mechanism for workflows or steps that fail due to transient errors, for example when steps interact with external services or resources that may be temporarily unavailable.
 
 ## Workflow-level using `retryConfig`
 
 You can configure retries at the workflow level, which applies to all steps in the workflow:
 
-```typescript {8-11} title="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
+```typescript {7-10} title="src/mastra/workflows/test-workflow.ts"
 import { createWorkflow, createStep } from "@mastra/core/workflows";
 import { z } from "zod";
 
 const step1 = createStep({...});
 
 export const testWorkflow = createWorkflow({
-  // ...
   retryConfig: {
     attempts: 5,
     delay: 2000
@@ -32,14 +192,13 @@ export const testWorkflow = createWorkflow({
 
 You can configure retries for individual steps using the `retries` property. This overrides the workflow-level retry configuration for that specific step:
 
-```typescript {17} title="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
+```typescript {16} title="src/mastra/workflows/test-workflow.ts"
 import { createWorkflow, createStep } from "@mastra/core/workflows";
 import { z } from "zod";
 
 const step1 = createStep({
-  // ...
   execute: async () => {
-    const response = await // ...
+    const response = await fetch('example-url');
 
     if (!response.ok) {
       throw new Error('Error');
@@ -57,15 +216,14 @@ const step1 = createStep({
 
 You can create alternative workflow paths based on the success or failure of previous steps using conditional logic:
 
-```typescript {15,19,33-34} title="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
+```typescript {14,18,29-32} title="src/mastra/workflows/test-workflow.ts"
 import { createWorkflow, createStep } from "@mastra/core/workflows";
 import { z } from "zod";
 
 const step1 = createStep({
-  // ...
   execute: async () => {
     try {
-      const response = await // ...
+      const response = await fetch('example-url');
 
       if (!response.ok) {
         throw new Error('error');
@@ -85,9 +243,7 @@ const step1 = createStep({
 const step2 = createStep({...});
 const fallback = createStep({...});
 
-export const testWorkflow = createWorkflow({
-  // ...
-})
+export const testWorkflow = createWorkflow({})
   .then(step1)
   .branch([
     [async ({ inputData: { status } }) => status === "ok", step2],
@@ -100,16 +256,14 @@ export const testWorkflow = createWorkflow({
 
 Use `getStepResult()` to inspect a previous step’s results.
 
-```typescript {10} title="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
+```typescript {8} title="src/mastra/workflows/test-workflow.ts"
 import { createStep } from "@mastra/core/workflows";
 import { z } from "zod";
 
 const step1 = createStep({...});
 
 const step2 = createStep({
-  // ...
   execute: async ({ getStepResult }) => {
-
     const step1Result = getStepResult(step1);
 
     return {
@@ -123,7 +277,7 @@ const step2 = createStep({
 
 Use `bail()` in a step to exit early with a successful result. This returns the provided payload as the step output and ends workflow execution.
 
-```typescript {7} title="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
+```typescript {7} title="src/mastra/workflows/test-workflow.ts"
 import { createWorkflow, createStep } from "@mastra/core/workflows";
 import { z } from "zod";
 
@@ -145,7 +299,7 @@ export const testWorkflow = createWorkflow({...})
 
 Use `throw new Error()` in a step to exit with an error.
 
-```typescript {7} title="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
+```typescript {7} title="src/mastra/workflows/test-workflow.ts"
 import { createWorkflow, createStep } from "@mastra/core/workflows";
 import { z } from "zod";
 
@@ -167,7 +321,7 @@ export const testWorkflow = createWorkflow({...})
 
 You can monitor workflows for errors using `stream`:
 
-```typescript {11} title="src/test-workflow.ts" showLineNumbers copy
+```typescript {11} title="src/test-workflow.ts"
 import { mastra } from "../src/mastra";
 
 const workflow = mastra.getWorkflow("testWorkflow");