@mastra/mcp-docs-server 0.13.39 → 1.0.0-beta.0

package/.docs/raw/reference/legacyWorkflows/until.mdx

@@ -1,168 +0,0 @@
----
-title: "Reference: Workflow.until() | Legacy Workflows | Mastra Docs"
-description: "Documentation for the `.until()` method in Mastra workflows, which repeats a step until a specified condition becomes true."
----
-
-# Workflow.until()
-
-The `.until()` method repeats a step until a specified condition becomes true. This creates a loop that continues executing the specified step until the condition is satisfied.
-
-## Usage
-
-```typescript
-workflow.step(incrementStep).until(condition, incrementStep).then(finalStep);
-```
-
-## Parameters
-
-<PropertiesTable
-  content={[
-    {
-      name: "condition",
-      type: "Function | ReferenceCondition",
-      description:
-        "A function or reference condition that determines when to stop looping",
-      isOptional: false,
-    },
-    {
-      name: "step",
-      type: "Step",
-      description: "The step to repeat until the condition is met",
-      isOptional: false,
-    },
-  ]}
-/>
-
-## Condition Types
-
-### Function Condition
-
-You can use a function that returns a boolean:
-
-```typescript
-workflow
-  .step(incrementStep)
-  .until(async ({ context }) => {
-    const result = context.getStepResult<{ value: number }>("increment");
-    return (result?.value ?? 0) >= 10; // Stop when value reaches or exceeds 10
-  }, incrementStep)
-  .then(finalStep);
-```
-
-### Reference Condition
-
-You can use a reference-based condition with comparison operators:
-
-```typescript
-workflow
-  .step(incrementStep)
-  .until(
-    {
-      ref: { step: incrementStep, path: "value" },
-      query: { $gte: 10 }, // Stop when value is greater than or equal to 10
-    },
-    incrementStep,
-  )
-  .then(finalStep);
-```
-
-## Comparison Operators
-
-When using reference-based conditions, you can use these comparison operators:
-
-| Operator | Description              | Example        |
-| -------- | ------------------------ | -------------- |
-| `$eq`    | Equal to                 | `{ $eq: 10 }`  |
-| `$ne`    | Not equal to             | `{ $ne: 0 }`   |
-| `$gt`    | Greater than             | `{ $gt: 5 }`   |
-| `$gte`   | Greater than or equal to | `{ $gte: 10 }` |
-| `$lt`    | Less than                | `{ $lt: 20 }`  |
-| `$lte`   | Less than or equal to    | `{ $lte: 15 }` |
-
-## Returns
-
-<PropertiesTable
-  content={[
-    {
-      name: "workflow",
-      type: "Workflow",
-      description: "The workflow instance for chaining",
-    },
-  ]}
-/>
-
-## Example
-
-```typescript
-import { LegacyWorkflow, LegacyStep } from "@mastra/core/workflows/legacy";
-import { z } from "zod";
-
-// Create a step that increments a counter
-const incrementStep = new LegacyStep({
-  id: "increment",
-  description: "Increments the counter by 1",
-  outputSchema: z.object({
-    value: z.number(),
-  }),
-  execute: async ({ context }) => {
-    // Get current value from previous execution or start at 0
-    const currentValue =
-      context.getStepResult<{ value: number }>("increment")?.value ||
-      context.getStepResult<{ startValue: number }>("trigger")?.startValue ||
-      0;
-
-    // Increment the value
-    const value = currentValue + 1;
-    console.log(`Incrementing to ${value}`);
-
-    return { value };
-  },
-});
-
-// Create a final step
-const finalStep = new LegacyStep({
-  id: "final",
-  description: "Final step after loop completes",
-  execute: async ({ context }) => {
-    const finalValue = context.getStepResult<{ value: number }>(
-      "increment",
-    )?.value;
-    console.log(`Loop completed with final value: ${finalValue}`);
-    return { finalValue };
-  },
-});
-
-// Create the workflow
-const counterWorkflow = new LegacyWorkflow({
-  name: "counter-workflow",
-  triggerSchema: z.object({
-    startValue: z.number(),
-    targetValue: z.number(),
-  }),
-});
-
-// Configure the workflow with an until loop
-counterWorkflow
-  .step(incrementStep)
-  .until(async ({ context }) => {
-    const targetValue = context.triggerData.targetValue;
-    const currentValue =
-      context.getStepResult<{ value: number }>("increment")?.value ?? 0;
-    return currentValue >= targetValue;
-  }, incrementStep)
-  .then(finalStep)
-  .commit();
-
-// Execute the workflow
-const run = counterWorkflow.createRun();
-const result = await run.start({
-  triggerData: { startValue: 0, targetValue: 5 },
-});
-// Will increment from 0 to 5, then stop and execute finalStep
-```
-
-## Related
-
-- [.while()](./while) - Loop while a condition is true
-- [Control Flow Guide](/docs/workflows-legacy/control-flow)
-- [Workflow Class Reference](./workflow)

package/.docs/raw/reference/legacyWorkflows/watch.mdx

@@ -1,124 +0,0 @@
----
-title: "Reference: run.watch() | Legacy Workflows | Mastra Docs"
-description: Documentation for the `.watch()` method in workflows, which monitors the status of a workflow run.
----
-
-# run.watch()
-
-The `.watch()` function subscribes to state changes on a mastra run, allowing you to monitor execution progress and react to state updates.
-
-## Usage Example
-
-```typescript
-import { LegacyWorkflow } from "@mastra/core/workflows/legacy";
-
-const workflow = new LegacyWorkflow({
-  name: "document-processor",
-});
-
-const run = workflow.createRun();
-
-// Subscribe to state changes
-const unsubscribe = run.watch(({ results, activePaths }) => {
-  console.log("Results:", results);
-  console.log("Active paths:", activePaths);
-});
-
-// Run the workflow
-await run.start({
-  input: { text: "Process this document" },
-});
-
-// Stop watching
-unsubscribe();
-```
-
-## Parameters
-
-<PropertiesTable
-  content={[
-    {
-      name: "callback",
-      type: "(state: LegacyWorkflowState) => void",
-      description: "Function called whenever the workflow state changes",
-      isOptional: false,
-    },
-  ]}
-/>
-
-### LegacyWorkflowState Properties
-
-<PropertiesTable
-  content={[
-    {
-      name: "results",
-      type: "Record<string, any>",
-      description: "Outputs from completed workflow steps",
-      isOptional: false,
-    },
-    {
-      name: "activePaths",
-      type: "Map<string, { status: string; suspendPayload?: any; stepPath: string[] }>",
-      description: "Current status of each step",
-      isOptional: false,
-    },
-    {
-      name: "runId",
-      type: "string",
-      description: "ID of the workflow run",
-      isOptional: false,
-    },
-    {
-      name: "timestamp",
-      type: "number",
-      description: "Timestamp of the workflow run",
-      isOptional: false,
-    },
-  ]}
-/>
-
-## Returns
-
-<PropertiesTable
-  content={[
-    {
-      name: "unsubscribe",
-      type: "() => void",
-      description: "Function to stop watching workflow state changes",
-    },
-  ]}
-/>
-
-## Additional Examples
-
-Monitor specific step completion:
-
-```typescript
-run.watch(({ results, activePaths }) => {
-  if (activePaths.get("processDocument")?.status === "completed") {
-    console.log(
-      "Document processing output:",
-      results["processDocument"].output,
-    );
-  }
-});
-```
-
-Error handling:
-
-```typescript
-run.watch(({ results, activePaths }) => {
-  if (activePaths.get("processDocument")?.status === "failed") {
-    console.error(
-      "Document processing failed:",
-      results["processDocument"].error,
-    );
-    // Implement error recovery logic
-  }
-});
-```
-
-### Related
-
-- [Workflow Creation](./createRun)
-- [Step Configuration](./step-class)

package/.docs/raw/reference/legacyWorkflows/while.mdx

@@ -1,168 +0,0 @@
----
-title: "Reference: Workflow.while() | Legacy Workflows | Mastra Docs"
-description: "Documentation for the `.while()` method in Mastra workflows, which repeats a step as long as a specified condition remains true."
----
-
-# Workflow.while()
-
-The `.while()` method repeats a step as long as a specified condition remains true. This creates a loop that continues executing the specified step until the condition becomes false.
-
-## Usage
-
-```typescript
-workflow.step(incrementStep).while(condition, incrementStep).then(finalStep);
-```
-
-## Parameters
-
-<PropertiesTable
-  content={[
-    {
-      name: "condition",
-      type: "Function | ReferenceCondition",
-      description:
-        "A function or reference condition that determines when to continue looping",
-      isOptional: false,
-    },
-    {
-      name: "step",
-      type: "Step",
-      description: "The step to repeat while the condition is true",
-      isOptional: false,
-    },
-  ]}
-/>
-
-## Condition Types
-
-### Function Condition
-
-You can use a function that returns a boolean:
-
-```typescript
-workflow
-  .step(incrementStep)
-  .while(async ({ context }) => {
-    const result = context.getStepResult<{ value: number }>("increment");
-    return (result?.value ?? 0) < 10; // Continue as long as value is less than 10
-  }, incrementStep)
-  .then(finalStep);
-```
-
-### Reference Condition
-
-You can use a reference-based condition with comparison operators:
-
-```typescript
-workflow
-  .step(incrementStep)
-  .while(
-    {
-      ref: { step: incrementStep, path: "value" },
-      query: { $lt: 10 }, // Continue as long as value is less than 10
-    },
-    incrementStep,
-  )
-  .then(finalStep);
-```
-
-## Comparison Operators
-
-When using reference-based conditions, you can use these comparison operators:
-
-| Operator | Description              | Example        |
-| -------- | ------------------------ | -------------- |
-| `$eq`    | Equal to                 | `{ $eq: 10 }`  |
-| `$ne`    | Not equal to             | `{ $ne: 0 }`   |
-| `$gt`    | Greater than             | `{ $gt: 5 }`   |
-| `$gte`   | Greater than or equal to | `{ $gte: 10 }` |
-| `$lt`    | Less than                | `{ $lt: 20 }`  |
-| `$lte`   | Less than or equal to    | `{ $lte: 15 }` |
-
-## Returns
-
-<PropertiesTable
-  content={[
-    {
-      name: "workflow",
-      type: "LegacyWorkflow",
-      description: "The workflow instance for chaining",
-    },
-  ]}
-/>
-
-## Example
-
-```typescript
-import { LegacyWorkflow, LegacyStep } from "@mastra/core/workflows/legacy";
-import { z } from "zod";
-
-// Create a step that increments a counter
-const incrementStep = new LegacyStep({
-  id: "increment",
-  description: "Increments the counter by 1",
-  outputSchema: z.object({
-    value: z.number(),
-  }),
-  execute: async ({ context }) => {
-    // Get current value from previous execution or start at 0
-    const currentValue =
-      context.getStepResult<{ value: number }>("increment")?.value ||
-      context.getStepResult<{ startValue: number }>("trigger")?.startValue ||
-      0;
-
-    // Increment the value
-    const value = currentValue + 1;
-    console.log(`Incrementing to ${value}`);
-
-    return { value };
-  },
-});
-
-// Create a final step
-const finalStep = new LegacyStep({
-  id: "final",
-  description: "Final step after loop completes",
-  execute: async ({ context }) => {
-    const finalValue = context.getStepResult<{ value: number }>(
-      "increment",
-    )?.value;
-    console.log(`Loop completed with final value: ${finalValue}`);
-    return { finalValue };
-  },
-});
-
-// Create the workflow
-const counterWorkflow = new LegacyWorkflow({
-  name: "counter-workflow",
-  triggerSchema: z.object({
-    startValue: z.number(),
-    targetValue: z.number(),
-  }),
-});
-
-// Configure the workflow with a while loop
-counterWorkflow
-  .step(incrementStep)
-  .while(async ({ context }) => {
-    const targetValue = context.triggerData.targetValue;
-    const currentValue =
-      context.getStepResult<{ value: number }>("increment")?.value ?? 0;
-    return currentValue < targetValue;
-  }, incrementStep)
-  .then(finalStep)
-  .commit();
-
-// Execute the workflow
-const run = counterWorkflow.createRun();
-const result = await run.start({
-  triggerData: { startValue: 0, targetValue: 5 },
-});
-// Will increment from 0 to 4, then stop and execute finalStep
-```
-
-## Related
-
-- [.until()](./until) - Loop until a condition becomes true
-- [Control Flow Guide](/docs/workflows-legacy/control-flow)
-- [Workflow Class Reference](./workflow)

package/.docs/raw/reference/legacyWorkflows/workflow.mdx

@@ -1,234 +0,0 @@
----
-title: "Reference: Workflow Class | Legacy Workflows | Mastra Docs"
-description: Documentation for the Workflow class in Mastra, which enables you to create state machines for complex sequences of operations with conditional branching and data validation.
----
-
-# Workflow Class
-
-The Workflow class enables you to create state machines for complex sequences of operations with conditional branching and data validation.
-
-```ts copy
-import { LegacyWorkflow } from "@mastra/core/workflows/legacy";
-
-const workflow = new LegacyWorkflow({ name: "my-workflow" });
-```
-
-## API Reference
-
-### Constructor
-
-<PropertiesTable
-  content={[
-    {
-      name: "name",
-      type: "string",
-      description: "Identifier for the workflow",
-    },
-    {
-      name: "logger",
-      type: "Logger<WorkflowLogMessage>",
-      isOptional: true,
-      description: "Optional logger instance for workflow execution details",
-    },
-    {
-      name: "steps",
-      type: "Step[]",
-      description: "Array of steps to include in the workflow",
-    },
-    {
-      name: "triggerSchema",
-      type: "z.Schema",
-      description: "Optional schema for validating workflow trigger data",
-    },
-  ]}
-/>
-
-### Core Methods
-
-#### `step()`
-
-Adds a [Step](./step-class) to the workflow, including transitions to other steps. Returns the workflow instance for chaining. [Learn more about steps](./step-class).
-
-#### `commit()`
-
-Validates and finalizes the workflow configuration. Must be called after adding all steps.
-
-#### `execute()`
-
-Executes the workflow with optional trigger data. Typed based on the [trigger schema](./workflow#trigger-schemas).
-
-## Trigger Schemas
-
-Trigger schemas validate the initial data passed to a workflow using Zod.
-
-```ts showLineNumbers copy
-const workflow = new LegacyWorkflow({
-  name: "order-process",
-  triggerSchema: z.object({
-    orderId: z.string(),
-    customer: z.object({
-      id: z.string(),
-      email: z.string().email(),
-    }),
-  }),
-});
-```
-
-The schema:
-
-- Validates data passed to `execute()`
-- Provides TypeScript types for your workflow input
-
-## Validation
-
-Workflow validation happens at two key times:
-
-### 1. At Commit Time
-
-When you call `.commit()`, the workflow validates:
-
-```ts showLineNumbers copy
-workflow
-  .step('step1', {...})
-  .step('step2', {...})
-  .commit(); // Validates workflow structure
-```
-
-- Circular dependencies between steps
-- Terminal paths (every path must end)
-- Unreachable steps
-- Variable references to non-existent steps
-- Duplicate step IDs
-
-### 2. During Execution
-
-When you call `start()`, it validates:
-
-```ts showLineNumbers copy
-const { runId, start } = workflow.createRun();
-
-// Validates trigger data against schema
-await start({
-  triggerData: {
-    orderId: "123",
-    customer: {
-      id: "cust_123",
-      email: "invalid-email", // Will fail validation
-    },
-  },
-});
-```
-
-- Trigger data against trigger schema
-- Each step's input data against its inputSchema
-- Variable paths exist in referenced step outputs
-- Required variables are present
-
-## Workflow Status
-
-A workflow's status indicates its current execution state. The possible values are:
-
-<PropertiesTable
-  content={[
-    {
-      name: "CREATED",
-      type: "string",
-      description: "Workflow instance has been created but not started",
-    },
-    {
-      name: "RUNNING",
-      type: "string",
-      description: "Workflow is actively executing steps",
-    },
-    {
-      name: "SUSPENDED",
-      type: "string",
-      description: "Workflow execution is paused waiting for resume",
-    },
-    {
-      name: "COMPLETED",
-      type: "string",
-      description: "All steps finished executing successfully",
-    },
-    {
-      name: "FAILED",
-      type: "string",
-      description: "Workflow encountered an error during execution",
-    },
-  ]}
-/>
-
-### Example: Handling Different Statuses
-
-```typescript showLineNumbers copy
-const { runId, start, watch } = workflow.createRun();
-
-watch(async ({ status }) => {
-  switch (status) {
-    case "SUSPENDED":
-      // Handle suspended state
-      break;
-    case "COMPLETED":
-      // Process results
-      break;
-    case "FAILED":
-      // Handle error state
-      break;
-  }
-});
-
-await start({ triggerData: data });
-```
-
-## Error Handling
-
-```ts showLineNumbers copy
-try {
-  const { runId, start, watch, resume } = workflow.createRun();
-  await start({ triggerData: data });
-} catch (error) {
-  if (error instanceof ValidationError) {
-    // Handle validation errors
-    console.log(error.type); // 'circular_dependency' | 'no_terminal_path' | 'unreachable_step'
-    console.log(error.details); // { stepId?: string, path?: string[] }
-  }
-}
-```
-
-## Passing Context Between Steps
-
-Steps can access data from previous steps in the workflow through the context object. Each step receives the accumulated context from all previous steps that have executed.
-
-```typescript showLineNumbers copy
-workflow
-  .step({
-    id: "getData",
-    execute: async ({ context }) => {
-      return {
-        data: { id: "123", value: "example" },
-      };
-    },
-  })
-  .step({
-    id: "processData",
-    execute: async ({ context }) => {
-      // Access data from previous step through context.steps
-      const previousData = context.steps.getData.output.data;
-      // Process previousData.id and previousData.value
-    },
-  });
-```
-
-The context object:
-
-- Contains results from all completed steps in `context.steps`
-- Provides access to step outputs through `context.steps.[stepId].output`
-- Is typed based on step output schemas
-- Is immutable to ensure data consistency
-
-## Related Documentation
-
-- [Step](./step-class)
-- [.then()](./then)
-- [.step()](./step-function)
-- [.after()](./after)