@mastra/memory 1.0.0-beta.8 → 1.0.0

package/dist/index.js

@@ -15,7 +15,7 @@ import { createTool } from '@mastra/core/tools';
 import { convertSchemaToZod } from '@mastra/schema-compat';
 export { MessageHistory, SemanticRecall, WorkingMemory } from '@mastra/core/processors';
 
-// ../_vendored/ai_v4/dist/chunk-IHGBB4AL.js
+// ../_vendored/ai_v4/dist/chunk-OPIPXJLE.js
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -377,7 +377,7 @@ function getErrorMessage2(error) {
 function isAbortError(error) {
   return error instanceof Error && (error.name === "AbortError" || error.name === "TimeoutError");
 }
-var validatorSymbol = Symbol.for("vercel.ai.validator");
+var validatorSymbol = /* @__PURE__ */ Symbol.for("vercel.ai.validator");
 function validator(validate) {
   return { [validatorSymbol]: true, validate };
 }
@@ -435,7 +435,7 @@ function safeParseJSON({
     };
   }
 }
-var ignoreOverride = Symbol("Let zodToJsonSchema decide on which parser to use");
+var ignoreOverride = /* @__PURE__ */ Symbol("Let zodToJsonSchema decide on which parser to use");
 var defaultOptions = {
   name: void 0,
   $refStrategy: "root",
@@ -2243,7 +2243,7 @@ function zodSchema(zodSchema22, options) {
     }
   );
 }
-var schemaSymbol = Symbol.for("vercel.ai.schema");
+var schemaSymbol = /* @__PURE__ */ Symbol.for("vercel.ai.schema");
 function jsonSchema(jsonSchema22, {
   validate
 } = {}) {
@@ -2330,7 +2330,7 @@ function _makeCompatibilityCheck(ownVersion) {
 }
 var isCompatible = _makeCompatibilityCheck(VERSION);
 var major = VERSION.split(".")[0];
-var GLOBAL_OPENTELEMETRY_API_KEY = Symbol.for("opentelemetry.js.api." + major);
+var GLOBAL_OPENTELEMETRY_API_KEY = /* @__PURE__ */ Symbol.for("opentelemetry.js.api." + major);
 var _global = _globalThis;
 function registerGlobal(type, instance, diag, allowOverride) {
   var _a172;
@@ -4693,7 +4693,7 @@ function secureJsonParse(text4) {
     Error.stackTraceLimit = stackTraceLimit;
   }
 }
-var validatorSymbol2 = Symbol.for("vercel.ai.validator");
+var validatorSymbol2 = /* @__PURE__ */ Symbol.for("vercel.ai.validator");
 function validator2(validate) {
   return { [validatorSymbol2]: true, validate };
 }
@@ -5007,7 +5007,7 @@ var getRelativePath2 = (pathA, pathB) => {
   }
   return [(pathA.length - i).toString(), ...pathB.slice(i)].join("/");
 };
-var ignoreOverride2 = Symbol(
+var ignoreOverride2 = /* @__PURE__ */ Symbol(
   "Let zodToJsonSchema decide on which parser to use"
 );
 var defaultOptions2 = {
@@ -6127,7 +6127,7 @@ function zodSchema2(zodSchema22, options) {
     return zod3Schema(zodSchema22);
   }
 }
-var schemaSymbol2 = Symbol.for("vercel.ai.schema");
+var schemaSymbol2 = /* @__PURE__ */ Symbol.for("vercel.ai.schema");
 function jsonSchema2(jsonSchema22, {
   validate
 } = {}) {
@@ -6182,7 +6182,7 @@ var require_get_context = __commonJS({
       getContext: () => getContext3
     });
     module.exports = __toCommonJS(get_context_exports);
-    var SYMBOL_FOR_REQ_CONTEXT = Symbol.for("@vercel/request-context");
+    var SYMBOL_FOR_REQ_CONTEXT = /* @__PURE__ */ Symbol.for("@vercel/request-context");
     function getContext3() {
       const fromSymbol = globalThis;
       return fromSymbol[SYMBOL_FOR_REQ_CONTEXT]?.get?.() ?? {};
@@ -7211,7 +7211,7 @@ function _makeCompatibilityCheck2(ownVersion) {
 }
 var isCompatible2 = _makeCompatibilityCheck2(VERSION22);
 var major2 = VERSION22.split(".")[0];
-var GLOBAL_OPENTELEMETRY_API_KEY2 = Symbol.for("opentelemetry.js.api." + major2);
+var GLOBAL_OPENTELEMETRY_API_KEY2 = /* @__PURE__ */ Symbol.for("opentelemetry.js.api." + major2);
 var _global2 = _globalThis2;
 function registerGlobal2(type, instance, diag, allowOverride) {
   var _a162;
@@ -9657,7 +9657,7 @@ function addAdditionalPropertiesToJsonSchema(jsonSchema22) {
   }
   return jsonSchema22;
 }
-var ignoreOverride3 = Symbol(
+var ignoreOverride3 = /* @__PURE__ */ Symbol(
   "Let zodToJsonSchema decide on which parser to use"
 );
 var defaultOptions3 = {
@@ -10739,7 +10739,7 @@ var zod3ToJsonSchema = (schema, options) => {
   combined.$schema = "http://json-schema.org/draft-07/schema#";
   return combined;
 };
-var schemaSymbol3 = Symbol.for("vercel.ai.schema");
+var schemaSymbol3 = /* @__PURE__ */ Symbol.for("vercel.ai.schema");
 function lazySchema(createSchema) {
   let schema;
   return () => {
@@ -11140,7 +11140,7 @@ var require_get_context2 = __commonJS$1({
       getContext: () => getContext3
     });
     module.exports = __toCommonJS(get_context_exports);
-    var SYMBOL_FOR_REQ_CONTEXT = Symbol.for("@vercel/request-context");
+    var SYMBOL_FOR_REQ_CONTEXT = /* @__PURE__ */ Symbol.for("@vercel/request-context");
     function getContext3() {
       const fromSymbol = globalThis;
       return fromSymbol[SYMBOL_FOR_REQ_CONTEXT]?.get?.() ?? {};
@@ -12173,7 +12173,7 @@ function _makeCompatibilityCheck3(ownVersion) {
 }
 var isCompatible3 = _makeCompatibilityCheck3(VERSION23);
 var major3 = VERSION23.split(".")[0];
-var GLOBAL_OPENTELEMETRY_API_KEY3 = Symbol.for("opentelemetry.js.api." + major3);
+var GLOBAL_OPENTELEMETRY_API_KEY3 = /* @__PURE__ */ Symbol.for("opentelemetry.js.api." + major3);
 var _global3 = _globalThis3;
 function registerGlobal3(type, instance, diag, allowOverride) {
   var _a146;
@@ -14408,6 +14408,9 @@ var DefaultEmbedManyResult3 = class {
 createIdGenerator3({ prefix: "aiobj", size: 24 });
 createIdGenerator3({ prefix: "aiobj", size: 24 });
 function deepMergeWorkingMemory(existing, update) {
+  if (!update || typeof update !== "object" || Object.keys(update).length === 0) {
+    return existing && typeof existing === "object" ? { ...existing } : {};
+  }
   if (!existing || typeof existing !== "object") {
     return update;
   }
@@ -14481,6 +14484,9 @@ var updateWorkingMemoryTool = (memoryConfig) => {
             existingData = null;
           }
         }
+        if (inputData.memory === void 0 || inputData.memory === null) {
+          return { success: true, message: "No memory data provided, existing memory unchanged." };
+        }
         let newData;
         if (typeof inputData.memory === "string") {
           try {
@@ -14693,9 +14699,9 @@ var Memory = class extends MastraMemory {
     const memoryStore = await this.getMemoryStore();
     return memoryStore.getThreadById({ threadId });
   }
-  async listThreadsByResourceId(args) {
+  async listThreads(args) {
     const memoryStore = await this.getMemoryStore();
-    return memoryStore.listThreadsByResourceId(args);
+    return memoryStore.listThreads(args);
   }
   async handleWorkingMemoryFromMetadata({
     workingMemory,
@@ -15223,15 +15229,102 @@ ${template.content !== this.defaultWorkingMemoryTemplate ? `- Only store informa
     return {};
   }
   /**
-   * Updates the metadata of a list of messages
-   * @param messages - The list of messages to update
+   * Updates a list of messages and syncs the vector database for semantic recall.
+   * When message content is updated, the corresponding vector embeddings are also updated
+   * to ensure semantic recall stays in sync with the message content.
+   *
+   * @param messages - The list of messages to update (must include id, can include partial content)
+   * @param memoryConfig - Optional memory configuration to determine if semantic recall is enabled
    * @returns The list of updated messages
    */
   async updateMessages({
-    messages
+    messages,
+    memoryConfig
   }) {
     if (messages.length === 0) return [];
     const memoryStore = await this.getMemoryStore();
+    const config = this.getMergedThreadConfig(memoryConfig);
+    if (this.vector && config.semanticRecall) {
+      const messagesWithContent = messages.filter((m) => m.content !== void 0);
+      if (messagesWithContent.length > 0) {
+        const existingMessagesResult = await memoryStore.listMessagesById({
+          messageIds: messagesWithContent.map((m) => m.id)
+        });
+        const existingMessagesMap = new Map(existingMessagesResult.messages.map((m) => [m.id, m]));
+        const embeddingData = [];
+        let dimension;
+        const messageIdsWithNewEmbeddings = /* @__PURE__ */ new Set();
+        const messageIdsWithClearedContent = /* @__PURE__ */ new Set();
+        await Promise.all(
+          messagesWithContent.map(async (message) => {
+            const existingMessage = existingMessagesMap.get(message.id);
+            if (!existingMessage) return;
+            let textForEmbedding = null;
+            const content = message.content;
+            if (content) {
+              if ("content" in content && content.content && typeof content.content === "string" && content.content.trim() !== "") {
+                textForEmbedding = content.content;
+              } else if ("parts" in content && content.parts && Array.isArray(content.parts) && content.parts.length > 0) {
+                const joined = content.parts.filter((part) => part?.type === "text").map((part) => part.text).join(" ").trim();
+                if (joined) textForEmbedding = joined;
+              }
+            }
+            if (textForEmbedding) {
+              const result = await this.embedMessageContent(textForEmbedding);
+              dimension = result.dimension;
+              embeddingData.push({
+                embeddings: result.embeddings,
+                metadata: result.chunks.map(() => ({
+                  message_id: message.id,
+                  thread_id: existingMessage.threadId,
+                  resource_id: existingMessage.resourceId
+                }))
+              });
+              messageIdsWithNewEmbeddings.add(message.id);
+            } else {
+              messageIdsWithClearedContent.add(message.id);
+            }
+          })
+        );
+        const messageIdsNeedingDeletion = /* @__PURE__ */ new Set([...messageIdsWithClearedContent, ...messageIdsWithNewEmbeddings]);
+        if (messageIdsNeedingDeletion.size > 0) {
+          try {
+            const indexes = await this.vector.listIndexes();
+            const memoryIndexes = indexes.filter((name21) => name21.startsWith("memory_messages"));
+            for (const indexName of memoryIndexes) {
+              for (const messageId of messageIdsNeedingDeletion) {
+                try {
+                  await this.vector.deleteVectors({
+                    indexName,
+                    filter: { message_id: messageId }
+                  });
+                } catch {
+                  this.logger.debug(
+                    `No existing vectors found for message ${messageId} in ${indexName}, skipping delete`
+                  );
+                }
+              }
+            }
+          } catch {
+            this.logger.debug(`No memory indexes found to delete from`);
+          }
+        }
+        if (embeddingData.length > 0 && dimension !== void 0) {
+          const { indexName } = await this.createEmbeddingIndex(dimension, config);
+          const allVectors = [];
+          const allMetadata = [];
+          for (const data of embeddingData) {
+            allVectors.push(...data.embeddings);
+            allMetadata.push(...data.metadata);
+          }
+          await this.vector.upsert({
+            indexName,
+            vectors: allVectors,
+            metadata: allMetadata
+          });
+        }
+      }
+    }
     return memoryStore.updateMessages({ messages });
   }
   /**
@@ -15265,6 +15358,233 @@ ${template.content !== this.defaultWorkingMemoryTemplate ? `- Only store informa
     const memoryStore = await this.getMemoryStore();
     await memoryStore.deleteMessages(messageIds);
   }
+  /**
+   * Clone a thread and its messages to create a new independent thread.
+   * The cloned thread will have metadata tracking its source.
+   *
+   * If semantic recall is enabled, the cloned messages will also be embedded
+   * and added to the vector store for semantic search.
+   *
+   * @param args - Clone configuration options
+   * @param args.sourceThreadId - ID of the thread to clone
+   * @param args.newThreadId - ID for the new cloned thread (if not provided, a random UUID will be generated)
+   * @param args.resourceId - Resource ID for the new thread (defaults to source thread's resourceId)
+   * @param args.title - Title for the new cloned thread
+   * @param args.metadata - Additional metadata to merge with clone metadata
+   * @param args.options - Options for filtering which messages to include
+   * @param args.options.messageLimit - Maximum number of messages to copy (from most recent)
+   * @param args.options.messageFilter - Filter messages by date range or specific IDs
+   * @param memoryConfig - Optional memory configuration override
+   * @returns The newly created thread and the cloned messages
+   *
+   * @example
+   * ```typescript
+   * // Clone entire thread
+   * const { thread, clonedMessages } = await memory.cloneThread({
+   *   sourceThreadId: 'thread-123',
+   * });
+   *
+   * // Clone with custom ID
+   * const { thread, clonedMessages } = await memory.cloneThread({
+   *   sourceThreadId: 'thread-123',
+   *   newThreadId: 'my-custom-thread-id',
+   * });
+   *
+   * // Clone with message limit
+   * const { thread, clonedMessages } = await memory.cloneThread({
+   *   sourceThreadId: 'thread-123',
+   *   title: 'My cloned conversation',
+   *   options: {
+   *     messageLimit: 10, // Only clone last 10 messages
+   *   },
+   * });
+   *
+   * // Clone with date filter
+   * const { thread, clonedMessages } = await memory.cloneThread({
+   *   sourceThreadId: 'thread-123',
+   *   options: {
+   *     messageFilter: {
+   *       startDate: new Date('2024-01-01'),
+   *       endDate: new Date('2024-06-01'),
+   *     },
+   *   },
+   * });
+   * ```
+   */
+  async cloneThread(args, memoryConfig) {
+    const memoryStore = await this.getMemoryStore();
+    const result = await memoryStore.cloneThread(args);
+    const config = this.getMergedThreadConfig(memoryConfig);
+    if (this.vector && config.semanticRecall && result.clonedMessages.length > 0) {
+      await this.embedClonedMessages(result.clonedMessages, config);
+    }
+    return result;
+  }
+  /**
+   * Embed cloned messages for semantic recall.
+   * This is similar to the embedding logic in saveMessages but operates on already-saved messages.
+   */
+  async embedClonedMessages(messages, config) {
+    if (!this.vector || !this.embedder) {
+      return;
+    }
+    const embeddingData = [];
+    let dimension;
+    await Promise.all(
+      messages.map(async (message) => {
+        let textForEmbedding = null;
+        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;
+        }
+        if (!textForEmbedding) return;
+        const result = await this.embedMessageContent(textForEmbedding);
+        dimension = result.dimension;
+        embeddingData.push({
+          embeddings: result.embeddings,
+          metadata: result.chunks.map(() => ({
+            message_id: message.id,
+            thread_id: message.threadId,
+            resource_id: message.resourceId
+          }))
+        });
+      })
+    );
+    if (embeddingData.length > 0 && dimension !== void 0) {
+      const { indexName } = await this.createEmbeddingIndex(dimension, config);
+      const allVectors = [];
+      const allMetadata = [];
+      for (const data of embeddingData) {
+        allVectors.push(...data.embeddings);
+        allMetadata.push(...data.metadata);
+      }
+      await this.vector.upsert({
+        indexName,
+        vectors: allVectors,
+        metadata: allMetadata
+      });
+    }
+  }
+  /**
+   * Get the clone metadata from a thread if it was cloned from another thread.
+   *
+   * @param thread - The thread to check
+   * @returns The clone metadata if the thread is a clone, null otherwise
+   *
+   * @example
+   * ```typescript
+   * const thread = await memory.getThreadById({ threadId: 'thread-123' });
+   * const cloneInfo = memory.getCloneMetadata(thread);
+   * if (cloneInfo) {
+   *   console.log(`This thread was cloned from ${cloneInfo.sourceThreadId}`);
+   * }
+   * ```
+   */
+  getCloneMetadata(thread) {
+    if (!thread?.metadata?.clone) {
+      return null;
+    }
+    return thread.metadata.clone;
+  }
+  /**
+   * Check if a thread is a clone of another thread.
+   *
+   * @param thread - The thread to check
+   * @returns True if the thread is a clone, false otherwise
+   *
+   * @example
+   * ```typescript
+   * const thread = await memory.getThreadById({ threadId: 'thread-123' });
+   * if (memory.isClone(thread)) {
+   *   console.log('This is a cloned thread');
+   * }
+   * ```
+   */
+  isClone(thread) {
+    return this.getCloneMetadata(thread) !== null;
+  }
+  /**
+   * Get the source thread that a cloned thread was created from.
+   *
+   * @param threadId - ID of the cloned thread
+   * @returns The source thread if found, null if the thread is not a clone or source doesn't exist
+   *
+   * @example
+   * ```typescript
+   * const sourceThread = await memory.getSourceThread('cloned-thread-123');
+   * if (sourceThread) {
+   *   console.log(`Original thread: ${sourceThread.title}`);
+   * }
+   * ```
+   */
+  async getSourceThread(threadId) {
+    const thread = await this.getThreadById({ threadId });
+    const cloneMetadata = this.getCloneMetadata(thread);
+    if (!cloneMetadata) {
+      return null;
+    }
+    return this.getThreadById({ threadId: cloneMetadata.sourceThreadId });
+  }
+  /**
+   * List all threads that were cloned from a specific source thread.
+   *
+   * @param sourceThreadId - ID of the source thread
+   * @param resourceId - Optional resource ID to filter by
+   * @returns Array of threads that are clones of the source thread
+   *
+   * @example
+   * ```typescript
+   * const clones = await memory.listClones('original-thread-123', 'user-456');
+   * console.log(`Found ${clones.length} clones of this thread`);
+   * ```
+   */
+  async listClones(sourceThreadId, resourceId) {
+    let targetResourceId = resourceId;
+    if (!targetResourceId) {
+      const sourceThread = await this.getThreadById({ threadId: sourceThreadId });
+      if (!sourceThread) {
+        return [];
+      }
+      targetResourceId = sourceThread.resourceId;
+    }
+    const { threads } = await this.listThreads({
+      filter: { resourceId: targetResourceId },
+      perPage: false
+      // Get all threads
+    });
+    return threads.filter((thread) => {
+      const cloneMetadata = this.getCloneMetadata(thread);
+      return cloneMetadata?.sourceThreadId === sourceThreadId;
+    });
+  }
+  /**
+   * Get the clone history chain for a thread (all ancestors back to the original).
+   *
+   * @param threadId - ID of the thread to get history for
+   * @returns Array of threads from oldest ancestor to the given thread (inclusive)
+   *
+   * @example
+   * ```typescript
+   * const history = await memory.getCloneHistory('deeply-cloned-thread');
+   * // Returns: [originalThread, firstClone, secondClone, deeplyClonedThread]
+   * ```
+   */
+  async getCloneHistory(threadId) {
+    const history = [];
+    let currentThreadId = threadId;
+    while (currentThreadId) {
+      const thread = await this.getThreadById({ threadId: currentThreadId });
+      if (!thread) {
+        break;
+      }
+      history.unshift(thread);
+      const cloneMetadata = this.getCloneMetadata(thread);
+      currentThreadId = cloneMetadata?.sourceThreadId ?? null;
+    }
+    return history;
+  }
 };
 
 export { Memory, deepMergeWorkingMemory };