Workflow SDK

https://workflow-sdk.dev/docs
Admin
Workflow SDK is a framework for building durable, production-ready AI agents that survive crashes,...
Tokens:324,199
Snippets:2,717
Trust Score:5.5
Update:2 weeks ago
Show doc for...
Tokens:
Raw
### start(workflow, args, options?)

Source: https://workflow-sdk.dev/docs/api-reference/workflow-api/start

Documentation for the start function from the workflow/api module, including usage examples and important notes about deploymentId.

```APIDOC
## start(workflow, args, options?)

### Description
Starts a workflow run with the provided arguments and optional start options.

### Method
start

### Parameters
- **workflow** (Workflow) - Required - The workflow to start.
- **args** (Array) - Required - An array of arguments to pass to the workflow.
- **options** (StartOptions) - Optional - Additional options for the workflow run.

#### StartOptions
- **deploymentId** (string) - Optional - The deployment ID to target. Set to `"latest"` to automatically resolve the most recent deployment for the current environment. This is a Vercel-specific feature.
- **attributes** (object) - Optional - Additional attributes to associate with the workflow run.

### Request Example
```typescript
import { start } from "workflow/api";
import { userSignupWorkflow } from "./workflows/user-signup";

const run = await start(userSignupWorkflow, ["user@example.com"]);
```

### Response
Returns a promise that resolves to a workflow run object.

### Notes
- When using `deploymentId: "latest"`, the workflow run will execute on a potentially different deployment than the one calling `start()`. Be mindful of forward and backward compatibility.
- The `deploymentId` option is currently a Vercel-specific feature. Other Worlds may implement this option differently.
- Resolving `"latest"` is the one `start()` path that calls the Vercel API, so it needs an identity that can see the calling deployment.
```

--------------------------------

### world.steps.get

Source: https://workflow-sdk.dev/docs/api-reference/workflow-runtime/world/storage

Example of getting a step and hydrating its I/O.

```APIDOC
## world.steps.get

### Description
Retrieves a single step by run ID and step ID. The returned step can be hydrated with `hydrateResourceIO` to decode input/output.

### Method
`world.steps.get`

### Parameters
- **runId** (string) - Required - The ID of the run containing the step.
- **stepId** (string) - Required - The ID of the step to retrieve.

### Request Example
```typescript
const step = await world.steps.get(runId, stepId);
```
```

--------------------------------

### buildWorkflowTests() manual setup

Source: https://workflow-sdk.dev/docs/api-reference/vitest

Use buildWorkflowTests() directly only for manual setup. It builds workflow and step bundles to disk. This example shows a setup function that calls it.

```typescript
import { buildWorkflowTests } from "@workflow/vitest";

export async function setup() {
  await buildWorkflowTests();
}
```

--------------------------------

### Clone Flight Booking Agent example app

Source: https://workflow-sdk.dev/docs/ai

Clones the Flight Booking Agent example app from the workflow-examples repository and navigates into its directory. Use this as a starting point for adding Workflow SDK to an existing chat interface.

```bash
git clone https://github.com/vercel/workflow-examples -b plain-ai-sdk
cd workflow-examples/flight-booking-app
```

--------------------------------

### Basic usage with GET and POST requests

Source: https://workflow-sdk.dev/docs/api-reference/workflow/fetch

Example showing GET and POST requests with the workflow `fetch`. Uses the standard fetch API signature with optional request options. The workflow runtime handles response serialization automatically.

```typescript
import { fetch } from "workflow"

async function apiWorkflow() {
    "use workflow"

    // Fetch data from an API
    const response = await fetch("https://api.example.com/data") // [!code highlight]
    const data = await response.json()

    // Make a POST request
    const postResponse = await fetch("https://api.example.com/create", { // [!code highlight]
        method: "POST",
        headers: {
            "Content-Type": "application/json"
        },
        body: JSON.stringify({ name: "test" })
    })

    return data
}
```

--------------------------------

### Global setup script for workflow server tests (vitest.server.setup.ts)

Source: https://workflow-sdk.dev/docs/testing/server-based

Starts a Nitro dev server before tests and tears it down after. Sets WORKFLOW_LOCAL_BASE_URL to http://localhost:4000 so the workflow runtime sends flow-route requests to the running server. Emits JSON log events (server_starting, server_stdout, server_stderr, server_ready, server_exit) and throws a timeout error with buffered output if startup fails within 15 seconds.

```typescript
import { spawn } from "node:child_process";
import { setTimeout as delay } from "node:timers/promises";
import type { ChildProcess } from "node:child_process";

let server: ChildProcess | null = null;
const PORT = "4000";

function emitSetupLog(event: string, fields: Record<string, unknown> = {}) {
  console.log(
    JSON.stringify({
      scope: "workflow-server-test",
      event,
      port: PORT,
      ...fields,
    })
  );
}

export async function setup() { // [!code highlight]
  const stdout: string[] = [];
  const stderr: string[] = [];

  emitSetupLog("server_starting", {
    command: `npx nitro dev --port ${PORT}`,
  });

  server = spawn("npx", ["nitro", "dev", "--port", PORT], {
    stdio: "pipe",
    detached: false,
    env: process.env,
  });

  const ready = await new Promise<boolean>((resolve) => {
    const timeout = setTimeout(() => resolve(false), 15_000);

    server?.stdout?.on("data", (data) => {
      const output = data.toString();
      stdout.push(output);
      emitSetupLog("server_stdout", { message: output.trim() });

      if (output.includes("listening") || output.includes("ready")) {
        clearTimeout(timeout);
        resolve(true);
      }
    });

    server?.stderr?.on("data", (data) => {
      const output = data.toString();
      stderr.push(output);
      emitSetupLog("server_stderr", { message: output.trim() });
    });

    server?.on("error", (error) => {
      emitSetupLog("server_process_error", {
        name: error.name,
        message: error.message,
      });
      clearTimeout(timeout);
      resolve(false);
    });

    server?.on("exit", (code, signal) => {
      emitSetupLog("server_exit", { code, signal });
    });
  });

  if (!ready) {
    const recentStdout = stdout.join("").trim().slice(-2000);
    const recentStderr = stderr.join("").trim().slice(-2000);

    throw new Error(
      [
        "Server failed to start within 15 seconds.",
        `Command: npx nitro dev --port ${PORT}`,
        `WORKFLOW_LOCAL_BASE_URL: http://localhost:${PORT}`,
        `Recent stdout:\n${recentStdout || "(empty)"}`,
        `Recent stderr:\n${recentStderr || "(empty)"}`,
      ].join("\n\n")
    );
  }

  await delay(2_000);

  process.env.WORKFLOW_LOCAL_BASE_URL = `http://localhost:${PORT}`; // [!code highlight]

  emitSetupLog("server_ready", {
    baseUrl: process.env.WORKFLOW_LOCAL_BASE_URL,
  });
}

export async function teardown() { // [!code highlight]
  if (!server) return;

  emitSetupLog("server_stopping");

  server.kill("SIGTERM");
  await delay(1_000);

  if (!server.killed) {
    emitSetupLog("server_force_kill");
    server.kill("SIGKILL");
  }
}

```

--------------------------------

### Start a workflow run with start()

Source: https://workflow-sdk.dev/docs/api-reference/workflow-api/start

Imports the start function and a workflow, then enqueues a new run by calling start(myWorkflow). The highlighted line shows the invocation.

```typescript
import { start } from "workflow/api";
import { myWorkflow } from "./workflows/my-workflow";

const run = await start(myWorkflow); // [!code highlight]
```

--------------------------------

### Install workflow and nitro packages

Source: https://workflow-sdk.dev/docs/getting-started/vite

Install the workflow and nitro packages using your preferred package manager. These are required for the Vite setup.

```bash
npm i workflow nitro
```

```bash
pnpm add workflow nitro
```

```bash
yarn add workflow nitro
```

```bash
bun add workflow nitro
```

--------------------------------

### Install dependencies with bun

Source: https://workflow-sdk.dev/docs/getting-started/fastify

Installs workflow, fastify, nitro, and rollup using bun.

```bash
bun add workflow fastify nitro rollup
```

--------------------------------

### start (with attributes)

Source: https://workflow-sdk.dev/docs/observability/attributes

Documentation for the start function with attributes option, which seeds attributes when starting a workflow run.

```APIDOC
## start (with attributes)

### Description
Starts a workflow run with initial attributes. This is used to seed attributes directly when starting a run.

### Method
Function call

### Signature
`start(workflow, args, options?: { attributes?: Record<string, string> }): Promise<Run>`

### Parameters
- **workflow** (function) - Required - The workflow function to start.
- **args** (array) - Required - Arguments to pass to the workflow function.
- **options.attributes** (object) - Optional - A map of attribute keys to string values to seed the run with.

### Example
```typescript
const run = await start(orderWorkflow, ["ord_123"], {
  attributes: { source: "checkout" },
})
```
```

--------------------------------

### Start workflow with StartOptions

Source: https://workflow-sdk.dev/docs/api-reference/workflow-api/start

Starts a workflow with additional options, including a custom deployment ID and attributes. The options object is passed as the third argument to start().

```typescript
import { start } from "workflow/api";
import { myWorkflow } from "./workflows/my-workflow";

const run = await start(myWorkflow, ["arg1", "arg2"], { // [!code highlight]
  deploymentId: "custom-deployment-id", // [!code highlight]
  attributes: { source: "checkout" } // [!code highlight]
}); // [!code highlight]
```

--------------------------------

### Install workflow package with bun

Source: https://workflow-sdk.dev/docs/getting-started/astro

Installs the workflow package using bun.

```bash
bun add workflow
```

--------------------------------

### Install dependencies with pnpm

Source: https://workflow-sdk.dev/docs/getting-started/fastify

Installs workflow, fastify, nitro, and rollup using pnpm.

```bash
pnpm add workflow fastify nitro rollup
```

--------------------------------

### Write integration test with start() and run.returnValue

Source: https://workflow-sdk.dev/docs/testing

Write an integration test that starts a workflow with start() and awaits run.returnValue to get the result. The returnValue promise blocks until the workflow completes or throws if it fails. The example also checks run.runId matches /^wrun_/ and that run.status equals "completed".

```typescript
import { describe, it, expect } from "vitest";
import { start } from "workflow/api"; // [!code highlight]
import { calculateWorkflow } from "./calculate";

describe("calculateWorkflow", () => {
  it("should compute the correct result", async () => {
    const run = await start(calculateWorkflow, [2, 7]); // [!code highlight]

    expect(run.runId).toMatch(/^wrun_/);

    // Blocks until the workflow completes or fails
    const result = await run.returnValue; // [!code highlight]
    expect(result).toEqual({
      sum: 9,
      product: 14,
      combined: 23,
    });

    const status = await run.status; // [!code highlight]
    expect(status).toEqual("completed");
  });
});
```

--------------------------------

### Create TanStack Start project

Source: https://workflow-sdk.dev/docs/getting-started/tanstack-start

Create a new TanStack Start project and enter the newly created directory.

```bash
npx @tanstack/cli create my-workflow-app
```

```bash
cd my-workflow-app
```

--------------------------------

### Create and initialize Express project

Source: https://workflow-sdk.dev/docs/getting-started/express

Create a new directory, enter it, and initialize a new npm project.

```bash
mkdir my-workflow-app
```

```bash
cd my-workflow-app
```

```bash
npm init --y
```

--------------------------------

### Initialize npm project

Source: https://workflow-sdk.dev/docs/getting-started/fastify

Initializes a new npm project with default settings.

```bash
npm init --y
```

--------------------------------

### world.runs.get

Source: https://workflow-sdk.dev/docs/api-reference/workflow-runtime/world/storage

Example of getting a run with full data or metadata only.

```APIDOC
## world.runs.get

### Description
Retrieves a single run by its ID. By default, includes serialized input/output. Use `resolveData: "none"` to fetch metadata only without loading I/O.

### Method
`world.runs.get`

### Parameters
- **runId** (string) - Required - The ID of the run to retrieve.
- **resolveData** (string) - Optional - Set to `"none"` to skip loading serialized input/output.

### Request Example
```typescript
// Full data (default)
const run = await world.runs.get(runId);

// Metadata only
const lightweight = await world.runs.get(runId, {
  resolveData: "none",
});
```
```

--------------------------------

### start()

Source: https://workflow-sdk.dev/docs/api-reference/workflow-api

Start/enqueue a new workflow run.

```APIDOC
## start()

### Description
Start/enqueue a new workflow run.

### Method
Function

### Endpoint
workflow/api.start()

### Parameters
None documented.

### Request Example
None documented.

### Response
None documented.
```

--------------------------------

### package.json for ESM setup

Source: https://workflow-sdk.dev/docs/getting-started/nestjs

Example package.json configuration for an ESM NestJS project. When using ESM, local imports must include the .js extension.

```json
{
  "name": "my-workflow-app",
  "type": "module"
}
```

--------------------------------

### start() - Dynamic Workflow Source

Source: https://workflow-sdk.dev/docs/api-reference/workflow-api/start

start() also accepts a string of workflow source instead of an imported function, for orchestration whose shape is only known after you deploy. This is experimental and off by default. The source is compiled and stored with the run through the same serialization path as other run payloads, including encryption when the World supplies run key material.

```APIDOC
## start() - Dynamic Workflow Source

### Description
`start()` also accepts a string of workflow **source** instead of an imported function, for orchestration whose shape is only known after you deploy. The source is compiled and stored with the run through the same serialization path as other run payloads, including encryption when the World supplies run key material. Dynamic source runs with the full privileges of your deployment's functions: it can read environment variables, use the network and filesystem, and call any step in the deployment. Only pass source you trust as much as your own code.

### Method
Function call

### Endpoint
`start(source, args, options?)`

### Parameters
#### Arguments
- **source** (string) - Required - The workflow source code as a string.
- **args** (array) - Required - The arguments to pass to the workflow function.
- **options** (object) - Optional - Additional options.

#### Options
- **experimental_dynamic.steps** (Record<string, StepFunction | { stepId: string }>) - Required - Registered steps the source may call, keyed by the alias it calls them under.
- **experimental_dynamic.exportName** (string) - Optional - Name of the async workflow function in the source. Use letters, digits, and `_`, not starting with a digit. Defaults to `"workflow"`.

### Request Example
```typescript
import { start } from "workflow/api";
import { fetchUser, sendEmail } from "./steps";

const run = await start(
  `
async function workflow(input) {
  "use workflow";

  const user = await steps.fetchUser(input.userId);
  await steps.sendEmail(user.email);

  return { ok: true };
}
`,
  [{ userId: "user_123" }],
  {
    experimental_dynamic: {
      steps: { fetchUser, sendEmail },
    },
  }
);
```

### Response
#### Success Response
- **run** (Run<unknown>) - The returned `Run` object. The workflow ID is derived from the source and its step bindings — it cannot be supplied.

#### Response Example
```typescript
const run = await start(source, args, options);
```

### Error Handling
A dynamic start throws a `WorkflowRuntimeError`, before anything is written, when:
- The deployment has not opted in (must set `WORKFLOW_EXPERIMENTAL_DYNAMIC_WORKFLOWS=1`).
- `deploymentId` targets another deployment (including `'latest'` resolving to one).
- The World's backend does not support dynamic-source storage.

### Notes
- Experimental and off by default. The API may change without a major version bump.
- Dynamic runs can only start on the current deployment.
- `experimental_dynamic.steps` maps the aliases the source may call to steps that are already registered in your deployment. It keeps ordinary source from calling a step by a name it was not given, but it is not a security boundary. There is no way to define a new step from source.
```

--------------------------------

### Run the app and start a workflow

Source: https://workflow-sdk.dev/docs/getting-started/react-router/v7

Run the development server, start a workflow with a curl request, and build/start the production server. Inspect local runs with `pnpm workflow web`.

```bash
pnpm vite dev
```

```bash
curl -X POST \
  -H "content-type: application/json" \
  -d '{"name":"Workflow"}' \
  http://localhost:3000/api/greeting
```

```bash
pnpm vite build
node ./build/server/index.mjs
```

--------------------------------

### setWorld with getWorld

Source: https://workflow-sdk.dev/docs/api-reference/workflow-runtime/set-world

Injects a custom World instance and then resolves it with getWorld(). The highlighted line shows the setWorld call. The example declares a customWorld variable via a @setup comment.

```typescript
import { setWorld, getWorld } from "workflow/runtime";
import type { World } from "@workflow/world";
declare const customWorld: World; // @setup

setWorld(customWorld); // [!code highlight]
const world = await getWorld(); // resolves customWorld
```

--------------------------------

### Start a dynamic workflow with start() and experimental_dynamic.steps

Source: https://workflow-sdk.dev/docs/api-reference/workflow-api/start

Start a dynamic workflow by passing source code as a string to start(). Requires WORKFLOW_EXPERIMENTAL_DYNAMIC_WORKFLOWS=1 and the deployment must support dynamic-source storage. experimental_dynamic.steps maps aliases the source may call to registered steps; it is not a security boundary. The return type is Run<unknown> and the workflow ID is derived from the source and step bindings.

```typescript
import { start } from "workflow/api";
import { fetchUser, sendEmail } from "./steps";

const run = await start(
  `
async function workflow(input) {
  "use workflow";

  const user = await steps.fetchUser(input.userId);
  await steps.sendEmail(user.email);

  return { ok: true };
}
`,
  [{ userId: "user_123" }],
  {
    experimental_dynamic: { // [!code highlight]
      steps: { fetchUser, sendEmail }, // [!code highlight]
    }, // [!code highlight]
  }
);
```

--------------------------------

### Inspect Workflow CLI Commands and List Runs

Source: https://workflow-sdk.dev/docs/observability

Get started inspecting local workflows. The first command shows all available commands, and the second lists recent workflow runs.

```bash
# See all available commands
npx workflow inspect --help

# List recent workflow runs
npx workflow inspect runs
```

--------------------------------

### Install Workflow SDK and migration skill

Source: https://workflow-sdk.dev/docs/whats-new

Install the latest Workflow SDK and add the migration skill for upgrading from v4 to v5.

```bash
npm install workflow@latest
npx skills add https://github.com/vercel/workflow --skill migrating-workflow-v4-to-v5
```

--------------------------------

### Passing a request body stream to a workflow (app/api/upload/route.ts)

Source: https://workflow-sdk.dev/docs/foundations/streaming

This example shows how to start a workflow with a stream as an argument. The request body stream is passed directly to the workflow, demonstrating that streams can be passed as arguments without using getWritable().

```typescript
import { start } from "workflow/api";
import { streamProcessingWorkflow } from "./workflows/streaming";

export async function POST(request: Request) {
  // Streams can be passed as workflow arguments
  const run = await start(streamProcessingWorkflow, [request.body]); // [!code highlight]
  await run.returnValue;

  return Response.json({ status: "complete" });
}
```

--------------------------------

### Get step metadata and log step ID

Source: https://workflow-sdk.dev/docs/api-reference/workflow/get-step-metadata

Call getStepMetadata inside a step function to retrieve the current step's metadata. The example logs the stepId to the console. This function can only be called inside a step function.

```typescript
import { getStepMetadata } from "workflow";

async function testWorkflow() {
  "use workflow";
  await logStepId();
}

async function logStepId() {
  "use step";
  const ctx = getStepMetadata(); // [!code highlight]
  console.log(ctx.stepId); // Grab the current step ID
}
```

--------------------------------

### Handle abort errors with FatalError.is()

Source: https://workflow-sdk.dev/docs/foundations/cancellation

Catches abort errors as FatalError (no retries) using a standard try/catch. The FatalError.is(err) check returns a cancelled status; other errors are rethrown. The @setup comment declares a helper function for the example.

```typescript
declare function cancellableStep(signal: AbortSignal): Promise<void>; // @setup
import { FatalError } from "workflow";

export async function workflow() {
  "use workflow";
  const controller = new AbortController();

  try {
    await cancellableStep(controller.signal);
  } catch (err) {
    if (FatalError.is(err)) { // [!code highlight]
      return { status: "cancelled" };
    }
    throw err;
  }
}
```

--------------------------------

### Change into project directory

Source: https://workflow-sdk.dev/docs/getting-started/astro

Navigates into the newly created Astro project directory.

```bash
cd my-workflow-app
```

--------------------------------

### Test webhook workflows with resumeWebhook() and waitForHook()

Source: https://workflow-sdk.dev/docs/testing

The workflow creates a webhook with createWebhook() and awaits it to receive a Request. The test starts the workflow, uses waitForHook() to get the generated token, then resumes the webhook with resumeWebhook() passing a Request object, and asserts the result.

```typescript
import { createWebhook } from "workflow";

export async function ingestWorkflow(endpointId: string) {
  "use workflow";

  // Webhook tokens are always generated for you
  using webhook = createWebhook(); // [!code highlight]

  const request = await webhook; // [!code highlight]
  const body = await request.text();
  const data = await parsePayload(body);

  return { endpointId, received: data };
}

async function parsePayload(body: string) {
  "use step";
  return JSON.parse(body);
}
```

```typescript
import { describe, it, expect } from "vitest";
import { start, resumeWebhook } from "workflow/api"; // [!code highlight]
import { waitForHook } from "@workflow/vitest"; // [!code highlight]
import { ingestWorkflow } from "./ingest";

describe("ingestWorkflow", () => {
  it("should process webhook data", async () => {
    const run = await start(ingestWorkflow, ["ep-1"]);

    // Discover the generated webhook token
    const hook = await waitForHook(run); // [!code highlight]

    // Resume the webhook with a Request object
    await resumeWebhook( // [!code highlight]
      hook.token, // [!code highlight]
      new Request("https://example.com/webhook", { // [!code highlight]
        method: "POST", // [!code highlight]
        body: JSON.stringify({ event: "order.created", orderId: "123" }), // [!code highlight]
      }) // [!code highlight]
    ); // [!code highlight]

    const result = await run.returnValue;
    expect(result).toEqual({
      endpointId: "ep-1",
      received: { event: "order.created", orderId: "123" },
    });
  });
});
```

--------------------------------

### Take over a hook token with experimental_force

Source: https://workflow-sdk.dev/docs/errors/hook-conflict

Forces the newest run to take over a hook token by setting experimental_force: true, avoiding HookConflictError. The previous owner's await hook rejects with HookForceClaimedError. Runs started at a Workflow spec version below 8 cannot be taken from, so the forced hook still gets HookConflictError in that case.

```typescript
import { createHook } from "workflow";

export async function processPayment(orderId: string) {
  "use workflow";

  const hook = createHook({
    token: `payment-${orderId}`,
    experimental_force: true, // [!code highlight]
  });
  const payment = await hook;
}
```

--------------------------------

### Create Nuxt project

Source: https://workflow-sdk.dev/docs/getting-started/nuxt

Create a new Nuxt project in a directory named nuxt-app, then enter that directory.

```bash
npm create nuxt@latest nuxt-app
```

```bash
cd nuxt-app
```

--------------------------------

### setupWorkflowTests() and teardownWorkflowTests() manual setup

Source: https://workflow-sdk.dev/docs/api-reference/vitest

Use setupWorkflowTests() and teardownWorkflowTests() directly only for manual setup. setupWorkflowTests() sets up an in-process workflow runtime in each test worker, and teardownWorkflowTests() tears it down.

```typescript
import { beforeAll, afterAll } from "vitest";
import { setupWorkflowTests, teardownWorkflowTests } from "@workflow/vitest";

beforeAll(async () => {
  await setupWorkflowTests();
});

afterAll(async () => {
  await teardownWorkflowTests();
});
```

--------------------------------

### Recursive and repeating workflows with start()

Source: https://workflow-sdk.dev/docs/foundations/starting-workflows

Recursive and repeating workflows: a workflow starts a new instance of itself to avoid long-running runs with large event logs. The first block processes batches and starts a new run if a next cursor exists. The second block creates a cron-like pattern by sleeping and then starting a new run. Both use `start()` from `workflow/api`.

```typescript
import { start } from "workflow/api";
declare function fetchBatch(cursor?: string): Promise<{ items: string[]; nextCursor?: string }>; // @setup
declare function processBatch(items: string[]): Promise<void>; // @setup

export async function processQueue(cursor?: string) {
  "use workflow";

  const { items, nextCursor } = await fetchBatch(cursor);
  await processBatch(items);

  if (nextCursor) {
    // Continue processing in a new workflow run
    await start(processQueue, [nextCursor]); // [!code highlight]
  }
}
```

```typescript
import { sleep } from "workflow";
import { start } from "workflow/api";
declare function refreshMetrics(): Promise<void>; // @setup

export async function syncDashboard() {
  "use workflow";

  await refreshMetrics();
  await sleep("1h");

  // Schedule the next run
  await start(syncDashboard); // [!code highlight]
}
```

--------------------------------

### world.steps.list

Source: https://workflow-sdk.dev/docs/api-reference/workflow-runtime/world/storage

Example of listing steps for a progress dashboard.

```APIDOC
## world.steps.list

### Description
Lists steps for a given run, useful for building a progress dashboard. Can be called with `resolveData: "none"` to avoid loading step I/O.

### Method
`world.steps.list`

### Parameters
- **runId** (string) - Required - The ID of the run whose steps to list.
- **resolveData** (string) - Optional - Set to `"none"` to skip loading step I/O.

### Request Example
```typescript
const steps = await world.steps.list({
  runId,
  resolveData: "none",
});
```

### Response
Returns an object with a `data` array of step objects, each containing `stepId`, `stepName`, and `status`.
```

--------------------------------

### Install workflow and @workflow/nest

Source: https://workflow-sdk.dev/docs/getting-started/nestjs

Install the Workflow SDK and its NestJS integration using your preferred package manager. Choose the command that matches your package manager.

```bash
npm i workflow @workflow/nest
```

```bash
pnpm add workflow @workflow/nest
```

```bash
yarn add workflow @workflow/nest
```

```bash
bun add workflow @workflow/nest
```
Tokens:
Raw