@workflow/core 5.0.0-beta.5 → 5.0.0-beta.50

package/docs/foundations/starting-workflows.mdx

@@ -1,5 +1,5 @@
 ---
-title: Starting Workflows
+title: Starting workflows
 description: Trigger workflow execution with the start() function and track progress with Run objects.
 type: guide
 summary: Trigger workflows and track their execution using the start() function.
@@ -9,11 +9,11 @@ related:
   - /docs/api-reference/workflow-api/start
 ---
 
-Once you've defined your workflow functions, you need to trigger them to begin execution. This is done using the `start()` function from `workflow/api`, which enqueues a new workflow run and returns a `Run` object that you can use to track its progress.
+After you define a workflow function, use the `start()` function from `workflow/api` to trigger it. The function enqueues a new workflow run and returns a `Run` object for tracking its progress.
 
-## The `start()` Function
+## The `start()` function
 
-The [`start()`](/docs/api-reference/workflow-api/start) function is used to programmatically trigger workflow executions from runtime contexts like API routes, Server Actions, or any server-side code.
+The [`start()`](/docs/api-reference/workflow-api/start) function programmatically triggers workflow executions from runtime contexts such as API routes, Server Actions, or other server-side code. In v5, you can also call `start()` inside a workflow function to spawn a child run or continue work in a new run.
 
 ```typescript lineNumbers
 import { start } from "workflow/api";
@@ -32,16 +32,21 @@ export async function POST(request: Request) {
 }
 ```
 
-**Key Points:**
+**Key points:**
 
-- `start()` returns immediately after enqueuing the workflow - it doesn't wait for completion
+- `start()` returns immediately after enqueuing the workflow. It doesn't wait for completion
 - The first argument is your workflow function
 - The second argument is an array of arguments to pass to the workflow (optional if the workflow takes no arguments)
 - All arguments must be [serializable](/docs/foundations/serialization)
+- On Worlds with a regional dimension, the optional `region` option pins the new run's storage, queuing, and streams to a specific region. See [Multi-region on the Vercel World](/worlds/vercel#multi-region)
 
-**Learn more**: [`start()` API Reference](/docs/api-reference/workflow-api/start)
+**Learn more**: [`start()` API reference](/docs/api-reference/workflow-api/start)
 
-## The `Run` Object
+<Callout type="info">
+For parent-child workflow patterns, see [Workflow Composition](/cookbook/common-patterns/workflow-composition). For long-lived workflows that intentionally hand off to newer deployments with `deploymentId: "latest"`, see [Versioning](/docs/foundations/versioning).
+</Callout>
+
+## The `Run` object
 
 When you call `start()`, it returns a [`Run`](/docs/api-reference/workflow-api/start#returns) object that provides access to the workflow's status and results.
 
@@ -61,24 +66,53 @@ const status = await run.status; // "running" | "completed" | "failed"
 const result = await run.returnValue;
 ```
 
-**Key Properties:**
+**Key properties:**
 
-- `runId` - Unique identifier for this workflow run
-- `status` - Current status of the workflow (async)
-- `returnValue` - The value returned by the workflow function (async, blocks until completion)
-- `readable` - ReadableStream for streaming updates from the workflow
+- `runId`: Unique identifier for this workflow run
+- `status`: Current status of the workflow (async)
+- `returnValue`: The value returned by the workflow function (async, blocks until completion)
+- `readable`: `ReadableStream` for streaming updates from the workflow
 
 <Callout type="info">
-Most `Run` properties are async getters that return promises. You need to `await` them to get their values. For a complete list of properties and methods, see the API reference below.
+Most `Run` properties are async getters that return promises. `await` them to get their values. For a complete list of properties and methods, see the API reference below.
 </Callout>
 
-**Learn more**: [`Run` API Reference](/docs/api-reference/workflow-api/start#returns)
+**Learn more**: [`Run` API reference](/docs/api-reference/workflow-api/start#returns)
+
+## Common patterns
+
+### Starting workflows from workflow functions
+
+You can also call `start()` directly inside workflow functions to spawn child workflows. For choosing between this and awaiting a workflow function directly, see [Workflow Composition](/cookbook/common-patterns/workflow-composition).
+
+```typescript lineNumbers
+import { start } from "workflow/api";
+import { childWorkflow } from "./workflows/child";
+
+export async function parentWorkflow(inputValue: number) {
+  "use workflow";
+
+  const childRun = await start(childWorkflow, [inputValue]); // [!code highlight]
 
-## Common Patterns
+  // childRun is a full Run object. Use it like normal.
+  const childResult = await childRun.returnValue;
+  return { childRunId: childRun.runId, childResult };
+}
+```
 
-### Fire and Forget
+When you call `start()` inside a workflow function, it automatically executes through an internal step to maintain deterministic replay. The returned `Run` object works as it does outside workflows. Properties such as `.runId`, `.status`, and `.returnValue`, and methods such as `.cancel()`, are all available. Each property access or method call executes as a separate step.
 
-The most common pattern is to start a workflow and immediately return, letting it execute in the background:
+<Callout type="info">
+Inside workflow functions, each `Run` property access (e.g., `run.status`, `run.returnValue`) triggers a workflow step. This means each access is recorded in the event log and replayed deterministically.
+</Callout>
+
+<Callout type="warn">
+Awaiting `returnValue` polls the child run every second, and the polling step holds its worker slot open until the child finishes. Size worker-based Worlds to cover the peak number of these polls in flight. If the child workflow is long-running, spawn it without awaiting `returnValue` and have it resume a [hook](/docs/foundations/hooks) when it completes. See the [`startAndWait()` pattern](/cookbook/advanced/child-workflows).
+</Callout>
+
+### Fire and forget
+
+Start a workflow and immediately return to let it execute in the background:
 
 ```typescript lineNumbers
 import { start } from "workflow/api";
@@ -96,7 +130,7 @@ export async function POST(request: Request) {
 }
 ```
 
-### Wait for Completion
+### Wait for completion
 
 If you need to wait for the workflow to complete before responding:
 
@@ -115,12 +149,12 @@ export async function POST(request: Request) {
 ```
 
 <Callout type="warn">
-Be cautious when waiting for `returnValue` - if your workflow takes a long time, your API route may timeout.
+Waiting for `returnValue` can cause your API route to time out if the workflow takes a long time.
 </Callout>
 
-### Stream Updates to Client
+### Stream updates to client
 
-Stream real-time updates from your workflow as it executes, without waiting for completion:
+Stream updates from your workflow as it executes without waiting for completion:
 
 ```typescript lineNumbers
 import { start } from "workflow/api";
@@ -144,7 +178,7 @@ export async function POST(request: Request) {
 }
 ```
 
-Your workflow can obtain a writable stream using [`getWritable()`](/docs/api-reference/workflow/get-writable):
+Your workflow can write to the stream using [`getWritable()`](/docs/api-reference/workflow/get-writable):
 
 ```typescript lineNumbers
 import { getWritable } from "workflow";
@@ -178,12 +212,12 @@ async function streamContentToClient(
 ```
 
 <Callout type="info">
-Streams are particularly useful for AI workflows where you want to show progress to users in real-time, or for long-running processes that produce intermediate results.
+Use streams to show users real-time progress from AI workflows or intermediate results from long-running processes.
 </Callout>
 
-**Learn more**: [Streaming in Workflows](/docs/foundations/serialization#streaming)
+**Learn more**: [Streaming in workflows](/docs/foundations/serialization#streaming)
 
-### Check Status Later
+### Check status later
 
 You can retrieve a workflow run later using its `runId` with [`getRun()`](/docs/api-reference/workflow-api/get-run):
 
@@ -209,10 +243,52 @@ export async function GET(request: Request) {
 }
 ```
 
-## Next Steps
+### Recursive and repeating workflows
+
+A workflow can start a new instance of itself. This pattern prevents a single long-running workflow from accumulating too many events. Large event logs are slower to replay, more expensive to store, and harder to inspect in the UI. Breaking work into smaller runs that chain together keeps each run lean.
+
+```typescript lineNumbers
+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]
+  }
+}
+```
+
+This pattern also enables **repeating cron-like workflows**. A workflow can complete its work, sleep, and then schedule a new instance of itself. This creates an indefinite chain without allowing any single run to grow too large:
+
+```typescript lineNumbers
+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]
+}
+```
+
+#### Starting against the latest deployment
+
+By default a chained run starts on the same deployment as its parent. For workflows that chain over long periods, pass [`deploymentId: "latest"`](/docs/api-reference/workflow-api/start#using-deploymentid-latest) so the next run picks up new code. [Versioning](/docs/foundations/versioning#self-upgrading-workflows) covers this pattern in full, including how the serialized state acts as the migration boundary between versions.
 
-Now that you understand how to start workflows and track their execution:
+## Next steps
 
 - Browse the [Cookbook](/cookbook) for copy-paste recipes covering composition, scheduling, timeouts, and more
-- Explore [Errors & Retrying](/docs/foundations/errors-and-retries) to handle failures gracefully
-- Check the [`start()` API Reference](/docs/api-reference/workflow-api/start) for complete details
+- Explore [Errors and retrying](/docs/foundations/errors-and-retries) to handle failures
+- Check the [`start()` API reference](/docs/api-reference/workflow-api/start) for complete details

package/docs/foundations/streaming.mdx

@@ -1,8 +1,8 @@
 ---
 title: Streaming
-description: Stream data in real-time to clients for progress updates and incremental content delivery.
+description: Stream data in real time to clients for progress updates and incremental content delivery.
 type: conceptual
-summary: Stream real-time data to clients without waiting for workflow completion.
+summary: Stream data to clients in real time without waiting for workflow completion.
 prerequisites:
   - /docs/foundations/workflows-and-steps
 related:
@@ -10,9 +10,9 @@ related:
   - /docs/ai/resumable-streams
 ---
 
-Workflows can stream data in real-time to clients without waiting for the entire workflow to complete. This enables progress updates, AI-generated content, log messages, and other incremental data to be delivered as workflows execute.
+Workflows can stream data to clients in real time without waiting for the entire workflow to complete. Clients can receive progress updates, AI-generated content, log messages, and other incremental data as workflows execute.
 
-## Getting Started with `getWritable()`
+## Getting started with `getWritable()`
 
 Every workflow run has a default writable stream that steps can write to using [`getWritable()`](/docs/api-reference/workflow/get-writable). Data written to this stream becomes immediately available to clients consuming the workflow's output.
 
@@ -38,7 +38,7 @@ export async function simpleStreamingWorkflow() {
 }
 ```
 
-### Consuming the Stream
+### Consuming the stream
 
 Use the `Run` object's `readable` property to consume the stream from your API route:
 
@@ -58,7 +58,31 @@ export async function POST() {
 
 When a client makes a request to this endpoint, they'll receive each message as it's written, without waiting for the workflow to complete.
 
-### Resuming Streams from a Specific Point
+### Avoiding function timeouts after client disconnects
+
+On Vercel, `run.readable` and `run.getReadable()` reconnect to Workflow's stream storage while the workflow is still running. By default, a client disconnect does not terminate the Vercel Function serving the stream. If a user closes the page or stops the request, the function can therefore keep reconnecting until it reaches its maximum duration and fails with `FUNCTION_INVOCATION_TIMEOUT`.
+
+For streaming routes using the Node.js runtime, opt in to [request cancellation](https://vercel.com/docs/functions/functions-api-reference#enable-cancellation) in `vercel.json`:
+
+```json filename="vercel.json"
+{
+  "functions": {
+    "app/api/stream/route.ts": {
+      "supportsCancellation": true
+    }
+  }
+}
+```
+
+Replace the function path with the path or glob for your streaming route. When the downstream client disconnects, Vercel terminates the matching function invocation instead of leaving its stream reader running. The workflow run and its durable stream continue independently, so the client can reconnect through another route invocation later.
+
+<Callout type="warn">
+Cancellation applies to every function matching the configured path or glob, even if the route does not listen to `request.signal`. Any other work in that invocation which is not wrapped in [`waitUntil`](https://vercel.com/docs/functions/functions-api-reference/vercel-functions-package#waituntil) or [`after`](https://nextjs.org/docs/app/api-reference/functions/after) can be lost. Only enable it for routes that are safe to terminate when their client disconnects.
+</Callout>
+
+This setting prevents abandoned stream readers from consuming the rest of a function invocation. It does not extend the function's maximum duration. An actively connected streaming response can still reach the configured limit, at which point the client should reconnect to the durable stream.
+
+### Resuming streams from a specific point
 
 Use `run.getReadable({ startIndex })` to resume a stream from a specific position. This is useful for reconnecting after timeouts or network interruptions:
 
@@ -85,7 +109,7 @@ export async function GET(
 }
 ```
 
-This allows clients to reconnect and continue receiving data from where they left off, rather than restarting from the beginning.
+Clients can reconnect and continue receiving data from where they left off instead of restarting from the beginning.
 
 `startIndex` also supports **negative values** to read relative to the end of the stream. For example, `startIndex: -5` starts 5 chunks before the current end. This is useful when you want to show the most recent output without reading the entire stream history.
 
@@ -103,31 +127,32 @@ If the absolute value exceeds the total number of chunks, reading starts from th
 Because streams are live and continue receiving chunks, negative `startIndex` values resolve to different absolute positions on each call. Accurate pagination over a live stream requires cursor-based access, which is not yet supported. Keep this in mind when building clients that paginate over stream data.
 </Callout>
 
-## Streams as Data Types
+## Streams as data types
 
-[`ReadableStream`](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream) and [`WritableStream`](https://developer.mozilla.org/en-US/docs/Web/API/WritableStream) are standard Web Streams API types that Workflow SDK makes serializable. These are not custom types - they follow the web standard - but Workflow SDK adds the ability to pass them between functions while maintaining their streaming capabilities.
+[`ReadableStream`](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream) and [`WritableStream`](https://developer.mozilla.org/en-US/docs/Web/API/WritableStream) are standard Web Streams API types that Workflow SDK makes serializable. Workflow SDK lets you pass these standard types between functions while maintaining their streaming capabilities.
 
 Unlike regular values that are fully serialized to the [event log](/docs/how-it-works/event-sourcing), streams maintain their streaming capabilities when passed between functions.
 
 **Key properties:**
+
 - Stream references can be passed between workflow and step functions
 - Stream data flows directly without being stored in the event log
 - Streams preserve their state across workflow suspension points
 
 <Callout type="info">
-**How Streams Persist Across Workflow Suspensions**
+**How streams persist across workflow suspensions**
 
-Streams in Workflow SDK are backed by persistent, resumable storage provided by the "world" implementation. This is what enables streams to maintain their state even when workflows suspend and resume:
+Persistent, resumable storage from the World implementation lets Workflow SDK streams maintain their state when workflows suspend and resume:
 
 - **Vercel deployments**: Streams are backed by a performant Redis-based stream
 - **Local development**: Stream chunks are stored in the filesystem
 </Callout>
 
-### Passing Streams as Arguments
+### Passing streams as arguments
 
-Since streams are serializable data types, you don't need to use the special [`getWritable()`](/docs/api-reference/workflow/get-writable). You can even wire your own streams through workflows, passing them as arguments from outside into steps.
+Because streams are serializable data types, you don't need to use [`getWritable()`](/docs/api-reference/workflow/get-writable). You can pass your own streams as arguments from outside a workflow into steps.
 
-Here's an example of passing a request body stream through a workflow to a step that processes it:
+The following example passes a request body stream through a workflow to a step that processes it:
 
 ```typescript title="app/api/upload/route.ts" lineNumbers
 import { start } from "workflow/api";
@@ -167,15 +192,15 @@ async function processInputStream(input: ReadableStream<Uint8Array>) {
 }
 ```
 
-## Important Limitation
+## Important limitation
 
 <Callout type="info">
-**Streams Cannot Be Used Directly in Workflow Context**
+**Streams cannot be used directly in workflow context**
 
 You cannot read from or write to streams directly within a workflow function. All stream operations must happen in step functions.
 </Callout>
 
-Workflow functions must be deterministic to support replay. Since streams bypass the [event log](/docs/how-it-works/event-sourcing) for performance, reading stream data in a workflow would break determinism - each replay could see different data. By requiring all stream operations to happen in steps, the framework ensures consistent behavior.
+Workflow functions must be deterministic to support replay. Streams bypass the [event log](/docs/how-it-works/event-sourcing) for performance, so reading stream data in a workflow would break determinism because each replay could see different data. Requiring all stream operations to happen in steps ensures consistent behavior.
 
 For more on determinism and replay, see [Workflows and Steps](/docs/foundations/workflows-and-steps).
 
@@ -214,7 +239,7 @@ async function writeToStream(data: string) {
 }
 ```
 
-## Namespaced Streams
+## Namespaced streams
 
 Use `getWritable({ namespace: 'name' })` to create multiple independent streams for different types of data. This is useful when you want to separate logs, metrics, data outputs, or other distinct channels.
 
@@ -264,7 +289,7 @@ export async function multiStreamWorkflow() {
 }
 ```
 
-### Consuming Namespaced Streams
+### Consuming namespaced streams
 
 Use `run.getReadable({ namespace: 'name' })` to access specific streams:
 
@@ -289,9 +314,37 @@ export async function POST(request: Request) {
 }
 ```
 
-## Common Patterns
+## Writing to another run's stream
+
+`getRun(runId).getWritable()` appends to a stream owned by another run. This lets short-lived runs contribute to a long-lived holder run's stream using only its ID.
 
-### Progress Updates for Long-Running Tasks
+```typescript title="workflows/turn.ts" lineNumbers
+import { getRun } from "workflow/api";
+
+type SessionEvent = { turn: number; text: string };
+
+async function runTurn(holderRunId: string, turn: number) {
+  "use step";
+
+  const writable = getRun(holderRunId).getWritable<SessionEvent>(); // [!code highlight]
+  const writer = writable.getWriter();
+
+  await writer.write({ turn, text: "done" });
+  writer.releaseLock(); // [!code highlight]
+}
+```
+
+Pass `{ namespace: "name" }` to target a [namespaced stream](#namespaced-streams). The writable can also be forwarded through `start()` and into steps.
+
+<Callout type="warn">
+Contributors should call `releaseLock()`, which flushes pending writes. Calling `close()` closes the shared stream for every writer.
+</Callout>
+
+The API grants append access, not read access or additional authorization. The owning run controls the stream's lifecycle, and writes to an unknown run fail.
+
+## Common patterns
+
+### Progress updates for long-running tasks
 
 Send incremental progress updates to keep users informed during lengthy workflows:
 
@@ -345,29 +398,19 @@ export async function batchProcessingWorkflow(items: string[]) {
 }
 ```
 
-### Streaming AI Responses with `DurableAgent`
+### Streaming AI responses with `WorkflowAgent`
 
-Stream AI-generated content using [`DurableAgent`](/docs/api-reference/workflow-ai/durable-agent) from `@workflow/ai`. Tools can also emit progress updates to the same stream using [data chunks](https://ai-sdk.dev/docs/ai-sdk-ui/streaming-data#streaming-custom-data) with the [`UIMessageChunk`](https://ai-sdk.dev/docs/ai-sdk-ui/stream-protocol) type from the AI SDK:
+Stream AI-generated content using AI SDK's [`WorkflowAgent`](https://ai-sdk.dev/v7/docs/agents/workflow-agent#workflowagent) from `@ai-sdk/workflow`. The agent writes `ModelCallStreamPart` chunks to the workflow stream, and route handlers convert them to UI message chunks with `createModelCallToUIChunkTransform()` before returning the response:
 
 ```typescript title="workflows/ai-assistant.ts" lineNumbers
-import { DurableAgent } from "@workflow/ai/agent";
+import { WorkflowAgent, type ModelCallStreamPart } from "@ai-sdk/workflow";
+import { tool } from "ai";
 import { getWritable } from "workflow";
 import { z } from "zod";
-import type { UIMessageChunk } from "ai";
 
 async function searchFlights({ query }: { query: string }) {
   "use step";
 
-  // Tools can emit progress updates to the stream
-  const writable = getWritable<UIMessageChunk>(); // [!code highlight]
-  const writer = writable.getWriter(); // [!code highlight]
-  await writer.write({ // [!code highlight]
-    type: "data-progress", // [!code highlight]
-    data: { message: `Searching flights for ${query}...` }, // [!code highlight]
-    transient: true, // [!code highlight]
-  }); // [!code highlight]
-  writer.releaseLock(); // [!code highlight]
-
   // ... search logic ...
   return { flights: [/* results */] };
 }
@@ -375,27 +418,28 @@ async function searchFlights({ query }: { query: string }) {
 export async function aiAssistantWorkflow(userMessage: string) {
   "use workflow";
 
-  const agent = new DurableAgent({
+  const agent = new WorkflowAgent({
     model: "anthropic/claude-haiku-4.5",
-    system: "You are a helpful flight assistant.",
+    instructions: "You are a helpful flight assistant.",
     tools: {
-      searchFlights: {
+      searchFlights: tool({
         description: "Search for flights",
         inputSchema: z.object({ query: z.string() }),
         execute: searchFlights,
-      },
+      }),
     },
   });
 
   // LLM response will be streamed to the run's writable
   await agent.stream({
     messages: [{ role: "user", content: userMessage }],
-    writable: getWritable<UIMessageChunk>(), // [!code highlight]
+    writable: getWritable<ModelCallStreamPart>(), // [!code highlight]
   });
 }
 ```
 
 ```typescript title="app/api/ai-assistant/route.ts" lineNumbers
+import { createModelCallToUIChunkTransform } from "@ai-sdk/workflow";
 import { createUIMessageStreamResponse } from "ai";
 import { start } from "workflow/api";
 import { aiAssistantWorkflow } from "./workflows/ai";
@@ -406,16 +450,16 @@ export async function POST(request: Request) {
   const run = await start(aiAssistantWorkflow, [message]);
 
   return createUIMessageStreamResponse({
-    stream: run.readable,
+    stream: run.readable.pipeThrough(createModelCallToUIChunkTransform()), // [!code highlight]
   });
 }
 ```
 
 <Callout type="info">
-For a complete implementation, see the [flight booking example](https://github.com/vercel/workflow-examples/tree/main/flight-booking-app) which demonstrates streaming AI responses with tool progress updates.
+For the full agent API and migration notes, see the [`WorkflowAgent` documentation](https://ai-sdk.dev/v7/docs/agents/workflow-agent#workflowagent).
 </Callout>
 
-### Streaming Between Steps
+### Streaming between steps
 
 One step produces a stream and another step consumes it:
 
@@ -456,7 +500,7 @@ async function consumeData(readable: ReadableStream<number>) {
 }
 ```
 
-### Processing Large Files Without Memory Overhead
+### Processing large files without memory overhead
 
 Process large files by streaming chunks through transformation steps:
 
@@ -497,7 +541,11 @@ async function uploadResult(stream: ReadableStream<Uint8Array>) {
 }
 ```
 
-## Best Practices
+## Best practices
+
+**Batching and first-chunk latency:**
+
+Writes are flushed immediately by default. The leading chunk of an idle stream dispatches as soon as it is written, and chunks arriving while a flush is in flight coalesce into the next batch. If you write bursts of many tiny chunks and prefer fewer round trips over first-chunk latency, set a group-commit window with the World's `streamFlushIntervalMs` option or the `WORKFLOW_STREAM_FLUSH_INTERVAL_MS` environment variable. See [Worlds configuration](/docs/configuration/worlds#streamflushintervalms).
 
 **Release locks properly:**
 
@@ -515,7 +563,7 @@ Stream locks acquired in a step only apply within that step, not across other st
 </Callout>
 
 <Callout type="warn">
-If a lock is not released, the step function's HTTP request cannot terminate. Even though the step returns and the workflow continues, the underlying request will remain active until it times out—wasting compute resources unnecessarily.
+If a lock is not released, the invocation that ran the step cannot terminate. Even though the step returns and the workflow continues, the underlying request remains active until it times out and wastes compute resources.
 </Callout>
 
 **Close streams when done:**
@@ -541,7 +589,7 @@ const writer = writable.getWriter();
 await writer.write({ /* typed data */ });
 ```
 
-## Stream Failures
+## Stream failures
 
 When a step returns a stream, the step is considered successful once it returns, even if the stream later encounters an error. The workflow won't automatically retry the step. The consumer of the stream must handle errors gracefully. For more on retry behavior, see [Errors and Retries](/docs/foundations/errors-and-retries).
 
@@ -584,17 +632,17 @@ export async function streamErrorWorkflow() {
 ```
 
 <Callout type="info">
-Stream errors don't trigger automatic retries for the producer step. Design your stream consumers to handle errors appropriately. Since the stream is already in an errored state, retrying the consumer won't help - use `FatalError` to fail the workflow immediately.
+Stream errors don't trigger automatic retries for the producer step. Design your stream consumers to handle errors. Because the stream is already in an errored state, retrying the consumer won't help. Use `FatalError` to fail the workflow immediately.
 </Callout>
 
-## Related Documentation
-
-- [`getWritable()` API Reference](/docs/api-reference/workflow/get-writable) - Get the workflow's writable stream
-- [`sleep()` API Reference](/docs/api-reference/workflow/sleep) - Pause workflow execution for a duration
-- [`start()` API Reference](/docs/api-reference/workflow-api/start) - Start workflows and access the `Run` object
-- [`getRun()` API Reference](/docs/api-reference/workflow-api/get-run) - Retrieve runs and their streams later
-- [world.streams](/docs/api-reference/workflow-api/world/streams) - Low-level stream read/write/close via World SDK
-- [DurableAgent](/docs/api-reference/workflow-ai/durable-agent) - AI agents with built-in streaming support
-- [Errors and Retries](/docs/foundations/errors-and-retries) - Understanding error handling and retry behavior
-- [Serialization](/docs/foundations/serialization) - Understanding what data types can be passed in workflows
-- [Workflows and Steps](/docs/foundations/workflows-and-steps) - Core concepts of workflow execution
+## Related documentation
+
+- [`getWritable()` API reference](/docs/api-reference/workflow/get-writable): Get the workflow's writable stream
+- [`sleep()` API reference](/docs/api-reference/workflow/sleep): Pause workflow execution for a duration
+- [`start()` API reference](/docs/api-reference/workflow-api/start): Start workflows and access the `Run` object
+- [`getRun()` API reference](/docs/api-reference/workflow-api/get-run): Retrieve runs and their streams later
+- [`world.streams`](/docs/api-reference/workflow-runtime/world/streams): Use low-level stream read, write, and close operations through the World SDK
+- [`WorkflowAgent`](https://ai-sdk.dev/v7/docs/agents/workflow-agent#workflowagent): Build AI agents with durable, resumable streaming support
+- [Errors and retries](/docs/foundations/errors-and-retries): Understand error handling and retry behavior
+- [Serialization](/docs/foundations/serialization): Understand which data types you can pass in workflows
+- [Workflows and steps](/docs/foundations/workflows-and-steps): Learn the core concepts of workflow execution