@mastra/mcp-docs-server 1.2.1 → 1.2.2-alpha.2

package/.docs/docs/agents/code-mode.md

@@ -2,7 +2,7 @@
 
 **Added in:** `@mastra/core@1.38.0`
 
-> **Alpha:** This feature is in alpha. Breaking changes may occur without a major version bump until the API is stable.
+> **Beta:** This feature is in beta. Breaking changes may occur without a major version bump until the API is stable.
 
 Code mode lets an agent run multi-tool computations in an isolated sandbox and return the result as a single, more accurate response. Instead of calling tools one turn at a time, the model writes a tailored function for the user query that orchestrates your existing tools as `external_*` functions, reduces or aggregates their results, and returns one structured answer.
 

package/.docs/docs/agents/goals.md

@@ -2,7 +2,7 @@
 
 **Added in:** `@mastra/core@1.42.0`
 
-> **Alpha:** The Goals feature is in alpha stage and subject to breaking changes in minor versions until it graduates from its alpha status.
+> **Beta:** The Goals feature is in beta stage and subject to breaking changes in minor versions until it graduates from its beta status.
 
 A goal is a durable, thread-scoped objective: a standing instruction the agent keeps working toward across loop iterations until a judge model decides it is satisfied or a run budget is exhausted. The objective is persisted in thread state, so it survives reloads and is evaluated in-loop — even when a new message arrives in the middle of an already-running turn.
 

package/.docs/docs/agents/processors.md

@@ -427,7 +427,7 @@ See the [`ProviderHistoryCompat` reference](https://mastra.ai/reference/processo
 
 ## Response caching
 
-> **Alpha:** This feature is in alpha. Breaking changes may occur without a major version bump until the API is stable.
+> **Beta:** This feature is in beta. Breaking changes may occur without a major version bump until the API is stable.
 
 Response caching skips the LLM call and replays a previously cached response when an agent receives an identical request. Use it to reduce latency and avoid paying for repeated calls.
 

package/.docs/docs/agents/signal-providers.md

@@ -2,7 +2,7 @@
 
 **Added in:** `@mastra/core@1.39.0`
 
-> **Alpha:** This feature is in alpha. Breaking changes may occur without a major version bump until the API is stable.
+> **Beta:** This feature is in beta. Breaking changes may occur without a major version bump until the API is stable.
 
 A signal provider monitors an external source, such as GitHub, Slack, continuous integration (CI), or your own API, and pushes [notification signals](https://mastra.ai/docs/agents/signals) into subscribed agent threads.
 

package/.docs/docs/agents/signals.md

@@ -2,7 +2,7 @@
 
 **Added in:** `@mastra/core@1.39.0`
 
-> **Alpha:** This feature is in alpha. Breaking changes may occur without a major version bump until the API is stable.
+> **Beta:** This feature is in beta. Breaking changes may occur without a major version bump until the API is stable.
 
 Signals are a way to interact with an agent through a thread. Instead of starting every interaction with `agent.stream()`, subscribe to a thread and send messages or signals. Mastra either wakes the agent when the thread is idle, drops input into the running agent loop, or queues input for the next turn.
 

package/.docs/docs/agents/supervisor-agents.md

@@ -261,6 +261,21 @@ for await (const chunk of stream.fullStream) {
 }
 ```
 
+## Cancellation
+
+When you pass an `abortSignal` to the supervisor's [`stream()`](https://mastra.ai/reference/streaming/agents/stream) or [`generate()`](https://mastra.ai/reference/agents/generate) call, Mastra forwards that same signal to delegated subagents. Calling `AbortController.abort()` cancels in-flight subagent runs at their next step instead of letting them run to completion.
+
+```typescript
+const controller = new AbortController()
+
+const stream = await supervisor.stream('Research AI trends', {
+  abortSignal: controller.signal,
+})
+
+// Cancel the supervisor and any in-flight subagents
+controller.abort()
+```
+
 ## Task completion scoring
 
 Agents don't always produce a complete, correct output on the first try. Task completion scorers can help with that by validating whether the task is complete after each iteration. If validation fails, the supervisor continues iterating. Feedback from failed scorers is included in the conversation context so subagents can see what was missing.

package/.docs/docs/evals/built-in-scorers.md

@@ -45,4 +45,20 @@ These scorers evaluate adherence to format, style, and safety requirements:
 - [`tone-consistency`](https://mastra.ai/reference/evals/tone-consistency): Measures consistency in formality, complexity, and style (`0-1`, higher is better)
 - [`toxicity`](https://mastra.ai/reference/evals/toxicity): Detects harmful or inappropriate content (`0-1`, lower is better)
 - [`bias`](https://mastra.ai/reference/evals/bias): Detects potential biases in the output (`0-1`, lower is better)
-- [`keyword-coverage`](https://mastra.ai/reference/evals/keyword-coverage): Assesses technical terminology usage (`0-1`, higher is better)
+- [`keyword-coverage`](https://mastra.ai/reference/evals/keyword-coverage): Assesses technical terminology usage (`0-1`, higher is better)
+
+### Quick Checks
+
+Zero-LLM micro-scorers for fast, deterministic assertions. See the [Quick Checks](https://mastra.ai/docs/evals/quick-checks) guide for usage details.
+
+- [`checks.includes`](https://mastra.ai/reference/evals/checks): Scores 1 if output contains a substring (`0` or `1`)
+- [`checks.excludes`](https://mastra.ai/reference/evals/checks): Scores 1 if output does not contain a substring (`0` or `1`)
+- [`checks.equals`](https://mastra.ai/reference/evals/checks): Scores 1 if output exactly matches a string (`0` or `1`)
+- [`checks.matches`](https://mastra.ai/reference/evals/checks): Scores 1 if output matches a regex (`0` or `1`)
+- [`checks.similarity`](https://mastra.ai/reference/evals/checks): String similarity via Dice coefficient (`0-1`, or binary with threshold)
+- [`checks.calledTool`](https://mastra.ai/reference/evals/checks): Scores 1 if a tool was called at least N times (`0` or `1`)
+- [`checks.didNotCall`](https://mastra.ai/reference/evals/checks): Scores 1 if a tool was not called (`0` or `1`)
+- [`checks.toolOrder`](https://mastra.ai/reference/evals/checks): Scores 1 if tools were called in order (`0` or `1`)
+- [`checks.maxToolCalls`](https://mastra.ai/reference/evals/checks): Scores 1 if tool call count is within limit (`0` or `1`)
+- [`checks.usedNoTools`](https://mastra.ai/reference/evals/checks): Scores 1 if no tools were called (`0` or `1`)
+- [`checks.noToolErrors`](https://mastra.ai/reference/evals/checks): Scores 1 if no tool calls had errors (`0` or `1`)

package/.docs/docs/evals/overview.md

@@ -135,6 +135,7 @@ Once registered, you can score traces interactively within Studio under the **Ob
 
 ## Next steps
 
+- Use [Quick Checks](https://mastra.ai/docs/evals/quick-checks) for fast, deterministic assertions on text and tool usage
 - Learn how to create your own scorers in the [Creating Custom Scorers](https://mastra.ai/docs/evals/custom-scorers) guide
 - Explore built-in scorers in the [Built-in Scorers](https://mastra.ai/docs/evals/built-in-scorers) section
 - Test scorers with [Studio](https://mastra.ai/docs/studio/overview)

package/.docs/docs/evals/quick-checks.md

@@ -0,0 +1,136 @@
+# Quick Checks
+
+Quick Checks are composable micro-scorers for common assertions like "output contains X" or "agent called tool Y." They require no LLM, run instantly, and plug into the same `scorers: [...]` array as any other scorer.
+
+## When to use Quick Checks
+
+Use Quick Checks when you need fast, deterministic assertions:
+
+- Verify output text contains or excludes specific strings
+- Confirm an agent called (or avoided) specific tools
+- Validate tool call ordering and count limits
+- Gate CI pipelines with zero-cost binary checks
+- Combine with LLM-based scorers for layered evaluation
+
+For subjective or semantic evaluation, use [LLM-based scorers](https://mastra.ai/docs/evals/built-in-scorers) instead.
+
+## Quickstart
+
+```typescript
+import { checks } from '@mastra/evals/checks'
+import { runEvals } from '@mastra/core/evals'
+import { weatherAgent } from '../agents'
+
+const result = await runEvals({
+  data: [{ input: 'What is the weather in Brooklyn?' }],
+  target: weatherAgent,
+  scorers: [checks.includes('Brooklyn'), checks.calledTool('get_weather'), checks.noToolErrors()],
+})
+
+console.log(result.scores)
+// { 'check-includes': 1, 'check-called-tool': 1, 'check-no-tool-errors': 1 }
+```
+
+## Available checks
+
+Quick Checks fall into two categories:
+
+### Text checks
+
+These scorers evaluate the agent's text output:
+
+| Check                    | What it does                          | Score                            |
+| ------------------------ | ------------------------------------- | -------------------------------- |
+| `checks.includes(str)`   | Output contains substring             | 1 or 0                           |
+| `checks.excludes(str)`   | Output does not contain substring     | 1 or 0                           |
+| `checks.equals(str)`     | Output exactly equals string          | 1 or 0                           |
+| `checks.matches(regex)`  | Output matches regular expression     | 1 or 0                           |
+| `checks.similarity(str)` | Dice coefficient similarity to string | 0-1 (or binary with `threshold`) |
+
+### Tool call checks
+
+These scorers evaluate tool usage from the agent's run:
+
+| Check                     | What it does                     | Score  |
+| ------------------------- | -------------------------------- | ------ |
+| `checks.calledTool(name)` | Tool was called at least N times | 1 or 0 |
+| `checks.didNotCall(name)` | Tool was not called              | 1 or 0 |
+| `checks.toolOrder([...])` | Tools called in expected order   | 1 or 0 |
+| `checks.maxToolCalls(n)`  | No more than N tool calls total  | 1 or 0 |
+| `checks.usedNoTools()`    | No tools called at all           | 1 or 0 |
+| `checks.noToolErrors()`   | No tool invocations had errors   | 1 or 0 |
+
+## Combining checks with LLM scorers
+
+Checks compose with LLM-based scorers in a single `runEvals` call. Use checks for deterministic gates and LLM scorers for qualitative evaluation:
+
+```typescript
+import { checks } from '@mastra/evals/checks'
+import { createFaithfulnessScorer } from '@mastra/evals/scorers/prebuilt'
+import { runEvals } from '@mastra/core/evals'
+import { myAgent } from '../agents'
+
+const result = await runEvals({
+  data: [
+    {
+      input: 'What is the weather in Brooklyn?',
+      context: ['Brooklyn weather data: sunny, 72°F'],
+    },
+  ],
+  target: myAgent,
+  scorers: [
+    // Deterministic checks (instant, free)
+    checks.includes('Brooklyn'),
+    checks.calledTool('get_weather'),
+    checks.excludes('error'),
+    checks.noToolErrors(),
+
+    // LLM-based scorer (semantic, costs tokens)
+    createFaithfulnessScorer({ model: 'openai/gpt-5-mini' }),
+  ],
+})
+```
+
+## Using checks in live scoring
+
+Attach checks to agents for continuous monitoring:
+
+```typescript
+import { Agent } from '@mastra/core/agent'
+import { checks } from '@mastra/evals/checks'
+
+export const weatherAgent = new Agent({
+  name: 'Weather Agent',
+  instructions: 'Answer weather questions using the get_weather tool.',
+  model: 'openai/gpt-5.5',
+  tools: { get_weather: weatherTool },
+  scorers: {
+    noErrors: {
+      scorer: checks.noToolErrors(),
+      sampling: { type: 'ratio', rate: 1 },
+    },
+    mentionCity: {
+      scorer: checks.includes('Brooklyn'),
+      sampling: { type: 'ratio', rate: 0.5 },
+    },
+  },
+})
+```
+
+## How checks work
+
+Each check is a standard `createScorer()` instance with a `preprocess` step and a `generateScore` step. They follow the same [four-step pipeline](https://mastra.ai/docs/evals/custom-scorers) as any other scorer:
+
+1. **preprocess**: Extracts and normalizes relevant data from the agent run (text content, tool calls)
+2. **generateScore**: Converts the preprocessed result into a score (typically binary 1 or 0)
+
+Because checks skip the `analyze` and `generateReason` steps and make no LLM calls, they run in microseconds.
+
+> **Note:** Visit the [Quick Checks reference](https://mastra.ai/reference/evals/checks) for the full API, including all parameters and options for each check.
+
+## Related
+
+- [Quick Checks reference](https://mastra.ai/reference/evals/checks)
+- [Built-in Scorers](https://mastra.ai/docs/evals/built-in-scorers)
+- [Custom Scorers](https://mastra.ai/docs/evals/custom-scorers)
+- [`runEvals()` reference](https://mastra.ai/reference/evals/run-evals)

package/.docs/docs/harness/overview.md

@@ -1,6 +1,6 @@
 # Harness overview
 
-> **Alpha:** The `Harness` feature is in alpha stage and subject to breaking changes in minor versions until it graduates from its alpha status.
+> **Beta:** The `Harness` feature is in beta stage and subject to breaking changes in minor versions until it graduates from its beta status.
 
 The Harness is a session controller for building interactive agent applications. It handles the runtime concerns that sit between your UI and the agent loop: managing conversation threads, switching between agent modes, persisting state, gating tool execution with approvals, and coordinating subagents. You can focus on what your agent does rather than how to wire it together.
 

package/.docs/docs/harness/session.md

@@ -10,7 +10,7 @@ Because each session has its own identity and state, one Harness can serve many
 
 The rest of this page walks through the Session's state. Each part is a focused sub-object on `harness.session`:
 
-- **Who and where**: [Identity](#identity) sets the resource the session belongs to, and [Thread](#thread) tracks the currently bound thread.
+- **Who and where**: [Identity](#identity) sets the stable session `id`, `ownerId`, and resource the session belongs to, and [Thread](#thread) tracks the currently bound thread.
 - **How the agent behaves**: [Mode and model](#mode-and-model) controls which agent profile and model are active, and [Permission grants](#permission-grants) records what the user has approved to run without prompting.
 - **What's happening right now**: [Run state](#run-state) reflects the in-flight generation, and [Follow-ups](#follow-ups) holds messages queued to send when it finishes.
 - **What you store and render**: [State](#state) holds your application's structured data, and [Display state](#display-state) is the single snapshot your UI renders from.
@@ -19,14 +19,18 @@ The Harness performs actions that change this state — switching threads, modes
 
 ## Identity
 
-`session.identity` holds the resource ID the conversation belongs to and the currently bound thread ID. Threads are scoped to a resource ID, so this is what groups a conversation's threads together:
+`session.identity` holds three stable identifiers for the conversation: a session `id`, an `ownerId`, and the resource ID. Threads are scoped to a resource ID, so this is what groups a conversation's threads together:
 
 ```typescript
+const sessionId = harness.session.identity.getId()
+const ownerId = harness.session.identity.getOwnerId()
 const resourceId = harness.session.identity.getResourceId()
 const threadId = harness.session.thread.getId()
 ```
 
-The resource ID is set on the Harness constructor and defaults to the harness `id`. See [Resource IDs](https://mastra.ai/docs/harness/threads-and-state) for how it scopes threads.
+The session `id` and `ownerId` are stable for the life of the session — they don't change when the resource ID is switched. They mirror the `id` and `ownerId` fields on `SessionRecord` in storage, so storage layers can key sessions by a stable identifier rather than the mutable resource ID.
+
+The resource ID is set when creating a session via [`harness.createSession()`](https://mastra.ai/reference/harness/harness-class) and defaults to the harness `id`. See [Resource IDs](https://mastra.ai/docs/harness/threads-and-state) for how it scopes threads.
 
 ## Thread
 

package/.docs/docs/harness/threads-and-state.md

@@ -131,6 +131,8 @@ The resource ID is part of a conversation's identity, so you read it from the Se
 const resourceId = harness.session.identity.getResourceId()
 ```
 
+The session also has a stable `id` and `ownerId` (read with `session.identity.getId()` and `session.identity.getOwnerId()`). Unlike the resource ID, these don't change when you switch resources — see [Session identity](https://mastra.ai/docs/harness/session) for details.
+
 ## Related
 
 - [Harness overview](https://mastra.ai/docs/harness/overview)

package/.docs/docs/memory/observational-memory.md

@@ -210,9 +210,7 @@ The result is a three-tier system:
 2. **Observations**: A log of what the Observer has seen
 3. **Reflections**: Condensed observations when memory becomes too long
 
-### Retrieval mode (experimental)
-
-> **Note:** Retrieval mode is experimental. The API may change in future releases.
+### Retrieval mode
 
 Normal OM compresses messages into observations, which is great for staying on task, but the original wording is gone. Retrieval mode fixes this by keeping each observation group linked to the raw messages that produced it. When the agent needs exact wording, tool output, or chronology that the summary compressed away, it can call a `recall` tool to page through the source messages.
 

package/.docs/guides/guide/signal-provider.md

@@ -4,7 +4,7 @@ In this guide, you'll build a signal provider that polls an external service on
 
 The example watches build pipelines in a fake CI service, but the pattern applies to any pull-based source: an issue tracker, a status API, a queue, or your own backend.
 
-> **Alpha:** Signal providers are in alpha. Breaking changes may occur without a major version bump until the API is stable.
+> **Beta:** Signal providers are in beta. Breaking changes may occur without a major version bump until the API is stable.
 
 ## Prerequisites
 

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

@@ -170,7 +170,7 @@ const response = await agent.generate('Help me organize my day', {
 
 **options.activeTools** (`Array<keyof ToolSet> | undefined`): Array of tool names that should be active during execution. If undefined, all available tools are active.
 
-**options.abortSignal** (`AbortSignal`): Signal object that allows you to abort the agent's execution. When the signal is aborted, all ongoing operations will be terminated.
+**options.abortSignal** (`AbortSignal`): Signal object that allows you to abort the agent's execution. When the signal is aborted, all ongoing operations will be terminated, including any in-flight subagent runs the agent delegated to.
 
 **options.prepareStep** (`PrepareStepFunction`): Callback function called before each step of multi-step execution.
 

package/.docs/reference/evals/checks.md

@@ -0,0 +1,210 @@
+# Quick Checks
+
+Quick Checks are zero-LLM, composable micro-scorers for common assertions. They plug into the existing `scorers: [...]` array anywhere scorers are used — in `runEvals`, live scoring, experiments, and Studio.
+
+Internally they are standard `createScorer()` instances, so they have the same observability, storage, and pipeline integration as any other scorer.
+
+## Usage example
+
+```typescript
+import { checks } from '@mastra/evals/checks'
+import { runEvals } from '@mastra/core/evals'
+import { myAgent } from '../agents'
+
+const result = await runEvals({
+  data: [{ input: 'What is the weather in Brooklyn?' }],
+  target: myAgent,
+  scorers: [
+    checks.includes('sunny'),
+    checks.calledTool('get_weather'),
+    checks.toolOrder(['get_weather', 'summarize']),
+    checks.noToolErrors(),
+  ],
+})
+
+console.log(result.scores)
+```
+
+## Text checks
+
+### `checks.includes(expected, options?)`
+
+Scores 1 if the agent's output text contains the expected substring, 0 otherwise.
+
+```typescript
+checks.includes('sunny')
+checks.includes('Sunny', { ignoreCase: false })
+```
+
+**expected** (`string`): Substring to search for in the output.
+
+**options.ignoreCase** (`boolean`): Case-insensitive matching. (Default: `true`)
+
+Returns: `1` if found, `0` otherwise.
+
+### `checks.excludes(unwanted, options?)`
+
+Scores 1 if the agent's output text does NOT contain the substring, 0 otherwise.
+
+```typescript
+checks.excludes('error')
+checks.excludes('Error', { ignoreCase: false })
+```
+
+**unwanted** (`string`): Substring that must not appear in the output.
+
+**options.ignoreCase** (`boolean`): Case-insensitive matching. (Default: `true`)
+
+Returns: `1` if absent, `0` otherwise.
+
+### `checks.equals(expected, options?)`
+
+Scores 1 if the output text exactly equals the expected string after optional normalization.
+
+```typescript
+checks.equals('Hello, world!')
+checks.equals('Hello', { ignoreCase: false })
+```
+
+**expected** (`string`): Exact string the output must match.
+
+**options.ignoreCase** (`boolean`): Case-insensitive matching. (Default: `true`)
+
+Returns: `1` if equal, `0` otherwise.
+
+### `checks.matches(pattern, options?)`
+
+Scores 1 if the output matches the given regular expression.
+
+```typescript
+checks.matches(/\d+°[FC]/)
+checks.matches(/^hello$/, { exact: true })
+```
+
+**pattern** (`RegExp`): Regular expression to test against the output.
+
+**options.exact** (`boolean`): Anchor the pattern to match the entire output (adds ^ and $). (Default: `false`)
+
+Returns: `1` if matched, `0` otherwise.
+
+### `checks.similarity(expected, options?)`
+
+Returns the string similarity score (0-1) between the output and an expected string using the Dice coefficient. When a `threshold` is set, returns binary 1/0 instead.
+
+```typescript
+checks.similarity('Sunny, 72°F')
+checks.similarity('Sunny, 72°F', { threshold: 0.7 })
+```
+
+**expected** (`string`): Reference string to compare against.
+
+**options.threshold** (`number`): Minimum similarity score (0-1) to return 1. When omitted, returns the raw similarity score.
+
+**options.ignoreCase** (`boolean`): Case-insensitive comparison. (Default: `true`)
+
+Returns: Raw similarity score (0-1), or binary `1`/`0` when `threshold` is set.
+
+## Tool call checks
+
+### `checks.calledTool(toolName, options?)`
+
+Scores 1 if the agent called the specified tool at least the required number of times.
+
+```typescript
+checks.calledTool('get_weather')
+checks.calledTool('search', { times: 2 })
+```
+
+**toolName** (`string`): Name of the tool to look for.
+
+**options.times** (`number`): Minimum number of times the tool must be called. (Default: `1`)
+
+Returns: `1` if called at least `times` times, `0` otherwise.
+
+### `checks.didNotCall(toolName)`
+
+Scores 1 if the agent did NOT call the specified tool.
+
+```typescript
+checks.didNotCall('delete_user')
+```
+
+**toolName** (`string`): Name of the tool that must not appear.
+
+Returns: `1` if the tool was not called, `0` otherwise.
+
+### `checks.toolOrder(expectedOrder)`
+
+Scores 1 if the tools were called in the specified order. Uses relaxed matching — other tool calls between the expected tools are allowed.
+
+```typescript
+checks.toolOrder(['search', 'summarize', 'respond'])
+```
+
+**expectedOrder** (`string[]`): Tool names in the expected calling sequence. Must appear as a subsequence of the actual tool calls.
+
+Returns: `1` if the expected order is satisfied, `0` otherwise.
+
+### `checks.maxToolCalls(max)`
+
+Scores 1 if the agent used no more than `max` tool calls.
+
+```typescript
+checks.maxToolCalls(5)
+```
+
+**max** (`number`): Maximum number of tool calls allowed.
+
+Returns: `1` if within the limit, `0` otherwise.
+
+### `checks.usedNoTools()`
+
+Scores 1 if the agent made no tool calls at all.
+
+```typescript
+checks.usedNoTools()
+```
+
+Returns: `1` if no tools were called, `0` otherwise.
+
+### `checks.noToolErrors()`
+
+Scores 1 if none of the tool invocations resulted in an error state. Detects both error results (`result.error` present) and incomplete tool calls (`state === 'call'`).
+
+```typescript
+checks.noToolErrors()
+```
+
+Returns: `1` if all tool calls succeeded, `0` otherwise.
+
+## Combining checks with other scorers
+
+Checks compose with LLM-based and code-based scorers in the same `scorers` array:
+
+```typescript
+import { checks } from '@mastra/evals/checks'
+import { createAnswerRelevancyScorer } from '@mastra/evals/scorers/prebuilt'
+import { runEvals } from '@mastra/core/evals'
+import { myAgent } from '../agents'
+
+const result = await runEvals({
+  data: [{ input: 'What is the weather in Brooklyn?' }],
+  target: myAgent,
+  scorers: [
+    // Zero-LLM checks
+    checks.includes('Brooklyn'),
+    checks.calledTool('get_weather'),
+    checks.noToolErrors(),
+    // LLM-based scorer
+    createAnswerRelevancyScorer({ model: 'openai/gpt-5-mini' }),
+  ],
+})
+```
+
+## Related
+
+- [Quick Checks overview](https://mastra.ai/docs/evals/quick-checks)
+- [Built-in Scorers](https://mastra.ai/docs/evals/built-in-scorers)
+- [`createScorer()` reference](https://mastra.ai/reference/evals/create-scorer)
+- [`runEvals()` reference](https://mastra.ai/reference/evals/run-evals)
+- [Custom Scorers](https://mastra.ai/docs/evals/custom-scorers)

package/.docs/reference/harness/harness-class.md

@@ -1,6 +1,6 @@
 # Harness class
 
-> **Alpha:** The `Harness` feature is in alpha stage and subject to breaking changes in minor versions until it graduates from its alpha status.
+> **Beta:** The `Harness` feature is in beta stage and subject to breaking changes in minor versions until it graduates from its beta status.
 
 The `Harness` class orchestrates multiple agent modes, shared state, memory, and storage. It provides a control layer that a TUI or other UI can drive to manage threads, switch models and modes, send messages, handle tool approvals, and track events.
 
@@ -166,6 +166,33 @@ Initialize the harness. Loads storage, initializes the workspace, propagates mem
 await harness.init()
 ```
 
+#### `createSession({ id, ownerId, resourceId? })`
+
+Create a new, fully-wired `Session` and bring it online. The session starts in the default mode with the seeded model, connects to the Harness's shared machinery (agent, storage/lock, config catalog), and has a current thread (the most recent thread for the resource, or a freshly created one). Call `init()` once before creating sessions so shared storage and workspace are ready.
+
+The Harness owns no session of its own — every consumer creates its own session and drives all work through it. In a server or multiplayer setting, each request, thread, or user gets its own session, isolated from every other: independent event bus, mode, model, state, and current thread.
+
+`id` and `ownerId` are required — they mirror `SessionRecord.id` and `SessionRecord.ownerId` and are stable for the life of the session. `resourceId` is optional and defaults to `config.resourceId` then `config.id`.
+
+```typescript
+const session = await harness.createSession({
+  id: 'session-xyz',
+  ownerId: 'user-123',
+})
+```
+
+You can also override the resource:
+
+```typescript
+const session = await harness.createSession({
+  id: 'session-xyz',
+  ownerId: 'user-123',
+  resourceId: 'project-abc',
+})
+```
+
+Switching the resource ID via `harness.setResourceId()` changes only the resource ID, not `id` or `ownerId`. Read them through `session.identity.getId()` and `session.identity.getOwnerId()`.
+
 #### `selectOrCreateThread()`
 
 Select the most recent thread for the current resource, or create one if none exist. Loads thread metadata and acquires a thread lock.

package/.docs/reference/harness/session.md

@@ -1,6 +1,6 @@
 # Session class
 
-> **Alpha:** The `Harness` feature is in alpha stage and subject to breaking changes in minor versions until it graduates from its alpha status.
+> **Beta:** The `Harness` feature is in beta stage and subject to breaking changes in minor versions until it graduates from its beta status.
 
 A `Session` owns all the state tied to a single conversation. The [`Harness`](https://mastra.ai/reference/harness/harness-class) is the shared host — agents, storage, config, the thread lock, and the event bus — while the `Session` holds everything that is per-conversation: identity, the active thread binding and reads, mode and model selection, run and abort state, the live agent stream, tool suspensions, follow-ups, approvals, permission grants, token usage, and the display-state snapshot.
 
@@ -29,7 +29,7 @@ harness.subscribe(event => {
 
 The session is organized into sub-objects, each owning one domain of per-conversation state.
 
-**identity** (`SessionIdentity`): Resource identity for the conversation. See identity methods below.
+**identity** (`SessionIdentity`): Stable session, owner, and resource identity for the conversation. See identity methods below.
 
 **thread** (`SessionThread`): Active thread binding and thread/message reads. See thread methods below.
 
@@ -125,7 +125,23 @@ const usage = harness.session.getTokenUsage()
 
 ## Identity
 
-`session.identity` owns the resource ID for the conversation.
+`session.identity` owns the stable identifiers for the conversation: the resource ID, a session `id`, and an `ownerId`. The `id` and `ownerId` are stable for the life of the session and do not change when the resource ID is switched. They mirror the `id` and `ownerId` fields on `SessionRecord` in storage.
+
+### `session.identity.getId()`
+
+Return the stable session identifier.
+
+```typescript
+const sessionId = harness.session.identity.getId()
+```
+
+### `session.identity.getOwnerId()`
+
+Return the stable owner identifier for the session.
+
+```typescript
+const ownerId = harness.session.identity.getOwnerId()
+```
 
 ### `session.identity.getResourceId()`
 
@@ -143,7 +159,7 @@ Return the resource ID the session was created with.
 const defaultResourceId = harness.session.identity.getDefaultResourceId()
 ```
 
-To change the resource ID, use [`harness.setResourceId()`](https://mastra.ai/reference/harness/harness-class), which also tears down the active thread.
+To change the resource ID, use [`harness.setResourceId()`](https://mastra.ai/reference/harness/harness-class), which also tears down the active thread. The session `id` and `ownerId` are not affected by resource switches.
 
 ## Thread
 

package/.docs/reference/index.md

@@ -118,6 +118,7 @@ The Reference section provides documentation of Mastra's API, including paramete
 - [createScorer()](https://mastra.ai/reference/evals/create-scorer)
 - [filterRun()](https://mastra.ai/reference/evals/filter-run)
 - [MastraScorer](https://mastra.ai/reference/evals/mastra-scorer)
+- [Quick Checks](https://mastra.ai/reference/evals/checks)
 - [runEvals()](https://mastra.ai/reference/evals/run-evals)
 - [Scorer Utils](https://mastra.ai/reference/evals/scorer-utils)
 - [Answer Relevancy Scorer](https://mastra.ai/reference/evals/answer-relevancy)

package/.docs/reference/memory/observational-memory.md

@@ -44,7 +44,7 @@ OM performs thresholding with fast local token estimation. Text uses `tokenx`, a
 
 **temporalMarkers** (`boolean`): Insert temporal-gap reminder markers before new user messages when the previous message in the thread is at least 10 minutes older. The marker is persisted in memory, emitted as an inline reminder event so clients can render it specially, and shown to the observer so it can anchor observations to when events occurred. (Default: `false`)
 
-**retrieval** (`boolean | { vector?: boolean; scope?: 'thread' | 'resource' }`): \*\*Experimental.\*\* Enable retrieval-mode observation groups as durable pointers to raw message history. \`true\` enables cross-thread browsing by default. \`{ vector: true }\` also enables semantic search using Memory's vector store and embedder. \`{ scope: 'thread' }\` restricts the recall tool to the current thread only. Default scope is \`'resource'\`. (Default: `false`)
+**retrieval** (`boolean | { vector?: boolean; scope?: 'thread' | 'resource' }`): Enable retrieval-mode observation groups as durable pointers to raw message history. \`true\` enables cross-thread browsing by default. \`{ vector: true }\` also enables semantic search using Memory's vector store and embedder. \`{ scope: 'thread' }\` restricts the recall tool to the current thread only. Default scope is \`'resource'\`. (Default: `false`)
 
 **observation** (`ObservationalMemoryObservationConfig`): Configuration for the observation step. Controls when the Observer agent runs and how it behaves.
 

package/.docs/reference/memory/serialized-memory-config.md

@@ -58,7 +58,7 @@ new MastraEditor({
 
 **temporalMarkers** (`boolean`): Persist inline temporal gap markers for long pauses between messages.
 
-**retrieval** (`boolean | { vector?: boolean; scope?: 'thread' | 'resource' }`): Experimental. Enable retrieval-mode observation groups as durable pointers to raw message history.
+**retrieval** (`boolean | { vector?: boolean; scope?: 'thread' | 'resource' }`): Enable retrieval-mode observation groups as durable pointers to raw message history.
 
 **observation** (`SerializedObservationalMemoryObservationConfig`): Observer-step configuration (model, token thresholds, buffering).
 

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

@@ -78,7 +78,7 @@ const stream = await agent.stream('message for agent')
 
 **options.onAbort** (`(event: any) => Promise<void> | void`): Callback function called when the stream is aborted.
 
-**options.abortSignal** (`AbortSignal`): Signal object that allows you to abort the agent's execution. When the signal is aborted, all ongoing operations will be terminated.
+**options.abortSignal** (`AbortSignal`): Signal object that allows you to abort the agent's execution. When the signal is aborted, all ongoing operations will be terminated, including any in-flight subagent runs the agent delegated to.
 
 **options.activeTools** (`Array<keyof ToolSet> | undefined`): Array of active tool names that can be used during execution.
 

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # @mastra/mcp-docs-server
 
+## 1.2.2-alpha.2
+
+### Patch Changes
+
+- Updated dependencies [[`7f9ae70`](https://github.com/mastra-ai/mastra/commit/7f9ae70826b047e5a66218f9e92f20e54a2d791f), [`1505c07`](https://github.com/mastra-ai/mastra/commit/1505c07603f6346bae12aa82f140e8b88ffea9ab), [`e940f09`](https://github.com/mastra-ai/mastra/commit/e940f099ef5d18b403e6f2b4937e086a4da857b1)]:
+  - @mastra/core@1.46.1-alpha.1
+
+## 1.2.2-alpha.0
+
+### Patch Changes
+
+- Updated dependencies [[`fbeda0c`](https://github.com/mastra-ai/mastra/commit/fbeda0c0f35def07e6837936dd3a003b2b7c5172), [`307573b`](https://github.com/mastra-ai/mastra/commit/307573b9ff3149b70c79540dbc86f1319b180f29)]:
+  - @mastra/core@1.46.1-alpha.0
+
 ## 1.2.1
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/mcp-docs-server",
-  "version": "1.2.1",
+  "version": "1.2.2-alpha.2",
   "description": "MCP server for accessing Mastra.ai documentation, changelogs, and news.",
   "type": "module",
   "main": "dist/index.js",
@@ -28,8 +28,8 @@
     "jsdom": "^26.1.0",
     "local-pkg": "^1.1.2",
     "zod": "^4.4.3",
-    "@mastra/core": "1.46.0",
-    "@mastra/mcp": "^1.12.0"
+    "@mastra/mcp": "^1.12.0",
+    "@mastra/core": "1.46.1-alpha.1"
   },
   "devDependencies": {
     "@hono/node-server": "^1.19.11",
@@ -47,7 +47,7 @@
     "vitest": "4.1.8",
     "@internal/lint": "0.0.108",
     "@internal/types-builder": "0.0.83",
-    "@mastra/core": "1.46.0"
+    "@mastra/core": "1.46.1-alpha.1"
   },
   "homepage": "https://mastra.ai",
   "repository": {