@mastra/mcp-docs-server 1.2.8-alpha.0 → 1.2.8-alpha.19

package/.docs/reference/evals/context-recall.md

@@ -0,0 +1,205 @@
+> Discover all available pages from the documentation index: https://mastra.ai/llms.txt
+
+# Context recall scorer
+
+The `createContextRecallScorer()` function creates a scorer that evaluates how well retrieved context covers the claims in a ground-truth reference answer. It measures retrieval completeness by checking what fraction of the ground truth's claims are attributable to the retrieved context.
+
+This scorer requires a ground-truth reference answer, making it suitable for labeled datasets in CI or test environments. When `groundTruth` is not provided in the run, the scorer returns a score of 0 rather than throwing an error.
+
+## RAG retrieval evaluation
+
+Ideal for evaluating retrieval completeness in RAG pipelines where:
+
+- You need to verify the retriever fetches all necessary information
+- You have labeled datasets with known-correct answers
+- You want to catch regressions in what the retriever returns
+
+## Dataset-driven testing
+
+Use when running evaluations against curated test sets:
+
+- CI pipelines with ground-truth labeled questions
+- A/B testing retrieval strategies
+- Benchmarking embedding models for coverage
+
+## Parameters
+
+**model** (`MastraModelConfig`): The language model to use for evaluating claim attribution
+
+**options** (`ContextRecallMetricOptions`): Configuration options for the scorer
+
+**Note**: Either `context` or `contextExtractor` must be provided. When both are provided, `contextExtractor` is used only if the run input and output are agent-shaped (`MastraDBMessage[]`); otherwise the scorer falls back to `context`.
+
+## `.run()` returns
+
+**score** (`number`): Recall score between 0 and scale (default 0-1), representing the fraction of ground-truth claims covered by the context
+
+**reason** (`string`): Human-readable explanation of which ground-truth claims were and were not found in the context
+
+## Scoring details
+
+### Claim attribution
+
+Context Recall uses a two-step LLM evaluation followed by a deterministic score calculation:
+
+1. **Claim extraction**: The ground-truth answer is decomposed into atomic claims
+2. **Attribution check**: Each claim is checked against the retrieval context for support
+
+The score is then calculated as the ratio of attributed claims to total claims, multiplied by scale.
+
+### Scoring formula
+
+```text
+Context Recall = attributed_claims / total_claims × scale
+
+Where:
+- attributed_claims = number of ground-truth claims supported by the context
+- total_claims = total number of claims extracted from the ground truth
+- Attribution is binary: a claim is either supported (yes) or not (no)
+```
+
+### Score interpretation
+
+These ranges assume the default `scale` of 1. When using a custom scale, multiply accordingly.
+
+- **0.9-1.0**: Excellent recall — context covers nearly all ground-truth claims
+- **0.7-0.8**: Good recall — most claims are covered, minor gaps
+- **0.4-0.6**: Moderate recall — significant information missing from context
+- **0.1-0.3**: Poor recall — most ground-truth claims not found in context
+- **0.0**: No recall — none of the ground-truth claims are in the context
+
+### Reason analysis
+
+The reason field explains:
+
+- Which ground-truth claims were found in the context
+- Which claims were missing and what information gaps exist
+- Specific context pieces that supported attributed claims
+
+### Optimization insights
+
+Use results to:
+
+- **Improve retrieval**: Identify what types of information the retriever misses
+- **Tune chunk size**: Ensure chunks contain enough detail to cover ground-truth claims
+- **Evaluate embeddings**: Test different embedding models for better information coverage
+- **Expand knowledge base**: Add documents that cover frequently missed claims
+
+### Example calculation
+
+Given ground truth: "Einstein was born in 1879. He developed relativity. He won the Nobel Prize."
+
+Claims extracted: 3
+
+- "Einstein was born in 1879" → attributed (context mentions birthdate)
+- "Einstein developed relativity" → attributed (context covers relativity)
+- "Einstein won the Nobel Prize" → not attributed (context doesn't mention Nobel Prize)
+
+Recall = 2/3 = 0.67
+
+## Scorer configuration
+
+### Dynamic context extraction
+
+```typescript
+const scorer = createContextRecallScorer({
+  model: 'openai/gpt-5.5',
+  options: {
+    contextExtractor: (input, output) => {
+      const query = input?.inputMessages?.[0]?.content || ''
+      const searchResults = vectorDB.search(query, { limit: 10 })
+      return searchResults.map(result => result.content)
+    },
+    scale: 1,
+  },
+})
+```
+
+### Static context evaluation
+
+```typescript
+const scorer = createContextRecallScorer({
+  model: 'openai/gpt-5.5',
+  options: {
+    context: [
+      'Document 1: Einstein was born on 14 March 1879 in Ulm, Germany.',
+      'Document 2: Einstein published the theory of special relativity in 1905.',
+      'Document 3: Einstein moved to the United States in 1933.',
+    ],
+  },
+})
+```
+
+## Example
+
+Evaluate RAG retrieval completeness against a labeled dataset:
+
+```typescript
+import { runEvals } from '@mastra/core/evals'
+import { createContextRecallScorer } from '@mastra/evals/scorers/prebuilt'
+import { myAgent } from './agent'
+
+const scorer = createContextRecallScorer({
+  model: 'openai/gpt-5.5',
+  options: {
+    contextExtractor: (input, output) => {
+      // Extract context from tool invocation results in the agent output
+      return output
+        .filter(msg => msg?.role === 'assistant')
+        .flatMap(msg => msg?.content?.toolInvocations ?? [])
+        .filter((tool: any) => tool.state === 'result')
+        .map((tool: any) => JSON.stringify(tool.result))
+    },
+  },
+})
+
+const result = await runEvals({
+  data: [
+    {
+      input: 'What are the health benefits of green tea?',
+      groundTruth:
+        'Green tea contains antioxidants that reduce inflammation, L-theanine that improves focus, and catechins that boost metabolism.',
+    },
+    {
+      input: 'How does photosynthesis work?',
+      groundTruth:
+        'Photosynthesis converts sunlight into chemical energy using chlorophyll in chloroplasts, producing glucose and oxygen from carbon dioxide and water.',
+    },
+  ],
+  scorers: [scorer],
+  target: myAgent,
+  onItemComplete: ({ scorerResults }) => {
+    console.log({
+      score: scorerResults[scorer.id].score,
+      reason: scorerResults[scorer.id].reason,
+    })
+  },
+})
+
+console.log(result.scores)
+```
+
+For more details on `runEvals`, see the [runEvals reference](https://mastra.ai/reference/evals/run-evals).
+
+To add this scorer to an agent, see the [Scorers overview](https://mastra.ai/docs/evals/overview) guide.
+
+## Comparison with context precision
+
+Choose the right scorer for your needs:
+
+| Use case                  | Context Recall           | Context Precision             |
+| ------------------------- | ------------------------ | ----------------------------- |
+| **What it measures**      | Coverage of ground truth | Relevance of retrieved chunks |
+| **Direction**             | Ground truth → context   | Context → ground truth        |
+| **Position sensitive**    | No                       | Yes (rewards early placement) |
+| **Requires ground truth** | Yes                      | Yes                           |
+| **Failure mode caught**   | Missing information      | Irrelevant noise              |
+
+Use both together for a complete picture of retrieval quality: precision catches junk in the context, recall catches gaps.
+
+## Related
+
+- [Context Precision Scorer](https://mastra.ai/reference/evals/context-precision): Evaluates if retrieved context is relevant and well-ranked
+- [Context Relevance Scorer](https://mastra.ai/reference/evals/context-relevance): Evaluates context usage and quality
+- [Faithfulness Scorer](https://mastra.ai/reference/evals/faithfulness): Measures answer groundedness in context
+- [Custom Scorers](https://mastra.ai/docs/evals/custom-scorers): Creating your own evaluation metrics

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

@@ -23,18 +23,12 @@ const scorer = createScorer({
     instructions: 'You are an expert evaluator...',
   },
 })
-  .preprocess({
-    /* step config */
-  })
-  .analyze({
-    /* step config */
-  })
+  .preprocess({/* step config */})
+  .analyze({/* step config */})
   .generateScore(({ run, results }) => {
     // Return a number
   })
-  .generateReason({
-    /* step config */
-  })
+  .generateReason({/* step config */})
 ```
 
 ## `createScorer` options
@@ -51,7 +45,7 @@ const scorer = createScorer({
 
 **judge.instructions** (`string`): System prompt/instructions for the LLM.
 
-**judge.jsonPromptInjection** (`boolean`): When true, inject the JSON schema into the prompt instead of using the provider's native response\_format API. Set this for models that don't support native structured output (e.g. some Groq Llama models) to avoid a wasted 400 call.
+**judge.jsonPromptInjection** (`boolean | 'system' | 'inline' | 'auto'`): Controls how the judge's structured output schema reaches the model. Defaults to 'auto', which uses native structured output when supported and inline prompt injection otherwise. Explicit values override automatic routing.
 
 **judge.inputProcessors** (`Processor[]`): Input processors applied to the internal judge agent before its messages reach the model (e.g. redaction, validation).
 

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

@@ -33,9 +33,7 @@ const result = await scorer.run({
   input: 'What is machine learning?',
   output: 'Machine learning is a subset of artificial intelligence...',
   runId: 'optional-run-id',
-  requestContext: {
-    /* optional context */
-  },
+  requestContext: {/* optional context */},
 })
 ```
 

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

@@ -31,6 +31,28 @@ console.log(`Average scores:`, result.scores)
 console.log(`Processed ${result.summary.totalItems} items`)
 ```
 
+### Multi-turn evaluation
+
+```typescript
+import { runEvals } from '@mastra/core/evals'
+import { checks } from '@mastra/evals/checks'
+import { weatherAgent } from './agents/weather-agent'
+
+const result = await runEvals({
+  target: weatherAgent,
+  data: [
+    {
+      inputs: [
+        'What is the weather in Brooklyn?',
+        'What about tomorrow?',
+        'Compare the two forecasts.',
+      ],
+    },
+  ],
+  scorers: [checks.calledTool('get_weather', { times: 2 }), checks.includes('Brooklyn')],
+})
+```
+
 ### With gates and thresholds
 
 ```typescript
@@ -60,7 +82,7 @@ result.thresholdResults // [{ id, passed, averageScore, threshold }]
 
 **gates** (`MastraScorer[]`): Scorers that must score 1.0 for the run to pass. If any gate averages below 1.0 across data items, the verdict is failed. Gates run before regular scorers on each data item. When provided, scorers may be omitted.
 
-**targetOptions** (`AgentExecutionOptions | WorkflowRunOptions`): Options forwarded to the target during execution. For agents: options passed to agent.generate() (e.g. maxSteps, modelSettings, instructions). For workflows: options passed to run.start() (e.g. perStep, outputOptions, initialState).
+**targetOptions** (`AgentExecutionOptions | WorkflowRunOptions`): Options forwarded to the target during execution. For agents: options passed to agent.generate() (e.g. maxSteps, modelSettings, instructions). For workflows: options passed to run.start() (e.g. perStep, outputOptions, initialState). For multi-turn agent runs (inputs/turns), runEvals generates and injects the shared thread and a resource, so memory.thread is optional; provide memory.resource to reuse a specific resource.
 
 **concurrency** (`number`): Number of test cases to run concurrently. (Default: `1`)
 
@@ -68,7 +90,11 @@ result.thresholdResults // [{ id, passed, averageScore, threshold }]
 
 ## Data item structure
 
-**input** (`string | string[] | CoreMessage[] | any`): Input data for the target. For agents: messages or strings. For workflows: workflow input data.
+**input** (`string | string[] | CoreMessage[] | any`): Input data for the target. For agents: messages or strings. For workflows: workflow input data. Optional when inputs is provided.
+
+**inputs** (`(string | string[] | CoreMessage[] | any)[]`): Multi-turn inputs. Each entry is one turn (same shape as input) sent sequentially to the agent on the same thread. Scorers see the accumulated output from all turns. Only supported for Agent targets. When provided, input can be omitted. Mutually exclusive with turns.
+
+**turns** (`EvalTurn[]`): Multi-turn conversation with per-turn assertions. Each turn is an object { input, gates?, scorers? } sent sequentially on the same thread; its gates/scorers evaluate only that turn's input and output. Per-turn outcomes are reported in turnResults and folded into the overall verdict. Only supported for Agent targets. Mutually exclusive with input and inputs.
 
 **groundTruth** (`any`): Expected or reference output for comparison during scoring.
 
@@ -112,6 +138,18 @@ For workflows, use `WorkflowScorerConfig` to specify scorers at different levels
 
 **thresholdResults** (`ThresholdResult[]`): Per-threshold-scorer results averaged across all data items. Each entry has id, passed, averageScore, and threshold.
 
+**turnResults** (`TurnResult[]`): Present when any data item uses turns. Each entry has index (zero-based turn), optional gateResults, thresholdResults, and scores (bare-scorer averages keyed by scorer id), aggregated by turn index across data items.
+
+## EvalTurn
+
+A single turn in a `turns` array. Its `gates`/`scorers` evaluate only that turn's input and output:
+
+**input** (`string | string[] | CoreMessage[] | any`): The input sent to the agent for this turn.
+
+**gates** (`MastraScorer[]`): Gates that must score 1.0 for this turn. A failing turn gate makes the overall verdict failed.
+
+**scorers** (`ScorerEntry[]`): Scorers (optionally with thresholds) evaluated against this turn only. A missed per-turn threshold (with gates passing) makes the verdict scored.
+
 ## ScorerEntry
 
 A scorer entry in the `scorers` array can be either a bare scorer or a scorer with a threshold:
@@ -314,8 +352,62 @@ const result = await runEvals({
 })
 ```
 
+### Multi-turn conversation evaluation
+
+Use `inputs` to send sequential turns on a shared thread. Scorers see the accumulated output from all turns:
+
+```typescript
+const result = await runEvals({
+  target: chatAgent,
+  data: [
+    {
+      inputs: ['My favorite city is Brooklyn.', 'What is the weather in my favorite city?'],
+    },
+  ],
+  gates: [checks.calledTool('get_weather')],
+  scorers: [{ scorer: checks.similarity('Brooklyn weather forecast'), threshold: 0.5 }],
+})
+
+// result.verdict: 'passed' | 'scored' | 'failed'
+```
+
+Each turn runs `agent.generate()` with the same `threadId`, so the agent sees the full conversation history. `runEvals` also injects a `resourceId` (Mastra memory scopes messages by resource + thread), defaulting it to the generated thread; pass `targetOptions.memory.resource` to pin a specific one. Cross-turn recall requires the agent to have a memory store configured; otherwise turns run in isolation. Mix single-turn (`input`) and multi-turn (`inputs`) items in the same `data` array. When using `inputs`, `input` can be omitted.
+
+Scoring uses the accumulated output from all turns as `run.output`, but only the first turn as `run.input`. Prefer output-based scorers (`checks.includes`, `checks.calledTool`, `checks.similarity`) for multi-turn; input-relative scorers (e.g. faithfulness) only see the first turn's input. Trajectory scorers that read from the trace (`AgentScorerConfig.trajectory`) resolve against the last turn's span; tool-call checks that read `run.output` (like `checks.calledTool`) still see every turn.
+
+### Per-turn assertions
+
+Use `turns` to attach `gates`/`scorers` to individual turns. Each per-turn assertion sees only that turn's input and output, so a later-turn regression can't be hidden by an earlier turn:
+
+```typescript
+const result = await runEvals({
+  target: chatAgent,
+  data: [
+    {
+      turns: [
+        {
+          input: 'What is the weather in Brooklyn?',
+          gates: [checks.calledTool('get_weather')],
+        },
+        {
+          input: 'What about tomorrow?',
+          gates: [checks.calledTool('get_weather')], // must call again this turn
+          scorers: [{ scorer: checks.similarity('tomorrow forecast'), threshold: 0.5 }],
+        },
+      ],
+    },
+  ],
+})
+
+result.verdict // folds in per-turn gate/threshold outcomes
+result.turnResults // [{ index, gateResults, thresholdResults, scores }]
+```
+
+Per-turn gates/scorers evaluate only that turn (`run.input`/`run.output` are that turn's). A failing turn gate makes the verdict `failed`; a missed turn threshold (gates passing) makes it `scored`. Top-level `scorers`/`gates` still score the accumulated conversation holistically. `turns` is Agent-only and cannot be combined with `input` or `inputs`.
+
 ## Related
 
+- [Multi-turn evals](https://mastra.ai/docs/evals/multi-turn): Conceptual guide to multi-turn evaluation
 - [Gates and Verdicts](https://mastra.ai/docs/evals/gates-and-verdicts): Conceptual guide to severity semantics
 - [Quick Checks](https://mastra.ai/reference/evals/checks): Zero-LLM composable micro-scorers
 - [createScorer()](https://mastra.ai/reference/evals/create-scorer): Create custom scorers for experiments

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

@@ -19,7 +19,7 @@ export default new PinoLogger({
 })
 ```
 
-Mastra registers the logger before storage, observability, and file-based agents, so those primitives log through this logger as they are wired up.
+Mastra registers the logger before storage, observability, and file-based agents, so those primitives log through this logger as they're wired up.
 
 ## Precedence with code
 

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

@@ -16,16 +16,17 @@ import { z } from 'zod'
 
 export default createTool({
   id: 'get_weather',
-  description: 'Get the current weather for a city.',
+  description: 'Get the current weather for a location.',
   inputSchema: z.object({
-    city: z.string(),
+    location: z.string(),
   }),
   outputSchema: z.object({
-    city: z.string(),
-    tempC: z.number(),
+    location: z.string(),
+    temperatureCelsius: z.number(),
+    conditions: z.string(),
   }),
-  execute: async ({ context }) => {
-    return { city: context.city, tempC: 21 }
+  execute: async ({ location }) => {
+    return { location, temperatureCelsius: 21, conditions: 'sunny' }
   },
 })
 ```

package/.docs/reference/index.md

@@ -57,6 +57,7 @@ The Reference section provides documentation of Mastra's API, including paramete
 - [WorkOS](https://mastra.ai/reference/auth/workos)
 - [AgentBrowser](https://mastra.ai/reference/browser/agent-browser)
 - [BrowserViewer](https://mastra.ai/reference/browser/browser-viewer)
+- [FirecrawlBrowser](https://mastra.ai/reference/browser/firecrawl-browser)
 - [MastraBrowser Class](https://mastra.ai/reference/browser/mastra-browser)
 - [StagehandBrowser](https://mastra.ai/reference/browser/stagehand-browser)
 - [ChannelProvider](https://mastra.ai/reference/channels/channel-provider)
@@ -97,6 +98,8 @@ The Reference section provides documentation of Mastra's API, including paramete
 - [.getServer()](https://mastra.ai/reference/core/getServer)
 - [.getStorage()](https://mastra.ai/reference/core/getStorage)
 - [.getTelemetry()](https://mastra.ai/reference/core/getTelemetry)
+- [.getTool()](https://mastra.ai/reference/core/getTool)
+- [.getToolById()](https://mastra.ai/reference/core/getToolById)
 - [.getVector()](https://mastra.ai/reference/core/getVector)
 - [.getWorkflow()](https://mastra.ai/reference/core/getWorkflow)
 - [.listAgents()](https://mastra.ai/reference/core/listAgents)
@@ -106,6 +109,7 @@ The Reference section provides documentation of Mastra's API, including paramete
 - [.listMCPServers()](https://mastra.ai/reference/core/listMCPServers)
 - [.listMemory()](https://mastra.ai/reference/core/listMemory)
 - [.listScorers()](https://mastra.ai/reference/core/listScorers)
+- [.listTools()](https://mastra.ai/reference/core/listTools)
 - [.listVectors()](https://mastra.ai/reference/core/listVectors)
 - [.listWorkflows()](https://mastra.ai/reference/core/listWorkflows)
 - [.removeWorkspace()](https://mastra.ai/reference/core/removeWorkspace)
@@ -139,6 +143,7 @@ The Reference section provides documentation of Mastra's API, including paramete
 - [Completeness](https://mastra.ai/reference/evals/completeness)
 - [Content Similarity Scorer](https://mastra.ai/reference/evals/content-similarity)
 - [Context Precision Scorer](https://mastra.ai/reference/evals/context-precision)
+- [Context Recall Scorer](https://mastra.ai/reference/evals/context-recall)
 - [Context Relevance Scorer](https://mastra.ai/reference/evals/context-relevance)
 - [Faithfulness](https://mastra.ai/reference/evals/faithfulness)
 - [Hallucination](https://mastra.ai/reference/evals/hallucination)
@@ -333,6 +338,7 @@ The Reference section provides documentation of Mastra's API, including paramete
 - [Inworld Realtime](https://mastra.ai/reference/voice/inworld-realtime)
 - [LiveKit](https://mastra.ai/reference/voice/livekit)
 - [Mastra Voice](https://mastra.ai/reference/voice/mastra-voice)
+- [Mistral](https://mastra.ai/reference/voice/mistral)
 - [Murf](https://mastra.ai/reference/voice/murf)
 - [OpenAI](https://mastra.ai/reference/voice/openai)
 - [OpenAI Realtime](https://mastra.ai/reference/voice/openai-realtime)
@@ -389,6 +395,8 @@ The Reference section provides documentation of Mastra's API, including paramete
 - [LocalSandbox](https://mastra.ai/reference/workspace/local-sandbox)
 - [MesaFilesystem](https://mastra.ai/reference/workspace/mesa-filesystem)
 - [ModalSandbox](https://mastra.ai/reference/workspace/modal-sandbox)
+- [PlatformFilesystem](https://mastra.ai/reference/workspace/platform-filesystem)
+- [PlatformSandbox](https://mastra.ai/reference/workspace/platform-sandbox)
 - [RailwaySandbox](https://mastra.ai/reference/workspace/railway-sandbox)
 - [S3Filesystem](https://mastra.ai/reference/workspace/s3-filesystem)
 - [SandboxProcessManager](https://mastra.ai/reference/workspace/process-manager)

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

@@ -408,6 +408,27 @@ Setting `bufferTokens: false` disables both observation and reflection async buf
 
 Observational Memory emits typed data parts during agent execution that clients can use for real-time UI feedback. These are streamed alongside the agent's response.
 
+### Read extractor results
+
+Both completion events carry extractor output in their `data` payload. The extractor fields are:
+
+```typescript
+interface DataOmObservationEndPart {
+  type: 'data-om-observation-end'
+  data: {
+    /** Whether the completed work was an observation or reflection */
+    operationType: 'observation' | 'reflection'
+    /** Values extracted during this OM operation, keyed by extractor slug */
+    extractedValues?: Record<string, unknown>
+    /** Extractor failures from this OM operation. Successful extractor values are still included */
+    extractionFailures?: Array<{ slug: string; error: string }>
+    // ...other fields documented in the tables below
+  }
+}
+```
+
+Both extractor fields are optional. A completion can include values, failures, both, or neither. `data-om-observation-end` reports synchronous completion. `data-om-buffering-end` reports completed background work whose buffered content still awaits activation, although extractor metadata is already persisted. `DataOmBufferingEndPart` carries the same extractor fields, and both types are exported from `@mastra/memory/processors`. See [Read extracted values from a stream](https://mastra.ai/docs/memory/observational-memory) for a consumer example.
+
 ### `data-om-status`
 
 Emitted once per agent loop step, before model generation. Provides a snapshot of the current memory state, including token usage for both context windows and the state of any async buffered content.

package/.docs/reference/observability/tracing/processors/sensitive-data-filter.md

@@ -14,9 +14,7 @@ To opt out or customize the auto-applied filter, use the `sensitiveDataFilter` o
 import { Observability } from '@mastra/observability'
 
 new Observability({
-  configs: {
-    /* ... */
-  },
+  configs: {/* ... */},
   // disable the auto-applied filter
   sensitiveDataFilter: false,
   // or customize it

package/.docs/reference/processors/token-limiter-processor.md

@@ -85,9 +85,7 @@ export const agent = new Agent({
   name: 'context-limited-agent',
   instructions: 'You are a helpful assistant',
   model: 'openai/gpt-5.5',
-  memory: new Memory({
-    /* ... */
-  }),
+  memory: new Memory({/* ... */}),
   inputProcessors: [
     new TokenLimiterProcessor({ limit: 4000 }), // Limits historical messages to ~4000 tokens
   ],

package/.docs/reference/rag/database-config.md

@@ -11,6 +11,7 @@ export type DatabaseConfig = {
   pinecone?: PineconeConfig
   pgvector?: PgVectorConfig
   chroma?: ChromaConfig
+  turbopuffer?: TurbopufferConfig
   [key: string]: any // Extensible for future databases
 }
 ```
@@ -90,6 +91,17 @@ whereDocument: { "$contains": "API documentation" }
 - Content-based document filtering
 - Complex query combinations
 
+### `TurbopufferConfig`
+
+Configuration options specific to Turbopuffer vector store.
+
+**consistency** (`'strong' | 'eventual'`): The consistency level for queries. "strong" (default) guarantees queries see all data written before the query started, at the cost of higher latency. "eventual" offers lower latency, but recently written data may not be visible yet.
+
+**Use Cases:**
+
+- Latency-sensitive queries where slightly stale data is acceptable (`eventual`)
+- Read-your-writes workflows that must see the latest data (`strong`)
+
 ## Usage examples
 
 **Basic Usage**:

package/.docs/reference/storage/clickhouse.md

@@ -131,7 +131,7 @@ bun x mastra migrate
 
 The migration copies span data from `mastra_ai_spans` into `mastra_span_events` in day-sized batches. It handles column mapping, deduplicates legacy rows, and preserves the original table as a backup. After migration, traces appear in Studio through the vNext adapter.
 
-> **Note:** The legacy table is not deleted. Drop it manually after verifying the migration.
+> **Note:** The legacy table isn't deleted. Drop it manually after verifying the migration.
 
 ### ClickHouse for every domain
 

package/.docs/reference/storage/convex.md

@@ -50,6 +50,7 @@ import {
   mastraResourcesTable,
   mastraWorkflowSnapshotsTable,
   mastraScoresTable,
+  mastraObservationalMemoryTable,
   mastraVectorIndexesTable,
   mastraVectorsTable,
   mastraCacheTable,
@@ -63,6 +64,7 @@ export default defineSchema({
   mastra_resources: mastraResourcesTable,
   mastra_workflow_snapshots: mastraWorkflowSnapshotsTable,
   mastra_scorers: mastraScoresTable,
+  mastra_observational_memory: mastraObservationalMemoryTable,
   mastra_vector_indexes: mastraVectorIndexesTable,
   mastra_vectors: mastraVectorsTable,
   mastra_cache: mastraCacheTable,
@@ -192,16 +194,21 @@ Use a non-empty `keyPrefix` unless you intentionally want `clear()` to remove ev
 
 The storage implementation uses typed Convex tables for each Mastra domain:
 
-| Domain      | Convex Table                | Purpose                                   |
-| ----------- | --------------------------- | ----------------------------------------- |
-| Threads     | `mastra_threads`            | Conversation threads                      |
-| Messages    | `mastra_messages`           | Chat messages                             |
-| Resources   | `mastra_resources`          | User working memory                       |
-| Workflows   | `mastra_workflow_snapshots` | Workflow state                            |
-| Scorers     | `mastra_scorers`            | Evaluation data                           |
-| Cache       | `mastra_cache`              | Cache values, counters, and list metadata |
-| Cache Items | `mastra_cache_list_items`   | Cache list entries                        |
-| Fallback    | `mastra_documents`          | Unknown tables                            |
+| Domain               | Convex Table                  | Purpose                                   |
+| -------------------- | ----------------------------- | ----------------------------------------- |
+| Threads              | `mastra_threads`              | Conversation threads                      |
+| Messages             | `mastra_messages`             | Chat messages                             |
+| Resources            | `mastra_resources`            | User working memory                       |
+| Observational Memory | `mastra_observational_memory` | Observational memory generations          |
+| Workflows            | `mastra_workflow_snapshots`   | Workflow state                            |
+| Scorers              | `mastra_scorers`              | Evaluation data                           |
+| Cache                | `mastra_cache`                | Cache values, counters, and list metadata |
+| Cache Items          | `mastra_cache_list_items`     | Cache list entries                        |
+| Fallback             | `mastra_documents`            | Unknown tables                            |
+
+### Observational memory
+
+`ConvexStore` supports [observational memory](https://mastra.ai/docs/memory/observational-memory). Add `mastraObservationalMemoryTable` to your Convex schema and redeploy with `npx convex deploy` to enable it. Existing deployments created before this table was added need the same schema update.
 
 ### Architecture
 

package/.docs/reference/storage/retention.md

@@ -228,7 +228,7 @@ const storage = new MongoDBStore({
 })
 ```
 
-> **Tip:** TTL indexes delete documents shortly after they expire (background thread runs every \~60 seconds), but the exact timing is not guaranteed. For precise, immediate cleanup, use `prune()` instead.
+> **Tip:** TTL indexes delete documents shortly after they expire (background thread runs every \~60 seconds), but the exact timing isn't guaranteed. For precise, immediate cleanup, use `prune()` instead.
 
 ## Reclaiming disk
 

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

@@ -100,7 +100,7 @@ const stream = await agent.stream('message for agent')
 
 **options.structuredOutput.instructions** (`string`): Additional instructions for the structured output model.
 
-**options.structuredOutput.jsonPromptInjection** (`boolean`): Injects system prompt into the main agent instructing it to return structured output, useful for when a model does not natively support structured outputs.
+**options.structuredOutput.jsonPromptInjection** (`boolean | 'system' | 'inline' | 'auto'`): Controls how the JSON schema reaches the model. Set to 'auto' to use native structured output when supported and inline prompt injection otherwise.
 
 **options.structuredOutput.providerOptions** (`ProviderOptions`): Provider-specific options passed to the internal structuring agent. Use this to control model behavior like reasoning effort for thinking models (e.g., { openai: { reasoningEffort: 'low' } }).
 
@@ -124,6 +124,8 @@ const stream = await agent.stream('message for agent')
 
 **options.memory.options** (`MemoryConfig`): Configuration for memory behavior including lastMessages, readOnly, semanticRecall, workingMemory, and filterIncompleteToolCalls.
 
+**options.memory.onTitleGenerated** (`(title: string) => void | Promise<void>`): Callback fired asynchronously when a thread title is generated and persisted to storage. Title generation runs in the background and may complete after the stream ends. Only fires when generateTitle is enabled in memory options and the thread has no existing title.
+
 **options.onFinish** (`StreamTextOnFinishCallback<any> | StreamObjectOnFinishCallback<OUTPUT>`): Callback function called when streaming completes. Receives the final result.
 
 **options.onStepFinish** (`StreamTextOnStepFinishCallback<any> | never`): Callback function called after each execution step. Receives step details as a JSON string. Unavailable for structured output