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

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

@@ -13,7 +13,7 @@ When you run a workflow, the result object contains the status and any errors th
 
 ### Checking the result status
 
-```typescript title="src/run-workflow.ts" showLineNumbers copy
+```typescript title="src/run-workflow.ts"
 import { mastra } from "./mastra";
 
 const workflow = mastra.getWorkflow("myWorkflow");
@@ -46,7 +46,7 @@ The result object contains:
 
 You can inspect individual step results to understand where a failure occurred:
 
-```typescript title="src/run-workflow.ts" showLineNumbers copy
+```typescript title="src/run-workflow.ts"
 const result = await run.start({ inputData: { value: "test" } });
 
 if (result.status === 'failed') {
@@ -67,7 +67,7 @@ For scenarios where you need to handle workflow completion without awaiting the
 
 Called when a workflow completes with any status (success, failed, suspended, or tripwire):
 
-```typescript {8-15} title="src/mastra/workflows/order-workflow.ts" showLineNumbers copy
+```typescript {8-15} title="src/mastra/workflows/order-workflow.ts"
 import { createWorkflow } from "@mastra/core/workflows";
 import { z } from "zod";
 
@@ -99,7 +99,7 @@ The `onFinish` callback receives:
 
 Called only when a workflow fails (status is `'failed'` or `'tripwire'`):
 
-```typescript {8-14} title="src/mastra/workflows/payment-workflow.ts" showLineNumbers copy
+```typescript {8-14} title="src/mastra/workflows/payment-workflow.ts"
 import { createWorkflow } from "@mastra/core/workflows";
 import { z } from "zod";
 
@@ -130,7 +130,7 @@ The `onError` callback receives:
 
 You can use both callbacks together:
 
-```typescript {8-16} title="src/mastra/workflows/pipeline-workflow.ts" showLineNumbers copy
+```typescript {8-16} title="src/mastra/workflows/pipeline-workflow.ts"
 import { createWorkflow } from "@mastra/core/workflows";
 import { z } from "zod";
 
@@ -172,14 +172,13 @@ Mastra has a retry mechanism for workflows or steps that fail due to transient e
 
 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
@@ -193,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');
@@ -218,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');
@@ -246,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],
@@ -261,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 {
@@ -284,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";
 
@@ -306,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";
 
@@ -328,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");

package/.docs/raw/workflows/human-in-the-loop.mdx

@@ -13,7 +13,7 @@ Human-in-the-loop input works much like [pausing a workflow](/docs/v1/workflows/
 
 ![Pausing a workflow with suspend()](/img/workflows/workflows-suspend.jpg)
 
-```typescript {12-17,22-26} title="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
+```typescript {12-17,22-26} title="src/mastra/workflows/test-workflow.ts"
 import { createWorkflow, createStep } from "@mastra/core/workflows";
 import { z } from "zod";
 
@@ -64,7 +64,7 @@ export const testWorkflow = createWorkflow({
 
 When a workflow is suspended, you can access the payload returned by `suspend()` by identifying the suspended step and reading its `suspendPayload`.
 
-```typescript {12} title="src/test-workflow.ts" showLineNumbers copy
+```typescript {12} title="src/test-workflow.ts"
 const workflow = mastra.getWorkflow("testWorkflow");
 const run = await workflow.createRun();
 
@@ -95,7 +95,7 @@ As with [restarting a workflow](/docs/v1/workflows/suspend-and-resume#restarting
 
 ![Restarting a workflow with resume()](/img/workflows/workflows-resume.jpg)
 
-```typescript {13} showLineNumbers copy
+```typescript {13}
 const workflow = mastra.getWorkflow("testWorkflow");
 const run = await workflow.createRun();
 
@@ -117,9 +117,8 @@ const handleResume = async () => {
 
 Use `bail()` to stop workflow execution at a step without triggering an error. This can be useful when a human explicitly rejects an action. The workflow completes with a `success` status, and any logic after the call to `bail()` is skipped.
 
-```typescript {7-11} showLineNumbers copy
+```typescript {6-10}
 const step1 = createStep({
-  // ...
   execute: async ({ inputData, resumeData, suspend, bail }) => {
     const { userEmail } = inputData;
     const { approved } = resumeData ?? {};
@@ -147,7 +146,7 @@ const step1 = createStep({
 
 For workflows that require input at multiple stages, the suspend pattern remains the same. Each step defines a `resumeSchema`, and `suspendSchema` typically with a reason that can be used to provide user feedback.
 
-```typescript {11-16,21-25} title="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
+```typescript {11-16,21-25} title="src/mastra/workflows/test-workflow.ts"
 const step1 = createStep({...});
 
 const step2 = createStep({
@@ -196,7 +195,7 @@ export const testWorkflow = createWorkflow({
 
 Each step must be resumed in sequence, with a separate call to `resume()` for each suspended step. This approach helps manage multi-step approvals with consistent UI feedback and clear input handling at each stage.
 
-```typescript {4,11} showLineNumbers copy
+```typescript {4,11}
 const handleResume = async () => {
   const result = await run.resume({
     step: "step-1",

package/.docs/raw/workflows/inngest-workflow.mdx

@@ -33,7 +33,7 @@ Initialize the Inngest integration to obtain Mastra-compatible workflow helpers.
 
 In development
 
-```ts showLineNumbers copy title="src/mastra/inngest/index.ts"
+```ts title="src/mastra/inngest/index.ts"
 import { Inngest } from "inngest";
 import { realtimeMiddleware } from "@inngest/realtime/middleware";
 
@@ -47,7 +47,7 @@ export const inngest = new Inngest({
 
 In production
 
-```ts showLineNumbers copy title="src/mastra/inngest/index.ts"
+```ts title="src/mastra/inngest/index.ts"
 import { Inngest } from "inngest";
 import { realtimeMiddleware } from "@inngest/realtime/middleware";
 
@@ -61,7 +61,7 @@ export const inngest = new Inngest({
 
 Define the individual steps that will compose your workflow:
 
-```ts showLineNumbers copy title="src/mastra/workflows/index.ts"
+```ts title="src/mastra/workflows/index.ts"
 import { z } from "zod";
 import { inngest } from "../inngest";
 import { init } from "@mastra/inngest";
@@ -88,7 +88,7 @@ const incrementStep = createStep({
 
 Compose the steps into a workflow using the `dountil` loop pattern. The createWorkflow function creates a function on inngest server that is invocable.
 
-```ts showLineNumbers copy title="src/mastra/workflows/index.ts"
+```ts title="src/mastra/workflows/index.ts"
 // workflow that is registered as a function on inngest server
 const workflow = createWorkflow({
   id: "increment-workflow",
@@ -109,7 +109,7 @@ export { workflow as incrementWorkflow };
 
 Register the workflow with Mastra and configure the Inngest API endpoint:
 
-```ts showLineNumbers copy title="src/mastra/index.ts"
+```ts title="src/mastra/index.ts"
 import { Mastra } from "@mastra/core";
 import { serve as inngestServe } from "@mastra/inngest";
 import { incrementWorkflow } from "./workflows";
@@ -216,11 +216,10 @@ docker run --rm -p 8288:8288 \
 
 1. Add Vercel Deployer to Mastra instance
 
-```ts showLineNumbers copy title="src/mastra/index.ts"
+```ts title="src/mastra/index.ts"
 import { VercelDeployer } from "@mastra/deployer-vercel";
 
 export const mastra = new Mastra({
-  // ...other config
   deployer: new VercelDeployer({
     teamSlug: "your_team_slug",
     projectName: "your_project_name",
@@ -291,7 +290,7 @@ You can serve additional Inngest functions alongside your Mastra workflows by us
 
 First, create your custom Inngest functions:
 
-```ts showLineNumbers copy title="src/inngest/custom-functions.ts"
+```ts title="src/inngest/custom-functions.ts"
 import { inngest } from "./inngest";
 
 // Define custom Inngest functions
@@ -320,7 +319,7 @@ export const customWebhookFunction = inngest.createFunction(
 
 Update your Mastra configuration to include the custom functions:
 
-```ts showLineNumbers copy title="src/mastra/index.ts"
+```ts title="src/mastra/index.ts"
 import { Mastra } from "@mastra/core";
 import { serve as inngestServe } from "@mastra/inngest";
 import { incrementWorkflow } from "./workflows";

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

@@ -18,7 +18,7 @@ In this example the `output` from `step1` is transformed to match the `inputSche
 
 ![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({...});
 
@@ -38,7 +38,7 @@ export const testWorkflow = createWorkflow({...})
 
 Use `inputData` to access the full output of the previous step:
 
-```typescript {3} title="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
+```typescript {3} title="src/mastra/workflows/test-workflow.ts"
   .then(step1)
   .map(({ inputData }) => {
     console.log(inputData);
@@ -49,7 +49,7 @@ Use `inputData` to access the full output of the previous step:
 
 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
+```typescript {3} title="src/mastra/workflows/test-workflow.ts"
   .then(step1)
   .map(async ({ getStepResult }) => {
     console.log(getStepResult(step1));
@@ -60,7 +60,7 @@ Use `getStepResult` to access the full output of a specific step by referencing
 
 Use `getInitData` to access the initial input data provided to the workflow:
 
-```typescript {3} title="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
+```typescript {3} title="src/mastra/workflows/test-workflow.ts"
   .then(step1)
   .map(async ({ getInitData }) => {
       console.log(getInitData());
@@ -71,7 +71,7 @@ Use `getInitData` to access the initial input data provided to the workflow:
 
 To use `mapVariable` import the necessary function from the workflows module:
 
-```typescript title="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
+```typescript title="src/mastra/workflows/test-workflow.ts"
 import { mapVariable } from "@mastra/core/workflows";
 ```
 
@@ -79,7 +79,7 @@ import { mapVariable } from "@mastra/core/workflows";
 
 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
+```typescript {3-6} title="src/mastra/workflows/test-workflow.ts"
   .then(step1)
   .map({
     details: mapVariable({
@@ -93,7 +93,7 @@ You can rename step outputs using the object syntax in `.map()`. In the example
 
 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
+```typescript {6-9} title="src/mastra/workflows/test-workflow.ts"
 export const testWorkflow = createWorkflow({...});
 
 testWorkflow