@mastra/libsql 0.0.0-workflow-timeout-issue-20260220185702 → 0.0.0-workflow-graph-crash-20260527191009

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

@@ -1,30 +1,30 @@
 # Storage
 
-For agents to remember previous interactions, Mastra needs a database. Use a storage adapter for one of the [supported databases](#supported-providers) and pass it to your Mastra instance.
+For agents to remember previous interactions, Mastra needs a storage adapter. Use one of the [supported providers](#supported-providers) and pass it to your Mastra instance.
 
 ```typescript
-import { Mastra } from "@mastra/core";
-import { LibSQLStore } from "@mastra/libsql";
+import { Mastra } from '@mastra/core'
+import { LibSQLStore } from '@mastra/libsql'
 
 export const mastra = new Mastra({
   storage: new LibSQLStore({
     id: 'mastra-storage',
-    url: "file:./mastra.db",
+    url: 'file:./mastra.db',
   }),
-});
+})
 ```
 
-> **Sharing the database with Mastra Studio:** When running `mastra dev` alongside your application (e.g., Next.js), use an absolute path to ensure both processes access the same database:
+> **Sharing the database with Studio:** When running `mastra dev` alongside your application (e.g., Next.js), use an absolute path to ensure both processes access the same database:
 >
 > ```typescript
-> url: "file:/absolute/path/to/your/project/mastra.db"
+> url: 'file:/absolute/path/to/your/project/mastra.db'
 > ```
 >
 > Relative paths like `file:./mastra.db` resolve based on each process's working directory, which may differ.
 
 This configures instance-level storage, which all agents share by default. You can also configure [agent-level storage](#agent-level-storage) for isolated data boundaries.
 
-Mastra automatically creates the necessary tables on first interaction. See the [core schema](https://mastra.ai/reference/storage/overview) for details on what gets created, including tables for messages, threads, resources, workflows, traces, and evaluation datasets.
+Mastra automatically initializes the necessary storage structures on first interaction. See [Storage Overview](https://mastra.ai/reference/storage/overview) for domain coverage and the schema used by the built-in database-backed domains.
 
 ## Supported providers
 
@@ -34,8 +34,9 @@ Each provider page includes installation instructions, configuration parameters,
 - [PostgreSQL](https://mastra.ai/reference/storage/postgresql)
 - [MongoDB](https://mastra.ai/reference/storage/mongodb)
 - [Upstash](https://mastra.ai/reference/storage/upstash)
+- [Redis](https://mastra.ai/reference/storage/redis)
 - [Cloudflare D1](https://mastra.ai/reference/storage/cloudflare-d1)
-- [Cloudflare Durable Objects](https://mastra.ai/reference/storage/cloudflare)
+- [Cloudflare KV & Durable Objects](https://mastra.ai/reference/storage/cloudflare)
 - [Convex](https://mastra.ai/reference/storage/convex)
 - [DynamoDB](https://mastra.ai/reference/storage/dynamodb)
 - [LanceDB](https://mastra.ai/reference/storage/lance)
@@ -49,42 +50,42 @@ Storage can be configured at the instance level (shared by all agents) or at the
 
 ### Instance-level storage
 
-Add storage to your Mastra instance so all agents, workflows, observability traces and scores share the same memory provider:
+Add storage to your Mastra instance so all agents, workflows, observability traces, and scores share the same storage backend:
 
 ```typescript
-import { Mastra } from "@mastra/core";
-import { PostgresStore } from "@mastra/pg";
+import { Mastra } from '@mastra/core'
+import { PostgresStore } from '@mastra/pg'
 
 export const mastra = new Mastra({
   storage: new PostgresStore({
     id: 'mastra-storage',
     connectionString: process.env.DATABASE_URL,
   }),
-});
+})
 
 // Both agents inherit storage from the Mastra instance above
-const agent1 = new Agent({ id: "agent-1", memory: new Memory() });
-const agent2 = new Agent({ id: "agent-2", 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
 
-[Composite storage](https://mastra.ai/reference/storage/composite) is an alternative way to configure instance-level storage. Use `MastraCompositeStore` to set the `memory` domain (and any other [domains](https://mastra.ai/reference/storage/composite) you need) to different storage providers.
+[Composite storage](https://mastra.ai/reference/storage/composite) is an alternative way to configure instance-level storage. Use `MastraCompositeStore` to route `memory` and any other [supported domains](https://mastra.ai/reference/storage/composite) to different storage providers.
 
 ```typescript
-import { Mastra } from "@mastra/core";
-import { MastraCompositeStore } from "@mastra/core/storage";
-import { MemoryLibSQL } from "@mastra/libsql";
-import { WorkflowsPG } from "@mastra/pg";
-import { ObservabilityStorageClickhouse } from "@mastra/clickhouse";
+import { Mastra } from '@mastra/core'
+import { MastraCompositeStore } 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 MastraCompositeStore({
-    id: "composite",
+    id: 'composite',
     domains: {
-      memory: new MemoryLibSQL({ url: "file:./memory.db" }),
+      memory: new MemoryLibSQL({ url: 'file:./memory.db' }),
       workflows: new WorkflowsPG({ connectionString: process.env.DATABASE_URL }),
       observability: new ObservabilityStorageClickhouse({
         url: process.env.CLICKHOUSE_URL,
@@ -93,65 +94,63 @@ export const mastra = new Mastra({
       }),
     },
   }),
-});
+})
 ```
 
 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.
 
 ### Agent-level storage
 
-Agent-level storage overrides storage configured at the instance level. 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 to keep data separate or use different providers per agent.
 
 ```typescript
-import { Agent } from "@mastra/core/agent";
-import { Memory } from "@mastra/memory";
-import { PostgresStore } from "@mastra/pg";
+import { Agent } from '@mastra/core/agent'
+import { Memory } from '@mastra/memory'
+import { PostgresStore } from '@mastra/pg'
 
 export const agent = new Agent({
-  id: "agent",
+  id: 'agent',
   memory: new Memory({
     storage: new PostgresStore({
       id: 'agent-storage',
       connectionString: process.env.AGENT_DATABASE_URL,
     }),
   }),
-});
+})
 ```
 
-> **Warning:** [Mastra Cloud Store](https://mastra.ai/docs/mastra-cloud/deployment) doesn't support agent-level storage.
-
 ## Threads and resources
 
 Mastra organizes conversations using two identifiers:
 
-- **Thread** - a conversation session containing a sequence of messages.
-- **Resource** - the entity that owns the thread, such as a user, organization, project, or any other domain entity in your application.
+- **Thread**: A conversation session containing a sequence of messages.
+- **Resource**: The entity that owns the thread, such as a user, organization, project, or any other domain entity in your application.
 
 Both identifiers are required for agents to store information:
 
-**Generate**:
+**.generate()**:
 
 ```typescript
-const response = await agent.generate("hello", {
+const response = await agent.generate('hello', {
   memory: {
-    thread: "conversation-abc-123",
-    resource: "user_123",
+    thread: 'conversation-abc-123',
+    resource: 'user_123',
   },
-});
+})
 ```
 
-**Stream**:
+**.stream()**:
 
 ```typescript
-const stream = await agent.stream("hello", {
+const stream = await agent.stream('hello', {
   memory: {
-    thread: "conversation-abc-123",
-    resource: "user_123",
+    thread: 'conversation-abc-123',
+    resource: 'user_123',
   },
-});
+})
 ```
 
-> **Note:** [Studio](https://mastra.ai/docs/getting-started/studio) automatically generates a thread and resource ID for you. When calling `stream()` or `generate()` yourself, remember to provide these identifiers explicitly.
+> **Note:** [Studio](https://mastra.ai/docs/studio/overview) automatically generates a thread and resource ID for you. When calling `stream()` or `generate()` yourself, remember to provide these identifiers explicitly.
 
 ### Thread title generation
 
@@ -161,31 +160,31 @@ Use this option when implementing a ChatGPT-style chat interface to render a tit
 
 ```typescript
 export const agent = new Agent({
-  id: "agent",
+  id: 'agent',
   memory: new Memory({
     options: {
       generateTitle: true,
     },
   }),
-});
+})
 ```
 
-Title generation runs asynchronously after the agent responds and does not affect response time.
+Title generation runs asynchronously after the agent responds and doesn't affect response time.
 
 To optimize cost or behavior, provide a smaller [`model`](https://mastra.ai/models) and custom `instructions`:
 
 ```typescript
 export const agent = new Agent({
-  id: "agent",
+  id: 'agent',
   memory: new Memory({
     options: {
       generateTitle: {
-        model: "openai/gpt-4o-mini",
-        instructions: "Generate a 1 word title",
+        model: '__OPENAI_MODEL_MINI__',
+        instructions: 'Generate a 1 word title',
       },
     },
   }),
-});
+})
 ```
 
 ## Semantic recall
@@ -207,41 +206,41 @@ PostgreSQL, MongoDB, and libSQL have higher limits and are generally unaffected.
 To avoid this, use an input processor to upload attachments to external storage (S3, R2, GCS, [Convex file storage](https://docs.convex.dev/file-storage), etc.) and replace them with URL references before persistence.
 
 ```typescript
-import type { Processor } from "@mastra/core/processors";
-import type { MastraDBMessage } from "@mastra/core/memory";
+import type { Processor } from '@mastra/core/processors'
+import type { MastraDBMessage } from '@mastra/core/memory'
 
 export class AttachmentUploader implements Processor {
-  id = "attachment-uploader";
+  id = 'attachment-uploader'
 
   async processInput({ messages }: { messages: MastraDBMessage[] }) {
-    return Promise.all(messages.map((msg) => this.processMessage(msg)));
+    return Promise.all(messages.map(msg => this.processMessage(msg)))
   }
 
   async processMessage(msg: MastraDBMessage) {
-    const attachments = msg.content.experimental_attachments;
-    if (!attachments?.length) return msg;
+    const attachments = msg.content.experimental_attachments
+    if (!attachments?.length) return msg
 
     const uploaded = await Promise.all(
-      attachments.map(async (att) => {
+      attachments.map(async att => {
         // Skip if already a URL
-        if (!att.url?.startsWith("data:")) return att;
+        if (!att.url?.startsWith('data:')) return att
 
         // Upload base64 data and replace with URL
-        const url = await this.upload(att.url, att.contentType);
-        return { ...att, url };
-      })
-    );
+        const url = await this.upload(att.url, att.contentType)
+        return { ...att, url }
+      }),
+    )
 
-    return { ...msg, content: { ...msg.content, experimental_attachments: uploaded } };
+    return { ...msg, content: { ...msg.content, experimental_attachments: uploaded } }
   }
 
   async upload(dataUri: string, contentType?: string): Promise<string> {
-    const base64 = dataUri.split(",")[1];
-    const buffer = Buffer.from(base64, "base64");
+    const base64 = dataUri.split(',')[1]
+    const buffer = Buffer.from(base64, 'base64')
 
     // Replace with your storage provider (S3, R2, GCS, Convex, etc.)
     // return await s3.upload(buffer, contentType);
-    throw new Error("Implement upload() with your storage provider");
+    throw new Error('Implement upload() with your storage provider')
   }
 }
 ```
@@ -249,13 +248,13 @@ export class AttachmentUploader implements Processor {
 Use the processor with your agent:
 
 ```typescript
-import { Agent } from "@mastra/core/agent";
-import { Memory } from "@mastra/memory";
-import { AttachmentUploader } from "./processors/attachment-uploader";
+import { Agent } from '@mastra/core/agent'
+import { Memory } from '@mastra/memory'
+import { AttachmentUploader } from './processors/attachment-uploader'
 
 const agent = new Agent({
-  id: "my-agent",
+  id: 'my-agent',
   memory: new Memory({ storage: yourStorage }),
   inputProcessors: [new AttachmentUploader()],
-});
+})
 ```

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

@@ -13,20 +13,20 @@ Working memory can persist at two different scopes:
 
 **Important:** Switching between scopes means the agent won't see memory from the other scope - thread-scoped memory is completely separate from resource-scoped memory.
 
-## Quick Start
+## Quickstart
 
 Here's a minimal example of setting up an agent with working memory:
 
 ```typescript
-import { Agent } from "@mastra/core/agent";
-import { Memory } from "@mastra/memory";
+import { Agent } from '@mastra/core/agent'
+import { Memory } from '@mastra/memory'
 
 // Create agent with working memory enabled
 const agent = new Agent({
-  id: "personal-assistant",
-  name: "PersonalAssistant",
-  instructions: "You are a helpful personal assistant.",
-  model: "openai/gpt-5.1",
+  id: 'personal-assistant',
+  name: 'PersonalAssistant',
+  instructions: 'You are a helpful personal assistant.',
+  model: 'openai/gpt-5.4',
   memory: new Memory({
     options: {
       workingMemory: {
@@ -34,16 +34,16 @@ const agent = new Agent({
       },
     },
   }),
-});
+})
 ```
 
-## How it Works
+## How it works
 
 Working memory is a block of Markdown text that the agent is able to update over time to store continuously relevant information:
 
 [YouTube video player](https://www.youtube-nocookie.com/embed/UMy_JHLf1n8)
 
-## Memory Persistence Scopes
+## Memory persistence scopes
 
 Working memory can operate in two different scopes, allowing you to choose how memory persists across conversations:
 
@@ -57,7 +57,7 @@ const memory = new Memory({
   options: {
     workingMemory: {
       enabled: true,
-      scope: "resource", // Memory persists across all user threads
+      scope: 'resource', // Memory persists across all user threads
       template: `# User Profile
 - **Name**:
 - **Location**:
@@ -67,7 +67,7 @@ const memory = new Memory({
 `,
     },
   },
-});
+})
 ```
 
 **Use cases:**
@@ -82,12 +82,12 @@ When using resource-scoped memory, make sure to pass the `resource` parameter in
 
 ```typescript
 // Resource-scoped memory requires resource
-const response = await agent.generate("Hello!", {
+const response = await agent.generate('Hello!', {
   memory: {
-    thread: "conversation-123",
-    resource: "user-alice-456", // Same user across different threads
+    thread: 'conversation-123',
+    resource: 'user-alice-456', // Same user across different threads
   },
-});
+})
 ```
 
 ### Thread-Scoped Memory
@@ -100,7 +100,7 @@ const memory = new Memory({
   options: {
     workingMemory: {
       enabled: true,
-      scope: "thread", // Memory is isolated per thread
+      scope: 'thread', // Memory is isolated per thread
       template: `# User Profile
 - **Name**:
 - **Interests**:
@@ -108,7 +108,7 @@ const memory = new Memory({
 `,
     },
   },
-});
+})
 ```
 
 **Use cases:**
@@ -117,7 +117,7 @@ const memory = new Memory({
 - Temporary or session-specific information
 - Workflows where each thread needs working memory but threads are ephemeral and not related to each other
 
-## Storage Adapter Support
+## Storage adapter support
 
 Resource-scoped working memory requires specific storage adapters that support the `mastra_resources` table:
 
@@ -128,9 +128,9 @@ Resource-scoped working memory requires specific storage adapters that support t
 - **Upstash** (`@mastra/upstash`)
 - **MongoDB** (`@mastra/mongodb`)
 
-## Custom Templates
+## Custom templates
 
-Templates guide the agent on what information to track and update in working memory. While a default template is used if none is provided, you'll typically want to define a custom template tailored to your agent's specific use case to ensure it remembers the most relevant information.
+Templates guide the agent on what information to track and update in working memory. While a default template is used if none is provided, you'll typically want to define a custom template tailored to your agent's specific use case to ensure it remembers the most relevant information. For threads shared by multiple users, see [Multi-user threads](https://mastra.ai/docs/memory/multi-user-threads).
 
 Here's an example of a custom template. In this example the agent will store the users name, location, timezone, etc as soon as the user sends a message containing any of the info:
 
@@ -142,7 +142,7 @@ const memory = new Memory({
       template: `
 # User Profile
 
-## Personal Info
+## Personal info
 
 - Name:
 - Location:
@@ -156,7 +156,7 @@ const memory = new Memory({
   - [Deadline 1]: [Date]
   - [Deadline 2]: [Date]
 
-## Session State
+## Session state
 
 - Last Task Discussed:
 - Open Questions:
@@ -165,16 +165,16 @@ const memory = new Memory({
 `,
     },
   },
-});
+})
 ```
 
-## Designing Effective Templates
+## Designing effective templates
 
-A well-structured template keeps the information easy for the agent to parse and update. Treat the template as a short form that you want the assistant to keep up to date.
+A well-structured template keeps the information straightforward for the agent to parse and update. Treat the template as a short form that you want the assistant to keep up to date.
 
-- **Short, focused labels.** Avoid paragraphs or very long headings. Keep labels brief (for example `## Personal Info` or `- Name:`) so updates are easy to read and less likely to be truncated.
+- **Short, focused labels.** Avoid paragraphs or very long headings. Keep labels brief (for example `## Personal Info` or `- Name:`) so updates are readable and less likely to be truncated.
 - **Use consistent casing.** Inconsistent capitalization (`Timezone:` vs `timezone:`) can cause messy updates. Stick to Title Case or lower case for headings and bullet labels.
-- **Keep placeholder text simple.** Use hints such as `[e.g., Formal]` or `[Date]` to help the LLM fill in the correct spots.
+- **Keep placeholder text minimal.** Use hints such as `[e.g., Formal]` or `[Date]` to help the LLM fill in the correct spots.
 - **Abbreviate very long values.** If you only need a short form, include guidance like `- Name: [First name or nickname]` or `- Address (short):` rather than the full legal text.
 - **Mention update rules in `instructions`.** You can instruct how and when to fill or clear parts of the template directly in the agent's `instructions` field.
 
@@ -190,7 +190,7 @@ const basicMemory = new Memory({
       template: `User Facts:\n- Name:\n- Favorite Color:\n- Current Topic:`,
     },
   },
-});
+})
 ```
 
 You can also store the key facts in a short paragraph format if you prefer a more narrative style:
@@ -203,20 +203,20 @@ const paragraphMemory = new Memory({
       template: `Important Details:\n\nKeep a short paragraph capturing the user's important facts (name, main goal, current task).`,
     },
   },
-});
+})
 ```
 
-## Structured Working Memory
+## Structured working memory
 
-Working memory can also be defined using a structured schema instead of a Markdown template. This allows you to specify the exact fields and types that should be tracked, using a [Zod](https://zod.dev/) schema. When using a schema, the agent will see and update working memory as a JSON object matching your schema.
+Working memory can also be defined using a structured schema instead of a Markdown template. This allows you to specify the exact fields and types that should be tracked, using a [Standard JSON Schema](https://standardschema.dev/json-schema) ([Zod](https://zod.dev/), [Valibot](https://valibot.dev/), [ArkType](https://arktype.io/), etc.). When using a schema, the agent will see and update working memory as a JSON object matching your schema.
 
 **Important:** You must specify either `template` or `schema`, but not both.
 
 ### Example: Schema-Based Working Memory
 
 ```typescript
-import { z } from "zod";
-import { Memory } from "@mastra/memory";
+import { z } from 'zod'
+import { Memory } from '@mastra/memory'
 
 const userProfileSchema = z.object({
   name: z.string().optional(),
@@ -229,7 +229,7 @@ const userProfileSchema = z.object({
       deadlines: z.array(z.string()).optional(),
     })
     .optional(),
-});
+})
 
 const memory = new Memory({
   options: {
@@ -239,7 +239,7 @@ const memory = new Memory({
       // template: ... (do not set)
     },
   },
-});
+})
 ```
 
 When a schema is provided, the agent receives the working memory as a JSON object. For example:
@@ -263,22 +263,22 @@ Schema-based working memory uses **merge semantics**, meaning the agent only nee
 
 - **Object fields are deep merged:** Only provided fields are updated; others remain unchanged
 - **Set a field to `null` to delete it:** This explicitly removes the field from memory
-- **Arrays are replaced entirely:** When an array field is provided, it replaces the existing array (arrays are not merged element-by-element)
+- **Arrays are replaced entirely:** When an array field is provided, it replaces the existing array (arrays aren't merged element-by-element)
 
-## Choosing Between Template and Schema
+## Choosing between template and schema
 
 - Use a **template** (Markdown) if you want the agent to maintain memory as a free-form text block, such as a user profile or scratchpad. Templates use **replace semantics** — the agent must provide the complete memory content on each update.
-- Use a **schema** if you need structured, type-safe data that can be validated and programmatically accessed as JSON. Schemas use **merge semantics** — the agent only provides fields to update, and existing fields are preserved.
-- Only one mode can be active at a time: setting both `template` and `schema` is not supported.
+- Use a **schema** if you need structured, type-safe data that can be validated and programmatically accessed as JSON. The `workingMemory.schema` field accepts any `PublicSchema`-compatible schema (including Zod v3, Zod v4, JSON Schema, or already-standard schemas). Schemas use **merge semantics** — the agent only provides fields to update, and existing fields are preserved.
+- Only one mode can be active at a time: setting both `template` and `schema` isn't supported.
 
-## Example: Multi-step Retention
+## Example: Multi-step retention
 
 Below is a simplified view of how the `User Profile` template updates across a short user conversation:
 
 ```nohighlight
 # User Profile
 
-## Personal Info
+## Personal info
 
 - Name:
 - Location:
@@ -301,9 +301,9 @@ Below is a simplified view of how the `User Profile` template updates across a s
 
 The agent can now refer to `Sam` or `Berlin` in later responses without requesting the information again because it has been stored in working memory.
 
-If your agent is not properly updating working memory when you expect it to, you can add system instructions on _how_ and _when_ to use this template in your agent's `instructions` setting.
+If your agent isn't properly updating working memory when you expect it to, you can add system instructions on _how_ and _when_ to use this template in your agent's `instructions` setting.
 
-## Setting Initial Working Memory
+## Setting initial working memory
 
 While agents typically update working memory through the `updateWorkingMemory` tool, you can also set initial working memory programmatically when creating or updating threads. This is useful for injecting user data (like their name, preferences, or other info) that you want available to the agent without passing it in every request.
 
@@ -314,9 +314,9 @@ When creating a thread, you can provide initial working memory through the metad
 ```typescript
 // Create a thread with initial working memory
 const thread = await memory.createThread({
-  threadId: "thread-123",
-  resourceId: "user-456",
-  title: "Medical Consultation",
+  threadId: 'thread-123',
+  resourceId: 'user-456',
+  title: 'Medical Consultation',
   metadata: {
     workingMemory: `# Patient Profile
 - Name: John Doe
@@ -326,15 +326,15 @@ const thread = await memory.createThread({
 - Medical History: Hypertension (controlled)
 `,
   },
-});
+})
 
 // The agent will now have access to this information in all messages
 await agent.generate("What's my blood type?", {
   memory: {
     thread: thread.id,
-    resource: "user-456",
+    resource: 'user-456',
   },
-});
+})
 // Response: "Your blood type is O+."
 ```
 
@@ -345,7 +345,7 @@ You can also update an existing thread's working memory:
 ```typescript
 // Update thread metadata to add/modify working memory
 await memory.updateThread({
-  id: "thread-123",
+  id: 'thread-123',
   title: thread.title,
   metadata: {
     ...thread.metadata,
@@ -357,7 +357,7 @@ await memory.updateThread({
 - Medical History: Hypertension (controlled)
 `,
   },
-});
+})
 ```
 
 ### Direct Memory Update
@@ -366,13 +366,13 @@ Alternatively, use the `updateWorkingMemory` method directly:
 
 ```typescript
 await memory.updateWorkingMemory({
-  threadId: "thread-123",
-  resourceId: "user-456", // Required for resource-scoped memory
-  workingMemory: "Updated memory content...",
-});
+  threadId: 'thread-123',
+  resourceId: 'user-456', // Required for resource-scoped memory
+  workingMemory: 'Updated memory content...',
+})
 ```
 
-## Read-Only Working Memory
+## Read-only working memory
 
 In some scenarios, you may want an agent to have access to working memory data without the ability to modify it. This is useful for:
 
@@ -382,19 +382,19 @@ In some scenarios, you may want an agent to have access to working memory data w
 To enable read-only mode, set `readOnly: true` in the memory options:
 
 ```typescript
-const response = await agent.generate("What do you know about me?", {
+const response = await agent.generate('What do you know about me?', {
   memory: {
-    thread: "conversation-123",
-    resource: "user-alice-456",
+    thread: 'conversation-123',
+    resource: 'user-alice-456',
     options: {
       readOnly: true, // Working memory is provided but cannot be updated
     },
   },
-});
+})
 ```
 
 ## Examples
 
 - [Working memory with template](https://github.com/mastra-ai/mastra/tree/main/examples/memory-with-template)
 - [Working memory with schema](https://github.com/mastra-ai/mastra/tree/main/examples/memory-with-schema)
-- [Per-resource working memory](https://github.com/mastra-ai/mastra/tree/main/examples/memory-per-resource-example) - Complete example showing resource-scoped memory persistence
+- [Per-resource working memory](https://github.com/mastra-ai/mastra/tree/main/examples/memory-per-resource-example): Complete example showing resource-scoped memory persistence