@mastra/mcp-docs-server 0.13.37 → 0.13.38

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

@@ -1,11 +1,11 @@
 ---
-title: "Suspend & Resume Workflows | Human-in-the-Loop | Mastra Docs"
+title: "Suspend & Resume | Workflows | Mastra Docs"
 description: "Suspend and resume in Mastra workflows allows you to pause execution while waiting for external input or resources."
 ---
 
 # Suspend & Resume
 
-Workflows can be paused at any step, with their current state persisted as a [snapshot](./snapshots.mdx) 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.
+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:
 
@@ -33,19 +33,19 @@ When running a workflow, its `status` can be one of the following:
 
 To pause execution at a specific step until user input is received, use the `⁠suspend` function to temporarily halt the workflow, allowing it to resume only when the necessary data is provided.
 
-![Suspending a workflow with suspend()](/image/workflows/workflows-suspend-resume-suspend.jpg)
+![Suspending a workflow with suspend()](/img/workflows/workflows-suspend-resume-suspend.jpg)
 
-```typescript {16} filename="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
+```typescript {16} title="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
 const step1 = createStep({
   id: "step-1",
   inputSchema: z.object({
-    input: z.string()
+    input: z.string(),
   }),
   outputSchema: z.object({
-    output: z.string()
+    output: z.string(),
   }),
   resumeSchema: z.object({
-    city: z.string()
+    city: z.string(),
   }),
   execute: async ({ resumeData, suspend }) => {
     const { city } = resumeData ?? {};
@@ -55,7 +55,7 @@ const step1 = createStep({
     }
 
     return { output: "" };
-  }
+  },
 });
 
 export const testWorkflow = createWorkflow({
@@ -65,21 +65,21 @@ export const testWorkflow = createWorkflow({
   .commit();
 ```
 
-> For more details, check out the [Suspend workflow example](../../examples/workflows/human-in-the-loop.mdx#suspend-workflow).
+> For more details, check out the [Suspend workflow example](/examples/workflows_legacy/suspend-and-resume).
 
 ### Identifying suspended steps
 
 To resume a suspended workflow, inspect the `suspended` array in the result to determine which step needs input:
 
-```typescript {15} filename="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
+```typescript {15} title="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
 import { mastra } from "./mastra";
 
 const run = await mastra.getWorkflow("testWorkflow").createRunAsync();
 
 const result = await run.start({
   inputData: {
-    city: "London"
-  }
+    city: "London",
+  },
 });
 
 console.log(JSON.stringify(result, null, 2));
@@ -88,8 +88,8 @@ if (result.status === "suspended") {
   const resumedResult = await run.resume({
     step: result.suspended[0],
     resumeData: {
-      city: "Berlin"
-    }
+      city: "Berlin",
+    },
   });
 }
 ```
@@ -103,52 +103,48 @@ In this case, the logic resumes the first step listed in the `suspended` array.
     // ...
     "step-1": {
       // ...
-      "status": "suspended",
+      "status": "suspended"
     }
   },
-  "suspended": [
-    [
-      "step-1"
-    ]
-  ]
+  "suspended": [["step-1"]]
 }
 ```
 
-> See [Run Workflow Results](./overview.mdx#run-workflow-results) for more details.
+> See [Workflow Output](./overview#workflow-output) for more details.
 
 ## Providing user feedback with suspend
 
 When a workflow is suspended, feedback can be surfaced to the user through the `suspendSchema`. Include a reason in the `suspend` payload to explain why the workflow paused.
 
-```typescript {13,23} filename="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
+```typescript {13,23} title="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
 import { createWorkflow, createStep } from "@mastra/core/workflows";
 import { z } from "zod";
 
 const step1 = createStep({
   id: "step-1",
   inputSchema: z.object({
-    value: z.string()
+    value: z.string(),
   }),
   resumeSchema: z.object({
-    confirm: z.boolean()
+    confirm: z.boolean(),
   }),
   suspendSchema: z.object({
-    reason: z.string()
+    reason: z.string(),
   }),
   outputSchema: z.object({
-    value: z.string()
+    value: z.string(),
   }),
   execute: async ({ resumeData, suspend }) => {
     const { confirm } = resumeData ?? {};
 
     if (!confirm) {
       return await suspend({
-        reason: "Confirm to continue"
+        reason: "Confirm to continue",
       });
     }
 
     return { value: "" };
-  }
+  },
 });
 
 export const testWorkflow = createWorkflow({
@@ -156,7 +152,6 @@ export const testWorkflow = createWorkflow({
 })
   .then(step1)
   .commit();
-
 ```
 
 In this case, the reason provided explains that the user must confirm to continue.
@@ -168,36 +163,36 @@ In this case, the reason provided explains that the user must confirm to continu
     "status": "suspended",
     "suspendPayload": {
       "reason": "Confirm to continue"
-    },
+    }
   }
 }
 ```
 
-> See [Run Workflow Results](./overview.mdx#run-workflow-results) for more details.
+> See [Workflow Output](./overview#workflow-output) for more details.
 
 ## Resuming a workflow with `resume()`
 
 A workflow can be resumed by calling `resume` and providing the required `resumeData`. You can either explicitly specify which step to resume from, or when exactly one step is suspended, omit the `step` parameter and the workflow will automatically resume that step.
 
-```typescript {16-18} filename="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
+```typescript {16-18} title="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
 import { mastra } from "./mastra";
 
 const run = await mastra.getWorkflow("testWorkflow").createRunAsync();
 
 const result = await run.start({
-   inputData: {
-    city: "London"
-  }
+  inputData: {
+    city: "London",
+  },
 });
 
 console.log(JSON.stringify(result, null, 2));
 
 if (result.status === "suspended") {
   const resumedResult = await run.resume({
-    step: 'step-1',
+    step: "step-1",
     resumeData: {
-      city: "Berlin"
-    }
+      city: "Berlin",
+    },
   });
 
   console.log(JSON.stringify(resumedResult, null, 2));
@@ -206,10 +201,10 @@ if (result.status === "suspended") {
 
 You can also omit the `step` parameter when exactly one step is suspended:
 
-```typescript {5} filename="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
+```typescript {5} title="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
 const resumedResult = await run.resume({
   resumeData: {
-    city: "Berlin"
+    city: "Berlin",
   },
   // step parameter omitted - automatically resumes the single suspended step
 });
@@ -217,43 +212,43 @@ const resumedResult = await run.resume({
 
 You can pass `runtimeContext` as an argument to both the `start` and `resume` commands.
 
-```typescript filename="src/mastra/workflows/test-workflow.ts"
+```typescript title="src/mastra/workflows/test-workflow.ts"
 import { RuntimeContext } from "@mastra/core/runtime-context";
 
 const runtimeContext = new RuntimeContext();
 
 const result = await run.start({
-  step: 'step-1',
+  step: "step-1",
   inputData: {
-    city: "London"
+    city: "London",
   },
-  runtimeContext
+  runtimeContext,
 });
 
 const resumedResult = await run.resume({
-  step: 'step-1',
+  step: "step-1",
   resumeData: {
-    city: "New York"
+    city: "New York",
   },
-  runtimeContext
+  runtimeContext,
 });
 ```
 
-> See [Runtime Context](../server-db/runtime-context.mdx) for more information.
+> See [Runtime Context](/docs/server-db/runtime-context) for more information.
 
 ### Resuming nested workflows
 
 To resume a suspended nested workflow pass the workflow instance to the `step` parameter of the `resume` function.
 
-```typescript {33-34} filename="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
+```typescript {33-34} title="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
 const dowhileWorkflow = createWorkflow({
-  id: 'dowhile-workflow',
+  id: "dowhile-workflow",
   inputSchema: z.object({ value: z.number() }),
   outputSchema: z.object({ value: z.number() }),
 })
   .dountil(
     createWorkflow({
-      id: 'simple-resume-workflow',
+      id: "simple-resume-workflow",
       inputSchema: z.object({ value: z.number() }),
       outputSchema: z.object({ value: z.number() }),
       steps: [incrementStep, resumeStep],
@@ -265,7 +260,7 @@ const dowhileWorkflow = createWorkflow({
   )
   .then(
     createStep({
-      id: 'final',
+      id: "final",
       inputSchema: z.object({ value: z.number() }),
       outputSchema: z.object({ value: z.number() }),
       execute: async ({ inputData }) => ({ value: inputData.value }),
@@ -279,7 +274,7 @@ const result = await run.start({ inputData: { value: 0 } });
 if (result.status === "suspended") {
   const resumedResult = await run.resume({
     resumeData: { value: 2 },
-    step: ['simple-resume-workflow', 'resume'],
+    step: ["simple-resume-workflow", "resume"],
   });
 
   console.log(JSON.stringify(resumedResult, null, 2));
@@ -292,7 +287,7 @@ Workflows can also pause execution for timed delays or external events. These me
 
 **Available methods:**
 
-- [`.sleep()`](../../reference/workflows/workflow-methods/sleep.mdx): Pause for a specified number of milliseconds
-- [`.sleepUntil()`](../../reference/workflows/workflow-methods/sleepUntil.mdx) : Pause until a specific date
-- [`.waitForEvent()`](../../reference/workflows/workflow-methods/waitForEvent.mdx): Pause until an external event is received
-- [`.sendEvent()`](../../reference/workflows/workflow-methods/sendEvent.mdx) : Send an event to resume a waiting workflow
+- [`.sleep()`](/reference/workflows/workflow-methods/sleep): Pause for a specified number of milliseconds
+- [`.sleepUntil()`](/reference/workflows/workflow-methods/sleepUntil) : Pause until a specific date
+- [`.waitForEvent()`](/reference/workflows/workflow-methods/waitForEvent): Pause until an external event is received
+- [`.sendEvent()`](/reference/workflows/workflow-methods/sendEvent) : Send an event to resume a waiting workflow

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

@@ -1,5 +1,7 @@
 ---
-title: "Branching, Merging, Conditions | Workflows (Legacy) | Mastra Docs"
+title: "Control Flow in Legacy Workflows: Branching, Merging, and Conditions | Workflows (Legacy) | Mastra Docs"
+sidebar_position: 7
+sidebar_label: "Control Flow"
 description: "Control flow in Mastra legacy workflows allows you to manage branching, merging, and conditions to construct legacy workflows that meet your logic requirements."
 ---
 
@@ -15,7 +17,7 @@ You can run multiple steps at the same time if they don't depend on each other.
 myWorkflow.step(fetchUserData).step(fetchOrderData);
 ```
 
-See the [Parallel Steps](../../examples/workflows_legacy/parallel-steps.mdx) example for more details.
+See the [Parallel Steps](/examples/workflows_legacy/parallel-steps) example for more details.
 
 ## Sequential Execution
 
@@ -25,7 +27,7 @@ Sometimes you need to run steps in strict order to ensure outputs from one step
 myWorkflow.step(fetchOrderData).then(validateData).then(processOrder);
 ```
 
-See the [Sequential Steps](../../examples/workflows_legacy/sequential-steps.mdx) example for more details.
+See the [Sequential Steps](/examples/workflows_legacy/sequential-steps) example for more details.
 
 ## Branching and Merging Paths
 
@@ -49,7 +51,7 @@ In this example:
 - Separately, stepA also triggers stepC, which in turn leads to stepE.
 - Separately, stepF is triggered when both stepD and stepE are completed.
 
-See the [Branching Paths](../../examples/workflows_legacy/branching-paths.mdx) example for more details.
+See the [Branching Paths](/examples/workflows_legacy/branching-paths) example for more details.
 
 ## Merging Multiple Branches
 
@@ -356,7 +358,7 @@ The `getStepResult` method provides a type-safe way to access step results. This
 
 For better type safety, you can provide a type parameter to `getStepResult`:
 
-```typescript showLineNumbers filename="src/mastra/workflows/get-step-result.ts" copy
+```typescript showLineNumbers title="src/mastra/workflows/get-step-result.ts" copy
 import { LegacyStep, LegacyWorkflow } from "@mastra/core/workflows/legacy";
 import { z } from "zod";
 
@@ -395,7 +397,7 @@ const analyzeDataStep = new LegacyStep({
 
 The most type-safe approach is to reference the step directly in the `getStepResult` call:
 
-```typescript showLineNumbers filename="src/mastra/workflows/step-reference.ts" copy
+```typescript showLineNumbers title="src/mastra/workflows/step-reference.ts" copy
 import { LegacyStep, LegacyWorkflow } from "@mastra/core/workflows/legacy";
 import { z } from "zod";
 
@@ -442,7 +444,7 @@ Variable mapping is an explicit way to define data flow between steps.
 This approach makes dependencies clear and provides good type safety.
 The data injected into the step is available in the `context.inputData` object, and typed based on the `inputSchema` of the step.
 
-```typescript showLineNumbers filename="src/mastra/workflows/variable-mapping.ts" copy
+```typescript showLineNumbers title="src/mastra/workflows/variable-mapping.ts" copy
 import { LegacyStep, LegacyWorkflow } from "@mastra/core/workflows/legacy";
 import { z } from "zod";
 
@@ -495,14 +497,14 @@ workflow
   .commit();
 ```
 
-For more details on variable mapping, see the [Data Mapping with Workflow Variables](./variables.mdx) documentation.
+For more details on variable mapping, see the [Data Mapping with Workflow Variables](./variables) documentation.
 
 ### Using the Context Object
 
 The context object provides direct access to all step results and their outputs. This approach is more flexible but requires careful handling to maintain type safety.
 You can access step results directly through the `context.steps` object:
 
-```typescript showLineNumbers filename="src/mastra/workflows/context-access.ts" copy
+```typescript showLineNumbers title="src/mastra/workflows/context-access.ts" copy
 import { LegacyStep, LegacyWorkflow } from "@mastra/core/workflows/legacy";
 import { z } from "zod";
 
@@ -537,7 +539,7 @@ workflow.step(fetchUserStep).then(processOrderStep).commit();
 For comprehensive type safety across your entire workflow, you can define types for all steps and pass them to the Workflow
 This allows you to get type safety for the context object on conditions, and on step results in the final workflow output.
 
-```typescript showLineNumbers filename="src/mastra/workflows/workflow-typing.ts" copy
+```typescript showLineNumbers title="src/mastra/workflows/workflow-typing.ts" copy
 import { LegacyStep, LegacyWorkflow } from "@mastra/core/workflows/legacy";
 import { z } from "zod";
 
@@ -592,7 +594,7 @@ workflow
 
 In addition to step results, you can access the original trigger data that started the workflow:
 
-```typescript showLineNumbers filename="src/mastra/workflows/trigger-data.ts" copy
+```typescript showLineNumbers title="src/mastra/workflows/trigger-data.ts" copy
 import { LegacyStep, LegacyWorkflow } from "@mastra/core/workflows/legacy";
 import { z } from "zod";
 
@@ -630,7 +632,7 @@ workflow.step(processOrderStep).commit();
 
 The data injected into the step is available in the `context.inputData` object, and typed based on the `inputSchema` of the step.
 
-```typescript showLineNumbers filename="src/mastra/workflows/resume-data.ts" copy
+```typescript showLineNumbers title="src/mastra/workflows/resume-data.ts" copy
 import { LegacyStep, LegacyWorkflow } from "@mastra/core/workflows/legacy";
 import { z } from "zod";
 
@@ -678,7 +680,7 @@ console.log({ resumedResult });
 
 You can get typed access to the results of a workflow by injecting the step types into the `Workflow` type params:
 
-```typescript showLineNumbers filename="src/mastra/workflows/get-results.ts" copy
+```typescript showLineNumbers title="src/mastra/workflows/get-results.ts" copy
 import { LegacyStep, LegacyWorkflow } from "@mastra/core/workflows/legacy";
 import { z } from "zod";
 
@@ -741,23 +743,19 @@ if (result.results.fetchUser.status === "success") {
 ### Best Practices for Data Flow
 
 1. **Use getStepResult with Step References for Type Safety**
-
    - Ensures TypeScript can infer the correct types
    - Catches type errors at compile time
 
 2. \*_Use Variable Mapping for Explicit Dependencies_
-
    - Makes data flow clear and maintainable
    - Provides good documentation of step dependencies
 
 3. **Define Output Schemas for Steps**
-
    - Validates data at runtime
    - Validates return type of the `execute` function
    - Improves type inference in TypeScript
 
 4. **Handle Missing Data Gracefully**
-
    - Always check if step results exist before accessing properties
    - Provide fallback values for optional data
 

package/.docs/raw/workflows-legacy/dynamic-workflows.mdx

@@ -1,5 +1,7 @@
 ---
-title: "Dynamic Workflows (Legacy) | Mastra Docs"
+title: "Dynamic Workflows (Legacy) | Workflows (Legacy) | Mastra Docs"
+sidebar_position: 3
+sidebar_label: "Dynamic Workflows"
 description: "Learn how to create dynamic workflows within legacy workflow steps, allowing for flexible workflow creation based on runtime conditions."
 ---
 

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

@@ -1,5 +1,7 @@
 ---
-title: "Error Handling in Workflows (Legacy) | Mastra Docs"
+title: "Error Handling in Workflows (Legacy) | Workflows (Legacy) | Mastra Docs"
+sidebar_position: 8
+sidebar_label: "Error Handling"
 description: "Learn how to handle errors in Mastra legacy workflows using step retries, conditional branching, and monitoring."
 ---
 
@@ -49,7 +51,7 @@ const apiStep = new LegacyStep({
 });
 ```
 
-For more details about step retries, see the [Step Retries](../../reference/legacyWorkflows/step-retries.mdx) reference.
+For more details about step retries, see the [Step Retries](/reference/legacyWorkflows/step-retries) reference.
 
 ## Conditional Branching
 
@@ -179,7 +181,7 @@ For more complex error handling scenarios, consider:
 
 ## Related
 
-- [Step Retries Reference](../../reference/legacyWorkflows/step-retries.mdx)
-- [Watch Method Reference](../../reference/legacyWorkflows/watch.mdx)
-- [Step Conditions](../../reference/legacyWorkflows/step-condition.mdx)
-- [Control Flow](./control-flow.mdx)
+- [Step Retries Reference](/reference/legacyWorkflows/step-retries)
+- [Watch Method Reference](/reference/legacyWorkflows/watch)
+- [Step Conditions](/reference/legacyWorkflows/step-condition)
+- [Control Flow](./control-flow)

package/.docs/raw/workflows-legacy/nested-workflows.mdx

@@ -1,3 +1,9 @@
+---
+title: "Nested Workflows (Legacy) | Workflows (Legacy) | Mastra Docs"
+sidebar_position: 4
+sidebar_label: "Nested Workflows"
+---
+
 # Nested Workflows (Legacy)
 
 Mastra allows you to use workflows as steps within other workflows, enabling you to create modular and reusable workflow components. This feature helps in organizing complex workflows into smaller, manageable pieces and promotes code reuse.

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

@@ -1,5 +1,7 @@
 ---
-title: "Handling Complex LLM Operations | Workflows (Legacy) | Mastra"
+title: "Handling Complex LLM Operations with Workflows (Legacy) | Workflows (Legacy) | Mastra Docs"
+sidebar_position: 1
+sidebar_label: "Overview"
 description: "Workflows in Mastra help you orchestrate complex sequences of operations with features like branching, parallel execution, resource suspension, and more."
 ---
 
@@ -7,14 +9,14 @@ description: "Workflows in Mastra help you orchestrate complex sequences of oper
 
 All the legacy workflow documentation is available on the links below.
 
-- [Steps](/docs/workflows-legacy/steps.mdx)
-- [Control Flow](/docs/workflows-legacy/control-flow.mdx)
-- [Variables](/docs/workflows-legacy/variables.mdx)
-- [Suspend & Resume](/docs/workflows-legacy/suspend-and-resume.mdx)
-- [Dynamic Workflows](/docs/workflows-legacy/dynamic-workflows.mdx)
-- [Error Handling](/docs/workflows-legacy/error-handling.mdx)
-- [Nested Workflows](/docs/workflows-legacy/nested-workflows.mdx)
-- [Runtime/Dynamic Variables](/docs/workflows-legacy/runtime-variables.mdx)
+- [Steps](/docs/workflows-legacy/steps)
+- [Control Flow](/docs/workflows-legacy/control-flow)
+- [Variables](/docs/workflows-legacy/variables)
+- [Suspend & Resume](/docs/workflows-legacy/suspend-and-resume)
+- [Dynamic Workflows](/docs/workflows-legacy/dynamic-workflows)
+- [Error Handling](/docs/workflows-legacy/error-handling)
+- [Nested Workflows](/docs/workflows-legacy/nested-workflows)
+- [Runtime/Dynamic Variables](/docs/workflows-legacy/runtime-variables)
 
 Workflows in Mastra help you orchestrate complex sequences of operations with features like branching, parallel execution, resource suspension, and more.
 
@@ -40,7 +42,7 @@ Let's examine each part of the workflow creation process:
 
 Here's how you define a workflow in Mastra. The `name` field determines the workflow's API endpoint (`/workflows/$NAME/`), while the `triggerSchema` defines the structure of the workflow's trigger data:
 
-```ts filename="src/mastra/workflow/index.ts"
+```ts title="src/mastra/workflow/index.ts"
 import { LegacyStep, LegacyWorkflow } from "@mastra/core/workflows/legacy";
 
 const myWorkflow = new LegacyWorkflow({
@@ -55,7 +57,7 @@ const myWorkflow = new LegacyWorkflow({
 
 Now, we'll define the workflow's steps. Each step can have its own input and output schemas. Here, `stepOne` doubles an input value, and `stepTwo` increments that result if `stepOne` was successful. (To keep things simple, we aren't making any LLM calls in this example):
 
-```ts filename="src/mastra/workflow/index.ts"
+```ts title="src/mastra/workflow/index.ts"
 const stepOne = new LegacyStep({
   id: "stepOne",
   outputSchema: z.object({
@@ -85,7 +87,7 @@ const stepTwo = new LegacyStep({
 
 Now, let's create the control flow, and "commit" (finalize the workflow). In this case, `stepOne` runs first and is followed by `stepTwo`.
 
-```ts filename="src/mastra/workflow/index.ts"
+```ts title="src/mastra/workflow/index.ts"
 myWorkflow.step(stepOne).then(stepTwo).commit();
 ```
 
@@ -93,7 +95,7 @@ myWorkflow.step(stepOne).then(stepTwo).commit();
 
 Register your workflow with Mastra to enable logging and telemetry:
 
-```ts showLineNumbers filename="src/mastra/index.ts"
+```ts showLineNumbers title="src/mastra/index.ts"
 import { Mastra } from "@mastra/core";
 
 export const mastra = new Mastra({
@@ -103,7 +105,7 @@ export const mastra = new Mastra({
 
 The workflow can also have the mastra instance injected into the context in the case where you need to create dynamic workflows:
 
-```ts filename="src/mastra/workflow/index.ts"
+```ts title="src/mastra/workflow/index.ts"
 import { Mastra } from "@mastra/core";
 import { LegacyWorkflow } from "@mastra/core/workflows/legacy";
 
@@ -119,7 +121,7 @@ const myWorkflow = new LegacyWorkflow({
 
 Execute your workflow programmatically or via API:
 
-```ts showLineNumbers filename="src/mastra/run-workflow.ts" copy
+```ts showLineNumbers title="src/mastra/run-workflow.ts" copy
 import { mastra } from "./index";
 
 // Get the workflow
@@ -146,23 +148,23 @@ This example shows the essentials: define your workflow, add steps, commit the w
 
 ## Defining Steps
 
-The basic building block of a workflow [is a step](./steps.mdx). Steps are defined using schemas for inputs and outputs, and can fetch prior step results.
+The basic building block of a workflow [is a step](./steps). Steps are defined using schemas for inputs and outputs, and can fetch prior step results.
 
 ## Control Flow
 
-Workflows let you define a [control flow](./control-flow.mdx) to chain steps together in with parallel steps, branching paths, and more.
+Workflows let you define a [control flow](./control-flow) to chain steps together in with parallel steps, branching paths, and more.
 
 ## Workflow Variables
 
-When you need to map data between steps or create dynamic data flows, [workflow variables](./variables.mdx) provide a powerful mechanism for passing information from one step to another and accessing nested properties within step outputs.
+When you need to map data between steps or create dynamic data flows, [workflow variables](./variables) provide a powerful mechanism for passing information from one step to another and accessing nested properties within step outputs.
 
 ## Suspend and Resume
 
-When you need to pause execution for external data, user input, or asynchronous events, Mastra [supports suspension at any step](./suspend-and-resume.mdx), persisting the state of the workflow so you can resume it later.
+When you need to pause execution for external data, user input, or asynchronous events, Mastra [supports suspension at any step](./suspend-and-resume), persisting the state of the workflow so you can resume it later.
 
 ## Observability and Debugging
 
-Mastra workflows automatically [log the input and output of each step within a workflow run](../../reference/observability/otel-config.mdx), allowing you to send this data to your preferred logging, telemetry, or observability tools.
+Mastra workflows automatically [log the input and output of each step within a workflow run](/docs/observability/otel-tracing), allowing you to send this data to your preferred logging, telemetry, or observability tools.
 
 You can:
 
@@ -172,9 +174,9 @@ You can:
 
 ## More Resources
 
-- [Sequential Steps workflow example](../../examples/workflows_legacy/sequential-steps.mdx)
-- [Parallel Steps workflow example](../../examples/workflows_legacy/parallel-steps.mdx)
-- [Branching Paths workflow example](../../examples/workflows_legacy/branching-paths.mdx)
-- [Workflow Variables example](../../examples/workflows_legacy/workflow-variables.mdx)
-- [Cyclical Dependencies workflow example](../../examples/workflows_legacy/cyclical-dependencies.mdx)
-- [Suspend and Resume workflow example](../../examples/workflows_legacy/suspend-and-resume.mdx)
+- [Sequential Steps workflow example](/examples/workflows_legacy/sequential-steps)
+- [Parallel Steps workflow example](/examples/workflows_legacy/parallel-steps)
+- [Branching Paths workflow example](/examples/workflows_legacy/branching-paths)
+- [Workflow Variables example](/examples/workflows_legacy/workflow-variables)
+- [Cyclical Dependencies workflow example](/examples/workflows_legacy/cyclical-dependencies)
+- [Suspend and Resume workflow example](/examples/workflows_legacy/suspend-and-resume)

package/.docs/raw/workflows-legacy/runtime-variables.mdx

@@ -1,5 +1,7 @@
 ---
-title: "Runtime variables - dependency injection | Workflows (Legacy) | Mastra Docs"
+title: "Workflow Runtime Variables (Legacy) | Workflows (Legacy) | Mastra Docs"
+sidebar_position: 6
+sidebar_label: "Runtime/Dynamic Variables"
 description: Learn how to use Mastra's dependency injection system to provide runtime configuration to workflows and steps.
 ---
 
@@ -41,7 +43,7 @@ await start({
 
 Here's how to dynamically set a multiplier value from an HTTP header:
 
-```typescript filename="src/index.ts"
+```typescript title="src/index.ts"
 import { Mastra } from "@mastra/core";
 import { RuntimeContext } from "@mastra/core/di";
 import { workflow as myWorkflow } from "./workflows";

package/.docs/raw/workflows-legacy/steps.mdx

@@ -1,5 +1,7 @@
 ---
-title: "Creating Steps and Adding to Workflows (Legacy) | Mastra Docs"
+title: "Defining Steps in a Workflow (Legacy) | Workflows (Legacy) | Mastra Docs"
+sidebar_position: 2
+sidebar_label: "Steps"
 description: "Steps in Mastra workflows provide a structured way to manage operations by defining inputs, outputs, and execution logic."
 ---
 
@@ -13,7 +15,7 @@ The code below shows how to define these steps inline or separately.
 
 You can create steps directly within your workflow using `.step()` and `.then()`. This code shows how to define, link, and execute two steps in sequence.
 
-```typescript showLineNumbers filename="src/mastra/workflows/index.ts" copy
+```typescript showLineNumbers title="src/mastra/workflows/index.ts" copy
 import { Mastra } from "@mastra/core";
 import { LegacyStep, LegacyWorkflow } from "@mastra/core/workflows/legacy";
 import { z } from "zod";
@@ -66,7 +68,7 @@ export const mastra = new Mastra({
 
 If you prefer to manage your step logic in separate entities, you can define steps outside and then add them to your workflow. This code shows how to define steps independently and link them afterward.
 
-```typescript showLineNumbers filename="src/mastra/workflows/index.ts" copy
+```typescript showLineNumbers title="src/mastra/workflows/index.ts" copy
 import { Mastra } from "@mastra/core";
 import { LegacyStep, LegacyWorkflow } from "@mastra/core/workflows/legacy";
 import { z } from "zod";