@mastra/memory 0.0.0-error-handler-fix-20251020202607 → 0.0.0-esbuild-bundle-worker-20260807182016

package/dist/index.cjs

@@ -1,893 +1,35 @@
-'use strict';
-
-var agent = require('@mastra/core/agent');
-var memory = require('@mastra/core/memory');
-var utils = require('@mastra/core/utils');
-var zodToJson = require('@mastra/schema-compat/zod-to-json');
-var ai = require('ai');
-var aiV5 = require('ai-v5');
-var asyncMutex = require('async-mutex');
-var xxhash = require('xxhash-wasm');
-var zod = require('zod');
-var tools = require('@mastra/core/tools');
-var schemaCompat = require('@mastra/schema-compat');
-
-function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
-
-var xxhash__default = /*#__PURE__*/_interopDefault(xxhash);
-
-// src/index.ts
-var updateWorkingMemoryTool = (memoryConfig) => {
-  const schema = memoryConfig?.workingMemory?.schema;
-  let inputSchema = zod.z.object({
-    memory: zod.z.string().describe(`The Markdown formatted working memory content to store. This MUST be a string. Never pass an object.`)
-  });
-  if (schema) {
-    inputSchema = zod.z.object({
-      memory: schema instanceof zod.ZodObject ? schema : schemaCompat.convertSchemaToZod({ jsonSchema: schema }).describe(
-        `The JSON formatted working memory content to store.`
-      )
-    });
-  }
-  return tools.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);
-      await memory.updateWorkingMemory({
-        threadId,
-        resourceId,
-        workingMemory,
-        memoryConfig
-      });
-      return { success: true };
-    }
-  });
-};
-var __experimental_updateWorkingMemoryToolVNext = (config) => {
-  return tools.createTool({
-    id: "update-working-memory",
-    description: "Update the working memory with new information.",
-    inputSchema: zod.z.object({
-      newMemory: zod.z.string().optional().describe(
-        `The ${config.workingMemory?.schema ? "JSON" : "Markdown"} formatted working memory content to store`
-      ),
-      searchString: zod.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: zod.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`) {
-        context.searchString = void 0;
-      }
-      if (context.updateReason === `append-new-memory` && context.searchString) {
-        context.searchString = void 0;
-      }
-      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}"`
-        };
-      }
-      const result = await memory.__experimental_updateWorkingMemoryVNext({
-        threadId,
-        resourceId,
-        workingMemory,
-        searchString: context.searchString,
-        memoryConfig: config
-      });
-      if (result) {
-        return result;
-      }
-      return { success: true };
-    }
-  });
-};
-
-// src/index.ts
-var CHARS_PER_TOKEN = 4;
-var DEFAULT_MESSAGE_RANGE = { before: 2, after: 2 };
-var DEFAULT_TOP_K = 2;
-var isZodObject = (v) => v instanceof zod.ZodObject;
-var Memory = class extends memory.MastraMemory {
-  constructor(config = {}) {
-    super({ name: "Memory", ...config });
-    const mergedConfig = this.getMergedThreadConfig({
-      workingMemory: config.options?.workingMemory || {
-        // these defaults are now set inside @mastra/core/memory in getMergedThreadConfig.
-        // In a future release we can remove it from this block - for now if we remove it
-        // and someone bumps @mastra/memory without bumping @mastra/core the defaults wouldn't exist yet
-        enabled: false,
-        template: this.defaultWorkingMemoryTemplate
-      }
-    });
-    this.threadConfig = mergedConfig;
-  }
-  async validateThreadIsOwnedByResource(threadId, resourceId, config) {
-    const resourceScope = typeof config?.semanticRecall === "object" && config?.semanticRecall?.scope === "resource";
-    const thread = await this.storage.getThreadById({ threadId });
-    if (!thread && !resourceScope) {
-      throw new Error(`No thread found with id ${threadId}`);
-    }
-    if (thread && thread.resourceId !== resourceId) {
-      throw new Error(
-        `Thread with id ${threadId} is for resource with id ${thread.resourceId} but resource ${resourceId} was queried.`
-      );
-    }
-  }
-  checkStorageFeatureSupport(config) {
-    if (typeof config.semanticRecall === `object` && config.semanticRecall.scope === `resource` && !this.storage.supports.selectByIncludeResourceScope) {
-      throw new Error(
-        `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,
-    resourceId,
-    selectBy,
-    threadConfig
-  }) {
-    const config = this.getMergedThreadConfig(threadConfig || {});
-    if (resourceId) await this.validateThreadIsOwnedByResource(threadId, resourceId, config);
-    const vectorResults = [];
-    this.logger.debug(`Memory query() with:`, {
-      threadId,
-      selectBy,
-      threadConfig
-    });
-    this.checkStorageFeatureSupport(config);
-    const defaultRange = DEFAULT_MESSAGE_RANGE;
-    const defaultTopK = DEFAULT_TOP_K;
-    const vectorConfig = typeof config?.semanticRecall === `boolean` ? {
-      topK: defaultTopK,
-      messageRange: defaultRange
-    } : {
-      topK: config?.semanticRecall?.topK ?? defaultTopK,
-      messageRange: config?.semanticRecall?.messageRange ?? defaultRange
-    };
-    const resourceScope = typeof config?.semanticRecall === "object" && config?.semanticRecall?.scope === `resource`;
-    if (config?.semanticRecall && selectBy?.vectorSearchString && this.vector) {
-      const { embeddings, dimension } = await this.embedMessageContent(selectBy.vectorSearchString);
-      const { indexName } = await this.createEmbeddingIndex(dimension, config);
-      await Promise.all(
-        embeddings.map(async (embedding) => {
-          if (typeof this.vector === `undefined`) {
-            throw new Error(
-              `Tried to query vector index ${indexName} but this Memory instance doesn't have an attached vector db.`
-            );
-          }
-          vectorResults.push(
-            ...await this.vector.query({
-              indexName,
-              queryVector: embedding,
-              topK: vectorConfig.topK,
-              filter: resourceScope ? {
-                resource_id: resourceId
-              } : {
-                thread_id: threadId
-              }
-            })
-          );
-        })
-      );
-    }
-    let rawMessages;
-    if (selectBy?.pagination) {
-      const paginatedResult = await this.storage.getMessagesPaginated({
-        threadId,
-        resourceId,
-        format: "v2",
-        selectBy: {
-          ...selectBy,
-          ...vectorResults?.length ? {
-            include: vectorResults.map((r) => ({
-              id: r.metadata?.message_id,
-              threadId: r.metadata?.thread_id,
-              withNextMessages: typeof vectorConfig.messageRange === "number" ? vectorConfig.messageRange : vectorConfig.messageRange.after,
-              withPreviousMessages: typeof vectorConfig.messageRange === "number" ? vectorConfig.messageRange : vectorConfig.messageRange.before
-            }))
-          } : {}
-        },
-        threadConfig: config
-      });
-      rawMessages = paginatedResult.messages;
-    } else {
-      rawMessages = await this.storage.getMessages({
-        threadId,
-        resourceId,
-        format: "v2",
-        selectBy: {
-          ...selectBy,
-          ...vectorResults?.length ? {
-            include: vectorResults.map((r) => ({
-              id: r.metadata?.message_id,
-              threadId: r.metadata?.thread_id,
-              withNextMessages: typeof vectorConfig.messageRange === "number" ? vectorConfig.messageRange : vectorConfig.messageRange.after,
-              withPreviousMessages: typeof vectorConfig.messageRange === "number" ? vectorConfig.messageRange : vectorConfig.messageRange.before
-            }))
-          } : {}
-        },
-        threadConfig: config
-      });
-    }
-    const list = new agent.MessageList({ threadId, resourceId }).add(rawMessages, "memory");
-    return {
-      get messages() {
-        const v1Messages = list.get.all.v1();
-        if (selectBy?.last && v1Messages.length > selectBy.last) {
-          return v1Messages.slice(v1Messages.length - selectBy.last);
-        }
-        return v1Messages;
-      },
-      get uiMessages() {
-        return list.get.all.ui();
-      },
-      get messagesV2() {
-        return list.get.all.v2();
-      }
-    };
-  }
-  async rememberMessages({
-    threadId,
-    resourceId,
-    vectorMessageSearch,
-    config
-  }) {
-    const threadConfig = this.getMergedThreadConfig(config || {});
-    if (resourceId) await this.validateThreadIsOwnedByResource(threadId, resourceId, threadConfig);
-    if (!threadConfig.lastMessages && !threadConfig.semanticRecall) {
-      return {
-        messages: [],
-        messagesV2: []
-      };
-    }
-    const messagesResult = await this.query({
-      resourceId,
-      threadId,
-      selectBy: {
-        last: threadConfig.lastMessages,
-        vectorSearchString: threadConfig.semanticRecall && vectorMessageSearch ? vectorMessageSearch : void 0
-      },
-      threadConfig: config,
-      format: "v2"
-    });
-    const list = new agent.MessageList({ threadId, resourceId }).add(messagesResult.messagesV2, "memory");
-    this.logger.debug(`Remembered message history includes ${messagesResult.messages.length} messages.`);
-    return { messages: list.get.all.v1(), messagesV2: list.get.all.v2() };
-  }
-  async getThreadById({ threadId }) {
-    return this.storage.getThreadById({ threadId });
-  }
-  async getThreadsByResourceId({
-    resourceId,
-    orderBy,
-    sortDirection
-  }) {
-    return this.storage.getThreadsByResourceId({ resourceId, orderBy, sortDirection });
-  }
-  async getThreadsByResourceIdPaginated({
-    resourceId,
-    page,
-    perPage,
-    orderBy,
-    sortDirection
-  }) {
-    return this.storage.getThreadsByResourceIdPaginated({
-      resourceId,
-      page,
-      perPage,
-      orderBy,
-      sortDirection
-    });
-  }
-  async handleWorkingMemoryFromMetadata({
-    workingMemory,
-    resourceId,
-    memoryConfig
-  }) {
-    const config = this.getMergedThreadConfig(memoryConfig || {});
-    if (config.workingMemory?.enabled) {
-      this.checkStorageFeatureSupport(config);
-      const scope = config.workingMemory.scope || "thread";
-      if (scope === "resource" && resourceId) {
-        await this.storage.updateResource({
-          resourceId,
-          workingMemory
-        });
-      }
-    }
-  }
-  async saveThread({
-    thread,
-    memoryConfig
-  }) {
-    const savedThread = await this.storage.saveThread({ thread });
-    if (thread.metadata?.workingMemory && typeof thread.metadata.workingMemory === "string" && thread.resourceId) {
-      await this.handleWorkingMemoryFromMetadata({
-        workingMemory: thread.metadata.workingMemory,
-        resourceId: thread.resourceId,
-        memoryConfig
-      });
-    }
-    return savedThread;
-  }
-  async updateThread({
-    id,
-    title,
-    metadata,
-    memoryConfig
-  }) {
-    const updatedThread = await this.storage.updateThread({
-      id,
-      title,
-      metadata
-    });
-    if (metadata?.workingMemory && typeof metadata.workingMemory === "string" && updatedThread.resourceId) {
-      await this.handleWorkingMemoryFromMetadata({
-        workingMemory: metadata.workingMemory,
-        resourceId: updatedThread.resourceId,
-        memoryConfig
-      });
-    }
-    return updatedThread;
-  }
-  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");
-    }
-    this.checkStorageFeatureSupport(config);
-    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
-        }
-      });
-    }
-  }
-  updateWorkingMemoryMutexes = /* @__PURE__ */ new Map();
-  /**
-   * @warning experimental! can be removed or changed at any time
-   */
-  async __experimental_updateWorkingMemoryVNext({
-    threadId,
-    resourceId,
-    workingMemory,
-    searchString,
-    memoryConfig
-  }) {
-    const config = this.getMergedThreadConfig(memoryConfig || {});
-    if (!config.workingMemory?.enabled) {
-      throw new Error("Working memory is not enabled for this memory instance");
-    }
-    this.checkStorageFeatureSupport(config);
-    const mutexKey = memoryConfig?.workingMemory?.scope === `resource` ? `resource-${resourceId}` : `thread-${threadId}`;
-    const mutex = this.updateWorkingMemoryMutexes.has(mutexKey) ? this.updateWorkingMemoryMutexes.get(mutexKey) : new asyncMutex.Mutex();
-    this.updateWorkingMemoryMutexes.set(mutexKey, mutex);
-    const release = await mutex.acquire();
-    try {
-      const existingWorkingMemory = await this.getWorkingMemory({ threadId, resourceId, memoryConfig }) || "";
-      const template = await this.getWorkingMemoryTemplate({ memoryConfig });
-      let reason = "";
-      if (existingWorkingMemory) {
-        if (searchString && existingWorkingMemory?.includes(searchString)) {
-          workingMemory = existingWorkingMemory.replace(searchString, workingMemory);
-          reason = `found and replaced searchString with newMemory`;
-        } else if (existingWorkingMemory.includes(workingMemory) || template?.content?.trim() === workingMemory.trim()) {
-          return {
-            success: false,
-            reason: `attempted to insert duplicate data into working memory. this entry was skipped`
-          };
-        } else {
-          if (searchString) {
-            reason = `attempted to replace working memory string that doesn't exist. Appending to working memory instead.`;
-          } else {
-            reason = `appended newMemory to end of working memory`;
-          }
-          workingMemory = existingWorkingMemory + `
-${workingMemory}`;
-        }
-      } else if (workingMemory === template?.content) {
-        return {
-          success: false,
-          reason: `try again when you have data to add. newMemory was equal to the working memory template`
-        };
-      } else {
-        reason = `started new working memory`;
-      }
-      workingMemory = template?.content ? workingMemory.replaceAll(template?.content, "") : workingMemory;
-      const scope = config.workingMemory.scope || "thread";
-      if (scope === "resource" && resourceId) {
-        await this.storage.updateResource({
-          resourceId,
-          workingMemory
-        });
-        if (reason) {
-          return { success: true, reason };
-        }
-      } 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
-          }
-        });
-      }
-      return { success: true, reason };
-    } catch (e) {
-      this.logger.error(e instanceof Error ? e.stack || e.message : JSON.stringify(e));
-      return { success: false, reason: "Tool error." };
-    } finally {
-      release();
-    }
-  }
-  chunkText(text, tokenSize = 4096) {
-    const charSize = tokenSize * CHARS_PER_TOKEN;
-    const chunks = [];
-    let currentChunk = "";
-    const words = text.split(/\s+/);
-    for (const word of words) {
-      const wordWithSpace = currentChunk ? " " + word : word;
-      if (currentChunk.length + wordWithSpace.length > charSize) {
-        chunks.push(currentChunk);
-        currentChunk = word;
-      } else {
-        currentChunk += wordWithSpace;
-      }
-    }
-    if (currentChunk) {
-      chunks.push(currentChunk);
-    }
-    return chunks;
-  }
-  hasher = xxhash__default.default();
-  // embedding is computationally expensive so cache content -> embeddings/chunks
-  embeddingCache = /* @__PURE__ */ new Map();
-  firstEmbed;
-  async embedMessageContent(content) {
-    const key = (await this.hasher).h32(content);
-    const cached = this.embeddingCache.get(key);
-    if (cached) return cached;
-    const chunks = this.chunkText(content);
-    if (typeof this.embedder === `undefined`) {
-      throw new Error(`Tried to embed message content but this Memory instance doesn't have an attached embedder.`);
-    }
-    const isFastEmbed = this.embedder.provider === `fastembed`;
-    if (isFastEmbed && this.firstEmbed instanceof Promise) {
-      await this.firstEmbed;
-    }
-    const promise = (this.embedder.specificationVersion === `v2` ? aiV5.embedMany : ai.embedMany)({
-      values: chunks,
-      maxRetries: 3,
-      // @ts-ignore
-      model: this.embedder
-    });
-    if (isFastEmbed && !this.firstEmbed) this.firstEmbed = promise;
-    const { embeddings } = await promise;
-    const result = {
-      embeddings,
-      chunks,
-      dimension: embeddings[0]?.length
-    };
-    this.embeddingCache.set(key, result);
-    return result;
-  }
-  async saveMessages({
-    messages,
-    memoryConfig,
-    format = `v1`
-  }) {
-    const updatedMessages = messages.map((m) => {
-      if (agent.MessageList.isMastraMessageV1(m)) {
-        return this.updateMessageToHideWorkingMemory(m);
-      }
-      if (!m.type) m.type = `v2`;
-      return this.updateMessageToHideWorkingMemoryV2(m);
-    }).filter((m) => Boolean(m));
-    const config = this.getMergedThreadConfig(memoryConfig);
-    const result = this.storage.saveMessages({
-      messages: new agent.MessageList().add(updatedMessages, "memory").get.all.v2(),
-      format: "v2"
-    });
-    if (this.vector && config.semanticRecall) {
-      let indexName;
-      await Promise.all(
-        updatedMessages.map(async (message) => {
-          let textForEmbedding = null;
-          if (agent.MessageList.isMastraMessageV2(message)) {
-            if (message.content.content && typeof message.content.content === "string" && message.content.content.trim() !== "") {
-              textForEmbedding = message.content.content;
-            } else if (message.content.parts && message.content.parts.length > 0) {
-              const joined = message.content.parts.filter((part) => part.type === "text").map((part) => part.text).join(" ").trim();
-              if (joined) textForEmbedding = joined;
-            }
-          } else if (agent.MessageList.isMastraMessageV1(message)) {
-            if (message.content && typeof message.content === "string" && message.content.trim() !== "") {
-              textForEmbedding = message.content;
-            } else if (message.content && Array.isArray(message.content) && message.content.length > 0) {
-              const joined = message.content.filter((part) => part.type === "text").map((part) => part.text).join(" ").trim();
-              if (joined) textForEmbedding = joined;
-            }
-          }
-          if (!textForEmbedding) return;
-          const { embeddings, chunks, dimension } = await this.embedMessageContent(textForEmbedding);
-          if (typeof indexName === `undefined`) {
-            indexName = this.createEmbeddingIndex(dimension, config).then((result2) => result2.indexName);
-          }
-          if (typeof this.vector === `undefined`) {
-            throw new Error(
-              `Tried to upsert embeddings to index ${indexName} but this Memory instance doesn't have an attached vector db.`
-            );
-          }
-          await this.vector.upsert({
-            indexName: await indexName,
-            vectors: embeddings,
-            metadata: chunks.map(() => ({
-              message_id: message.id,
-              thread_id: message.threadId,
-              resource_id: message.resourceId
-            }))
-          });
-        })
-      );
-    }
-    if (format === `v1`) return new agent.MessageList().add(await result, "memory").get.all.v1();
-    return result;
-  }
-  updateMessageToHideWorkingMemory(message) {
-    const workingMemoryRegex = /<working_memory>([^]*?)<\/working_memory>/g;
-    if (typeof message?.content === `string`) {
-      return {
-        ...message,
-        content: message.content.replace(workingMemoryRegex, ``).trim()
-      };
-    } else if (Array.isArray(message?.content)) {
-      const filteredContent = message.content.filter(
-        (content) => content.type !== "tool-call" && content.type !== "tool-result" || content.toolName !== "updateWorkingMemory"
-      );
-      const newContent = filteredContent.map((content) => {
-        if (content.type === "text") {
-          return {
-            ...content,
-            text: content.text.replace(workingMemoryRegex, "").trim()
-          };
-        }
-        return { ...content };
-      });
-      if (!newContent.length) return null;
-      return { ...message, content: newContent };
-    } else {
-      return { ...message };
-    }
-  }
-  updateMessageToHideWorkingMemoryV2(message) {
-    const workingMemoryRegex = /<working_memory>([^]*?)<\/working_memory>/g;
-    const newMessage = { ...message, content: { ...message.content } };
-    if (newMessage.content.content && typeof newMessage.content.content === "string") {
-      newMessage.content.content = newMessage.content.content.replace(workingMemoryRegex, "").trim();
-    }
-    if (newMessage.content.parts) {
-      newMessage.content.parts = newMessage.content.parts.filter((part) => {
-        if (part.type === "tool-invocation") {
-          return part.toolInvocation.toolName !== "updateWorkingMemory";
-        }
-        return true;
-      }).map((part) => {
-        if (part.type === "text") {
-          return {
-            ...part,
-            text: part.text.replace(workingMemoryRegex, "").trim()
-          };
-        }
-        return part;
-      });
-      if (newMessage.content.parts.length === 0) {
-        return null;
-      }
-    }
-    return newMessage;
-  }
-  parseWorkingMemory(text) {
-    if (!this.threadConfig.workingMemory?.enabled) return null;
-    const workingMemoryRegex = /<working_memory>([^]*?)<\/working_memory>/g;
-    const matches = text.match(workingMemoryRegex);
-    const match = matches?.[0];
-    if (match) {
-      return match.replace(/<\/?working_memory>/g, "").trim();
-    }
-    return null;
-  }
-  async getWorkingMemory({
-    threadId,
-    resourceId,
-    memoryConfig
-  }) {
-    const config = this.getMergedThreadConfig(memoryConfig || {});
-    if (!config.workingMemory?.enabled) {
-      return null;
-    }
-    this.checkStorageFeatureSupport(config);
-    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;
-    }
-    if (!workingMemoryData) {
-      return null;
-    }
-    return workingMemoryData;
-  }
-  /**
-   * Gets the working memory template for the current memory configuration.
-   * Supports both ZodObject and JSONSchema7 schemas.
-   *
-   * @param memoryConfig - The memory configuration containing the working memory settings
-   * @returns The working memory template with format and content, or null if working memory is disabled
-   */
-  async getWorkingMemoryTemplate({
-    memoryConfig
-  }) {
-    const config = this.getMergedThreadConfig(memoryConfig || {});
-    if (!config.workingMemory?.enabled) {
-      return null;
-    }
-    if (config.workingMemory?.schema) {
-      try {
-        const schema = config.workingMemory.schema;
-        let convertedSchema;
-        if (isZodObject(schema)) {
-          convertedSchema = zodToJson.zodToJsonSchema(schema);
-        } else {
-          convertedSchema = schema;
-        }
-        return { format: "json", content: JSON.stringify(convertedSchema) };
-      } catch (error) {
-        this.logger.error("Error converting schema", error);
-        throw error;
-      }
-    }
-    const memory = config.workingMemory.template || this.defaultWorkingMemoryTemplate;
-    return { format: "markdown", content: memory.trim() };
-  }
-  async getSystemMessage({
-    threadId,
-    resourceId,
-    memoryConfig
-  }) {
-    const config = this.getMergedThreadConfig(memoryConfig);
-    if (!config.workingMemory?.enabled) {
-      return null;
-    }
-    const workingMemoryTemplate = await this.getWorkingMemoryTemplate({ memoryConfig: config });
-    const workingMemoryData = await this.getWorkingMemory({ threadId, resourceId, memoryConfig: config });
-    if (!workingMemoryTemplate) {
-      return null;
-    }
-    return this.isVNextWorkingMemoryConfig(memoryConfig) ? this.__experimental_getWorkingMemoryToolInstructionVNext({
-      template: workingMemoryTemplate,
-      data: workingMemoryData
-    }) : this.getWorkingMemoryToolInstruction({
-      template: workingMemoryTemplate,
-      data: workingMemoryData
-    });
-  }
-  defaultWorkingMemoryTemplate = `
-# User Information
-- **First Name**: 
-- **Last Name**: 
-- **Location**: 
-- **Occupation**: 
-- **Interests**: 
-- **Goals**: 
-- **Events**: 
-- **Facts**: 
-- **Projects**: 
-`;
-  getWorkingMemoryToolInstruction({
-    template,
-    data
-  }) {
-    const emptyWorkingMemoryTemplateObject = template.format === "json" ? utils.generateEmptyFromSchema(template.content) : null;
-    const hasEmptyWorkingMemoryTemplateObject = emptyWorkingMemoryTemplateObject && Object.keys(emptyWorkingMemoryTemplateObject).length > 0;
-    return `WORKING_MEMORY_SYSTEM_INSTRUCTION:
-Store and update any conversation-relevant information by calling the updateWorkingMemory tool. If information might be referenced again - store it!
-
-Guidelines:
-1. Store anything that could be useful later in the conversation
-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"
-${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.` : ""}
-
-
-${template.format !== "json" ? `<working_memory_template>
-${template.content}
-</working_memory_template>` : ""}
-
-${hasEmptyWorkingMemoryTemplateObject ? "When working with json data, the object format below represents the template:" : ""}
-${hasEmptyWorkingMemoryTemplateObject ? JSON.stringify(emptyWorkingMemoryTemplateObject) : ""}
-
-<working_memory_data>
-${data}
-</working_memory_data>
-
-Notes:
-- Update memory whenever referenced information changes
-- If you're unsure whether to store something, store it (eg if the user tells you information about themselves, call updateWorkingMemory immediately to update it)
-- This system is here so that you can maintain the conversation when your context window is very short. Update your working memory because you may need it to maintain the conversation without the full conversation history
-- Do not remove empty sections - you must include the empty sections along with the ones you're filling in
-- REMEMBER: the way you update your working memory is by calling the updateWorkingMemory tool with the entire ${template.format === "json" ? "JSON" : "Markdown"} content. The system will store it for you. The user will not see it.
-- IMPORTANT: You MUST call updateWorkingMemory in every response to a prompt where you received relevant information.
-- IMPORTANT: Preserve the ${template.format === "json" ? "JSON" : "Markdown"} formatting structure above while updating the content.`;
-  }
-  __experimental_getWorkingMemoryToolInstructionVNext({
-    template,
-    data
-  }) {
-    return `WORKING_MEMORY_SYSTEM_INSTRUCTION:
-Store and update any conversation-relevant information by calling the updateWorkingMemory tool.
-
-Guidelines:
-1. Store anything that could be useful later in the conversation
-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. If your memory has not changed, you do not need to call the updateWorkingMemory tool. By default it will persist and be available for you in future interactions
-6. Information not being relevant to the current conversation is not a valid reason to replace or remove working memory information. Your working memory spans across multiple conversations and may be needed again later, even if it's not currently relevant.
-
-<working_memory_template>
-${template.content}
-</working_memory_template>
-
-<working_memory_data>
-${data}
-</working_memory_data>
-
-Notes:
-- Update memory whenever referenced information changes
-${template.content !== this.defaultWorkingMemoryTemplate ? `- Only store information if it's in the working memory template, do not store other information unless the user asks you to remember it, as that non-template information may be irrelevant` : `- If you're unsure whether to store something, store it (eg if the user tells you information about themselves, call updateWorkingMemory immediately to update it)
-`}
-- This system is here so that you can maintain the conversation when your context window is very short. Update your working memory because you may need it to maintain the conversation without the full conversation history
-- REMEMBER: the way you update your working memory is by calling the updateWorkingMemory tool with the ${template.format === "json" ? "JSON" : "Markdown"} content. The system will store it for you. The user will not see it. 
-- IMPORTANT: You MUST call updateWorkingMemory in every response to a prompt where you received relevant information if that information is not already stored.
-- IMPORTANT: Preserve the ${template.format === "json" ? "JSON" : "Markdown"} formatting structure above while updating the content.
-`;
-  }
-  isVNextWorkingMemoryConfig(config) {
-    if (!config?.workingMemory) return false;
-    const isMDWorkingMemory = !(`schema` in config.workingMemory) && (typeof config.workingMemory.template === `string` || config.workingMemory.template) && config.workingMemory;
-    return Boolean(isMDWorkingMemory && isMDWorkingMemory.version === `vnext`);
-  }
-  getTools(config) {
-    const mergedConfig = this.getMergedThreadConfig(config);
-    if (mergedConfig.workingMemory?.enabled) {
-      return {
-        updateWorkingMemory: this.isVNextWorkingMemoryConfig(mergedConfig) ? (
-          // use the new experimental tool
-          __experimental_updateWorkingMemoryToolVNext(mergedConfig)
-        ) : updateWorkingMemoryTool(mergedConfig)
-      };
-    }
-    return {};
-  }
-  /**
-   * Updates the metadata of a list of messages
-   * @param messages - The list of messages to update
-   * @returns The list of updated messages
-   */
-  async updateMessages({
-    messages
-  }) {
-    if (messages.length === 0) return [];
-    return this.storage.updateMessages({ messages });
-  }
-  /**
-   * Deletes one or more messages
-   * @param input - Must be an array containing either:
-   *   - Message ID strings
-   *   - Message objects with 'id' properties
-   * @returns Promise that resolves when all messages are deleted
-   */
-  async deleteMessages(input) {
-    let messageIds;
-    if (!Array.isArray(input)) {
-      throw new Error("Invalid input: must be an array of message IDs or message objects");
-    }
-    if (input.length === 0) {
-      return;
-    }
-    messageIds = input.map((item) => {
-      if (typeof item === "string") {
-        return item;
-      } else if (item && typeof item === "object" && "id" in item) {
-        return item.id;
-      } else {
-        throw new Error("Invalid input: array items must be strings or objects with an id property");
-      }
-    });
-    const invalidIds = messageIds.filter((id) => !id || typeof id !== "string");
-    if (invalidIds.length > 0) {
-      throw new Error("All message IDs must be non-empty strings");
-    }
-    await this.storage.deleteMessages(messageIds);
-  }
-};
-
-exports.Memory = Memory;
-//# sourceMappingURL=index.cjs.map
-//# sourceMappingURL=index.cjs.map
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_src = require("./src-DqoifKIy.cjs");
+let _mastra_core_processors = require("@mastra/core/processors");
+exports.Extractor = require_src.Extractor;
+exports.Memory = require_src.Memory;
+Object.defineProperty(exports, "MessageHistory", {
+	enumerable: true,
+	get: function() {
+		return _mastra_core_processors.MessageHistory;
+	}
+});
+exports.ModelByInputTokens = require_src.ModelByInputTokens;
+exports.SUMMARIZE_THREAD_DEFAULTS = require_src.SUMMARIZE_THREAD_DEFAULTS;
+Object.defineProperty(exports, "SemanticRecall", {
+	enumerable: true,
+	get: function() {
+		return _mastra_core_processors.SemanticRecall;
+	}
+});
+exports.WORKING_MEMORY_STATE_ID = require_src.WORKING_MEMORY_STATE_ID;
+exports.WORKING_MEMORY_STATE_PROCESSOR_ID = require_src.WORKING_MEMORY_STATE_PROCESSOR_ID;
+Object.defineProperty(exports, "WorkingMemory", {
+	enumerable: true,
+	get: function() {
+		return _mastra_core_processors.WorkingMemory;
+	}
+});
+exports.WorkingMemoryExtractor = require_src.WorkingMemoryExtractor;
+exports.WorkingMemoryStateProcessor = require_src.WorkingMemoryStateProcessor;
+exports.deepMergeWorkingMemory = require_src.deepMergeWorkingMemory;
+exports.extractWorkingMemoryContent = require_src.extractWorkingMemoryContent;
+exports.extractWorkingMemoryTags = require_src.extractWorkingMemoryTags;
+exports.getObservationsAsOf = require_src.getObservationsAsOf;
+exports.removeWorkingMemoryTags = require_src.removeWorkingMemoryTags;
+exports.summarizeConversation = require_src.summarizeConversation;