@mastra/mcp-docs-server 1.1.28 → 1.1.29-alpha.11

package/.docs/reference/configuration.md

@@ -36,6 +36,69 @@ export const mastra = new Mastra({
 })
 ```
 
+### backgroundTasks
+
+**Type:** `BackgroundTaskManagerConfig`
+
+Enables and configures the background task manager. When enabled, agents can dispatch long-running tool calls (including subagent invocations) to run asynchronously while the agentic loop continues. Tasks are persisted, so a configured `storage` backend is required.
+
+Visit the [Background tasks documentation](https://mastra.ai/docs/agents/background-tasks) to learn more.
+
+```typescript
+import { Mastra } from '@mastra/core'
+import { LibSQLStore } from '@mastra/libsql'
+
+export const mastra = new Mastra({
+  storage: new LibSQLStore({
+    id: 'mastra-storage',
+    url: 'file:./mastra.db',
+  }),
+  backgroundTasks: {
+    enabled: true,
+    globalConcurrency: 10,
+    perAgentConcurrency: 5,
+    backpressure: 'queue',
+    defaultTimeoutMs: 300_000,
+  },
+})
+```
+
+**enabled** (`boolean`): Whether background tasks are enabled. The manager only initializes when this is true and a storage backend is configured. (Default: `false`)
+
+**globalConcurrency** (`number`): Maximum number of background tasks running concurrently across all agents. (Default: `10`)
+
+**perAgentConcurrency** (`number`): Maximum number of background tasks running concurrently for a single agent. (Default: `5`)
+
+**backpressure** (`'queue' | 'reject' | 'fallback-sync'`): Behavior when a concurrency limit is reached. 'queue' waits for a slot, 'reject' throws on enqueue, 'fallback-sync' runs the tool synchronously in the agentic loop instead. (Default: `'queue'`)
+
+**defaultTimeoutMs** (`number`): Default per-task timeout in milliseconds. Can be overridden per-tool or per-call. (Default: `300000`)
+
+**defaultRetries** (`RetryConfig`): Default retry policy applied to tasks that fail.
+
+**defaultRetries.maxRetries** (`number`): Maximum retry attempts before the task is marked failed.
+
+**defaultRetries.retryDelayMs** (`number`): Delay between retries in milliseconds.
+
+**defaultRetries.backoffMultiplier** (`number`): Multiplier applied to retryDelayMs on each subsequent attempt.
+
+**defaultRetries.maxRetryDelayMs** (`number`): Upper bound on the retry delay regardless of backoff.
+
+**defaultRetries.retryableErrors** (`(error: Error) => boolean`): Predicate that decides whether a given error should be retried. Default: retry all errors.
+
+**cleanup** (`CleanupConfig`): Controls how long task records are kept and how often the cleanup process runs.
+
+**cleanup.completedTtlMs** (`number`): How long to keep completed task records, in milliseconds. Default: 1 hour.
+
+**cleanup.failedTtlMs** (`number`): How long to keep failed task records, in milliseconds. Default: 24 hours.
+
+**cleanup.cleanupIntervalMs** (`number`): How often the cleanup process runs, in milliseconds. Default: 1 minute.
+
+**waitTimeoutMs** (`number`): How long the agentic loop waits for a background task to complete before moving on. If a task has not finished within this time, the loop proceeds without setting isContinued. Default: undefined (do not wait). Can be overridden per-agent or per-tool.
+
+**onTaskComplete** (`(task: BackgroundTask) => void | Promise<void>`): Global callback invoked when any background task completes successfully. Fires in addition to per-tool and per-agent callbacks.
+
+**onTaskFailed** (`(task: BackgroundTask) => void | Promise<void>`): Global callback invoked when any background task fails. Fires in addition to per-tool and per-agent callbacks.
+
 ### deployer
 
 **Type:** `MastraDeployer`

package/.docs/reference/evals/create-scorer.md

@@ -51,6 +51,8 @@ const scorer = createScorer({
 
 **type** (`string`): Type specification for input/output. Use 'agent' for automatic agent types. For custom types, use the generic approach instead.
 
+**prepareRun** (`(run: ScorerRun) => ScorerRun | Promise<ScorerRun>`): Transform the scorer run data before the pipeline executes. Use this to filter messages, limit context size, or drop fields the scorer doesn't need. The \[\`filterRun()\`]\(/reference/evals/filter-run) utility creates this function from declarative options. Can be async.
+
 This function returns a scorer builder that you can chain step methods onto. See the [MastraScorer reference](https://mastra.ai/reference/evals/mastra-scorer) for details on the `.run()` method and its input/output.
 
 The judge only runs for steps defined as **prompt objects** (`preprocess`, `analyze`, `generateScore`, `generateReason` in prompt mode). If you use function steps only, the judge is never called and there is no LLM output to inspect. In that case, any score/reason must be produced by your functions.

package/.docs/reference/evals/filter-run.md

@@ -0,0 +1,117 @@
+# filterRun()
+
+Creates a `prepareRun` function from declarative options. Pass the result to `createScorer()` to filter messages, limit context size, and drop unnecessary fields before the scorer pipeline runs.
+
+Use [`filterRun()`](#usage-example) for declarative filtering. Write a custom `prepareRun` function directly when you need imperative logic that `filterRun()` doesn't cover. See [Custom scorers: input filtering](https://mastra.ai/docs/evals/custom-scorers) for more.
+
+## Usage example
+
+The following example creates a scorer that only sees tool invocations and text messages, limited to the 20 most recent context messages:
+
+```typescript
+import { createScorer, filterRun } from '@mastra/core/evals'
+
+const toolScorer = createScorer({
+  id: 'tool-usage',
+  description: 'Evaluates tool usage patterns',
+  type: 'agent',
+  prepareRun: filterRun({
+    partTypes: ['tool-invocation', 'text'],
+    maxRememberedMessages: 20,
+  }),
+}).generateScore(({ run }) => {
+  // run.input.rememberedMessages contains only tool and text messages
+  // run.output contains only tool and text messages
+  return 1
+})
+```
+
+### Filter by tool name
+
+Keep only messages involving specific tools:
+
+```typescript
+import { createScorer, filterRun } from '@mastra/core/evals'
+
+const fileEditScorer = createScorer({
+  id: 'file-edit-quality',
+  description: 'Evaluates file editing patterns',
+  type: 'agent',
+  prepareRun: filterRun({
+    toolNames: ['write_file', 'string_replace_lsp', 'view'],
+  }),
+}).generateScore(({ run }) => {
+  // Only messages with these tool calls remain
+  return 1
+})
+```
+
+### Drop fields
+
+Remove fields the scorer doesn't need:
+
+```typescript
+import { createScorer, filterRun } from '@mastra/core/evals'
+
+const simpleScorer = createScorer({
+  id: 'response-length',
+  description: 'Checks response length',
+  type: 'agent',
+  prepareRun: filterRun({
+    dropRequestContext: true,
+    dropExpectedTrajectory: true,
+    dropGroundTruth: true,
+    maxOutputMessages: 5,
+  }),
+}).generateScore(({ run }) => {
+  return run.output.length > 0 ? 1 : 0
+})
+```
+
+## Parameters
+
+**options** (`FilterRunOptions`): Configuration object that controls what data the scorer receives.
+
+**options.partTypes** (`MastraPartType[]`): Keep only messages whose parts match these types. Each entry is prefix-matched against the message part's type. Plain text messages (no tool invocations) are always kept unless explicitly excluded. System messages and tagged system messages are never filtered.
+
+**options.toolNames** (`string[]`): Keep only tool-invocation messages for these specific tools. Each entry is prefix-matched against the tool name. Non-tool messages (text, data) are unaffected.
+
+**options.maxRememberedMessages** (`number`): Maximum number of messages to keep in remembered messages (context). Takes from the end (most recent). Applied after type and tool filtering.
+
+**options.maxOutputMessages** (`number`): Maximum number of messages to keep in the output. Takes from the end. Applied after type and tool filtering.
+
+**options.dropRequestContext** (`boolean`): Remove request context from the run entirely.
+
+**options.dropExpectedTrajectory** (`boolean`): Remove expected trajectory from the run.
+
+**options.dropGroundTruth** (`boolean`): Remove ground truth from the run.
+
+**Returns:** `(run: ScorerRun) => ScorerRun` — A function suitable for the `prepareRun` option on [`createScorer()`](https://mastra.ai/reference/evals/create-scorer).
+
+## Part types
+
+The `partTypes` option accepts `MastraPartType` values. Each value is prefix-matched, so `'data-'` matches all data part types.
+
+| Type                | Description                                  |
+| ------------------- | -------------------------------------------- |
+| `'text'`            | Text content parts                           |
+| `'tool-invocation'` | Tool call and result parts                   |
+| `'reasoning'`       | Chain-of-thought reasoning parts             |
+| `'step-start'`      | Step marker parts                            |
+| `'image'`           | Image parts                                  |
+| `'file'`            | File parts                                   |
+| `'source'`          | Source reference parts                       |
+| `'source-document'` | Source document parts                        |
+| `'data-'`           | All data parts (matches any `data-*` prefix) |
+| `'data-om-'`        | Observational memory data parts              |
+| `'data-workspace-'` | Workspace data parts                         |
+| `'data-sandbox-'`   | Sandbox data parts                           |
+| `'data-tool-'`      | Tool-related data parts                      |
+
+## Filtering behavior
+
+- **Part type filtering** applies to both `input.rememberedMessages` and `output` when they contain agent message arrays.
+- **Tool name filtering** only affects messages that contain tool invocations. Text-only messages pass through.
+- **System messages** (`systemMessages`, `taggedSystemMessages`) are never filtered, regardless of `partTypes` or `toolNames`.
+- **Message limits** (`maxRememberedMessages`, `maxOutputMessages`) apply after type and tool filtering, taking the most recent messages.
+- When both `partTypes` and `toolNames` are set, a message must satisfy both filters to be kept.

package/.docs/reference/index.md

@@ -96,6 +96,7 @@ The Reference section provides documentation of Mastra's API, including paramete
 - [MastraEditor Class](https://mastra.ai/reference/editor/mastra-editor)
 - [ToolProvider](https://mastra.ai/reference/editor/tool-provider)
 - [createScorer()](https://mastra.ai/reference/evals/create-scorer)
+- [filterRun()](https://mastra.ai/reference/evals/filter-run)
 - [MastraScorer](https://mastra.ai/reference/evals/mastra-scorer)
 - [runEvals()](https://mastra.ai/reference/evals/run-evals)
 - [Scorer Utils](https://mastra.ai/reference/evals/scorer-utils)
@@ -208,6 +209,7 @@ The Reference section provides documentation of Mastra's API, including paramete
 - [MastraModelOutput](https://mastra.ai/reference/streaming/agents/MastraModelOutput)
 - [.stream()](https://mastra.ai/reference/streaming/agents/stream)
 - [.streamLegacy()](https://mastra.ai/reference/streaming/agents/streamLegacy)
+- [.streamUntilIdle()](https://mastra.ai/reference/streaming/agents/streamUntilIdle)
 - [.observeStream()](https://mastra.ai/reference/streaming/workflows/observeStream)
 - [.resumeStream()](https://mastra.ai/reference/streaming/workflows/resumeStream)
 - [.stream()](https://mastra.ai/reference/streaming/workflows/stream)
@@ -285,6 +287,7 @@ The Reference section provides documentation of Mastra's API, including paramete
 - [.startAsync()](https://mastra.ai/reference/workflows/run-methods/startAsync)
 - [.timeTravel()](https://mastra.ai/reference/workflows/run-methods/timeTravel)
 - [AgentFSFilesystem](https://mastra.ai/reference/workspace/agentfs-filesystem)
+- [AzureBlobFilesystem](https://mastra.ai/reference/workspace/azure-blob-filesystem)
 - [BlaxelSandbox](https://mastra.ai/reference/workspace/blaxel-sandbox)
 - [DaytonaSandbox](https://mastra.ai/reference/workspace/daytona-sandbox)
 - [DockerSandbox](https://mastra.ai/reference/workspace/docker-sandbox)

package/.docs/reference/memory/clone-utilities.md

@@ -153,8 +153,10 @@ async function manageClones() {
 
   // Have a conversation...
   await agent.generate("Hello! Let's discuss project options.", {
-    threadId: originalThread.id,
-    resourceId: 'user-123',
+    memory: {
+      thread: originalThread.id,
+      resource: 'user-123',
+    },
   })
 
   // Create multiple branches (clones) to explore different paths

package/.docs/reference/memory/cloneThread.md

@@ -93,8 +93,10 @@ const { thread: dateFilteredClone } = await memory.cloneThread({
 
 // Continue conversation on the cloned thread
 const response = await agent.generate("Let's try a different approach", {
-  threadId: fullClone.id,
-  resourceId: fullClone.resourceId,
+  memory: {
+    thread: fullClone.id,
+    resource: fullClone.resourceId,
+  },
 })
 ```
 

package/.docs/reference/processors/skill-search-processor.md

@@ -47,7 +47,7 @@ import { Workspace, LocalFilesystem } from '@mastra/core/workspace'
 
 const workspace = new Workspace({
   filesystem: new LocalFilesystem({ basePath: './project' }),
-  skills: ['/skills'],
+  skills: ['skills'],
   bm25: true,
 })
 

package/.docs/reference/server/routes.md

@@ -4,14 +4,15 @@ Server adapters register these routes when you call `server.init()`. All routes
 
 ## Agents
 
-| Method | Path                                         | Description                                     |
-| ------ | -------------------------------------------- | ----------------------------------------------- |
-| `GET`  | `/api/agents`                                | List all agents                                 |
-| `GET`  | `/api/agents/:agentId`                       | Get agent by ID (supports version query params) |
-| `POST` | `/api/agents/:agentId/generate`              | Generate agent response                         |
-| `POST` | `/api/agents/:agentId/stream`                | Stream agent response                           |
-| `GET`  | `/api/agents/:agentId/tools`                 | List agent tools                                |
-| `POST` | `/api/agents/:agentId/tools/:toolId/execute` | Execute agent tool                              |
+| Method | Path                                         | Description                                      |
+| ------ | -------------------------------------------- | ------------------------------------------------ |
+| `GET`  | `/api/agents`                                | List all agents                                  |
+| `GET`  | `/api/agents/:agentId`                       | Get agent by ID (supports version query params)  |
+| `POST` | `/api/agents/:agentId/generate`              | Generate agent response                          |
+| `POST` | `/api/agents/:agentId/stream`                | Stream agent response                            |
+| `POST` | `/api/agents/:agentId/resume-stream`         | Resume a suspended agent stream with custom data |
+| `GET`  | `/api/agents/:agentId/tools`                 | List agent tools                                 |
+| `POST` | `/api/agents/:agentId/tools/:toolId/execute` | Execute agent tool                               |
 
 ### Get agent query parameters
 

package/.docs/reference/streaming/ChunkType.md

@@ -398,6 +398,146 @@ Contains output from workflow step execution, used primarily for usage tracking
 
 **payload.output** (`ChunkType`): Nested chunk data from step execution, typically containing finish events or other step results
 
+## Background task chunks
+
+Emitted when a tool call is dispatched as a [background task](https://mastra.ai/docs/agents/background-tasks) and `streamUntilIdle()` is used.
+
+### background-task-started
+
+Emitted when a tool call is enqueued as a background task and assigned a `taskId`.
+
+**type** (`"background-task-started"`): Chunk type identifier
+
+**payload** (`BackgroundTaskStartedPayload`): Identifies the newly enqueued task
+
+**payload.taskId** (`string`): Unique identifier for the background task
+
+**payload.toolName** (`string`): Name of the tool being executed
+
+**payload.toolCallId** (`string`): Tool-call ID from the originating LLM tool call
+
+### background-task-running
+
+Emitted when a worker picks up the task and execution begins.
+
+**type** (`"background-task-running"`): Chunk type identifier
+
+**payload** (`BackgroundTaskRunningPayload`): Details about the running task
+
+**payload.taskId** (`string`): Unique identifier for the background task
+
+**payload.toolName** (`string`): Name of the tool being executed
+
+**payload.toolCallId** (`string`): Tool-call ID from the originating LLM tool call
+
+**payload.runId** (`string`): Run ID of the agent that dispatched the task
+
+**payload.agentId** (`string`): ID of the agent that dispatched the task
+
+**payload.startedAt** (`Date`): Timestamp at which execution started
+
+**payload.args** (`Record<string, unknown>`): Arguments passed to the tool's execute function
+
+### background-task-progress
+
+Periodic snapshot of how many background tasks are currently running across the agent.
+
+**type** (`"background-task-progress"`): Chunk type identifier
+
+**payload** (`BackgroundTaskProgressPayload`): Aggregate progress for all running tasks
+
+**payload.taskIds** (`string[]`): IDs of all currently running background tasks
+
+**payload.runningCount** (`number`): Number of background tasks currently running
+
+**payload.elapsedMs** (`number`): Milliseconds elapsed since the agent run started
+
+### background-task-output
+
+A streamed output chunk emitted by the task's `execute` function. Wraps an inner [`tool-output`](#tool-output) chunk.
+
+**type** (`"background-task-output"`): Chunk type identifier
+
+**payload** (`BackgroundTaskOutputPayload`): Streamed output from the running task
+
+**payload.taskId** (`string`): Unique identifier for the background task
+
+**payload.toolName** (`string`): Name of the tool being executed
+
+**payload.toolCallId** (`string`): Tool-call ID from the originating LLM tool call
+
+**payload.runId** (`string`): Run ID of the agent that dispatched the task
+
+**payload.agentId** (`string`): ID of the agent that dispatched the task
+
+**payload.payload** (`ToolOutputChunk`): Inner tool-output chunk produced by the task
+
+### background-task-completed
+
+Emitted when the task finishes successfully. Triggers a continuation turn when consumed by [`Agent.streamUntilIdle()`](https://mastra.ai/reference/streaming/agents/streamUntilIdle).
+
+**type** (`"background-task-completed"`): Chunk type identifier
+
+**payload** (`BackgroundTaskResultPayload`): The completed task's result
+
+**payload.taskId** (`string`): Unique identifier for the background task
+
+**payload.toolName** (`string`): Name of the tool that was executed
+
+**payload.toolCallId** (`string`): Tool-call ID from the originating LLM tool call
+
+**payload.agentId** (`string`): ID of the agent that dispatched the task
+
+**payload.runId** (`string`): Run ID of the agent that dispatched the task
+
+**payload.result** (`unknown`): The tool's resolved return value
+
+**payload.completedAt** (`Date`): Timestamp at which the task completed
+
+**payload.isError** (`boolean`): True when the tool returned an error result rather than throwing
+
+### background-task-failed
+
+Emitted when the task throws or times out. Triggers a continuation turn when consumed by [`Agent.streamUntilIdle()`](https://mastra.ai/reference/streaming/agents/streamUntilIdle).
+
+**type** (`"background-task-failed"`): Chunk type identifier
+
+**payload** (`BackgroundTaskFailedPayload`): Failure details for the task
+
+**payload.taskId** (`string`): Unique identifier for the background task
+
+**payload.toolName** (`string`): Name of the tool that was executed
+
+**payload.toolCallId** (`string`): Tool-call ID from the originating LLM tool call
+
+**payload.runId** (`string`): Run ID of the agent that dispatched the task
+
+**payload.agentId** (`string`): ID of the agent that dispatched the task
+
+**payload.error** (`{ message: string }`): Error details thrown by the task
+
+**payload.completedAt** (`Date`): Timestamp at which the task failed
+
+### background-task-cancelled
+
+Emitted when the task is cancelled before completing. Triggers a continuation turn when consumed by [`Agent.streamUntilIdle()`](https://mastra.ai/reference/streaming/agents/streamUntilIdle).
+
+**type** (`"background-task-cancelled"`): Chunk type identifier
+
+**payload** (`BackgroundTaskCancelledPayload`): Cancellation details for the task
+
+**payload.taskId** (`string`): Unique identifier for the background task
+
+**payload.toolName** (`string`): Name of the tool that was executed
+
+**payload.toolCallId** (`string`): Tool-call ID from the originating LLM tool call
+
+**payload.runId** (`string`): Run ID of the agent that dispatched the task
+
+**payload.agentId** (`string`): ID of the agent that dispatched the task
+
+**payload.completedAt** (`Date`): Timestamp at which the task was cancelled
+
 ## Metadata and special chunks
 
 ### response-metadata

package/.docs/reference/streaming/agents/streamUntilIdle.md

@@ -0,0 +1,94 @@
+# Agent.streamUntilIdle()
+
+**Added in:** `@mastra/core@1.28.0`
+
+`streamUntilIdle()` streams an agent's response and keeps the stream open until every background task dispatched during the run completes. When a task finishes, its result is written to memory and the agentic loop re-enters automatically so the LLM can react to it. The stream closes once no tasks are running and no completions are queued.
+
+Use it when the agent dispatches background tasks (typically long-running tools or subagents) and you want a single stream that spans the initial response **plus** every continuation triggered by a task completion. For foreground-only runs or if you prefer to manage the continuation manually (manually prompt agent to process the result), use [`Agent.stream()`](https://mastra.ai/reference/streaming/agents/stream).
+
+## Usage example
+
+```ts
+const stream = await agent.streamUntilIdle('Research solana for me', {
+  memory: { thread: 't1', resource: 'u1' },
+})
+
+for await (const chunk of stream.fullStream) {
+  // chunks from the initial turn AND any continuation turns triggered by
+  // background task completions flow through here
+}
+```
+
+> **Info:** `streamUntilIdle()` requires both a [`BackgroundTaskManager`](https://mastra.ai/reference/configuration) and a [memory](https://mastra.ai/docs/memory/overview) backend. Without either, it falls through to a plain `agent.stream()` call.
+
+## Parameters
+
+**messages** (`string | string[] | CoreMessage[] | AiMessageType[] | UIMessageWithMetadata[]`): The messages to send to the agent. Can be a single string, array of strings, or structured message objects.
+
+**options** (`AgentExecutionOptions<Output> & { maxIdleMs?: number }`): Accepts every option that Agent.stream() accepts, plus maxIdleMs. See the Agent.stream() reference for the full list.
+
+**options.maxIdleMs** (`number`): Closes the outer stream after this many ms of idleness between turns. The timer only runs while the wrapper is between turns, so a slow first token does not close the stream. Default: 5 minutes.
+
+**options.memory** (`{ thread?: string | { id: string }; resource?: string }`): Memory thread and resource for the run. Required for continuations to write background task results back into the conversation.
+
+**options.structuredOutput** (`PublicStructuredOutputOptions<Output>`): Schema-based structured output. Same shape as Agent.stream(). Note that aggregate properties resolve against the first turn only.
+
+For every other option (`maxSteps`, `modelSettings`, `toolChoice`, `outputProcessors`, `onFinish`, `onChunk`, etc.), see the [`Agent.stream()` parameters](https://mastra.ai/reference/streaming/agents/stream). `streamUntilIdle()` forwards them to the initial turn.
+
+## Returns
+
+**stream** (`MastraModelOutput<Output>`): A MastraModelOutput where fullStream spans the initial turn plus every auto-continuation. Aggregate properties (text, toolCalls, toolResults, finishReason, messageList, getFullOutput()) resolve against the first turn only.
+
+### Aggregate properties caveat
+
+`streamUntilIdle()` returns a proxy over the first turn's `MastraModelOutput`. Only `fullStream` is replaced with a combined stream that spans every continuation. Every other property — `text`, `toolCalls`, `toolResults`, `finishReason`, `messageList`, `getFullOutput()` — resolves against the **first turn's** internal buffer.
+
+If you need an aggregate view across all continuations, consume `fullStream` yourself and accumulate.
+
+## Continuation behavior
+
+Internally, `streamUntilIdle()`:
+
+1. Runs the initial turn via `agent.stream(...)` and pipes its `fullStream` into the outer stream.
+2. Subscribes to background-task completion events for the resolved memory scope.
+3. Queues each terminal event (`background-task-completed`, `background-task-failed`, `background-task-cancelled`) and, when the outer wrapper is idle between turns, re-invokes `agent.stream([], ...)` with a directive listing the just-completed `toolCallId`s. The continuation turn flows into the same outer stream.
+4. Closes the outer stream once no tasks are running and no completions are queued.
+
+## Extended usage example
+
+### Cap idle time between turns
+
+```ts
+const stream = await agent.streamUntilIdle('Kick off the long jobs', {
+  memory: { thread: 't1', resource: 'u1' },
+  maxIdleMs: 60_000, // close the stream after 1 minute of idleness between turns
+})
+
+for await (const chunk of stream.fullStream) {
+  if (chunk.type === 'background-task-completed') {
+    console.log('Task complete:', chunk.payload.taskId)
+  }
+}
+```
+
+### Aggregate text across continuations
+
+```ts
+const stream = await agent.streamUntilIdle('Research and summarize', {
+  memory: { thread: 't1', resource: 'u1' },
+})
+
+let fullText = ''
+for await (const chunk of stream.fullStream) {
+  if (chunk.type === 'text-delta') {
+    fullText += chunk.payload.text
+  }
+}
+```
+
+## Related
+
+- [Background tasks](https://mastra.ai/docs/agents/background-tasks)
+- [`Agent.stream()` reference](https://mastra.ai/reference/streaming/agents/stream)
+- [backgroundTasks configuration reference](https://mastra.ai/reference/configuration)
+- [Stream chunk types](https://mastra.ai/reference/streaming/ChunkType)