@mastra/memory 0.12.1 → 0.12.2-alpha.1

package/dist/tools/working-memory.d.ts

@@ -1,4 +1,29 @@
-import type { CoreTool, MemoryConfig } from '@mastra/core';
-export declare const updateWorkingMemoryTool: (memoryConfig?: MemoryConfig) => CoreTool;
-export declare const __experimental_updateWorkingMemoryToolVNext: (config: MemoryConfig) => CoreTool;
+import type { MemoryConfig } from '@mastra/core';
+import { z } from 'zod';
+export declare const updateWorkingMemoryTool: (memoryConfig?: MemoryConfig) => import("@mastra/core/tools").Tool<z.ZodTypeAny, undefined, import("@mastra/core").ToolExecutionContext<z.ZodTypeAny>>;
+export declare const __experimental_updateWorkingMemoryToolVNext: (config: MemoryConfig) => import("@mastra/core/tools").Tool<z.ZodObject<{
+    newMemory: z.ZodOptional<z.ZodString>;
+    searchString: z.ZodOptional<z.ZodString>;
+    updateReason: z.ZodOptional<z.ZodEnum<["append-new-memory", "clarify-existing-memory", "replace-irrelevant-memory"]>>;
+}, "strip", z.ZodTypeAny, {
+    newMemory?: string | undefined;
+    searchString?: string | undefined;
+    updateReason?: "append-new-memory" | "clarify-existing-memory" | "replace-irrelevant-memory" | undefined;
+}, {
+    newMemory?: string | undefined;
+    searchString?: string | undefined;
+    updateReason?: "append-new-memory" | "clarify-existing-memory" | "replace-irrelevant-memory" | undefined;
+}>, undefined, import("@mastra/core").ToolExecutionContext<z.ZodObject<{
+    newMemory: z.ZodOptional<z.ZodString>;
+    searchString: z.ZodOptional<z.ZodString>;
+    updateReason: z.ZodOptional<z.ZodEnum<["append-new-memory", "clarify-existing-memory", "replace-irrelevant-memory"]>>;
+}, "strip", z.ZodTypeAny, {
+    newMemory?: string | undefined;
+    searchString?: string | undefined;
+    updateReason?: "append-new-memory" | "clarify-existing-memory" | "replace-irrelevant-memory" | undefined;
+}, {
+    newMemory?: string | undefined;
+    searchString?: string | undefined;
+    updateReason?: "append-new-memory" | "clarify-existing-memory" | "replace-irrelevant-memory" | undefined;
+}>>>;
 //# sourceMappingURL=working-memory.d.ts.map

package/dist/tools/working-memory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"working-memory.d.ts","sourceRoot":"","sources":["../../src/tools/working-memory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAG3D,eAAO,MAAM,uBAAuB,GAAI,eAAe,YAAY,KAAG,QA0CpE,CAAC;AAEH,eAAO,MAAM,2CAA2C,GAAI,QAAQ,YAAY,KAAG,QAqFjF,CAAC"}
+{"version":3,"file":"working-memory.d.ts","sourceRoot":"","sources":["../../src/tools/working-memory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAIjD,OAAO,EAAE,CAAC,EAAa,MAAM,KAAK,CAAC;AAGnC,eAAO,MAAM,uBAAuB,GAAI,eAAe,YAAY,0HAyDlE,CAAC;AAEF,eAAO,MAAM,2CAA2C,GAAI,QAAQ,YAAY;;;;;;;;;;;;;;;;;;;;;;;;IAuF/E,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/memory",
-  "version": "0.12.1",
+  "version": "0.12.2-alpha.1",
   "description": "",
   "type": "module",
   "main": "./dist/index.js",
@@ -43,7 +43,8 @@
     "async-mutex": "^0.5.0",
     "xxhash-wasm": "^1.1.0",
     "zod": "^3.25.67",
-    "zod-to-json-schema": "^3.24.5"
+    "zod-to-json-schema": "^3.24.5",
+    "@mastra/schema-compat": "0.10.7-alpha.0"
   },
   "devDependencies": {
     "@ai-sdk/openai": "^1.3.22",
@@ -56,9 +57,9 @@
     "typescript": "^5.8.3",
     "typescript-eslint": "^8.38.0",
     "vitest": "^3.2.4",
-    "@internal/lint": "0.0.27",
-    "@internal/types-builder": "0.0.2",
-    "@mastra/core": "0.13.0"
+    "@internal/lint": "0.0.28",
+    "@mastra/core": "0.13.2-alpha.1",
+    "@internal/types-builder": "0.0.3"
   },
   "peerDependencies": {
     "@mastra/core": ">=0.13.0-0 <0.14.0-0"

package/src/index.ts

@@ -1,5 +1,5 @@
 import { generateEmptyFromSchema } from '@mastra/core';
-import type { CoreTool, MastraMessageV1 } from '@mastra/core';
+import type { MastraMessageV1, ToolAction } from '@mastra/core';
 import { MessageList } from '@mastra/core/agent';
 import type { MastraMessageV2, UIMessageWithMetadata } from '@mastra/core/agent';
 import { MastraMemory } from '@mastra/core/memory';
@@ -871,13 +871,22 @@ Guidelines:
 2. Update proactively when information changes, no matter how small
 3. Use ${template.format === 'json' ? 'JSON' : 'Markdown'} format for all data
 4. Act naturally - don't mention this system to users. Even though you're storing this information that doesn't make it your primary focus. Do not ask them generally for "information about yourself"
-5. IMPORTANT: When calling updateWorkingMemory, the only valid parameter is the memory field. 
+${
+  template.format !== 'json'
+    ? `5. IMPORTANT: When calling updateWorkingMemory, the only valid parameter is the memory field. DO NOT pass an object.
 6. IMPORTANT: ALWAYS pass the data you want to store in the memory field as a string. DO NOT pass an object.
-7. IMPORTANT: Data must only be sent as a string no matter which format is used.
+7. IMPORTANT: Data must only be sent as a string no matter which format is used.`
+    : ''
+}
 
-<working_memory_template>
+
+${
+  template.format !== 'json'
+    ? `<working_memory_template>
 ${template.content}
-</working_memory_template>
+</working_memory_template>`
+    : ''
+}
 
 ${hasEmptyWorkingMemoryTemplateObject ? 'When working with json data, the object format below represents the template:' : ''}
 ${hasEmptyWorkingMemoryTemplateObject ? JSON.stringify(emptyWorkingMemoryTemplateObject) : ''}
@@ -948,7 +957,7 @@ ${
     return Boolean(isMDWorkingMemory && isMDWorkingMemory.version === `vnext`);
   }
 
-  public getTools(config?: MemoryConfig): Record<string, CoreTool> {
+  public getTools(config?: MemoryConfig): Record<string, ToolAction<any, any, any>> {
     const mergedConfig = this.getMergedThreadConfig(config);
     if (mergedConfig.workingMemory?.enabled) {
       return {

package/src/tools/working-memory.ts

@@ -1,133 +1,154 @@
-import type { CoreTool, MemoryConfig } from '@mastra/core';
-import { z } from 'zod';
+import type { MemoryConfig } from '@mastra/core';
+import { createTool } from '@mastra/core';
+import { convertSchemaToZod } from '@mastra/schema-compat';
+import type { Schema } from 'ai';
+import { z, ZodObject } from 'zod';
+import type { ZodTypeAny } from 'zod';
 
-export const updateWorkingMemoryTool = (memoryConfig?: MemoryConfig): CoreTool => ({
-  description:
-    'Update the working memory with new information. Always pass data as string to the memory field. Never pass an object.',
-  parameters: z.object({
+export const updateWorkingMemoryTool = (memoryConfig?: MemoryConfig) => {
+  const schema = memoryConfig?.workingMemory?.schema;
+
+  let inputSchema: ZodTypeAny = z.object({
     memory: z
       .string()
-      .describe(
-        `The ${!!memoryConfig?.workingMemory?.schema ? 'JSON' : 'Markdown'} formatted working memory content to store. This MUST be a string. Never pass an object.`,
-      ),
-  }),
-  execute: async (params: any) => {
-    const { context, threadId, memory, resourceId } = params;
-    if (!threadId || !memory) {
-      throw new Error('Thread ID and Memory instance are required for working memory updates');
-    }
-
-    let thread = await memory.getThreadById({ threadId });
-
-    if (!thread) {
-      thread = await memory.createThread({
+      .describe(`The Markdown formatted working memory content to store. This MUST be a string. Never pass an object.`),
+  });
+
+  if (schema) {
+    inputSchema = z.object({
+      memory:
+        schema instanceof ZodObject
+          ? schema
+          : convertSchemaToZod({ jsonSchema: schema } as Schema).describe(
+              `The JSON formatted working memory content to store.`,
+            ),
+    });
+  }
+
+  return createTool({
+    id: 'update-working-memory',
+    description: `Update the working memory with new information. Any data not included will be overwritten.${schema ? ' Always pass data as string to the memory field. Never pass an object.' : ''}`,
+    inputSchema,
+    execute: async params => {
+      const { context, threadId, memory, resourceId } = params;
+      if (!threadId || !memory || !resourceId) {
+        throw new Error('Thread ID, Memory instance, and resourceId are required for working memory updates');
+      }
+
+      let thread = await memory.getThreadById({ threadId });
+
+      if (!thread) {
+        thread = await memory.createThread({
+          threadId,
+          resourceId,
+          memoryConfig,
+        });
+      }
+
+      if (thread.resourceId && thread.resourceId !== resourceId) {
+        throw new Error(`Thread with id ${threadId} resourceId does not match the current resourceId ${resourceId}`);
+      }
+
+      const workingMemory = typeof context.memory === 'string' ? context.memory : JSON.stringify(context.memory);
+
+      // Use the new updateWorkingMemory method which handles both thread and resource scope
+      await memory.updateWorkingMemory({
         threadId,
-        resourceId: resourceId || thread.resourceId,
+        resourceId,
+        workingMemory,
         memoryConfig,
       });
-    }
-
-    if (thread.resourceId && thread.resourceId !== resourceId) {
-      throw new Error(`Thread with id ${threadId} resourceId does not match the current resourceId ${resourceId}`);
-    }
-
-    const workingMemory = context.memory;
-
-    // Use the new updateWorkingMemory method which handles both thread and resource scope
-    await memory.updateWorkingMemory({
-      threadId,
-      resourceId: resourceId || thread.resourceId,
-      workingMemory: workingMemory,
-      memoryConfig,
-    });
-
-    return { success: true };
-  },
-});
 
-export const __experimental_updateWorkingMemoryToolVNext = (config: MemoryConfig): CoreTool => ({
-  description: 'Update the working memory with new information.',
-  parameters: z.object({
-    newMemory: z
-      .string()
-      .optional()
-      .nullable()
-      .describe(`The ${config.workingMemory?.schema ? 'JSON' : 'Markdown'} formatted working memory content to store`),
-    searchString: z
-      .string()
-      .optional()
-      .nullable()
-      .describe(
-        "The working memory string to find. Will be replaced with the newMemory string. If this is omitted or doesn't exist, the newMemory string will be appended to the end of your working memory. Replacing single lines at a time is encouraged for greater accuracy. If updateReason is not 'append-new-memory', this search string must be provided or the tool call will be rejected.",
-      ),
-    updateReason: z
-      .enum(['append-new-memory', 'clarify-existing-memory', 'replace-irrelevant-memory'])
-      .optional()
-      .nullable()
-      .describe(
-        "The reason you're updating working memory. Passing any value other than 'append-new-memory' requires a searchString to be provided. Defaults to append-new-memory",
-      ),
-  }),
-  execute: async (params: any) => {
-    const { context, threadId, memory, resourceId } = params;
-    if (!threadId || !memory) {
-      throw new Error('Thread ID and Memory instance are required for working memory updates');
-    }
-
-    let thread = await memory.getThreadById({ threadId });
-
-    if (!thread) {
-      thread = await memory.createThread({
+      return { success: true };
+    },
+  });
+};
+
+export const __experimental_updateWorkingMemoryToolVNext = (config: MemoryConfig) => {
+  return createTool({
+    id: 'update-working-memory',
+    description: 'Update the working memory with new information.',
+    inputSchema: z.object({
+      newMemory: z
+        .string()
+        .optional()
+        .describe(
+          `The ${config.workingMemory?.schema ? 'JSON' : 'Markdown'} formatted working memory content to store`,
+        ),
+      searchString: z
+        .string()
+        .optional()
+        .describe(
+          "The working memory string to find. Will be replaced with the newMemory string. If this is omitted or doesn't exist, the newMemory string will be appended to the end of your working memory. Replacing single lines at a time is encouraged for greater accuracy. If updateReason is not 'append-new-memory', this search string must be provided or the tool call will be rejected.",
+        ),
+      updateReason: z
+        .enum(['append-new-memory', 'clarify-existing-memory', 'replace-irrelevant-memory'])
+        .optional()
+        .describe(
+          "The reason you're updating working memory. Passing any value other than 'append-new-memory' requires a searchString to be provided. Defaults to append-new-memory",
+        ),
+    }),
+    execute: async params => {
+      const { context, threadId, memory, resourceId } = params;
+      if (!threadId || !memory || !resourceId) {
+        throw new Error('Thread ID, Memory instance, and resourceId are required for working memory updates');
+      }
+
+      let thread = await memory.getThreadById({ threadId });
+
+      if (!thread) {
+        thread = await memory.createThread({
+          threadId,
+          resourceId,
+          memoryConfig: config,
+        });
+      }
+
+      if (thread.resourceId && thread.resourceId !== resourceId) {
+        throw new Error(`Thread with id ${threadId} resourceId does not match the current resourceId ${resourceId}`);
+      }
+
+      const workingMemory = context.newMemory || '';
+      if (!context.updateReason) context.updateReason = `append-new-memory`;
+
+      if (
+        context.searchString &&
+        config.workingMemory?.scope === `resource` &&
+        context.updateReason === `replace-irrelevant-memory`
+      ) {
+        // don't allow replacements due to something not being relevant to the current conversation
+        // if there's no searchString, then we will append.
+        context.searchString = undefined;
+      }
+
+      if (context.updateReason === `append-new-memory` && context.searchString) {
+        // do not find/replace when append-new-memory is selected
+        // some models get confused and pass a search string even when they don't want to replace it.
+        // TODO: maybe they're trying to add new info after the search string?
+        context.searchString = undefined;
+      }
+
+      if (context.updateReason !== `append-new-memory` && !context.searchString) {
+        return {
+          success: false,
+          reason: `updateReason was ${context.updateReason} but no searchString was provided. Unable to replace undefined with "${context.newMemory}"`,
+        };
+      }
+
+      // Use the new updateWorkingMemory method which handles both thread and resource scope
+      const result = await memory.__experimental_updateWorkingMemoryVNext({
         threadId,
-        resourceId: resourceId || thread.resourceId,
-        config,
+        resourceId,
+        workingMemory: workingMemory,
+        searchString: context.searchString,
+        memoryConfig: config,
       });
-    }
-
-    if (thread.resourceId && thread.resourceId !== resourceId) {
-      throw new Error(`Thread with id ${threadId} resourceId does not match the current resourceId ${resourceId}`);
-    }
-
-    const workingMemory = context.newMemory || '';
-    if (!context.updateReason) context.updateReason = `append-new-memory`;
-
-    if (
-      context.searchString &&
-      config.workingMemory?.scope === `resource` &&
-      context.updateReason === `replace-irrelevant-memory`
-    ) {
-      // don't allow replacements due to something not being relevant to the current conversation
-      // if there's no searchString, then we will append.
-      context.searchString = undefined;
-    }
-
-    if (context.updateReason === `append-new-memory` && context.searchString) {
-      // do not find/replace when append-new-memory is selected
-      // some models get confused and pass a search string even when they don't want to replace it.
-      // TODO: maybe they're trying to add new info after the search string?
-      context.searchString = undefined;
-    }
-
-    if (context.updateReason !== `append-new-memory` && !context.searchString) {
-      return {
-        success: false,
-        reason: `updateReason was ${context.updateReason} but no searchString was provided. Unable to replace undefined with "${context.newMemory}"`,
-      };
-    }
-
-    // Use the new updateWorkingMemory method which handles both thread and resource scope
-    const result = await memory.__experimental_updateWorkingMemoryVNext({
-      threadId,
-      resourceId: resourceId || thread.resourceId,
-      workingMemory: workingMemory,
-      searchString: context.searchString,
-      memoryConfig: config,
-    });
 
-    if (result) {
-      return result;
-    }
+      if (result) {
+        return result;
+      }
 
-    return { success: true };
-  },
-});
+      return { success: true };
+    },
+  });
+};