@mastra/memory 1.0.0-beta.12 → 1.0.0-beta.14

package/CHANGELOG.md

@@ -1,5 +1,45 @@
 # @mastra/memory
 
+## 1.0.0-beta.14
+
+### Patch Changes
+
+- Updated dependencies [[`1dbd8c7`](https://github.com/mastra-ai/mastra/commit/1dbd8c729fb6536ec52f00064d76b80253d346e9), [`c59e13c`](https://github.com/mastra-ai/mastra/commit/c59e13c7688284bd96b2baee3e314335003548de), [`f93e2f5`](https://github.com/mastra-ai/mastra/commit/f93e2f575e775e627e5c1927cefdd72db07858ed), [`f9a2509`](https://github.com/mastra-ai/mastra/commit/f9a25093ea72d210a5e52cfcb3bcc8b5e02dc25c), [`7a010c5`](https://github.com/mastra-ai/mastra/commit/7a010c56b846a313a49ae42fccd3d8de2b9f292d)]:
+  - @mastra/core@1.0.0-beta.24
+  - @mastra/schema-compat@1.0.0-beta.7
+
+## 1.0.0-beta.13
+
+### Major Changes
+
+- Refactor workflow and tool types to remove Zod-specific constraints ([#11814](https://github.com/mastra-ai/mastra/pull/11814))
+
+  Removed Zod-specific type constraints across all workflow implementations and tool types, replacing them with generic types. This ensures type consistency across default, evented, and inngest workflows while preparing for Zod v4 migration.
+
+  **Workflow Changes:**
+  - Removed `z.ZodObject<any>` and `z.ZodType<any>` constraints from all workflow generic types
+  - Updated method signatures to use `TInput` and `TState` directly instead of `z.infer<TInput>` and `z.infer<TState>`
+  - Aligned conditional types across all workflow implementations using `TInput extends unknown` pattern
+  - Fixed `TSteps` generic to properly use `TEngineType` instead of `any`
+
+  **Tool Changes:**
+  - Removed Zod schema constraints from `ToolExecutionContext` and related interfaces
+  - Simplified type parameters from `TSuspendSchema extends ZodLikeSchema` to `TSuspend` and `TResume`
+  - Updated tool execution context types to use generic types
+
+  **Type Utilities:**
+  - Refactored type helpers to work with generic schemas instead of Zod-specific types
+  - Updated type extraction utilities for better compatibility
+
+  This change maintains backward compatibility while improving type consistency and preparing for Zod v4 support across all affected packages.
+
+### Patch Changes
+
+- Fix updateMessages() to sync vector database for semantic recall. Previously, updating a message's content would not update the corresponding vector embeddings, causing semantic recall to return stale results based on old content. ([#11842](https://github.com/mastra-ai/mastra/pull/11842))
+
+- Updated dependencies [[`ebae12a`](https://github.com/mastra-ai/mastra/commit/ebae12a2dd0212e75478981053b148a2c246962d), [`c61a0a5`](https://github.com/mastra-ai/mastra/commit/c61a0a5de4904c88fd8b3718bc26d1be1c2ec6e7), [`69136e7`](https://github.com/mastra-ai/mastra/commit/69136e748e32f57297728a4e0f9a75988462f1a7), [`449aed2`](https://github.com/mastra-ai/mastra/commit/449aed2ba9d507b75bf93d427646ea94f734dfd1), [`eb648a2`](https://github.com/mastra-ai/mastra/commit/eb648a2cc1728f7678768dd70cd77619b448dab9), [`0131105`](https://github.com/mastra-ai/mastra/commit/0131105532e83bdcbb73352fc7d0879eebf140dc), [`9d5059e`](https://github.com/mastra-ai/mastra/commit/9d5059eae810829935fb08e81a9bb7ecd5b144a7), [`ef756c6`](https://github.com/mastra-ai/mastra/commit/ef756c65f82d16531c43f49a27290a416611e526), [`b00ccd3`](https://github.com/mastra-ai/mastra/commit/b00ccd325ebd5d9e37e34dd0a105caae67eb568f), [`3bdfa75`](https://github.com/mastra-ai/mastra/commit/3bdfa7507a91db66f176ba8221aa28dd546e464a), [`e770de9`](https://github.com/mastra-ai/mastra/commit/e770de941a287a49b1964d44db5a5763d19890a6), [`52e2716`](https://github.com/mastra-ai/mastra/commit/52e2716b42df6eff443de72360ae83e86ec23993), [`27b4040`](https://github.com/mastra-ai/mastra/commit/27b4040bfa1a95d92546f420a02a626b1419a1d6), [`610a70b`](https://github.com/mastra-ai/mastra/commit/610a70bdad282079f0c630e0d7bb284578f20151), [`8dc7f55`](https://github.com/mastra-ai/mastra/commit/8dc7f55900395771da851dc7d78d53ae84fe34ec), [`8379099`](https://github.com/mastra-ai/mastra/commit/8379099fc467af6bef54dd7f80c9bd75bf8bbddf), [`8c0ec25`](https://github.com/mastra-ai/mastra/commit/8c0ec25646c8a7df253ed1e5ff4863a0d3f1316c), [`ff4d9a6`](https://github.com/mastra-ai/mastra/commit/ff4d9a6704fc87b31a380a76ed22736fdedbba5a), [`69821ef`](https://github.com/mastra-ai/mastra/commit/69821ef806482e2c44e2197ac0b050c3fe3a5285), [`1ed5716`](https://github.com/mastra-ai/mastra/commit/1ed5716830867b3774c4a1b43cc0d82935f32b96), [`4186bdd`](https://github.com/mastra-ai/mastra/commit/4186bdd00731305726fa06adba0b076a1d50b49f), [`7aaf973`](https://github.com/mastra-ai/mastra/commit/7aaf973f83fbbe9521f1f9e7a4fd99b8de464617)]:
+  - @mastra/core@1.0.0-beta.22
+
 ## 1.0.0-beta.12
 
 ### Patch Changes

package/dist/docs/README.md

@@ -22,7 +22,7 @@ docs/
 ├── SKILL.md           # Entry point
 ├── README.md          # This file
 ├── SOURCE_MAP.json    # Export index
-├── agents/ (3 files)
+├── agents/ (4 files)
 ├── core/ (2 files)
 ├── memory/ (11 files)
 ├── processors/ (1 files)
@@ -33,4 +33,4 @@ docs/
 ## Version
 
 Package: @mastra/memory
-Version: 1.0.0-beta.12
+Version: 1.0.0-beta.14

package/dist/docs/SKILL.md

@@ -5,7 +5,7 @@ description: Documentation for @mastra/memory. Includes links to type definition
 
 # @mastra/memory Documentation
 
-> **Version**: 1.0.0-beta.12
+> **Version**: 1.0.0-beta.14
 > **Package**: @mastra/memory
 
 ## Quick Navigation
@@ -34,7 +34,7 @@ See SOURCE_MAP.json for the complete list.
 
 ## Available Topics
 
-- [Agents](agents/) - 3 file(s)
+- [Agents](agents/) - 4 file(s)
 - [Core](core/) - 2 file(s)
 - [Memory](memory/) - 11 file(s)
 - [Processors](processors/) - 1 file(s)

package/dist/docs/SOURCE_MAP.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.0.0-beta.12",
+  "version": "1.0.0-beta.14",
   "package": "@mastra/memory",
   "exports": {
     "extractWorkingMemoryContent": {

package/dist/docs/agents/01-agent-memory.md

@@ -90,6 +90,9 @@ export const memoryAgent = new Agent({
 });
 ```
 
+> **Mastra Cloud Store limitation**
+Agent-level storage is not supported when using [Mastra Cloud Store](https://mastra.ai/docs/v1/mastra-cloud/deployment#using-mastra-cloud-store). If you use Mastra Cloud Store, configure storage on the Mastra instance instead. This limitation does not apply if you bring your own database.
+
 ## Message history
 
 Include a `memory` object with both `resource` and `thread` to track message history during agent calls.

package/dist/docs/agents/03-agent-approval.md

@@ -85,8 +85,8 @@ export const testTool = createTool({
   resumeSchema: z.object({
     approved: z.boolean()
   }),
-  execute: async ({ location }) => {
-    const response = await fetch(`https://wttr.in/${location}?format=3`);
+  execute: async (inputData) => {
+    const response = await fetch(`https://wttr.in/${inputData.location}?format=3`);
     const weather = await response.text();
 
     return { weather };
@@ -121,7 +121,6 @@ const handleResume = async () => {
 With this approach, neither the agent nor the tool uses `requireApproval`. Instead, the tool implementation calls `suspend` to pause execution and return context or confirmation prompts to the user.
 
 ```typescript
-
 export const testToolB = createTool({
   id: "test-tool-b",
   description: "Fetches weather for a location",
@@ -137,14 +136,14 @@ export const testToolB = createTool({
   suspendSchema: z.object({
     reason: z.string()
   }),
-  execute: async ({ location }, { agent } = {}) => {
-    const { resumeData: { approved } = {}, suspend } = agent ?? {};
+  execute: async (inputData, context) => {
+    const { resumeData: { approved } = {}, suspend } = context?.agent ?? {};
 
     if (!approved) {
       return suspend?.({ reason: "Approval required." });
     }
 
-    const response = await fetch(`https://wttr.in/${location}?format=3`);
+    const response = await fetch(`https://wttr.in/${inputData.location}?format=3`);
     const weather = await response.text();
 
     return { weather };

package/dist/docs/agents/04-network-approval.md

@@ -0,0 +1,274 @@
+> Learn how to require approvals, suspend execution, and resume suspended networks while keeping humans in control of agent network workflows.
+
+# Network Approval
+
+Agent networks can require the same [human-in-the-loop](https://mastra.ai/docs/v1/workflows/human-in-the-loop) oversight used in individual agents and workflows. When a tool, sub-agent, or workflow within a network requires approval or suspends execution, the network pauses and emits events that allow your application to collect user input before resuming.
+
+## Storage
+
+Network approval uses snapshots to capture execution state. Ensure you've enabled a storage provider in your Mastra instance. If storage isn't enabled you'll see an error relating to snapshot not found.
+
+```typescript title="src/mastra/index.ts"
+import { Mastra } from "@mastra/core/mastra";
+import { LibSQLStore } from "@mastra/libsql";
+
+export const mastra = new Mastra({
+  storage: new LibSQLStore({
+    id: "mastra-storage",
+    url: ":memory:"
+  })
+});
+```
+
+## Approving network tool calls
+
+When a tool within a network has `requireApproval: true`, the network stream emits an `agent-execution-approval` chunk and pauses. To allow the tool to execute, call `approveNetworkToolCall` with the `runId`.
+
+```typescript
+const stream = await routingAgent.network("Process this query", {
+  memory: {
+    thread: "user-123",
+    resource: "my-app"
+  }
+});
+
+let runId: string;
+
+for await (const chunk of stream) {
+  runId = stream.runId;
+  // if the requirApproval is in a tool inside a subAgent or the subAgent has requireToolApproval set to true
+  if (chunk.type === "agent-execution-approval") { 
+    console.log("Tool requires approval:", chunk.payload);
+  }
+
+  // if the requirApproval is in a tool directly in the network agent
+  if (chunk.type === "tool-execution-approval") {
+    console.log("Tool requires approval:", chunk.payload);
+  }
+}
+
+// Approve and resume execution
+const approvedStream = await routingAgent.approveNetworkToolCall({
+  runId,
+  memory: {
+    thread: "user-123",
+    resource: "my-app"
+  }
+});
+
+for await (const chunk of approvedStream) {
+  if (chunk.type === "network-execution-event-step-finish") {
+    console.log(chunk.payload.result);
+  }
+}
+```
+
+## Declining network tool calls
+
+To decline a pending tool call and prevent execution, call `declineNetworkToolCall`. The network continues without executing the tool.
+
+```typescript
+const declinedStream = await routingAgent.declineNetworkToolCall({
+  runId,
+  memory: {
+    thread: "user-123",
+    resource: "my-app"
+  }
+});
+
+for await (const chunk of declinedStream) {
+  if (chunk.type === "network-execution-event-step-finish") {
+    console.log(chunk.payload.result);
+  }
+}
+```
+
+## Resuming suspended networks
+
+When a primitive in the network calls `suspend()`, the stream emits an `agent-execution-suspended`/`tool-execution-suspended`/`workflow-execution-suspended` chunk with a `suspendPayload` containing context from the primitive. Use `resumeNetwork` to provide the data requested by the primitive and continue execution.
+
+```typescript
+import { createTool } from "@mastra/core/tools";
+import { z } from "zod";
+
+const confirmationTool = createTool({
+  id: "confirmation-tool",
+  description: "Requests user confirmation before proceeding",
+  inputSchema: z.object({
+    action: z.string()
+  }),
+  outputSchema: z.object({
+    confirmed: z.boolean(),
+    action: z.string()
+  }),
+  suspendSchema: z.object({
+    message: z.string(),
+    action: z.string()
+  }),
+  resumeSchema: z.object({
+    confirmed: z.boolean()
+  }),
+  execute: async (inputData, context) => {
+    const { resumeData, suspend } = context?.agent ?? {};
+
+    if (!resumeData?.confirmed) {
+      return suspend?.({
+        message: `Please confirm: ${inputData.action}`,
+        action: inputData.action
+      });
+    }
+
+    return { confirmed: true, action: inputData.action };
+  }
+});
+```
+
+Handle the suspension and resume with user-provided data:
+
+```typescript
+const stream = await routingAgent.network("Delete the old records", {
+  memory: {
+    thread: "user-123",
+    resource: "my-app"
+  }
+});
+
+for await (const chunk of stream) {
+  if (chunk.type === "workflow-execution-suspended") {
+    console.log(chunk.payload.suspendPayload);
+    // { message: "Please confirm: delete old records", action: "delete old records" }
+  }
+}
+
+// Resume with user confirmation
+const resumedStream = await routingAgent.resumeNetwork(
+  { confirmed: true },
+  {
+    runId: stream.runId,
+    memory: {
+      thread: "user-123",
+      resource: "my-app"
+    }
+  }
+);
+
+for await (const chunk of resumedStream) {
+  if (chunk.type === "network-execution-event-step-finish") {
+    console.log(chunk.payload.result);
+  }
+}
+```
+
+## Automatic primitive resumption
+
+When using primitives that call `suspend()`, you can enable automatic resumption so the network resumes suspended primitives based on the user's next message. This creates a conversational flow where users provide the required information naturally.
+
+### Enabling auto-resume
+
+Set `autoResumeSuspendedTools` to `true` in the agent's `defaultNetworkOptions` or when calling `network()`:
+
+```typescript
+import { Agent } from "@mastra/core/agent";
+import { Memory } from "@mastra/memory";
+
+// Option 1: In agent configuration
+const routingAgent = new Agent({
+  id: "routing-agent",
+  name: "Routing Agent",
+  instructions: "You coordinate tasks across multiple agents",
+  model: "openai/gpt-4o-mini",
+  tools: { confirmationTool },
+  memory: new Memory(),
+  defaultNetworkOptions: {
+    autoResumeSuspendedTools: true,
+  },
+});
+
+// Option 2: Per-request
+const stream = await routingAgent.network("Process this request", {
+  autoResumeSuspendedTools: true,
+  memory: {
+    thread: "user-123",
+    resource: "my-app"
+  }
+});
+```
+
+### How it works
+
+When `autoResumeSuspendedTools` is enabled:
+
+1. A primitive suspends execution by calling `suspend()` with a payload
+2. The suspension is persisted to memory along with the conversation
+3. When the user sends their next message on the same thread, the network:
+   - Detects the suspended primitive from message history
+   - Extracts `resumeData` from the user's message based on the tool's `resumeSchema`
+   - Automatically resumes the primitive with the extracted data
+
+### Example
+
+```typescript
+const stream = await routingAgent.network("Delete the old records", {
+  autoResumeSuspendedTools: true,
+  memory: {
+    thread: "user-123",
+    resource: "my-app"
+  }
+});
+
+for await (const chunk of stream) {
+  if (chunk.type === "workflow-execution-suspended") {
+    console.log(chunk.payload.suspendPayload);
+    // { message: "Please confirm: delete old records", action: "delete old records" }
+  }
+}
+
+// User provides confirmation in their next message
+const resumedStream = await routingAgent.network("Yes, confirmed", {
+  autoResumeSuspendedTools: true,
+  memory: {
+    thread: "user-123",
+    resource: "my-app"
+  }
+});
+
+for await (const chunk of resumedStream) {
+  if (chunk.type === "network-execution-event-step-finish") {
+    console.log(chunk.payload.result);
+  }
+}
+```
+
+**Conversation flow:**
+
+```
+User: "Delete the old records"
+Agent: "Please confirm: delete old records"
+
+User: "Yes, confirmed"
+Agent: "Records deleted successfully"
+```
+
+### Requirements
+
+For automatic tool resumption to work:
+
+- **Memory configured**: The agent needs memory to track suspended tools across messages
+- **Same thread**: The follow-up message must use the same memory thread and resource identifiers
+- **`resumeSchema` defined**: The tool (either directly in the network agent or in a subAgent) / workflow (step that gets suspended) must define a `resumeSchema` so the agent knows what data to extract from the user's message
+
+### Manual vs automatic resumption
+
+| Approach | Use case |
+|----------|----------|
+| Manual (`resumeNetwork()`) | Programmatic control, webhooks, button clicks, external triggers |
+| Automatic (`autoResumeSuspendedTools`) | Conversational flows where users provide resume data in natural language |
+
+Both approaches work with the same tool definitions. Automatic resumption triggers only when suspended tools exist in the message history and the user sends a new message on the same thread.
+
+## Related
+
+- [Agent Networks](./networks)
+- [Agent Approval](./agent-approval)
+- [Human-in-the-Loop](https://mastra.ai/docs/v1/workflows/human-in-the-loop)
+- [Agent Memory](./agent-memory)

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

@@ -35,7 +35,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({
@@ -87,12 +87,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({

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,10 @@ 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
+> **Mastra Cloud Store limitation**
+Agent-level storage is not supported when using [Mastra Cloud Store](https://mastra.ai/docs/v1/mastra-cloud/deployment#using-mastra-cloud-store). If you use Mastra Cloud Store, configure storage on the Mastra instance instead. This limitation does not apply if you bring your own database.
+
+## Threads and resources
 
 Mastra organizes memory into threads using two identifiers:
 
@@ -89,7 +127,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 +145,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 +162,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 +180,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 +188,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 +196,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: {

package/dist/docs/memory/03-working-memory.md

@@ -80,13 +80,15 @@ const memory = new Memory({
 
 ### Usage with Agents
 
-When using resource-scoped memory, make sure to pass the `resourceId` parameter:
+When using resource-scoped memory, make sure to pass the `resource` parameter in the memory options:
 
 ```typescript
-// Resource-scoped memory requires resourceId
+// Resource-scoped memory requires resource
 const response = await agent.generate("Hello!", {
-  threadId: "conversation-123",
-  resourceId: "user-alice-456", // Same user across different threads
+  memory: {
+    thread: "conversation-123",
+    resource: "user-alice-456", // Same user across different threads
+  },
 });
 ```
 
@@ -339,8 +341,10 @@ const thread = await memory.createThread({
 
 // The agent will now have access to this information in all messages
 await agent.generate("What's my blood type?", {
-  threadId: thread.id,
-  resourceId: "user-456",
+  memory: {
+    thread: thread.id,
+    resource: "user-456",
+  },
 });
 // Response: "Your blood type is O+."
 ```

package/dist/docs/memory/04-semantic-recall.md

@@ -56,7 +56,7 @@ const agent = new Agent({
     // this is the default vector db if omitted
     vector: new LibSQLVector({
       id: 'agent-vector',
-      connectionUrl: "file:./local.db",
+      url: "file:./local.db",
     }),
   }),
 });
@@ -230,6 +230,4 @@ You might want to disable semantic recall in scenarios like:
 
 ## Viewing Recalled Messages
 
-When tracing is enabled, any messages retrieved via semantic recall will appear in the agent's trace output, alongside recent message history (if configured).
-
-For more info on viewing message traces, see [Viewing Retrieved Messages](./overview#viewing-retrieved-messages).
+When tracing is enabled, any messages retrieved via semantic recall will appear in the agent's trace output, alongside recent message history (if configured).