@mastra/core 1.0.0-beta.21 → 1.0.0-beta.22

package/dist/docs/core/01-reference.md

@@ -1,6 +1,6 @@
 # Core API Reference
 
-> API reference for core - 33 entries
+> API reference for core - 32 entries
 
 
 ---
@@ -9,12 +9,9 @@
 
 > Documentation for the `Mastra` class in Mastra, the core entry point for managing agents, workflows, MCP servers, and server endpoints.
 
-The `Mastra` class is the central orchestrator in any Mastra application, managing agents, workflows, storage, logging, telemetry, and more. Typically, you create a single instance of `Mastra` to coordinate your application.
+The `Mastra` class is the central orchestrator in any Mastra application, managing agents, workflows, storage, logging, observability, and more. Typically, you create a single instance of `Mastra` to coordinate your application.
 
-Think of `Mastra` as a top-level registry:
-
-- Registering **integrations** makes them accessible to **agents**, **workflows**, and **tools** alike.
-- **tools** aren’t registered on `Mastra` directly but are associated with agents and discovered automatically.
+Think of `Mastra` as a top-level registry where you register agents, workflows, tools, and other components that need to be accessible throughout your application.
 
 ## Usage example
 
@@ -41,6 +38,8 @@ export const mastra = new Mastra({
 
 ## Constructor parameters
 
+Visit the [Configuration reference](https://mastra.ai/reference/v1/configuration) for detailed documentation on all available configuration options.
+
 ---
 
 ## Reference: MastraModelGateway
@@ -516,7 +515,7 @@ import { Memory } from "@mastra/memory";
 import { LibSQLStore } from "@mastra/libsql";
 
 const conversationMemory = new Memory({
-  storage: new LibSQLStore({ url: ":memory:" }),
+  storage: new LibSQLStore({ id: 'conversation-store', url: ":memory:" }),
 });
 
 const mastra = new Mastra({
@@ -1025,12 +1024,12 @@ import { LibSQLStore } from "@mastra/libsql";
 
 const conversationMemory = new Memory({
   id: "conversation-memory",
-  storage: new LibSQLStore({ url: ":memory:" }),
+  storage: new LibSQLStore({ id: 'conversation-store', url: ":memory:" }),
 });
 
 const analyticsMemory = new Memory({
   id: "analytics-memory",
-  storage: new LibSQLStore({ url: ":memory:" }),
+  storage: new LibSQLStore({ id: 'analytics-store', url: ":memory:" }),
 });
 
 const mastra = new Mastra({
@@ -1265,29 +1264,4 @@ This method does not return a value.
 ## Related
 
 - [Storage overview](https://mastra.ai/reference/v1/storage/overview)
-- [Storage reference](https://mastra.ai/reference/v1/storage/libsql)
-
----
-
-## Reference: Mastra.setTelemetry()
-
-> Documentation for the `Mastra.setTelemetry()` method in Mastra, which sets the telemetry configuration for all components.
-
-The `.setTelemetry()` method is used to set the telemetry configuration for all components in the Mastra instance. This method accepts a single telemetry configuration object.
-
-## Usage example
-
-```typescript
-mastra.setTelemetry({ export: { type: "console" } });
-```
-
-## Parameters
-
-## Returns
-
-This method does not return a value.
-
-## Related
-
-- [Logging](https://mastra.ai/docs/v1/observability/logging)
-- [PinoLogger](https://mastra.ai/reference/v1/logging/pino-logger)
+- [Storage reference](https://mastra.ai/reference/v1/storage/libsql)

package/dist/docs/deployer/01-reference.md

@@ -19,7 +19,7 @@ import { CloudflareDeployer } from "@mastra/deployer-cloudflare";
 
 export const mastra = new Mastra({
   deployer: new CloudflareDeployer({
-    projectName: "hello-mastra",
+    name: "hello-mastra",
     routes: [
       {
         pattern: "example.com/*",
@@ -27,12 +27,11 @@ export const mastra = new Mastra({
         custom_domain: true
       }
     ],
-    workerNamespace: "my-namespace",
-    env: {
+    vars: {
       NODE_ENV: "production",
       API_KEY: "<api-key>"
     },
-    d1Databases: [
+    d1_databases: [
       {
         binding: "DB",
         database_name: "my-database",
@@ -40,16 +39,30 @@ export const mastra = new Mastra({
         preview_database_id: "your-preview-database-id"
       }
     ],
-    kvNamespaces: [
+    kv_namespaces: [
       {
         binding: "CACHE",
         id: "kv-namespace-id"
       }
     ]
+  })
 });
 ```
 
-## Parameters
+## Constructor options
+
+The `CloudflareDeployer` constructor accepts the same configuration options as `wrangler.json`. See the [Wrangler configuration documentation](https://developers.cloudflare.com/workers/wrangler/configuration/) for all available options.
+
+### Migrating from earlier versions
+
+The following fields are deprecated and should be replaced with their standard `wrangler.json` equivalents:
+
+| Deprecated | Use instead |
+|------------|-------------|
+| `projectName` | `name` |
+| `d1Databases` | `d1_databases` |
+| `kvNamespaces` | `kv_namespaces` |
+| `workerNamespace` | *(removed, no longer used)* |
 
 ---
 

package/dist/docs/evals/01-overview.md

@@ -1,11 +1,11 @@
 > Overview of scorers in Mastra, detailing their capabilities for evaluating AI outputs and measuring performance.
 
 > **Code References:**
-- `Agent`: dist/agent/agent.d.ts → dist/chunk-IC2MIQBW.js:16163
-- `createWorkflow`: dist/workflows/index.d.ts → dist/chunk-IC2MIQBW.js:8318
-- `createStep`: dist/workflows/index.d.ts → dist/chunk-IC2MIQBW.js:7656
-- `Workflow`: dist/workflows/workflow.d.ts → dist/chunk-IC2MIQBW.js:8334
-- `Mastra`: dist/mastra/index.d.ts → dist/chunk-XBZWAUZ3.js:24
+- `Agent`: dist/agent/agent.d.ts → dist/chunk-UVOQLIWL.js:16630
+- `createWorkflow`: dist/workflows/index.d.ts → dist/chunk-UVOQLIWL.js:8230
+- `createStep`: dist/workflows/index.d.ts → dist/chunk-UVOQLIWL.js:7570
+- `Workflow`: dist/workflows/workflow.d.ts → dist/chunk-UVOQLIWL.js:8246
+- `Mastra`: dist/mastra/index.d.ts → dist/chunk-IFPQ2MLB.js:24
 
 # Scorers overview
 

package/dist/docs/evals/02-custom-scorers.md

@@ -29,17 +29,19 @@ Each step can use either **functions** or **prompt objects** (LLM-based evaluati
 - Natural language understanding tasks
 - Nuanced context evaluation
 
+**What “prompt object” means:** Instead of a function, the step is an object with `description` + `createPrompt` (and `outputSchema` for `preprocess`/`analyze`). That object tells Mastra to run the judge LLM for the step and store the structured output in `results.<step>StepResult`.
+
 You can mix and match approaches within a single scorer - for example, use a function for preprocessing data and an LLM for analyzing quality.
 
 ### Initializing a Scorer
 
-Every scorer starts with the `createScorer` factory function, which requires a name and description, and optionally accepts a type specification and judge configuration.
+Every scorer starts with the `createScorer` factory function, which requires an id and description, and optionally accepts a type specification and judge configuration.
 
 ```typescript
 import { createScorer } from '@mastra/core/evals';
 
 const glutenCheckerScorer = createScorer({
-  name: 'Gluten Checker',
+  id: 'gluten-checker',
   description: 'Check if recipes contain gluten ingredients',
   judge: {                    // Optional: for prompt object steps
     model: 'openai/gpt-5.1',
@@ -55,6 +57,49 @@ const glutenCheckerScorer = createScorer({
 
 The judge configuration is only needed if you plan to use prompt objects in any step. Individual steps can override this default configuration with their own judge settings.
 
+If all steps are function-based, the judge is never called and there is no judge output. To see LLM output, define at least one step as a prompt object and read the corresponding step result (for example, `results.analyzeStepResult`).
+
+#### Minimal judge example (prompt object)
+
+This example uses a prompt object in `analyze`, so the judge runs and its structured output is available as `results.analyzeStepResult`.
+
+```typescript
+import { createScorer } from "@mastra/core/evals";
+import { z } from "zod";
+
+const quoteSourcesScorer = createScorer({
+  id: "quote-sources",
+  description: "Check if the response includes sources",
+  judge: {
+    model: "openai/gpt-4.1-nano",
+    instructions: "You are a strict evaluator.",
+  },
+})
+  .analyze({
+    description: "Detect whether sources are present",
+    outputSchema: z.object({
+      hasSources: z.boolean(),
+      sources: z.array(z.string()),
+    }),
+    createPrompt: ({ run }) => `
+Does the response contain sources? Extract them as a list.
+
+Response:
+${run.output}
+`,
+  })
+  .generateScore(({ results }) => (results.analyzeStepResult.hasSources ? 1 : 0));
+
+// Run the scorer and inspect judge output
+const result = await quoteSourcesScorer.run({
+  input: "What is the capital of France?",
+  output: "Paris is the capital of France [1]. Source: [1] Wikipedia",
+});
+
+console.log(result.score);              // 1
+console.log(result.analyzeStepResult);  // { hasSources: true, sources: ["Wikipedia"] }
+```
+
 #### Agent Type for Agent Evaluation
 
 For type safety and compatibility with both live agent scoring and trace scoring, use `type: 'agent'` when creating scorers for agent evaluation. This allows you to use the same scorer for an agent and also use it to score traces:
@@ -295,7 +340,7 @@ Return your response in this format:
 "This recipe is [gluten-free/contains gluten] because [explanation]"`;
 
 export const glutenCheckerScorer = createScorer({
-  name: "Gluten Checker",
+  id: "gluten-checker",
   description: "Check if the output contains any gluten",
   judge: {
     model: "openai/gpt-4.1-nano",
@@ -392,8 +437,6 @@ Provides human-readable explanations for the score using another LLM call.
 
 The reason generation step creates explanations that help users understand why a particular score was assigned, using both the boolean result and the specific gluten sources identified by the analysis step.
 
-````
-
 ## High gluten-free example
 
 ```typescript title="src/example-high-gluten-free.ts"
@@ -405,7 +448,7 @@ const result = await glutenCheckerScorer.run({
 console.log('Score:', result.score);
 console.log('Gluten sources:', result.analyzeStepResult.glutenSources);
 console.log('Reason:', result.reason);
-````
+```
 
 ### High gluten-free output
 

package/dist/docs/evals/04-reference.md

@@ -688,6 +688,8 @@ Mastra provides a unified `createScorer` factory that allows you to define custo
 
 Use the `createScorer` factory to define your scorer with a name, description, and optional judge configuration. Then chain step methods to build your evaluation pipeline. You must provide at least a `generateScore` step.
 
+**Prompt object steps** are step configurations expressed as objects with `description` + `createPrompt` (and `outputSchema` for `preprocess`/`analyze`). These steps invoke the judge LLM. **Function steps** are plain functions and never call the judge.
+
 ```typescript
 import { createScorer } from "@mastra/core/evals";
 
@@ -721,6 +723,10 @@ This function returns a scorer builder that you can chain step methods onto. See
 
 ## Judge Object
 
+The judge only runs for steps defined as **prompt objects** (`preprocess`, `analyze`, `generateScore`, `generateReason` in prompt mode). If you use function steps only, the judge is never called and there is no LLM output to inspect. In that case, any score/reason must be produced by your functions.
+
+When a prompt-object step runs, its structured LLM output is stored in the corresponding result field (`preprocessStepResult`, `analyzeStepResult`, or the value consumed by `calculateScore` in `generateScore`).
+
 ## Type Safety
 
 You can specify input/output types when creating scorers for better type inference and IntelliSense support:
@@ -734,7 +740,7 @@ import { createScorer } from "@mastra/core/evals";
 
 // Agent scorer with automatic typing
 const agentScorer = createScorer({
-  name: "Agent Response Quality",
+  id: "agent-response-quality",
   description: "Evaluates agent responses",
   type: "agent", // Automatically provides ScorerRunInputForAgent/ScorerRunOutputForAgent
 })
@@ -761,7 +767,7 @@ type CustomInput = { query: string; context: string[] };
 type CustomOutput = { answer: string; confidence: number };
 
 const customScorer = createScorer<CustomInput, CustomOutput>({
-  name: "Custom Scorer",
+  id: "custom-scorer",
   description: "Evaluates custom data",
 }).generateScore(({ run }) => {
   // run.input is typed as CustomInput
@@ -783,7 +789,7 @@ When you use `type: 'agent'`, your scorer is compatible for both adding directly
 
 ```typescript
 const agentTraceScorer = createScorer({
-  name: "Agent Trace Length",
+  id: "agent-trace-length",
   description: "Evaluates agent response length",
   type: "agent",
 }).generateScore(({ run }) => {
@@ -1330,7 +1336,7 @@ For workflows, you can specify scorers at different levels using `WorkflowScorer
 import { createScorer, runEvals } from "@mastra/core/evals";
 
 const myScorer = createScorer({
-  name: "My Scorer",
+  id: "my-scorer",
   description: "Check if Agent's response contains ground truth",
   type: "agent",
 }).generateScore(({ run }) => {

package/dist/docs/mcp/01-overview.md

@@ -1,8 +1,8 @@
 > Learn about the Model Context Protocol (MCP), how to use third-party tools via MCPClient, connect to registries, and share your own tools using MCPServer.
 
 > **Code References:**
-- `Agent`: dist/agent/agent.d.ts → dist/chunk-IC2MIQBW.js:16163
-- `Mastra`: dist/mastra/index.d.ts → dist/chunk-XBZWAUZ3.js:24
+- `Agent`: dist/agent/agent.d.ts → dist/chunk-UVOQLIWL.js:16630
+- `Mastra`: dist/mastra/index.d.ts → dist/chunk-IFPQ2MLB.js:24
 
 # MCP Overview
 
@@ -50,9 +50,13 @@ export const testMcpClient = new MCPClient({
 
 Visit [MCPClient](https://mastra.ai/reference/v1/tools/mcp-client) for a full list of configuration options.
 
+> **Note:** Authentication
+
+For connecting to OAuth-protected MCP servers, see the [OAuth Authentication](https://mastra.ai/reference/v1/tools/mcp-client#oauth-authentication) section.
+
 ## Using `MCPClient` with an agent
 
-To use tools from an MCP server in an agent, import your `MCPClient` and call `.getTools()` in the `tools` parameter. This loads from the defined MCP servers, making them available to the agent.
+To use tools from an MCP server in an agent, import your `MCPClient` and call `.listTools()` in the `tools` parameter. This loads from the defined MCP servers, making them available to the agent.
 
 ```typescript {3,15} title="src/mastra/agents/test-agent.ts"
 import { Agent } from "@mastra/core/agent";
@@ -60,6 +64,7 @@ import { Agent } from "@mastra/core/agent";
 import { testMcpClient } from "../mcp/test-mcp-client";
 
 export const testAgent = new Agent({
+  id: "test-agent",
   name: "Test Agent",
   description: "You are a helpful AI assistant",
   instructions: `
@@ -69,7 +74,7 @@ export const testAgent = new Agent({
 
       Answer questions using the information you find using the MCP Servers.`,
   model: "openai/gpt-5.1",
-  tools: await testMcpClient.getTools(),
+  tools: await testMcpClient.listTools(),
 });
 ```
 
@@ -102,6 +107,10 @@ export const testMcpServer = new MCPServer({
 
 Visit [MCPServer](https://mastra.ai/reference/v1/tools/mcp-server) for a full list of configuration options.
 
+> **Note:** Authentication
+
+To protect your MCP server with OAuth, see the [OAuth Protection](https://mastra.ai/reference/v1/tools/mcp-server#oauth-protection) section.
+
 ## Registering an `MCPServer`
 
 To make an MCP server available to other systems or agents that support the protocol, register it in the main `Mastra` instance using `mcpServers`.
@@ -120,20 +129,20 @@ export const mastra = new Mastra({
 
 `MCPClient` offers two approaches to retrieving tools from connected servers, suitable for different application architectures:
 
-| Feature           | Static Configuration (`await mcp.getTools()`) | Dynamic Configuration (`await mcp.getToolsets()`)    |
-| :---------------- | :-------------------------------------------- | :--------------------------------------------------- |
-| **Use Case**      | Single-user, static config (e.g., CLI tool)   | Multi-user, dynamic config (e.g., SaaS app)          |
-| **Configuration** | Fixed at agent initialization                 | Per-request, dynamic                                 |
-| **Credentials**   | Shared across all uses                        | Can vary per user/request                            |
-| **Agent Setup**   | Tools added in `Agent` constructor            | Tools passed in `.generate()` or `.stream()` options |
+| Feature           | Static Configuration (`await mcp.listTools()`) | Dynamic Configuration (`await mcp.listToolsets()`)   |
+| :---------------- | :--------------------------------------------- | :--------------------------------------------------- |
+| **Use Case**      | Single-user, static config (e.g., CLI tool)    | Multi-user, dynamic config (e.g., SaaS app)          |
+| **Configuration** | Fixed at agent initialization                  | Per-request, dynamic                                 |
+| **Credentials**   | Shared across all uses                         | Can vary per user/request                            |
+| **Agent Setup**   | Tools added in `Agent` constructor             | Tools passed in `.generate()` or `.stream()` options |
 
 ### Static tools
 
-Use the `.getTools()` method to fetch tools from all configured MCP servers. This is suitable when configuration (such as API keys) is static and consistent across users or requests. Call it once and pass the result to the `tools` property when defining your agent.
+Use the `.listTools()` method to fetch tools from all configured MCP servers. This is suitable when configuration (such as API keys) is static and consistent across users or requests. Call it once and pass the result to the `tools` property when defining your agent.
 
 > **Note:**
 
-Visit [getTools()](https://mastra.ai/reference/v1/tools/mcp-client#gettools) for more information.
+Visit [listTools()](https://mastra.ai/reference/v1/tools/mcp-client#listtools) for more information.
 
 ```typescript {6} title="src/mastra/agents/test-agent.ts"
 import { Agent } from "@mastra/core/agent";
@@ -141,13 +150,14 @@ import { Agent } from "@mastra/core/agent";
 import { testMcpClient } from "../mcp/test-mcp-client";
 
 export const testAgent = new Agent({
-  tools: await testMcpClient.getTools(),
+  id: "test-agent",
+  tools: await testMcpClient.listTools(),
 });
 ```
 
 ### Dynamic tools
 
-Use the `.getToolsets()` method when tool configuration may vary by request or user, such as in a multi-tenant system where each user provides their own API key. This method returns toolsets that can be passed to the `toolsets` option in the agent's `.generate()` or `.stream()` calls.
+Use the `.listToolsets()` method when tool configuration may vary by request or user, such as in a multi-tenant system where each user provides their own API key. This method returns toolsets that can be passed to the `toolsets` option in the agent's `.generate()` or `.stream()` calls.
 
 ```typescript {5-16,21}
 import { MCPClient } from "@mastra/mcp";
@@ -170,7 +180,7 @@ async function handleRequest(userPrompt: string, userApiKey: string) {
   const agent = mastra.getAgent("testAgent");
 
   const response = await agent.generate(userPrompt, {
-    toolsets: await userMcp.getToolsets(),
+    toolsets: await userMcp.listToolsets(),
   });
 
   await userMcp.disconnect();
@@ -183,7 +193,7 @@ async function handleRequest(userPrompt: string, userApiKey: string) {
 
 > **Note:**
 
-Visit [getToolsets()](https://mastra.ai/reference/v1/tools/mcp-client#gettoolsets) for more information.
+Visit [listToolsets()](https://mastra.ai/reference/v1/tools/mcp-client#listtoolsets) for more information.
 
 ## Connecting to an MCP registry
 

package/dist/docs/mcp/02-publishing-mcp-server.md

@@ -104,8 +104,8 @@ const mcp = new MCPClient({
 });
 
 // You can then get tools or toolsets from this configuration to use in your agent
-const tools = await mcp.getTools();
-const toolsets = await mcp.getToolsets();
+const tools = await mcp.listTools();
+const toolsets = await mcp.listToolsets();
 ```
 
 Note: If you published without an organization scope, the `args` might just be `["-y", "your-package-name@latest"]`.

package/dist/docs/memory/01-overview.md

@@ -1,8 +1,8 @@
 > Learn how Mastra
 
 > **Code References:**
-- `Mastra`: dist/mastra/index.d.ts → dist/chunk-XBZWAUZ3.js:24
-- `Agent`: dist/agent/agent.d.ts → dist/chunk-IC2MIQBW.js:16163
+- `Mastra`: dist/mastra/index.d.ts → dist/chunk-IFPQ2MLB.js:24
+- `Agent`: dist/agent/agent.d.ts → dist/chunk-UVOQLIWL.js:16630
 
 # Memory
 

package/dist/docs/memory/02-storage.md

@@ -4,11 +4,11 @@
 
 For Mastra to remember previous interactions, you must configure a storage adapter. Mastra is designed to work with your preferred database provider - choose from the [supported providers](#supported-providers) and pass it to your Mastra instance.
 
-```typescript 
+```typescript title="src/mastra/index.ts"
 import { Mastra } from "@mastra/core";
 import { LibSQLStore } from "@mastra/libsql";
 
-const mastra = new Mastra({
+export const mastra = new Mastra({
   storage: new LibSQLStore({
     id: 'mastra-storage',
     url: "file:./mastra.db",
@@ -17,7 +17,7 @@ const mastra = new Mastra({
 ```
 On first interaction, Mastra automatically creates the necessary tables following the [core schema](https://mastra.ai/reference/v1/storage/overview#core-schema). This includes tables for messages, threads, resources, workflows, traces, and evaluation datasets.
 
-## Supported Providers
+## Supported providers
 
 Each provider page includes installation instructions, configuration parameters, and usage examples:
 
@@ -35,19 +35,19 @@ Each provider page includes installation instructions, configuration parameters,
 > **Note:**
 libSQL is the easiest way to get started because it doesn’t require running a separate database server
 
-## Configuration Scope
+## Configuration scope
 
 You can configure storage at two different scopes:
 
 ### Instance-level storage
 
-Add storage to your Mastra instance so all agents share the same memory provider:
+Add storage to your Mastra instance so all agents, workflows, observability traces and scores share the same memory provider:
 
-```typescript 
+```typescript
 import { Mastra } from "@mastra/core";
 import { PostgresStore } from "@mastra/pg";
 
-const mastra = new Mastra({
+export const mastra = new Mastra({
   storage: new PostgresStore({
     id: 'mastra-storage',
     connectionString: process.env.DATABASE_URL,
@@ -55,20 +55,55 @@ const mastra = new Mastra({
 });
 
 // All agents automatically use this storage
-const agent1 = new Agent({ memory: new Memory() });
-const agent2 = new Agent({ memory: new Memory() });
+const agent1 = new Agent({ id: "agent-1", memory: new Memory() });
+const agent2 = new Agent({ id: "agent-2", memory: new Memory() });
+```
+
+This is useful when all primitives share the same storage backend and have similar performance, scaling, and operational requirements.
+
+#### Composite storage
+
+Add storage to your Mastra instance using `MastraStorage` and configure individual storage domains to use different storage providers.
+
+```typescript title="src/mastra/index.ts"
+import { Mastra } from "@mastra/core";
+import { MastraStorage } from "@mastra/core/storage";
+import { MemoryLibSQL } from "@mastra/libsql";
+import { WorkflowsPG } from "@mastra/pg";
+import { ObservabilityStorageClickhouse } from "@mastra/clickhouse";
+
+export const mastra = new Mastra({
+  storage: new MastraStorage({
+    id: "composite",
+    domains: {
+      memory: new MemoryLibSQL({ url: "file:./memory.db" }),
+      workflows: new WorkflowsPG({ connectionString: process.env.DATABASE_URL }),
+      observability: new ObservabilityStorageClickhouse({
+        url: process.env.CLICKHOUSE_URL,
+        username: process.env.CLICKHOUSE_USERNAME,
+        password: process.env.CLICKHOUSE_PASSWORD,
+      }),
+    },
+  }),
+});
 ```
 
+This is useful when different types of data have different performance or operational requirements, such as low-latency storage for memory, durable storage for workflows, and high-throughput storage for observability.
+
+> **Note:**
+See [Storage Domains](https://mastra.ai/reference/v1/storage/composite#storage-domains) for more information.
+
 ### Agent-level storage
 
-Add storage to a specific agent when you need data boundaries or compliance requirements:
+Agent-level storage overrides storage configured at the instance-level. Add storage to a specific agent when you need data boundaries or compliance requirements:
 
-```typescript 
+```typescript title="src/mastra/agents/memory-agent.ts"
 import { Agent } from "@mastra/core/agent";
 import { Memory } from "@mastra/memory";
 import { PostgresStore } from "@mastra/pg";
 
-const agent = new Agent({
+export const agent = new Agent({
+  id: "agent",
   memory: new Memory({
     storage: new PostgresStore({
       id: 'agent-storage',
@@ -80,7 +115,7 @@ const agent = new Agent({
 
 This is useful when different agents need to store data in separate databases for security, compliance, or organizational reasons.
 
-## Threads and Resources
+## Threads and resources
 
 Mastra organizes memory into threads using two identifiers:
 
@@ -89,7 +124,7 @@ Mastra organizes memory into threads using two identifiers:
 
 Both identifiers are required for agents to store and recall information:
 
-```typescript 
+```typescript
 const stream = await agent.stream("message for agent", {
   memory: {
     thread: "convo_123",
@@ -107,8 +142,9 @@ Mastra can automatically generate descriptive thread titles based on the user's
 
 Use this option when implementing a ChatGPT-style chat interface to render a title alongside each thread in the conversation list (for example, in a sidebar) derived from the thread’s initial user message.
 
-```typescript 
+```typescript
 export const testAgent = new Agent({
+  id: "test-agent",
   memory: new Memory({
     options: {
       generateTitle: true,
@@ -123,13 +159,12 @@ To optimize cost or behavior, provide a smaller `model` and custom `instructions
 
 ```typescript
 export const testAgent = new Agent({
+  id: "test-agent",
   memory: new Memory({
     options: {
-      threads: {
-        generateTitle: {
-          model: "openai/gpt-4o-mini",
-          instructions: "Generate a concise title based on the user's first message",
-        },
+      generateTitle: {
+        model: "openai/gpt-4o-mini",
+        instructions: "Generate a concise title based on the user's first message",
       },
     },
   }),
@@ -142,7 +177,7 @@ Semantic recall uses vector embeddings to retrieve relevant past messages based
 
 The vector database doesn't have to be the same as your storage provider. For example, you might use PostgreSQL for storage and Pinecone for vectors:
 
-```typescript 
+```typescript
 import { Mastra } from "@mastra/core";
 import { Agent } from "@mastra/core/agent";
 import { Memory } from "@mastra/memory";
@@ -150,7 +185,7 @@ import { PostgresStore } from "@mastra/pg";
 import { PineconeVector } from "@mastra/pinecone";
 
 // Instance-level vector configuration
-const mastra = new Mastra({
+export const mastra = new Mastra({
   storage: new PostgresStore({
     id: 'mastra-storage',
     connectionString: process.env.DATABASE_URL,
@@ -158,13 +193,12 @@ const mastra = new Mastra({
 });
 
 // Agent-level vector configuration
-const agent = new Agent({
+export const agent = new Agent({
+  id: "agent",
   memory: new Memory({
     vector: new PineconeVector({
       id: 'agent-vector',
       apiKey: process.env.PINECONE_API_KEY,
-      environment: process.env.PINECONE_ENVIRONMENT,
-      indexName: 'agent-embeddings',
     }),
     options: {
       semanticRecall: {