# Step Class

The Step class defines individual units of work within a workflow, encapsulating execution logic, data validation, and input/output handling. It can take either a tool or an agent as a parameter to automatically create a step from them.

## Usage example

```typescript
import { createWorkflow, createStep } from "@mastra/core/workflows";
import { z } from "zod";

const step1 = createStep({
  id: "step-1",
  description: "passes value from input to output",
  inputSchema: z.object({
    value: z.number(),
  }),
  outputSchema: z.object({
    value: z.number(),
  }),
  execute: async ({ inputData }) => {
    const { value } = inputData;
    return {
      value,
    };
  },
});
```

## Creating steps from agents

You can create a step directly from an agent. The step will use the agent's name as its ID.

### Basic agent step

```typescript
import { testAgent } from "../agents/test-agent";

const agentStep = createStep(testAgent);
// inputSchema: { prompt: string }
// outputSchema: { text: string }
```

### Agent step with structured output

Pass `structuredOutput` to have the agent return typed structured data:

```typescript
const articleSchema = z.object({
  title: z.string(),
  summary: z.string(),
  tags: z.array(z.string()),
});

const agentStep = createStep(testAgent, {
  structuredOutput: { schema: articleSchema },
});
// inputSchema: { prompt: string }
// outputSchema: { title: string, summary: string, tags: string[] }
```

### Agent step options

**structuredOutput:** (`{ schema: z.ZodType<any> }`): When provided, the agent returns structured data matching this schema instead of plain text. The step's outputSchema is set to the provided schema.

**onFinish:** (`(result: AgentResult) => void`): Callback invoked when the agent completes generation.

## Constructor Parameters

**id:** (`string`): Unique identifier for the step

**description:** (`string`): Optional description of what the step does

**inputSchema:** (`z.ZodType<any>`): Zod schema defining the input structure

**outputSchema:** (`z.ZodType<any>`): Zod schema defining the output structure

**resumeSchema:** (`z.ZodType<any>`): Optional Zod schema for resuming the step

**suspendSchema:** (`z.ZodType<any>`): Optional Zod schema for suspending the step

**stateSchema:** (`z.ZodObject<any>`): Optional Zod schema for the step state. Automatically injected when using Mastra's state system. The stateSchema must be a subset of the workflow's stateSchema. If not specified, type is 'any'.

**requestContextSchema:** (`z.ZodType<any>`): Zod schema for validating request context values. When provided, the context is validated before the step's execute() runs, failing the step if validation fails.

**execute:** (`(params: ExecuteParams) => Promise<any>`): Async function containing step logic

**metadata:** (`Record<string, any>`): Optional key-value pairs for storing additional step information. Values must be serializable (no functions, circular references, etc.).

### ExecuteParams

**inputData:** (`z.infer<TStepInput>`): The input data matching the inputSchema

**resumeData:** (`z.infer<TResumeSchema>`): The resume data matching the resumeSchema, when resuming the step from a suspended state. Only exists if the step is being resumed.

**suspendData:** (`z.infer<TSuspendSchema>`): The suspend data that was originally passed to suspend() when the step was suspended. Only exists if the step is being resumed and was previously suspended with data.

**mastra:** (`Mastra`): Access to Mastra services (agents, tools, etc.)

**getStepResult:** (`(step: Step | string) => any`): Function to access results from other steps

**getInitData:** (`() => any`): Function to access the initial input data of the workflow in any step

**suspend:** (`(suspendPayload: any, suspendOptions?: { resumeLabel?: string }) => Promise<void>`): Function to pause workflow execution

**state:** (`z.infer<TState>`): The current workflow state. Contains shared values that persist across all steps and suspend/resume cycles. The structure is defined by the step's stateSchema.

**setState:** (`(state: z.infer<TState>) => void`): Function to set the state of the workflow. Inject via reducer-like pattern, such as 'setState({ ...state, ...newState })'

**runId:** (`string`): Current run id

**requestContext?:** (`RequestContext`): Request Context for dependency injection and contextual information.

**retryCount?:** (`number`): The retry count for this specific step, it automatically increases each time the step is retried

## Related

- [Workflow state](https://mastra.ai/docs/workflows/workflow-state)
- [Control flow](https://mastra.ai/docs/workflows/control-flow)
- [Using agents and tools](https://mastra.ai/docs/workflows/agents-and-tools)