@mastra/memory 0.10.5-alpha.0 → 0.10.5-alpha.1

package/.turbo/turbo-build.log

@@ -1,9 +1,9 @@
 
-> @mastra/memory@0.10.5-alpha.0 build /home/runner/work/mastra/mastra/packages/memory
+> @mastra/memory@0.10.5-alpha.1 build /home/runner/work/mastra/mastra/packages/memory
 > pnpm run check && tsup --silent src/index.ts src/processors/index.ts --format esm,cjs --experimental-dts --clean --treeshake=smallest --splitting
 
 
-> @mastra/memory@0.10.5-alpha.0 check /home/runner/work/mastra/mastra/packages/memory
+> @mastra/memory@0.10.5-alpha.1 check /home/runner/work/mastra/mastra/packages/memory
 > tsc --noEmit
 
 Analysis will use the bundled TypeScript version 5.8.3

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # @mastra/memory
 
+## 0.10.5-alpha.1
+
+### Patch Changes
+
+- 8e1b6e9: dependencies updates:
+  - Updated dependency [`zod@^3.25.67` ↗︎](https://www.npmjs.com/package/zod/v/3.25.67) (from `^3.25.57`, in `dependencies`)
+- 15e9d26: Added per-resource working memory for LibSQL, Upstash, and PG
+- Updated dependencies [15e9d26]
+- Updated dependencies [07d6d88]
+- Updated dependencies [5d74aab]
+- Updated dependencies [144eb0b]
+  - @mastra/core@0.10.7-alpha.2
+
 ## 0.10.5-alpha.0
 
 ### Patch Changes

package/dist/_tsup-dts-rollup.d.cts

@@ -56,6 +56,12 @@ export declare class Memory extends MastraMemory {
         metadata: Record<string, unknown>;
     }): Promise<StorageThreadType>;
     deleteThread(threadId: string): Promise<void>;
+    updateWorkingMemory({ threadId, resourceId, workingMemory, memoryConfig, }: {
+        threadId: string;
+        resourceId?: string;
+        workingMemory: string;
+        memoryConfig?: MemoryConfig;
+    }): Promise<void>;
     private chunkText;
     private hasher;
     private embeddingCache;
@@ -74,17 +80,21 @@ export declare class Memory extends MastraMemory {
     protected updateMessageToHideWorkingMemory(message: MastraMessageV1): MastraMessageV1 | null;
     protected updateMessageToHideWorkingMemoryV2(message: MastraMessageV2): MastraMessageV2 | null;
     protected parseWorkingMemory(text: string): string | null;
-    getWorkingMemory({ threadId, format, }: {
+    getWorkingMemory({ threadId, resourceId, memoryConfig, }: {
         threadId: string;
-        format?: WorkingMemoryFormat;
+        resourceId?: string;
+        memoryConfig?: MemoryConfig;
     }): Promise<string | null>;
     getWorkingMemoryTemplate(): Promise<WorkingMemoryTemplate | null>;
-    getSystemMessage({ threadId, memoryConfig, }: {
+    getSystemMessage({ threadId, resourceId, memoryConfig, }: {
         threadId: string;
+        resourceId?: string;
         memoryConfig?: MemoryConfig;
     }): Promise<string | null>;
-    getUserContextMessage({ threadId }: {
+    getUserContextMessage({ threadId, resourceId, memoryConfig, }: {
         threadId: string;
+        resourceId?: string;
+        memoryConfig?: MemoryConfig;
     }): Promise<string | null>;
     defaultWorkingMemoryTemplate: string;
     private getWorkingMemoryToolInstruction;

package/dist/_tsup-dts-rollup.d.ts

@@ -56,6 +56,12 @@ export declare class Memory extends MastraMemory {
         metadata: Record<string, unknown>;
     }): Promise<StorageThreadType>;
     deleteThread(threadId: string): Promise<void>;
+    updateWorkingMemory({ threadId, resourceId, workingMemory, memoryConfig, }: {
+        threadId: string;
+        resourceId?: string;
+        workingMemory: string;
+        memoryConfig?: MemoryConfig;
+    }): Promise<void>;
     private chunkText;
     private hasher;
     private embeddingCache;
@@ -74,17 +80,21 @@ export declare class Memory extends MastraMemory {
     protected updateMessageToHideWorkingMemory(message: MastraMessageV1): MastraMessageV1 | null;
     protected updateMessageToHideWorkingMemoryV2(message: MastraMessageV2): MastraMessageV2 | null;
     protected parseWorkingMemory(text: string): string | null;
-    getWorkingMemory({ threadId, format, }: {
+    getWorkingMemory({ threadId, resourceId, memoryConfig, }: {
         threadId: string;
-        format?: WorkingMemoryFormat;
+        resourceId?: string;
+        memoryConfig?: MemoryConfig;
     }): Promise<string | null>;
     getWorkingMemoryTemplate(): Promise<WorkingMemoryTemplate | null>;
-    getSystemMessage({ threadId, memoryConfig, }: {
+    getSystemMessage({ threadId, resourceId, memoryConfig, }: {
         threadId: string;
+        resourceId?: string;
         memoryConfig?: MemoryConfig;
     }): Promise<string | null>;
-    getUserContextMessage({ threadId }: {
+    getUserContextMessage({ threadId, resourceId, memoryConfig, }: {
         threadId: string;
+        resourceId?: string;
+        memoryConfig?: MemoryConfig;
     }): Promise<string | null>;
     defaultWorkingMemoryTemplate: string;
     private getWorkingMemoryToolInstruction;

package/dist/index.cjs

@@ -32,14 +32,10 @@ var updateWorkingMemoryTool = ({ format }) => ({
       throw new Error(`Thread with id ${threadId} resourceId does not match the current resourceId ${resourceId}`);
     }
     const workingMemory = context.memory;
-    await memory.saveThread({
-      thread: {
-        ...thread,
-        metadata: {
-          ...thread.metadata,
-          workingMemory
-        }
-      }
+    await memory.updateWorkingMemory({
+      threadId,
+      resourceId: resourceId || thread.resourceId,
+      workingMemory
     });
     return { success: true };
   }
@@ -81,6 +77,11 @@ var Memory = class extends memory.MastraMemory {
         `Memory error: Attached storage adapter "${this.storage.name || "unknown"}" doesn't support semanticRecall: { scope: "resource" } yet and currently only supports per-thread semantic recall.`
       );
     }
+    if (config.workingMemory?.enabled && config.workingMemory.scope === `resource` && !this.storage.supports.resourceWorkingMemory) {
+      throw new Error(
+        `Memory error: Attached storage adapter "${this.storage.name || "unknown"}" doesn't support workingMemory: { scope: "resource" } yet and currently only supports per-thread working memory. Supported adapters: LibSQL, PostgreSQL, Upstash.`
+      );
+    }
   }
   async query({
     threadId,
@@ -205,18 +206,33 @@ var Memory = class extends memory.MastraMemory {
     memoryConfig
   }) {
     const config = this.getMergedThreadConfig(memoryConfig || {});
-    if (config.workingMemory?.enabled && !thread?.metadata?.workingMemory) {
-      let workingMemory = config.workingMemory.template || this.defaultWorkingMemoryTemplate;
-      if (config.workingMemory.schema) {
-        workingMemory = JSON.stringify(zodToJsonSchema__default.default(config.workingMemory.schema));
-      }
-      return this.storage.saveThread({
-        thread: core.deepMerge(thread, {
-          metadata: {
-            workingMemory
+    if (config.workingMemory?.enabled) {
+      const scope = config.workingMemory.scope || "thread";
+      if (scope === "resource" && thread.resourceId) {
+        const existingResource = await this.storage.getResourceById({ resourceId: thread.resourceId });
+        if (!existingResource?.workingMemory) {
+          let workingMemory = config.workingMemory.template || this.defaultWorkingMemoryTemplate;
+          if (config.workingMemory.schema) {
+            workingMemory = JSON.stringify(zodToJsonSchema__default.default(config.workingMemory.schema));
           }
-        })
-      });
+          await this.storage.updateResource({
+            resourceId: thread.resourceId,
+            workingMemory
+          });
+        }
+      } else if (scope === "thread" && !thread?.metadata?.workingMemory) {
+        let workingMemory = config.workingMemory.template || this.defaultWorkingMemoryTemplate;
+        if (config.workingMemory.schema) {
+          workingMemory = JSON.stringify(zodToJsonSchema__default.default(config.workingMemory.schema));
+        }
+        return this.storage.saveThread({
+          thread: core.deepMerge(thread, {
+            metadata: {
+              workingMemory
+            }
+          })
+        });
+      }
     }
     return this.storage.saveThread({ thread });
   }
@@ -234,6 +250,37 @@ var Memory = class extends memory.MastraMemory {
   async deleteThread(threadId) {
     await this.storage.deleteThread({ threadId });
   }
+  async updateWorkingMemory({
+    threadId,
+    resourceId,
+    workingMemory,
+    memoryConfig
+  }) {
+    const config = this.getMergedThreadConfig(memoryConfig || {});
+    if (!config.workingMemory?.enabled) {
+      throw new Error("Working memory is not enabled for this memory instance");
+    }
+    const scope = config.workingMemory.scope || "thread";
+    if (scope === "resource" && resourceId) {
+      await this.storage.updateResource({
+        resourceId,
+        workingMemory
+      });
+    } else {
+      const thread = await this.storage.getThreadById({ threadId });
+      if (!thread) {
+        throw new Error(`Thread ${threadId} not found`);
+      }
+      await this.storage.updateThread({
+        id: threadId,
+        title: thread.title || "Untitled Thread",
+        metadata: {
+          ...thread.metadata,
+          workingMemory
+        }
+      });
+    }
+  }
   chunkText(text, tokenSize = 4096) {
     const charSize = tokenSize * CHARS_PER_TOKEN;
     const chunks = [];
@@ -411,20 +458,26 @@ var Memory = class extends memory.MastraMemory {
   }
   async getWorkingMemory({
     threadId,
-    format
+    resourceId,
+    memoryConfig
   }) {
-    if (!this.threadConfig.workingMemory?.enabled) {
+    const config = this.getMergedThreadConfig(memoryConfig || {});
+    if (!config.workingMemory?.enabled) {
       return null;
     }
-    const thread = await this.storage.getThreadById({ threadId });
-    if (format === "json") {
-      try {
-        return JSON.parse(thread?.metadata?.workingMemory) || null;
-      } catch (e) {
-        this.logger.error("Unable to parse working memory as JSON. Returning string.", e);
-      }
+    const scope = config.workingMemory.scope || "thread";
+    let workingMemoryData = null;
+    if (scope === "resource" && resourceId) {
+      const resource = await this.storage.getResourceById({ resourceId });
+      workingMemoryData = resource?.workingMemory || null;
+    } else {
+      const thread = await this.storage.getThreadById({ threadId });
+      workingMemoryData = thread?.metadata?.workingMemory;
     }
-    return thread?.metadata?.workingMemory ? JSON.stringify(thread?.metadata?.workingMemory) : null;
+    if (!workingMemoryData) {
+      return null;
+    }
+    return workingMemoryData;
   }
   async getWorkingMemoryTemplate() {
     if (!this.threadConfig.workingMemory?.enabled) {
@@ -447,6 +500,7 @@ var Memory = class extends memory.MastraMemory {
   }
   async getSystemMessage({
     threadId,
+    resourceId,
     memoryConfig
   }) {
     const config = this.getMergedThreadConfig(memoryConfig);
@@ -454,7 +508,7 @@ var Memory = class extends memory.MastraMemory {
       return null;
     }
     const workingMemoryTemplate = await this.getWorkingMemoryTemplate();
-    const workingMemoryData = await this.getWorkingMemory({ threadId });
+    const workingMemoryData = await this.getWorkingMemory({ threadId, resourceId, memoryConfig: config });
     if (!workingMemoryTemplate) {
       return null;
     }
@@ -463,8 +517,12 @@ var Memory = class extends memory.MastraMemory {
       data: workingMemoryData
     });
   }
-  async getUserContextMessage({ threadId }) {
-    const workingMemory = await this.getWorkingMemory({ threadId });
+  async getUserContextMessage({
+    threadId,
+    resourceId,
+    memoryConfig
+  }) {
+    const workingMemory = await this.getWorkingMemory({ threadId, resourceId, memoryConfig });
     if (!workingMemory) {
       return null;
     }

package/dist/index.js

@@ -25,14 +25,10 @@ var updateWorkingMemoryTool = ({ format }) => ({
       throw new Error(`Thread with id ${threadId} resourceId does not match the current resourceId ${resourceId}`);
     }
     const workingMemory = context.memory;
-    await memory.saveThread({
-      thread: {
-        ...thread,
-        metadata: {
-          ...thread.metadata,
-          workingMemory
-        }
-      }
+    await memory.updateWorkingMemory({
+      threadId,
+      resourceId: resourceId || thread.resourceId,
+      workingMemory
     });
     return { success: true };
   }
@@ -74,6 +70,11 @@ var Memory = class extends MastraMemory {
         `Memory error: Attached storage adapter "${this.storage.name || "unknown"}" doesn't support semanticRecall: { scope: "resource" } yet and currently only supports per-thread semantic recall.`
       );
     }
+    if (config.workingMemory?.enabled && config.workingMemory.scope === `resource` && !this.storage.supports.resourceWorkingMemory) {
+      throw new Error(
+        `Memory error: Attached storage adapter "${this.storage.name || "unknown"}" doesn't support workingMemory: { scope: "resource" } yet and currently only supports per-thread working memory. Supported adapters: LibSQL, PostgreSQL, Upstash.`
+      );
+    }
   }
   async query({
     threadId,
@@ -198,18 +199,33 @@ var Memory = class extends MastraMemory {
     memoryConfig
   }) {
     const config = this.getMergedThreadConfig(memoryConfig || {});
-    if (config.workingMemory?.enabled && !thread?.metadata?.workingMemory) {
-      let workingMemory = config.workingMemory.template || this.defaultWorkingMemoryTemplate;
-      if (config.workingMemory.schema) {
-        workingMemory = JSON.stringify(zodToJsonSchema(config.workingMemory.schema));
-      }
-      return this.storage.saveThread({
-        thread: deepMerge(thread, {
-          metadata: {
-            workingMemory
+    if (config.workingMemory?.enabled) {
+      const scope = config.workingMemory.scope || "thread";
+      if (scope === "resource" && thread.resourceId) {
+        const existingResource = await this.storage.getResourceById({ resourceId: thread.resourceId });
+        if (!existingResource?.workingMemory) {
+          let workingMemory = config.workingMemory.template || this.defaultWorkingMemoryTemplate;
+          if (config.workingMemory.schema) {
+            workingMemory = JSON.stringify(zodToJsonSchema(config.workingMemory.schema));
           }
-        })
-      });
+          await this.storage.updateResource({
+            resourceId: thread.resourceId,
+            workingMemory
+          });
+        }
+      } else if (scope === "thread" && !thread?.metadata?.workingMemory) {
+        let workingMemory = config.workingMemory.template || this.defaultWorkingMemoryTemplate;
+        if (config.workingMemory.schema) {
+          workingMemory = JSON.stringify(zodToJsonSchema(config.workingMemory.schema));
+        }
+        return this.storage.saveThread({
+          thread: deepMerge(thread, {
+            metadata: {
+              workingMemory
+            }
+          })
+        });
+      }
     }
     return this.storage.saveThread({ thread });
   }
@@ -227,6 +243,37 @@ var Memory = class extends MastraMemory {
   async deleteThread(threadId) {
     await this.storage.deleteThread({ threadId });
   }
+  async updateWorkingMemory({
+    threadId,
+    resourceId,
+    workingMemory,
+    memoryConfig
+  }) {
+    const config = this.getMergedThreadConfig(memoryConfig || {});
+    if (!config.workingMemory?.enabled) {
+      throw new Error("Working memory is not enabled for this memory instance");
+    }
+    const scope = config.workingMemory.scope || "thread";
+    if (scope === "resource" && resourceId) {
+      await this.storage.updateResource({
+        resourceId,
+        workingMemory
+      });
+    } else {
+      const thread = await this.storage.getThreadById({ threadId });
+      if (!thread) {
+        throw new Error(`Thread ${threadId} not found`);
+      }
+      await this.storage.updateThread({
+        id: threadId,
+        title: thread.title || "Untitled Thread",
+        metadata: {
+          ...thread.metadata,
+          workingMemory
+        }
+      });
+    }
+  }
   chunkText(text, tokenSize = 4096) {
     const charSize = tokenSize * CHARS_PER_TOKEN;
     const chunks = [];
@@ -404,20 +451,26 @@ var Memory = class extends MastraMemory {
   }
   async getWorkingMemory({
     threadId,
-    format
+    resourceId,
+    memoryConfig
   }) {
-    if (!this.threadConfig.workingMemory?.enabled) {
+    const config = this.getMergedThreadConfig(memoryConfig || {});
+    if (!config.workingMemory?.enabled) {
       return null;
     }
-    const thread = await this.storage.getThreadById({ threadId });
-    if (format === "json") {
-      try {
-        return JSON.parse(thread?.metadata?.workingMemory) || null;
-      } catch (e) {
-        this.logger.error("Unable to parse working memory as JSON. Returning string.", e);
-      }
+    const scope = config.workingMemory.scope || "thread";
+    let workingMemoryData = null;
+    if (scope === "resource" && resourceId) {
+      const resource = await this.storage.getResourceById({ resourceId });
+      workingMemoryData = resource?.workingMemory || null;
+    } else {
+      const thread = await this.storage.getThreadById({ threadId });
+      workingMemoryData = thread?.metadata?.workingMemory;
     }
-    return thread?.metadata?.workingMemory ? JSON.stringify(thread?.metadata?.workingMemory) : null;
+    if (!workingMemoryData) {
+      return null;
+    }
+    return workingMemoryData;
   }
   async getWorkingMemoryTemplate() {
     if (!this.threadConfig.workingMemory?.enabled) {
@@ -440,6 +493,7 @@ var Memory = class extends MastraMemory {
   }
   async getSystemMessage({
     threadId,
+    resourceId,
     memoryConfig
   }) {
     const config = this.getMergedThreadConfig(memoryConfig);
@@ -447,7 +501,7 @@ var Memory = class extends MastraMemory {
       return null;
     }
     const workingMemoryTemplate = await this.getWorkingMemoryTemplate();
-    const workingMemoryData = await this.getWorkingMemory({ threadId });
+    const workingMemoryData = await this.getWorkingMemory({ threadId, resourceId, memoryConfig: config });
     if (!workingMemoryTemplate) {
       return null;
     }
@@ -456,8 +510,12 @@ var Memory = class extends MastraMemory {
       data: workingMemoryData
     });
   }
-  async getUserContextMessage({ threadId }) {
-    const workingMemory = await this.getWorkingMemory({ threadId });
+  async getUserContextMessage({
+    threadId,
+    resourceId,
+    memoryConfig
+  }) {
+    const workingMemory = await this.getWorkingMemory({ threadId, resourceId, memoryConfig });
     if (!workingMemory) {
       return null;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/memory",
-  "version": "0.10.5-alpha.0",
+  "version": "0.10.5-alpha.1",
   "description": "",
   "type": "module",
   "main": "./dist/index.js",
@@ -40,7 +40,7 @@
     "postgres": "^3.4.7",
     "redis": "^4.7.1",
     "xxhash-wasm": "^1.1.0",
-    "zod": "^3.25.57",
+    "zod": "^3.25.67",
     "zod-to-json-schema": "^3.24.5"
   },
   "devDependencies": {
@@ -48,13 +48,13 @@
     "@microsoft/api-extractor": "^7.52.8",
     "@types/node": "^20.19.0",
     "@types/pg": "^8.15.4",
-    "eslint": "^9.28.0",
+    "eslint": "^9.29.0",
     "tsup": "^8.5.0",
     "typescript": "^5.8.3",
     "typescript-eslint": "^8.34.0",
     "vitest": "^3.2.3",
     "@internal/lint": "0.0.13",
-    "@mastra/core": "0.10.7-alpha.0"
+    "@mastra/core": "0.10.7-alpha.2"
   },
   "peerDependencies": {
     "@mastra/core": ">=0.10.4-0 <0.11.0"

package/src/index.ts

@@ -3,13 +3,7 @@ import type { CoreTool, MastraMessageV1 } from '@mastra/core';
 import { MessageList } from '@mastra/core/agent';
 import type { MastraMessageV2 } from '@mastra/core/agent';
 import { MastraMemory } from '@mastra/core/memory';
-import type {
-  MemoryConfig,
-  SharedMemoryConfig,
-  StorageThreadType,
-  WorkingMemoryFormat,
-  WorkingMemoryTemplate,
-} from '@mastra/core/memory';
+import type { MemoryConfig, SharedMemoryConfig, StorageThreadType, WorkingMemoryTemplate } from '@mastra/core/memory';
 import type { StorageGetMessagesArg } from '@mastra/core/storage';
 import { embedMany } from 'ai';
 import type { CoreMessage, TextPart, UIMessage } from 'ai';
@@ -68,6 +62,16 @@ export class Memory extends MastraMemory {
         `Memory error: Attached storage adapter "${this.storage.name || 'unknown'}" doesn't support semanticRecall: { scope: "resource" } yet and currently only supports per-thread semantic recall.`,
       );
     }
+
+    if (
+      config.workingMemory?.enabled &&
+      config.workingMemory.scope === `resource` &&
+      !this.storage.supports.resourceWorkingMemory
+    ) {
+      throw new Error(
+        `Memory error: Attached storage adapter "${this.storage.name || 'unknown'}" doesn't support workingMemory: { scope: "resource" } yet and currently only supports per-thread working memory. Supported adapters: LibSQL, PostgreSQL, Upstash.`,
+      );
+    }
   }
 
   async query({
@@ -252,21 +256,41 @@ export class Memory extends MastraMemory {
   }): Promise<StorageThreadType> {
     const config = this.getMergedThreadConfig(memoryConfig || {});
 
-    if (config.workingMemory?.enabled && !thread?.metadata?.workingMemory) {
-      // if working memory is enabled but the thread doesn't have it, we need to set it
-      let workingMemory = config.workingMemory.template || this.defaultWorkingMemoryTemplate;
+    if (config.workingMemory?.enabled) {
+      const scope = config.workingMemory.scope || 'thread';
 
-      if (config.workingMemory.schema) {
-        workingMemory = JSON.stringify(zodToJsonSchema(config.workingMemory.schema));
-      }
+      if (scope === 'resource' && thread.resourceId) {
+        // For resource scope, initialize working memory in resource table
+        const existingResource = await this.storage.getResourceById({ resourceId: thread.resourceId });
+
+        if (!existingResource?.workingMemory) {
+          let workingMemory = config.workingMemory.template || this.defaultWorkingMemoryTemplate;
 
-      return this.storage.saveThread({
-        thread: deepMerge(thread, {
-          metadata: {
+          if (config.workingMemory.schema) {
+            workingMemory = JSON.stringify(zodToJsonSchema(config.workingMemory.schema));
+          }
+
+          await this.storage.updateResource({
+            resourceId: thread.resourceId,
             workingMemory,
-          },
-        }),
-      });
+          });
+        }
+      } else if (scope === 'thread' && !thread?.metadata?.workingMemory) {
+        // For thread scope, initialize working memory in thread metadata (existing behavior)
+        let workingMemory = config.workingMemory.template || this.defaultWorkingMemoryTemplate;
+
+        if (config.workingMemory.schema) {
+          workingMemory = JSON.stringify(zodToJsonSchema(config.workingMemory.schema));
+        }
+
+        return this.storage.saveThread({
+          thread: deepMerge(thread, {
+            metadata: {
+              workingMemory,
+            },
+          }),
+        });
+      }
     }
 
     return this.storage.saveThread({ thread });
@@ -292,6 +316,49 @@ export class Memory extends MastraMemory {
     await this.storage.deleteThread({ threadId });
   }
 
+  async updateWorkingMemory({
+    threadId,
+    resourceId,
+    workingMemory,
+    memoryConfig,
+  }: {
+    threadId: string;
+    resourceId?: string;
+    workingMemory: string;
+    memoryConfig?: MemoryConfig;
+  }): Promise<void> {
+    const config = this.getMergedThreadConfig(memoryConfig || {});
+
+    if (!config.workingMemory?.enabled) {
+      throw new Error('Working memory is not enabled for this memory instance');
+    }
+
+    const scope = config.workingMemory.scope || 'thread';
+
+    if (scope === 'resource' && resourceId) {
+      // Update working memory in resource table
+      await this.storage.updateResource({
+        resourceId,
+        workingMemory,
+      });
+    } else {
+      // Update working memory in thread metadata (existing behavior)
+      const thread = await this.storage.getThreadById({ threadId });
+      if (!thread) {
+        throw new Error(`Thread ${threadId} not found`);
+      }
+
+      await this.storage.updateThread({
+        id: threadId,
+        title: thread.title || 'Untitled Thread',
+        metadata: {
+          ...thread.metadata,
+          workingMemory,
+        },
+      });
+    }
+  }
+
   private chunkText(text: string, tokenSize = 4096) {
     // Convert token size to character size with some buffer
     const charSize = tokenSize * CHARS_PER_TOKEN;
@@ -555,26 +622,36 @@ export class Memory extends MastraMemory {
 
   public async getWorkingMemory({
     threadId,
-    format,
+    resourceId,
+    memoryConfig,
   }: {
     threadId: string;
-    format?: WorkingMemoryFormat;
+    resourceId?: string;
+    memoryConfig?: MemoryConfig;
   }): Promise<string | null> {
-    if (!this.threadConfig.workingMemory?.enabled) {
+    const config = this.getMergedThreadConfig(memoryConfig || {});
+    if (!config.workingMemory?.enabled) {
       return null;
     }
 
-    const thread = await this.storage.getThreadById({ threadId });
+    const scope = config.workingMemory.scope || 'thread';
+    let workingMemoryData: string | null = null;
 
-    if (format === 'json') {
-      try {
-        return JSON.parse(thread?.metadata?.workingMemory as string) || null;
-      } catch (e) {
-        this.logger.error('Unable to parse working memory as JSON. Returning string.', e);
-      }
+    if (scope === 'resource' && resourceId) {
+      // Get working memory from resource table
+      const resource = await this.storage.getResourceById({ resourceId });
+      workingMemoryData = resource?.workingMemory || null;
+    } else {
+      // Get working memory from thread metadata (default behavior)
+      const thread = await this.storage.getThreadById({ threadId });
+      workingMemoryData = thread?.metadata?.workingMemory as string;
+    }
+
+    if (!workingMemoryData) {
+      return null;
     }
 
-    return thread?.metadata?.workingMemory ? JSON.stringify(thread?.metadata?.workingMemory) : null;
+    return workingMemoryData;
   }
 
   public async getWorkingMemoryTemplate(): Promise<WorkingMemoryTemplate | null> {
@@ -605,9 +682,11 @@ export class Memory extends MastraMemory {
 
   public async getSystemMessage({
     threadId,
+    resourceId,
     memoryConfig,
   }: {
     threadId: string;
+    resourceId?: string;
     memoryConfig?: MemoryConfig;
   }): Promise<string | null> {
     const config = this.getMergedThreadConfig(memoryConfig);
@@ -616,7 +695,7 @@ export class Memory extends MastraMemory {
     }
 
     const workingMemoryTemplate = await this.getWorkingMemoryTemplate();
-    const workingMemoryData = await this.getWorkingMemory({ threadId });
+    const workingMemoryData = await this.getWorkingMemory({ threadId, resourceId, memoryConfig: config });
 
     if (!workingMemoryTemplate) {
       return null;
@@ -628,8 +707,16 @@ export class Memory extends MastraMemory {
     });
   }
 
-  public async getUserContextMessage({ threadId }: { threadId: string }) {
-    const workingMemory = await this.getWorkingMemory({ threadId });
+  public async getUserContextMessage({
+    threadId,
+    resourceId,
+    memoryConfig,
+  }: {
+    threadId: string;
+    resourceId?: string;
+    memoryConfig?: MemoryConfig;
+  }) {
+    const workingMemory = await this.getWorkingMemory({ threadId, resourceId, memoryConfig });
     if (!workingMemory) {
       return null;
     }

package/src/tools/working-memory.ts

@@ -27,15 +27,11 @@ export const updateWorkingMemoryTool = ({ format }: { format: WorkingMemoryForma
 
     const workingMemory = context.memory;
 
-    // Update thread metadata with new working memory
-    await memory.saveThread({
-      thread: {
-        ...thread,
-        metadata: {
-          ...thread.metadata,
-          workingMemory: workingMemory,
-        },
-      },
+    // Use the new updateWorkingMemory method which handles both thread and resource scope
+    await memory.updateWorkingMemory({
+      threadId,
+      resourceId: resourceId || thread.resourceId,
+      workingMemory: workingMemory,
     });
 
     return { success: true };