@mastra/mcp-docs-server 1.2.15-alpha.1 → 1.2.15-alpha.10

package/.docs/models/providers/upstage.md

@@ -2,7 +2,7 @@
 
 # ![Upstage logo](https://models.dev/logos/upstage.svg)Upstage
 
-Access 3 Upstage models through Mastra's model router. Authentication is handled automatically using the `UPSTAGE_API_KEY` environment variable.
+Access 4 Upstage models through Mastra's model router. Authentication is handled automatically using the `UPSTAGE_API_KEY` environment variable.
 
 Learn more in the [Upstage documentation](https://developers.upstage.ai).
 
@@ -39,6 +39,7 @@ for await (const chunk of stream) {
 | `upstage/solar-mini` | 33K     |       |           |       |       |       | $0.15      | $0.15       |
 | `upstage/solar-pro2` | 66K     |       |           |       |       |       | $0.25      | $0.25       |
 | `upstage/solar-pro3` | 131K    |       |           |       |       |       | $0.25      | $0.25       |
+| `upstage/solar-pro4` | 524K    |       |           |       |       |       | $0.30      | $1          |
 
 ## Advanced configuration
 
@@ -68,7 +69,7 @@ const agent = new Agent({
   model: ({ requestContext }) => {
     const useAdvanced = requestContext.task === "complex";
     return useAdvanced
-      ? "upstage/solar-pro3"
+      ? "upstage/solar-pro4"
       : "upstage/solar-mini";
   }
 });

package/.docs/models/providers/vivgrid.md

@@ -2,7 +2,7 @@
 
 # ![Vivgrid logo](https://models.dev/logos/vivgrid.svg)Vivgrid
 
-Access 17 Vivgrid models through Mastra's model router. Authentication is handled automatically using the `VIVGRID_API_KEY` environment variable.
+Access 19 Vivgrid models through Mastra's model router. Authentication is handled automatically using the `VIVGRID_API_KEY` environment variable.
 
 Learn more in the [Vivgrid documentation](https://docs.vivgrid.com/models).
 
@@ -37,6 +37,7 @@ for await (const chunk of stream) {
 | Model                                   | Context | Tools | Reasoning | Image | Audio | Video | Input $/1M | Output $/1M |
 | --------------------------------------- | ------- | ----- | --------- | ----- | ----- | ----- | ---------- | ----------- |
 | `vivgrid/deepseek-v3.2`                 | 128K    |       |           |       |       |       | $0.28      | $0.42       |
+| `vivgrid/deepseek-v4-flash`             | 1.0M    |       |           |       |       |       | $0.15      | $0.30       |
 | `vivgrid/deepseek-v4-pro`               | 1.0M    |       |           |       |       |       | $0.43      | $0.87       |
 | `vivgrid/gemini-3.1-flash-lite-preview` | 1.0M    |       |           |       |       |       | $0.25      | $2          |
 | `vivgrid/gemini-3.1-pro-preview`        | 1.0M    |       |           |       |       |       | $2         | $12         |
@@ -53,6 +54,7 @@ for await (const chunk of stream) {
 | `vivgrid/gpt-5.6-luna`                  | 1.1M    |       |           |       |       |       | $1         | $6          |
 | `vivgrid/gpt-5.6-sol`                   | 1.1M    |       |           |       |       |       | $5         | $30         |
 | `vivgrid/gpt-5.6-terra`                 | 1.1M    |       |           |       |       |       | $3         | $15         |
+| `vivgrid/kimi-k3`                       | 1.0M    |       |           |       |       |       | $3         | $15         |
 
 ## Advanced configuration
 
@@ -82,7 +84,7 @@ const agent = new Agent({
   model: ({ requestContext }) => {
     const useAdvanced = requestContext.task === "complex";
     return useAdvanced
-      ? "vivgrid/gpt-5.6-terra"
+      ? "vivgrid/kimi-k3"
       : "vivgrid/deepseek-v3.2";
   }
 });

package/.docs/models/providers/wandb.md

@@ -39,7 +39,7 @@ for await (const chunk of stream) {
 | `wandb/deepseek-ai/DeepSeek-V3.1`                    | 161K    |       |           |       |       |       | $0.55      | $2          |
 | `wandb/deepseek-ai/DeepSeek-V4-Flash`                | 1.0M    |       |           |       |       |       | $0.14      | $0.28       |
 | `wandb/deepseek-ai/DeepSeek-V4-Flash-0731`           | 262K    |       |           |       |       |       | $0.13      | $0.28       |
-| `wandb/deepseek-ai/DeepSeek-V4-Pro`                  | 1.0M    |       |           |       |       |       | $2         | $3          |
+| `wandb/deepseek-ai/DeepSeek-V4-Pro`                  | 1.0M    |       |           |       |       |       | $1         | $3          |
 | `wandb/google/gemma-4-31B-it`                        | 262K    |       |           |       |       |       | $0.10      | $0.34       |
 | `wandb/ibm-granite/granite-4.1-8b`                   | 131K    |       |           |       |       |       | $0.05      | $0.10       |
 | `wandb/JetBrains/Mellum2-12B-A2.5B-Instruct`         | 131K    |       |           |       |       |       | $0.05      | $0.10       |

package/.docs/reference/agents/channels.md

@@ -102,7 +102,9 @@ const agent = new Agent({
 
 **streaming** (`boolean | { updateIntervalMs?: number }`): Stream agent text deltas to the channel as the agent generates them instead of buffering and posting once per step. Requires the underlying adapter to support post-and-edit streaming. Slack defaults to true; other adapters default to false. (Default: `false (true for Slack)`)
 
-**toolDisplay** (`'cards' | 'text' | 'timeline' | 'grouped' | 'hidden' | ToolDisplayFn`): How tool calls are rendered in the channel. "cards" posts per-tool running/result cards as rich Block Kit. "text" posts the same lifecycle as plain text (no Block Kit). "timeline" and "grouped" stream tool state as inline task\_update chunks (requires streaming: true; Slack only today — other adapters may render a placeholder). "hidden" executes tools silently. Pass a function to render tool events yourself; return { kind: "post", message } for a discrete post/edit, { kind: "stream", chunk } to push into the active streaming widget, or undefined to skip rendering that event. Approve/deny prompts always render as a separate card regardless of mode. (Default: `'cards' ('grouped' for Slack)`)
+**textFormat** (`'markdown' | 'plain'`): Dialect for the agent's final reply text. 'markdown' (the default) posts replies as markdown: adapters with native markdown rendering (Slack) render it directly, others convert it to their platform format. 'plain' posts replies as literal plain text, restoring the pre-markdown behavior for agents prompted to emit a platform dialect such as Slack mrkdwn. Applies to final reply text only; tool cards, error messages, and tripwire notices are unaffected. Native streaming is always markdown regardless of this setting. (Default: `'markdown'`)
+
+**toolDisplay** (`'cards' | 'text' | 'timeline' | 'grouped' | 'hidden' | ToolDisplayFn`): How tool calls are rendered in the channel. "cards" posts per-tool running/result cards as rich Block Kit. "text" posts the same lifecycle as plain text (no Block Kit). "timeline" and "grouped" stream tool state as inline task\_update chunks (requires streaming: true; Slack only today — other adapters may render a placeholder). "hidden" executes tools silently. Pass a function to render tool events yourself; return { kind: "post", message } for a discrete post/edit, { kind: "stream", chunk } to push into the streaming widget, or undefined to skip rendering that event. Add openIfEmpty: false to a stream result when its chunk should only apply to an active streaming session. Approve/deny prompts always render as a separate card regardless of mode. (Default: `'cards' ('grouped' for Slack)`)
 
 **typingStatus** (`boolean | ((chunk: AgentChunkType, ctx: TypingStatusContext) => string | false | null | undefined | void)`): Control the platform typing indicator. true uses built-in defaults (is typing… on text, is calling {tool}… on tool-call, is waiting for approval… on tool-call-approval). false suppresses typing entirely — useful when a live streaming widget (e.g. toolDisplay: "grouped" in Slack) already conveys progress. Pass a function to set custom status copy per chunk; return a string to set the status, or false/null/undefined to leave it unchanged. Compose with defaultTypingStatus (exported from @mastra/core/channels) to fall back to defaults for chunks you don't handle. (Default: `true`)
 
@@ -116,6 +118,25 @@ const agent = new Agent({
 
 Pass a function to `toolDisplay` for fully custom rendering. The function receives a `ToolDisplayEvent` (`running` / `result` / `error` / `approval`) and a `ToolDisplayContext` (`{ mode, platform }`); return `{ kind: 'post', message }` for a discrete post/edit, `{ kind: 'stream', chunk }` to push into the active streaming widget, or `undefined` to skip rendering that event.
 
+By default, a stream result opens a streaming session when none is active. Set `openIfEmpty: false` when the chunk only applies to an existing session. Mastra skips the chunk when no session is active. Static channels ignore this option and keep their existing plain-text fallback behavior.
+
+```typescript
+toolDisplay: event => {
+  if (event.kind !== 'running') return undefined
+
+  return {
+    kind: 'stream',
+    chunk: {
+      type: 'task_update',
+      id: event.toolCallId,
+      title: event.displayName,
+      status: 'in_progress',
+    },
+    openIfEmpty: false,
+  }
+}
+```
+
 Approve/deny prompts (`requireApproval`) always render as a separate card regardless of mode, because inline task entries can't carry interactive buttons.
 
 ```typescript

package/.docs/reference/agents/generate.md

@@ -56,7 +56,7 @@ const result = await agent.generate('message for agent')
 
 **options.delegation** (`DelegationConfig`): Configuration for subagent delegation. Use this to control and monitor when the agent delegates tasks to other agents, including the ability to modify, reject delegations, and provide feedback to guide the supervisor.
 
-**options.delegation.onDelegationStart** (`(context: DelegationStartContext) => DelegationStartResult | void | Promise<DelegationStartResult | void>`): Called before delegating to a subagent. Use this to modify the delegation parameters or reject the delegation entirely.
+**options.delegation.onDelegationStart** (`(context: DelegationStartContext) => DelegationStartResult | void | Promise<DelegationStartResult | void>`): Called before delegating to a subagent. Use this to modify the delegation parameters, reject the delegation entirely, or mutate context.requestContext to add entries to the subagent run's request context.
 
 **options.delegation.onDelegationComplete** (`(context: DelegationCompleteContext) => { feedback?: string } | void | Promise<{ feedback?: string } | void>`): Called after a subagent delegation completes. The context includes a bail() method to stop further execution, and you can return { feedback } to guide the supervisor's next action. Feedback is saved to supervisor memory as an assistant message.
 

package/.docs/reference/ai-sdk/chat-route.md

@@ -69,6 +69,8 @@ export const mastra = new Mastra({
 
 **sendSources** (`boolean`): Whether to include source citations in the stream. (Default: `false`)
 
+**heartbeatMs** (`number`): Interval in milliseconds for SSE heartbeats that keep connections active through infrastructure with idle timeouts.
+
 ## Additional configuration
 
 You can use [`prepareSendMessagesRequest`](https://ai-sdk.dev/docs/reference/ai-sdk-ui/use-chat#transport.default-chat-transport.prepare-send-messages-request) to customize the request sent to the chat route, for example to pass additional configuration to the agent:

package/.docs/reference/browser/agent-browser.md

@@ -32,7 +32,7 @@ then interact with elements using their refs (e.g., @e5).`,
 
 **headless** (`boolean`): Whether to run the browser in headless mode (no visible UI). (Default: `true`)
 
-**viewport** (`{ width: number; height: number }`): Browser viewport dimensions. (Default: `{ width: 1280, height: 720 }`)
+**viewport** (`{ width: number; height: number } | 'window'`): Browser viewport dimensions, or 'window' to match the real browser window instead of a fixed size. (Default: `{ width: 1280, height: 720 }`)
 
 **timeout** (`number`): Default timeout in milliseconds for browser operations. (Default: `30000`)
 

package/.docs/reference/browser/mastra-browser.md

@@ -35,7 +35,7 @@ export const browserAgent = new Agent({
 
 **headless** (`boolean`): Whether to run the browser in headless mode (no visible UI). (Default: `true`)
 
-**viewport** (`{ width: number; height: number }`): Browser viewport dimensions. Controls the size of the browser window. (Default: `{ width: 1280, height: 720 }`)
+**viewport** (`{ width: number; height: number } | 'window'`): Browser viewport dimensions. Controls the size of the browser window. Set to 'window' to match the real browser window instead of a fixed size, supported by the agent-browser provider and by Stagehand when connecting over CDP. (Default: `{ width: 1280, height: 720 }`)
 
 **timeout** (`number`): Default timeout in milliseconds. Each provider defines its own semantics and default. See the provider reference for details.
 

package/.docs/reference/browser/stagehand-browser.md

@@ -33,7 +33,7 @@ Use stagehand_extract to get data from pages.`,
 
 **headless** (`boolean`): Whether to run the browser in headless mode. (Default: `true`)
 
-**viewport** (`{ width: number; height: number }`): Browser viewport dimensions. (Default: `{ width: 1280, height: 720 }`)
+**viewport** (`{ width: number; height: number } | 'window'`): Browser viewport dimensions. 'window' matches the real browser window and only applies when connecting over CDP; a locally launched browser falls back to the default size. (Default: `{ width: 1280, height: 720 }`)
 
 **env** (`'LOCAL' | 'BROWSERBASE'`): Environment to run the browser in. Use 'BROWSERBASE' for cloud execution. (Default: `'LOCAL'`)
 

package/.docs/reference/channels/slack-provider.md

@@ -53,6 +53,8 @@ await slack.configure({
 
 **streaming** (`StreamingConfig | false`): Stream agent text deltas to Slack as they're generated. Pass { updateIntervalMs } to customize the post-and-edit interval, or false to buffer text until step-finish. Disabling streaming restricts toolDisplay to static modes. (Default: `true`)
 
+**textFormat** (`'markdown' | 'plain'`): Dialect for the agent's final reply text, forwarded to the Slack adapter. 'markdown' (the default) posts replies as markdown so Slack renders bold text, links, and tables natively. 'plain' posts literal plain text, the escape hatch for agents prompted to emit Slack mrkdwn. Applies to buffered replies (streaming: false) and the streaming fallback; native streaming is always markdown. (Default: `'markdown'`)
+
 **toolDisplay** (`ToolDisplay`): How tool calls are rendered in Slack: 'cards', 'text', 'timeline', 'grouped', 'hidden', or a function. 'hidden' suppresses tool call/result rendering entirely. 'timeline' and 'grouped' require streaming. With streaming: false, only static modes are available and the default is 'cards'. (Default: `'grouped'`)
 
 **typingStatus** (`boolean | TypingStatusFn`): Show a typing indicator while the agent works. Set false to disable, or pass a function to return custom status text per stream chunk (return undefined to fall back to the default for that chunk). (Default: `true`)

package/.docs/reference/client-js/observability.md

@@ -41,6 +41,28 @@ console.log(`Total pages: ${traces.pagination.totalPages}`)
 const completeTrace = await mastraClient.getTrace(traces.spans[0].traceId)
 ```
 
+## Listing traces for a list view
+
+`listTracesLight()` returns the same rows as a trace list, without the `input`, `output` and `attributes` payloads. Each row carries a short `inputPreview` string instead, so a list can render a preview column without transferring the whole prompt.
+
+Prefer it whenever you are rendering many traces at once, and fetch the full record only when a row is opened:
+
+```typescript
+const list = await mastraClient.listTracesLight({
+  pagination: { page: 0, perPage: 25 },
+  filters: { entityType: 'agent' },
+})
+
+for (const span of list.spans) {
+  console.log(span.name, span.inputPreview)
+}
+
+// Fetch the full payload only for the trace the user selects
+const selected = await mastraClient.getTrace(list.spans[0].traceId)
+```
+
+It accepts the same filtering, ordering and delta-polling arguments as `listTraces()`. Use `listTraces()` when you actually need the full span payloads.
+
 ## Scoring traces
 
 Score specific traces using registered scorers for evaluation:

package/.docs/reference/client-js/workflows.md

@@ -12,6 +12,19 @@ Retrieve a list of all available workflows:
 const workflows = await mastraClient.listWorkflows()
 ```
 
+## Getting workflow run counts
+
+Retrieve per-workflow counts of `running` and [`suspended`](https://mastra.ai/docs/workflows/suspend-and-resume) runs in a single request. The counts are computed on the server and keyed by the workflow's registry key — the key used when registering the workflow in the Mastra config, which can differ from the workflow's own `id`:
+
+```typescript
+const runCounts = await mastraClient.listWorkflowRunCounts()
+// { "cityWorkflow": { running: 2, suspended: 1 }, ... }
+```
+
+Returns: `Record<string, { running: number; suspended: number }>`
+
+The server may cache the counts for a few seconds between requests. Servers that predate this endpoint respond with `404 Not Found` — handle the error when the client can talk to older deployments.
+
 ## Working with a specific workflow
 
 Get an instance of a specific workflow by its ID:
@@ -212,28 +225,28 @@ A workflow run result yields the following:
 
 **payload** (`object`): Contains currentStep (id, status, output, payload) and workflowState (status, steps record)
 
-## Stored workflows
+## Dynamic workflows
 
-> **Beta:** Stored workflows are in beta. Breaking changes may occur without a major version bump until the API is stable.
+> **Beta:** Dynamic workflows are in beta. Breaking changes may occur without a major version bump until the API is stable.
 
-Stored workflows are workflow definitions expressed as JSON. The server persists each definition and registers it as a runnable workflow. See [Stored workflows](https://mastra.ai/docs/workflows/stored-workflows) for the definition format.
+Dynamic workflows are workflow definitions expressed as JSON. The server persists each definition and registers it as a runnable workflow. See [Dynamic workflows](https://mastra.ai/docs/workflows/dynamic-workflows) for the definition format.
 
-### `listStoredWorkflows()`
+### `listDynamicWorkflows()`
 
-List stored workflow definitions, optionally filtered by `status` (`'active' | 'archived'`) and `authorId`:
+List dynamic workflow definitions, optionally filtered by `status` (`'active' | 'archived'`) and `authorId`:
 
 ```typescript
-const { definitions, total } = await mastraClient.listStoredWorkflows({
+const { definitions, total } = await mastraClient.listDynamicWorkflows({
   status: 'active',
 })
 ```
 
-### `upsertStoredWorkflow()`
+### `upsertDynamicWorkflow()`
 
-Create or replace a stored workflow definition. The server validates the definition, persists it, and live-registers it for execution:
+Create or replace a dynamic workflow definition. The server validates the definition, persists it, and live-registers it for execution:
 
 ```typescript
-const stored = await mastraClient.upsertStoredWorkflow({
+const stored = await mastraClient.upsertDynamicWorkflow({
   id: 'greeting-workflow',
   description: 'Returns a greeting for the supplied name',
   inputSchema: {
@@ -261,7 +274,7 @@ const stored = await mastraClient.upsertStoredWorkflow({
 When the root definition nests helper workflows that don't exist yet, pass them in the same request through `dependencies`. The server validates and registers the bundle as a unit and echoes the helper ids back as `dependencyIds`:
 
 ```typescript
-const stored = await mastraClient.upsertStoredWorkflow({
+const stored = await mastraClient.upsertDynamicWorkflow({
   id: 'root-workflow',
   // ...schemas and graph referencing 'helper-workflow'...
   dependencies: [helperDefinition],
@@ -270,33 +283,33 @@ const stored = await mastraClient.upsertStoredWorkflow({
 console.log(stored.dependencyIds) // ['helper-workflow']
 ```
 
-### `getStoredWorkflow()`
+### `getDynamicWorkflow()`
 
-Get a stored workflow instance for definition management. To execute a stored workflow, use `getWorkflow(id).createRun()` like any other workflow:
+Get a dynamic workflow instance for definition management. To execute a dynamic workflow, use `getWorkflow(id).createRun()` like any other workflow:
 
 ```typescript
-const storedWorkflow = mastraClient.getStoredWorkflow('greeting-workflow')
+const dynamicWorkflow = mastraClient.getDynamicWorkflow('greeting-workflow')
 ```
 
-### `storedWorkflow.details()`
+### `dynamicWorkflow.details()`
 
 Retrieve the persisted definition, including schemas, graph, status, and timestamps:
 
 ```typescript
-const definition = await storedWorkflow.details()
+const definition = await dynamicWorkflow.details()
 ```
 
-### `storedWorkflow.delete()`
+### `dynamicWorkflow.delete()`
 
 Delete the stored definition and unregister the live workflow:
 
 ```typescript
-await storedWorkflow.delete()
+await dynamicWorkflow.delete()
 ```
 
-### Executing a stored workflow
+### Executing a dynamic workflow
 
-Once registered, a stored workflow runs through the ordinary workflow API:
+Once registered, a dynamic workflow runs through the ordinary workflow API:
 
 ```typescript
 const workflow = mastraClient.getWorkflow('greeting-workflow')

package/.docs/reference/configuration.md

@@ -438,7 +438,7 @@ export const mastra = new Mastra({
 
 **Type:** `Record<string, MastraVector>`
 
-Vector stores for semantic search and embeddings. Used in RAG pipelines, similarity search, and other embedding-based features. Mastra supports multiple vector databases including Pinecone, PostgreSQL with pgvector, MongoDB, and more.
+Vector stores for semantic search and embeddings. Used in RAG pipelines, similarity search, and other embedding-based features. Mastra supports multiple vector databases including Pinecone, PostgreSQL with pgvector, OracleDB, MongoDB, and more.
 
 Visit the [RAG documentation](https://mastra.ai/guides/rag/overview) to learn more.
 
@@ -500,6 +500,31 @@ const mastra = new Mastra({
 
 ## Bundler options
 
+### bundler.entries
+
+**Type:** `Record<string, string>`\
+**Default:** `{}`
+
+Additional process entries to emit alongside the server bundle, as a map of output name to source path relative to your Mastra directory. Each entry becomes its own `<name>.mjs` in `.mastra/output`.
+
+Use this for long-running processes that run beside your Mastra server rather than inside it, such as a [LiveKit voice worker](https://mastra.ai/guides/voice/realtime-voice). The entry shares the output directory, `package.json`, and installed dependencies with the server, so one `mastra build` produces one deployable artifact you can start with different commands.
+
+```typescript
+import { Mastra } from '@mastra/core'
+
+export const mastra = new Mastra({
+  bundler: {
+    entries: { 'voice-worker': './voice-worker.ts' },
+  },
+})
+```
+
+This emits `.mastra/output/voice-worker.mjs` next to `.mastra/output/index.mjs`. Dependencies imported only by the extra entry are analyzed too, so they're installed into the output.
+
+Entry names can contain `/` to nest the output. They can't be `index`, which is the server bundle, `tools`, which is the tool aggregator, or start with `tools/`, which is reserved for tool bundles.
+
+> **Note:** `mastra build` applies the [`bundler.externals`](#bundlerexternals) default of `true` only when you set no bundler options at all. Once you set `entries`, set `externals` explicitly as well if your extra entry depends on packages that can't be bundled, such as native modules.
+
 ### bundler.externals
 
 **Type:** `boolean | string[]`\

package/.docs/reference/core/{addStoredWorkflow.md → addDynamicWorkflow.md}

@@ -1,17 +1,17 @@
 > Discover all available pages from the documentation index: https://mastra.ai/llms.txt
 
-# Mastra.addStoredWorkflow()
+# Mastra.addDynamicWorkflow()
 
-> **Beta:** Stored workflows are in beta. Breaking changes may occur without a major version bump until the API is stable.
+> **Beta:** Dynamic workflows are in beta. Breaking changes may occur without a major version bump until the API is stable.
 
-The `.addStoredWorkflow()` method validates a stored workflow definition and registers it as a live workflow on the instance, persisting it through the `workflowDefinitions` storage domain. Once registered, the workflow runs like any other workflow via [`getWorkflow()`](https://mastra.ai/reference/core/getWorkflow).
+The `.addDynamicWorkflow()` method validates a dynamic workflow definition and registers it as a live workflow on the instance, persisting it through the `workflowDefinitions` storage domain. Once registered, the workflow runs like any other workflow via [`getWorkflow()`](https://mastra.ai/reference/core/getWorkflow).
 
-See [Stored workflows](https://mastra.ai/docs/workflows/stored-workflows) for a complete setup example and the [stored workflow definition reference](https://mastra.ai/reference/workflows/stored-workflow-definition) for the accepted fields and graph entries.
+See [Dynamic workflows](https://mastra.ai/docs/workflows/dynamic-workflows) for a complete setup example and the [dynamic workflow definition reference](https://mastra.ai/reference/workflows/dynamic-workflow-definition) for the accepted fields and graph entries.
 
 ## Usage example
 
 ```typescript
-await mastra.addStoredWorkflow({
+await mastra.addDynamicWorkflow({
   id: 'greeting-workflow',
   description: 'Returns a greeting for the supplied name',
   inputSchema: {
@@ -41,7 +41,7 @@ const result = await run.start({ inputData: { name: 'Ada' } })
 
 ## Parameters
 
-**def** (`StoredWorkflowGraph`): The workflow definition: id, optional description and metadata, JSON Schema input/output schemas, optional state and request-context schemas, and the step graph.
+**def** (`DynamicWorkflowGraph`): The workflow definition: id, optional description and metadata, JSON Schema input/output schemas, optional state and request-context schemas, and the step graph.
 
 ## Returns
 
@@ -52,11 +52,11 @@ A promise that resolves once the definition is validated, registered, and persis
 - The definition is fully validated (structure, references, schema flow) before anything is mutated. Agents, tools, and workflows referenced by the graph must already be registered on the instance.
 - Adding a definition with an existing ID replaces both the stored definition and the live registration. In-flight runs keep the graph they started with.
 - Without a storage adapter that supports the `workflowDefinitions` domain, the workflow is still validated and registered in memory, but the definition is lost on restart.
-- To add a root workflow together with helper workflows it nests, use [`addStoredWorkflows()`](https://mastra.ai/reference/core/addStoredWorkflows).
+- To add a root workflow together with helper workflows it nests, use [`addDynamicWorkflows()`](https://mastra.ai/reference/core/addDynamicWorkflows).
 
 ## Related
 
-- [Mastra.addStoredWorkflows()](https://mastra.ai/reference/core/addStoredWorkflows): Add a dependency-ordered bundle of definitions
+- [Mastra.addDynamicWorkflows()](https://mastra.ai/reference/core/addDynamicWorkflows): Add a dependency-ordered bundle of definitions
 - [Mastra.getWorkflow()](https://mastra.ai/reference/core/getWorkflow): Retrieve a registered workflow
-- [Stored workflows](https://mastra.ai/docs/workflows/stored-workflows): Set up and use stored workflows
-- [Stored workflow definition](https://mastra.ai/reference/workflows/stored-workflow-definition): Definition fields and graph entries
+- [Dynamic workflows](https://mastra.ai/docs/workflows/dynamic-workflows): Set up and use dynamic workflows
+- [Dynamic workflow definition](https://mastra.ai/reference/workflows/dynamic-workflow-definition): Definition fields and graph entries

package/.docs/reference/core/{addStoredWorkflows.md → addDynamicWorkflows.md}

@@ -1,19 +1,19 @@
 > Discover all available pages from the documentation index: https://mastra.ai/llms.txt
 
-# Mastra.addStoredWorkflows()
+# Mastra.addDynamicWorkflows()
 
-> **Beta:** Stored workflows are in beta. Breaking changes may occur without a major version bump until the API is stable.
+> **Beta:** Dynamic workflows are in beta. Breaking changes may occur without a major version bump until the API is stable.
 
-The `.addStoredWorkflows()` method adds a bundle of stored workflow definitions that may reference each other. The typical case is a root workflow plus helper workflows it nests, where none of the definitions exist yet.
+The `.addDynamicWorkflows()` method adds a bundle of dynamic workflow definitions that may reference each other. The typical case is a root workflow plus helper workflows it nests, where none of the definitions exist yet.
 
 The whole bundle is validated up front. Members are then registered in dependency order, so a helper is always in place before the workflow that nests it.
 
-[`addStoredWorkflow()`](https://mastra.ai/reference/core/addStoredWorkflow) is the single-member case.
+[`addDynamicWorkflow()`](https://mastra.ai/reference/core/addDynamicWorkflow) is the single-member case.
 
 ## Usage example
 
 ```typescript
-await mastra.addStoredWorkflows([
+await mastra.addDynamicWorkflows([
   helperDefinition, // nested by the root — order in the array doesn't matter
   rootDefinition, // graph contains { type: 'workflow', workflowId: helperDefinition.id }
 ])
@@ -21,7 +21,7 @@ await mastra.addStoredWorkflows([
 
 ## Parameters
 
-**defs** (`readonly StoredWorkflowGraph[]`): The workflow definitions to add. Nested-workflow references may resolve against the live registries or against other members of the same bundle.
+**defs** (`readonly DynamicWorkflowGraph[]`): The workflow definitions to add. Nested-workflow references may resolve against the live registries or against other members of the same bundle.
 
 ## Returns
 
@@ -35,6 +35,6 @@ A promise that resolves once every member is validated, registered, and persiste
 
 ## Related
 
-- [Mastra.addStoredWorkflow()](https://mastra.ai/reference/core/addStoredWorkflow): Add a single definition
-- [Stored workflows](https://mastra.ai/docs/workflows/stored-workflows): Set up and use stored workflows
-- [Stored workflow definition](https://mastra.ai/reference/workflows/stored-workflow-definition): Definition fields and graph entries
+- [Mastra.addDynamicWorkflow()](https://mastra.ai/reference/core/addDynamicWorkflow): Add a single definition
+- [Dynamic workflows](https://mastra.ai/docs/workflows/dynamic-workflows): Set up and use dynamic workflows
+- [Dynamic workflow definition](https://mastra.ai/reference/workflows/dynamic-workflow-definition): Definition fields and graph entries

package/.docs/reference/editor/tool-provider.md

@@ -83,7 +83,32 @@ Composio tools use uppercase slug format: `GITHUB_CREATE_ISSUE`, `SLACK_SEND_MES
 
 ### Authentication
 
-Connections use per-author scope by default. Set `defaultScope: 'caller-supplied'` to bucket authorization by the caller identity resolved from request context.
+Connections use per-author scope by default. Set `defaultScope: 'caller-supplied'` to bucket authorization by the caller identity resolved from `MASTRA_RESOURCE_ID_KEY` in request context. Ensure each authenticated request provides a stable, unique resource ID. When using `MastraAuthWorkos`, configure `mapUserToResourceId` to set this value from the authenticated user.
+
+### Connection management tools
+
+Composio provides tools for starting and monitoring authorization from an agent chat. When `allowedToolkits` is set, include `composio` to make these tools available:
+
+```typescript
+const editor = new MastraEditor({
+  toolProviders: {
+    composio: new ComposioToolProvider({
+      apiKey: process.env.COMPOSIO_API_KEY!,
+      allowedToolkits: ['composio', 'gmail'],
+      defaultScope: 'caller-supplied',
+    }),
+  },
+})
+```
+
+Add only the connection management tools that the agent needs:
+
+| Tool                            | Behavior                                                                     |
+| ------------------------------- | ---------------------------------------------------------------------------- |
+| `COMPOSIO_MANAGE_CONNECTIONS`   | Creates an authorization link in chat through a session owned by the caller. |
+| `COMPOSIO_WAIT_FOR_CONNECTIONS` | Waits for the caller to finish authorization before the agent continues.     |
+
+`COMPOSIO_WAIT_FOR_CONNECTIONS` is optional. Without it, complete authorization and return to the chat. Then ask the agent to continue. The connected account remains associated with the caller resource ID for later requests.
 
 ***
 

package/.docs/reference/file-based-agents/config.md

@@ -69,32 +69,33 @@ Please note:
 
 Keep `config.ts` focused on runtime options. Use sibling files for concerns that benefit from their own location.
 
-| Setting      | File or folder                                                                  | Why it lives there                                                   |
-| ------------ | ------------------------------------------------------------------------------- | -------------------------------------------------------------------- |
-| Instructions | [`instructions.md`](https://mastra.ai/reference/file-based-agents/instructions) | Keeps the always-on prompt readable as markdown                      |
-| Tools        | [`tools/`](https://mastra.ai/reference/file-based-agents/tools)                 | Gives each callable action its own typed module                      |
-| Skills       | [`skills/`](https://mastra.ai/reference/file-based-agents/skills)               | Keeps load-on-demand procedures separate from always-on instructions |
-| Memory       | [`memory.ts`](https://mastra.ai/reference/file-based-agents/memory)             | Configures persistent memory without crowding runtime options        |
-| Workspace    | [`workspace.ts`](https://mastra.ai/reference/file-based-agents/workspace)       | Configures files and sandbox behavior separately from model settings |
-| Processors   | [`processors/`](https://mastra.ai/reference/file-based-agents/processors)       | Separates input and output processing pipelines                      |
-| Subagents    | [`subagents/`](https://mastra.ai/reference/file-based-agents/subagents)         | Gives each specialist child agent its own directory                  |
+| Setting      | File or folder                                                                                       | Why it lives there                                                         |
+| ------------ | ---------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------- |
+| Instructions | [`instructions.md` or `instructions.ts`](https://mastra.ai/reference/file-based-agents/instructions) | Keeps the always-on prompt readable as markdown, or computed in TypeScript |
+| Tools        | [`tools/`](https://mastra.ai/reference/file-based-agents/tools)                                      | Gives each callable action its own typed module                            |
+| Skills       | [`skills/`](https://mastra.ai/reference/file-based-agents/skills)                                    | Keeps load-on-demand procedures separate from always-on instructions       |
+| Memory       | [`memory.ts`](https://mastra.ai/reference/file-based-agents/memory)                                  | Configures persistent memory without crowding runtime options              |
+| Workspace    | [`workspace.ts`](https://mastra.ai/reference/file-based-agents/workspace)                            | Configures files and sandbox behavior separately from model settings       |
+| Processors   | [`processors/`](https://mastra.ai/reference/file-based-agents/processors)                            | Separates input and output processing pipelines                            |
+| Subagents    | [`subagents/`](https://mastra.ai/reference/file-based-agents/subagents)                              | Gives each specialist child agent its own directory                        |
 
 ## Precedence
 
 `config.ts` merges with the agent's other files according to these rules:
 
-| Domain       | Source A                      | Source B                                                                        | Winner                                                  |
-| ------------ | ----------------------------- | ------------------------------------------------------------------------------- | ------------------------------------------------------- |
-| Instructions | Dynamic `config.instructions` | [`instructions.md`](https://mastra.ai/reference/file-based-agents/instructions) | Dynamic `config.instructions`                           |
-| Instructions | Static `config.instructions`  | [`instructions.md`](https://mastra.ai/reference/file-based-agents/instructions) | `instructions.md`                                       |
-| Tools        | `config.tools`                | [`tools/`](https://mastra.ai/reference/file-based-agents/tools)                 | Both merge; `config.tools` wins on key collisions       |
-| Tools        | Function `config.tools`       | [`tools/`](https://mastra.ai/reference/file-based-agents/tools)                 | Function `config.tools`; discovered tools are ignored   |
-| Skills       | `config.skills`               | [`skills/`](https://mastra.ai/reference/file-based-agents/skills)               | Both merge; `config.skills` wins on name collisions     |
-| Skills       | Function `config.skills`      | [`skills/`](https://mastra.ai/reference/file-based-agents/skills)               | Function `config.skills`; discovered skills are ignored |
-| Memory       | `config.memory`               | [`memory.ts`](https://mastra.ai/reference/file-based-agents/memory)             | `config.memory`                                         |
-| Workspace    | `config.workspace`            | [`workspace.ts`](https://mastra.ai/reference/file-based-agents/workspace)       | `config.workspace`                                      |
-
-Missing both `instructions.md` and `config.instructions` fails the build. Missing both `config.memory` and `memory.ts` leaves the agent without memory.
+| Domain       | Source A                                                                        | Source B                                                                                             | Winner                                                  |
+| ------------ | ------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------- | ------------------------------------------------------- |
+| Instructions | Dynamic `config.instructions`                                                   | [`instructions.ts` or `instructions.md`](https://mastra.ai/reference/file-based-agents/instructions) | Dynamic `config.instructions`                           |
+| Instructions | Static `config.instructions`                                                    | [`instructions.ts` or `instructions.md`](https://mastra.ai/reference/file-based-agents/instructions) | The instructions file                                   |
+| Instructions | [`instructions.ts`](https://mastra.ai/reference/file-based-agents/instructions) | [`instructions.md`](https://mastra.ai/reference/file-based-agents/instructions)                      | `instructions.ts`                                       |
+| Tools        | `config.tools`                                                                  | [`tools/`](https://mastra.ai/reference/file-based-agents/tools)                                      | Both merge; `config.tools` wins on key collisions       |
+| Tools        | Function `config.tools`                                                         | [`tools/`](https://mastra.ai/reference/file-based-agents/tools)                                      | Function `config.tools`; discovered tools are ignored   |
+| Skills       | `config.skills`                                                                 | [`skills/`](https://mastra.ai/reference/file-based-agents/skills)                                    | Both merge; `config.skills` wins on name collisions     |
+| Skills       | Function `config.skills`                                                        | [`skills/`](https://mastra.ai/reference/file-based-agents/skills)                                    | Function `config.skills`; discovered skills are ignored |
+| Memory       | `config.memory`                                                                 | [`memory.ts`](https://mastra.ai/reference/file-based-agents/memory)                                  | `config.memory`                                         |
+| Workspace    | `config.workspace`                                                              | [`workspace.ts`](https://mastra.ai/reference/file-based-agents/workspace)                            | `config.workspace`                                      |
+
+Missing `instructions.md`, `instructions.ts`, and `config.instructions` fails the build. Missing both `config.memory` and `memory.ts` leaves the agent without memory.
 
 ## Discovery lifecycle