@mastra/upstash 0.0.0-working-memory-per-user-20250620163010 → 0.0.0-zod-v4-compat-part-2-20250822105954

package/dist/index.cjs

@@ -1,158 +1,51 @@
 'use strict';
 
-var agent = require('@mastra/core/agent');
 var storage = require('@mastra/core/storage');
 var redis = require('@upstash/redis');
+var error = require('@mastra/core/error');
+var agent = require('@mastra/core/agent');
 var vector = require('@mastra/core/vector');
 var vector$1 = require('@upstash/vector');
 var filter = require('@mastra/core/vector/filter');
 
 // src/storage/index.ts
-var UpstashStore = class extends storage.MastraStorage {
-  redis;
-  constructor(config) {
-    super({ name: "Upstash" });
-    this.redis = new redis.Redis({
-      url: config.url,
-      token: config.token
-    });
-  }
-  get supports() {
-    return {
-      selectByIncludeResourceScope: true,
-      resourceWorkingMemory: true
-    };
-  }
-  transformEvalRecord(record) {
-    let result = record.result;
-    if (typeof result === "string") {
-      try {
-        result = JSON.parse(result);
-      } catch {
-        console.warn("Failed to parse result JSON:");
-      }
-    }
-    let testInfo = record.test_info;
-    if (typeof testInfo === "string") {
-      try {
-        testInfo = JSON.parse(testInfo);
-      } catch {
-        console.warn("Failed to parse test_info JSON:");
-      }
-    }
-    return {
-      agentName: record.agent_name,
-      input: record.input,
-      output: record.output,
-      result,
-      metricName: record.metric_name,
-      instructions: record.instructions,
-      testInfo,
-      globalRunId: record.global_run_id,
-      runId: record.run_id,
-      createdAt: typeof record.created_at === "string" ? record.created_at : record.created_at instanceof Date ? record.created_at.toISOString() : (/* @__PURE__ */ new Date()).toISOString()
-    };
-  }
-  parseJSON(value) {
-    if (typeof value === "string") {
-      try {
-        return JSON.parse(value);
-      } catch {
-        return value;
-      }
+function transformEvalRecord(record) {
+  let result = record.result;
+  if (typeof result === "string") {
+    try {
+      result = JSON.parse(result);
+    } catch {
+      console.warn("Failed to parse result JSON:");
     }
-    return value;
-  }
-  getKey(tableName, keys) {
-    const keyParts = Object.entries(keys).filter(([_, value]) => value !== void 0).map(([key, value]) => `${key}:${value}`);
-    return `${tableName}:${keyParts.join(":")}`;
-  }
-  /**
-   * Scans for keys matching the given pattern using SCAN and returns them as an array.
-   * @param pattern Redis key pattern, e.g. "table:*"
-   * @param batchSize Number of keys to scan per batch (default: 1000)
-   */
-  async scanKeys(pattern, batchSize = 1e4) {
-    let cursor = "0";
-    let keys = [];
-    do {
-      const [nextCursor, batch] = await this.redis.scan(cursor, {
-        match: pattern,
-        count: batchSize
-      });
-      keys.push(...batch);
-      cursor = nextCursor;
-    } while (cursor !== "0");
-    return keys;
-  }
-  /**
-   * Deletes all keys matching the given pattern using SCAN and DEL in batches.
-   * @param pattern Redis key pattern, e.g. "table:*"
-   * @param batchSize Number of keys to delete per batch (default: 1000)
-   */
-  async scanAndDelete(pattern, batchSize = 1e4) {
-    let cursor = "0";
-    let totalDeleted = 0;
-    do {
-      const [nextCursor, keys] = await this.redis.scan(cursor, {
-        match: pattern,
-        count: batchSize
-      });
-      if (keys.length > 0) {
-        await this.redis.del(...keys);
-        totalDeleted += keys.length;
-      }
-      cursor = nextCursor;
-    } while (cursor !== "0");
-    return totalDeleted;
-  }
-  getMessageKey(threadId, messageId) {
-    const key = this.getKey(storage.TABLE_MESSAGES, { threadId, id: messageId });
-    return key;
   }
-  getThreadMessagesKey(threadId) {
-    return `thread:${threadId}:messages`;
-  }
-  parseWorkflowRun(row) {
-    let parsedSnapshot = row.snapshot;
-    if (typeof parsedSnapshot === "string") {
-      try {
-        parsedSnapshot = JSON.parse(row.snapshot);
-      } catch (e) {
-        console.warn(`Failed to parse snapshot for workflow ${row.workflow_name}: ${e}`);
-      }
+  let testInfo = record.test_info;
+  if (typeof testInfo === "string") {
+    try {
+      testInfo = JSON.parse(testInfo);
+    } catch {
+      console.warn("Failed to parse test_info JSON:");
     }
-    return {
-      workflowName: row.workflow_name,
-      runId: row.run_id,
-      snapshot: parsedSnapshot,
-      createdAt: this.ensureDate(row.createdAt),
-      updatedAt: this.ensureDate(row.updatedAt),
-      resourceId: row.resourceId
-    };
   }
-  processRecord(tableName, record) {
-    let key;
-    if (tableName === storage.TABLE_MESSAGES) {
-      key = this.getKey(tableName, { threadId: record.threadId, id: record.id });
-    } else if (tableName === storage.TABLE_WORKFLOW_SNAPSHOT) {
-      key = this.getKey(tableName, {
-        namespace: record.namespace || "workflows",
-        workflow_name: record.workflow_name,
-        run_id: record.run_id,
-        ...record.resourceId ? { resourceId: record.resourceId } : {}
-      });
-    } else if (tableName === storage.TABLE_EVALS) {
-      key = this.getKey(tableName, { id: record.run_id });
-    } else {
-      key = this.getKey(tableName, { id: record.id });
-    }
-    const processedRecord = {
-      ...record,
-      createdAt: this.serializeDate(record.createdAt),
-      updatedAt: this.serializeDate(record.updatedAt)
-    };
-    return { key, processedRecord };
+  return {
+    agentName: record.agent_name,
+    input: record.input,
+    output: record.output,
+    result,
+    metricName: record.metric_name,
+    instructions: record.instructions,
+    testInfo,
+    globalRunId: record.global_run_id,
+    runId: record.run_id,
+    createdAt: typeof record.created_at === "string" ? record.created_at : record.created_at instanceof Date ? record.created_at.toISOString() : (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+var StoreLegacyEvalsUpstash = class extends storage.LegacyEvalsStorage {
+  client;
+  operations;
+  constructor({ client, operations }) {
+    super();
+    this.client = client;
+    this.operations = operations;
   }
   /**
    * @deprecated Use getEvals instead
@@ -160,11 +53,11 @@ var UpstashStore = class extends storage.MastraStorage {
   async getEvalsByAgentName(agentName, type) {
     try {
       const pattern = `${storage.TABLE_EVALS}:*`;
-      const keys = await this.scanKeys(pattern);
+      const keys = await this.operations.scanKeys(pattern);
       if (keys.length === 0) {
         return [];
       }
-      const pipeline = this.redis.pipeline();
+      const pipeline = this.client.pipeline();
       keys.forEach((key) => pipeline.get(key));
       const results = await pipeline.exec();
       const nonNullRecords = results.filter(
@@ -198,170 +91,220 @@ var UpstashStore = class extends storage.MastraStorage {
           }
         });
       }
-      return filteredEvals.map((record) => this.transformEvalRecord(record));
-    } catch (error) {
-      console.error("Failed to get evals for the specified agent:", error);
+      return filteredEvals.map((record) => transformEvalRecord(record));
+    } catch (error$1) {
+      const mastraError = new error.MastraError(
+        {
+          id: "STORAGE_UPSTASH_STORAGE_GET_EVALS_BY_AGENT_NAME_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { agentName }
+        },
+        error$1
+      );
+      this.logger?.trackException(mastraError);
+      this.logger.error(mastraError.toString());
       return [];
     }
   }
   /**
-   * @deprecated use getTracesPaginated instead
+   * Get all evaluations with pagination and total count
+   * @param options Pagination and filtering options
+   * @returns Object with evals array and total count
    */
-  async getTraces(args) {
-    if (args.fromDate || args.toDate) {
-      args.dateRange = {
-        start: args.fromDate,
-        end: args.toDate
-      };
-    }
-    const { traces } = await this.getTracesPaginated(args);
-    return traces;
-  }
-  async getTracesPaginated(args) {
-    const { name, scope, page = 0, perPage = 100, attributes, filters, dateRange } = args;
-    const fromDate = dateRange?.start;
-    const toDate = dateRange?.end;
+  async getEvals(options) {
     try {
-      const pattern = `${storage.TABLE_TRACES}:*`;
-      const keys = await this.scanKeys(pattern);
+      const { agentName, type, page = 0, perPage = 100, dateRange } = options || {};
+      const fromDate = dateRange?.start;
+      const toDate = dateRange?.end;
+      const pattern = `${storage.TABLE_EVALS}:*`;
+      const keys = await this.operations.scanKeys(pattern);
       if (keys.length === 0) {
         return {
-          traces: [],
+          evals: [],
           total: 0,
           page,
-          perPage: perPage || 100,
+          perPage,
           hasMore: false
         };
       }
-      const pipeline = this.redis.pipeline();
+      const pipeline = this.client.pipeline();
       keys.forEach((key) => pipeline.get(key));
       const results = await pipeline.exec();
-      let filteredTraces = results.filter(
-        (record) => record !== null && typeof record === "object"
-      );
-      if (name) {
-        filteredTraces = filteredTraces.filter((record) => record.name?.toLowerCase().startsWith(name.toLowerCase()));
-      }
-      if (scope) {
-        filteredTraces = filteredTraces.filter((record) => record.scope === scope);
+      let filteredEvals = results.map((result) => result).filter((record) => record !== null && typeof record === "object");
+      if (agentName) {
+        filteredEvals = filteredEvals.filter((record) => record.agent_name === agentName);
       }
-      if (attributes) {
-        filteredTraces = filteredTraces.filter((record) => {
-          const recordAttributes = record.attributes;
-          if (!recordAttributes) return false;
-          const parsedAttributes = typeof recordAttributes === "string" ? JSON.parse(recordAttributes) : recordAttributes;
-          return Object.entries(attributes).every(([key, value]) => parsedAttributes[key] === value);
+      if (type === "test") {
+        filteredEvals = filteredEvals.filter((record) => {
+          if (!record.test_info) return false;
+          try {
+            if (typeof record.test_info === "string") {
+              const parsedTestInfo = JSON.parse(record.test_info);
+              return parsedTestInfo && typeof parsedTestInfo === "object" && "testPath" in parsedTestInfo;
+            }
+            return typeof record.test_info === "object" && "testPath" in record.test_info;
+          } catch {
+            return false;
+          }
+        });
+      } else if (type === "live") {
+        filteredEvals = filteredEvals.filter((record) => {
+          if (!record.test_info) return true;
+          try {
+            if (typeof record.test_info === "string") {
+              const parsedTestInfo = JSON.parse(record.test_info);
+              return !(parsedTestInfo && typeof parsedTestInfo === "object" && "testPath" in parsedTestInfo);
+            }
+            return !(typeof record.test_info === "object" && "testPath" in record.test_info);
+          } catch {
+            return true;
+          }
         });
-      }
-      if (filters) {
-        filteredTraces = filteredTraces.filter(
-          (record) => Object.entries(filters).every(([key, value]) => record[key] === value)
-        );
       }
       if (fromDate) {
-        filteredTraces = filteredTraces.filter(
-          (record) => new Date(record.createdAt).getTime() >= new Date(fromDate).getTime()
-        );
+        filteredEvals = filteredEvals.filter((record) => {
+          const createdAt = new Date(record.created_at || record.createdAt || 0);
+          return createdAt.getTime() >= fromDate.getTime();
+        });
       }
       if (toDate) {
-        filteredTraces = filteredTraces.filter(
-          (record) => new Date(record.createdAt).getTime() <= new Date(toDate).getTime()
-        );
+        filteredEvals = filteredEvals.filter((record) => {
+          const createdAt = new Date(record.created_at || record.createdAt || 0);
+          return createdAt.getTime() <= toDate.getTime();
+        });
       }
-      filteredTraces.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
-      const transformedTraces = filteredTraces.map((record) => ({
-        id: record.id,
-        parentSpanId: record.parentSpanId,
-        traceId: record.traceId,
-        name: record.name,
-        scope: record.scope,
-        kind: record.kind,
-        status: this.parseJSON(record.status),
-        events: this.parseJSON(record.events),
-        links: this.parseJSON(record.links),
-        attributes: this.parseJSON(record.attributes),
-        startTime: record.startTime,
-        endTime: record.endTime,
-        other: this.parseJSON(record.other),
-        createdAt: this.ensureDate(record.createdAt)
-      }));
-      const total = transformedTraces.length;
-      const resolvedPerPage = perPage || 100;
-      const start = page * resolvedPerPage;
-      const end = start + resolvedPerPage;
-      const paginatedTraces = transformedTraces.slice(start, end);
+      filteredEvals.sort((a, b) => {
+        const dateA = new Date(a.created_at || a.createdAt || 0).getTime();
+        const dateB = new Date(b.created_at || b.createdAt || 0).getTime();
+        return dateB - dateA;
+      });
+      const total = filteredEvals.length;
+      const start = page * perPage;
+      const end = start + perPage;
+      const paginatedEvals = filteredEvals.slice(start, end);
       const hasMore = end < total;
+      const evals = paginatedEvals.map((record) => transformEvalRecord(record));
       return {
-        traces: paginatedTraces,
+        evals,
         total,
         page,
-        perPage: resolvedPerPage,
+        perPage,
         hasMore
       };
-    } catch (error) {
-      console.error("Failed to get traces:", error);
+    } catch (error$1) {
+      const { page = 0, perPage = 100 } = options || {};
+      const mastraError = new error.MastraError(
+        {
+          id: "STORAGE_UPSTASH_STORAGE_GET_EVALS_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            page,
+            perPage
+          }
+        },
+        error$1
+      );
+      this.logger.error(mastraError.toString());
+      this.logger?.trackException(mastraError);
       return {
-        traces: [],
+        evals: [],
         total: 0,
         page,
-        perPage: perPage || 100,
+        perPage,
         hasMore: false
       };
     }
   }
-  async createTable({
-    tableName,
-    schema
-  }) {
-    await this.redis.set(`schema:${tableName}`, schema);
-  }
-  /**
-   * No-op: This backend is schemaless and does not require schema changes.
-   * @param tableName Name of the table
-   * @param schema Schema of the table
-   * @param ifNotExists Array of column names to add if they don't exist
-   */
-  async alterTable(_args) {
-  }
-  async clearTable({ tableName }) {
-    const pattern = `${tableName}:*`;
-    await this.scanAndDelete(pattern);
-  }
-  async insert({ tableName, record }) {
-    const { key, processedRecord } = this.processRecord(tableName, record);
-    await this.redis.set(key, processedRecord);
-  }
-  async batchInsert(input) {
-    const { tableName, records } = input;
-    if (!records.length) return;
-    const batchSize = 1e3;
-    for (let i = 0; i < records.length; i += batchSize) {
-      const batch = records.slice(i, i + batchSize);
-      const pipeline = this.redis.pipeline();
-      for (const record of batch) {
-        const { key, processedRecord } = this.processRecord(tableName, record);
-        pipeline.set(key, processedRecord);
-      }
-      await pipeline.exec();
+};
+function ensureDate(value) {
+  if (!value) return null;
+  if (value instanceof Date) return value;
+  if (typeof value === "string") return new Date(value);
+  if (typeof value === "number") return new Date(value);
+  return null;
+}
+function parseJSON(value) {
+  if (typeof value === "string") {
+    try {
+      return JSON.parse(value);
+    } catch {
+      return value;
     }
   }
-  async load({ tableName, keys }) {
-    const key = this.getKey(tableName, keys);
-    const data = await this.redis.get(key);
-    return data || null;
+  return value;
+}
+function getKey(tableName, keys) {
+  const keyParts = Object.entries(keys).filter(([_, value]) => value !== void 0).map(([key, value]) => `${key}:${value}`);
+  return `${tableName}:${keyParts.join(":")}`;
+}
+function processRecord(tableName, record) {
+  let key;
+  if (tableName === storage.TABLE_MESSAGES) {
+    key = getKey(tableName, { threadId: record.threadId, id: record.id });
+  } else if (tableName === storage.TABLE_WORKFLOW_SNAPSHOT) {
+    key = getKey(tableName, {
+      namespace: record.namespace || "workflows",
+      workflow_name: record.workflow_name,
+      run_id: record.run_id,
+      ...record.resourceId ? { resourceId: record.resourceId } : {}
+    });
+  } else if (tableName === storage.TABLE_EVALS) {
+    key = getKey(tableName, { id: record.run_id });
+  } else {
+    key = getKey(tableName, { id: record.id });
+  }
+  const processedRecord = {
+    ...record,
+    createdAt: storage.serializeDate(record.createdAt),
+    updatedAt: storage.serializeDate(record.updatedAt)
+  };
+  return { key, processedRecord };
+}
+
+// src/storage/domains/memory/index.ts
+function getThreadMessagesKey(threadId) {
+  return `thread:${threadId}:messages`;
+}
+function getMessageKey(threadId, messageId) {
+  const key = getKey(storage.TABLE_MESSAGES, { threadId, id: messageId });
+  return key;
+}
+var StoreMemoryUpstash = class extends storage.MemoryStorage {
+  client;
+  operations;
+  constructor({ client, operations }) {
+    super();
+    this.client = client;
+    this.operations = operations;
   }
   async getThreadById({ threadId }) {
-    const thread = await this.load({
-      tableName: storage.TABLE_THREADS,
-      keys: { id: threadId }
-    });
-    if (!thread) return null;
-    return {
-      ...thread,
-      createdAt: this.ensureDate(thread.createdAt),
-      updatedAt: this.ensureDate(thread.updatedAt),
-      metadata: typeof thread.metadata === "string" ? JSON.parse(thread.metadata) : thread.metadata
-    };
+    try {
+      const thread = await this.operations.load({
+        tableName: storage.TABLE_THREADS,
+        keys: { id: threadId }
+      });
+      if (!thread) return null;
+      return {
+        ...thread,
+        createdAt: ensureDate(thread.createdAt),
+        updatedAt: ensureDate(thread.updatedAt),
+        metadata: typeof thread.metadata === "string" ? JSON.parse(thread.metadata) : thread.metadata
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_UPSTASH_STORAGE_GET_THREAD_BY_ID_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            threadId
+          }
+        },
+        error$1
+      );
+    }
   }
   /**
    * @deprecated use getThreadsByResourceIdPaginated instead
@@ -369,12 +312,12 @@ var UpstashStore = class extends storage.MastraStorage {
   async getThreadsByResourceId({ resourceId }) {
     try {
       const pattern = `${storage.TABLE_THREADS}:*`;
-      const keys = await this.scanKeys(pattern);
+      const keys = await this.operations.scanKeys(pattern);
       if (keys.length === 0) {
         return [];
       }
       const allThreads = [];
-      const pipeline = this.redis.pipeline();
+      const pipeline = this.client.pipeline();
       keys.forEach((key) => pipeline.get(key));
       const results = await pipeline.exec();
       for (let i = 0; i < results.length; i++) {
@@ -382,16 +325,28 @@ var UpstashStore = class extends storage.MastraStorage {
         if (thread && thread.resourceId === resourceId) {
           allThreads.push({
             ...thread,
-            createdAt: this.ensureDate(thread.createdAt),
-            updatedAt: this.ensureDate(thread.updatedAt),
+            createdAt: ensureDate(thread.createdAt),
+            updatedAt: ensureDate(thread.updatedAt),
             metadata: typeof thread.metadata === "string" ? JSON.parse(thread.metadata) : thread.metadata
           });
         }
       }
       allThreads.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
       return allThreads;
-    } catch (error) {
-      console.error("Error in getThreadsByResourceId:", error);
+    } catch (error$1) {
+      const mastraError = new error.MastraError(
+        {
+          id: "STORAGE_UPSTASH_STORAGE_GET_THREADS_BY_RESOURCE_ID_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            resourceId
+          }
+        },
+        error$1
+      );
+      this.logger?.trackException(mastraError);
+      this.logger.error(mastraError.toString());
       return [];
     }
   }
@@ -411,8 +366,22 @@ var UpstashStore = class extends storage.MastraStorage {
         perPage,
         hasMore
       };
-    } catch (error) {
-      console.error("Error in getThreadsByResourceIdPaginated:", error);
+    } catch (error$1) {
+      const mastraError = new error.MastraError(
+        {
+          id: "STORAGE_UPSTASH_STORAGE_GET_THREADS_BY_RESOURCE_ID_PAGINATED_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            resourceId,
+            page,
+            perPage
+          }
+        },
+        error$1
+      );
+      this.logger?.trackException(mastraError);
+      this.logger.error(mastraError.toString());
       return {
         threads: [],
         total: 0,
@@ -423,11 +392,28 @@ var UpstashStore = class extends storage.MastraStorage {
     }
   }
   async saveThread({ thread }) {
-    await this.insert({
-      tableName: storage.TABLE_THREADS,
-      record: thread
-    });
-    return thread;
+    try {
+      await this.operations.insert({
+        tableName: storage.TABLE_THREADS,
+        record: thread
+      });
+      return thread;
+    } catch (error$1) {
+      const mastraError = new error.MastraError(
+        {
+          id: "STORAGE_UPSTASH_STORAGE_SAVE_THREAD_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            threadId: thread.id
+          }
+        },
+        error$1
+      );
+      this.logger?.trackException(mastraError);
+      this.logger.error(mastraError.toString());
+      throw mastraError;
+    }
   }
   async updateThread({
     id,
@@ -436,7 +422,15 @@ var UpstashStore = class extends storage.MastraStorage {
   }) {
     const thread = await this.getThreadById({ threadId: id });
     if (!thread) {
-      throw new Error(`Thread ${id} not found`);
+      throw new error.MastraError({
+        id: "STORAGE_UPSTASH_STORAGE_UPDATE_THREAD_FAILED",
+        domain: error.ErrorDomain.STORAGE,
+        category: error.ErrorCategory.USER,
+        text: `Thread ${id} not found`,
+        details: {
+          threadId: id
+        }
+      });
     }
     const updatedThread = {
       ...thread,
@@ -446,67 +440,149 @@ var UpstashStore = class extends storage.MastraStorage {
         ...metadata
       }
     };
-    await this.saveThread({ thread: updatedThread });
-    return updatedThread;
+    try {
+      await this.saveThread({ thread: updatedThread });
+      return updatedThread;
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_UPSTASH_STORAGE_UPDATE_THREAD_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            threadId: id
+          }
+        },
+        error$1
+      );
+    }
   }
   async deleteThread({ threadId }) {
-    const threadKey = this.getKey(storage.TABLE_THREADS, { id: threadId });
-    const threadMessagesKey = this.getThreadMessagesKey(threadId);
-    const messageIds = await this.redis.zrange(threadMessagesKey, 0, -1);
-    const pipeline = this.redis.pipeline();
-    pipeline.del(threadKey);
-    pipeline.del(threadMessagesKey);
-    for (let i = 0; i < messageIds.length; i++) {
-      const messageId = messageIds[i];
-      const messageKey = this.getMessageKey(threadId, messageId);
-      pipeline.del(messageKey);
-    }
-    await pipeline.exec();
-    await this.scanAndDelete(this.getMessageKey(threadId, "*"));
+    const threadKey = getKey(storage.TABLE_THREADS, { id: threadId });
+    const threadMessagesKey = getThreadMessagesKey(threadId);
+    try {
+      const messageIds = await this.client.zrange(threadMessagesKey, 0, -1);
+      const pipeline = this.client.pipeline();
+      pipeline.del(threadKey);
+      pipeline.del(threadMessagesKey);
+      for (let i = 0; i < messageIds.length; i++) {
+        const messageId = messageIds[i];
+        const messageKey = getMessageKey(threadId, messageId);
+        pipeline.del(messageKey);
+      }
+      await pipeline.exec();
+      await this.operations.scanAndDelete(getMessageKey(threadId, "*"));
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_UPSTASH_STORAGE_DELETE_THREAD_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            threadId
+          }
+        },
+        error$1
+      );
+    }
   }
   async saveMessages(args) {
     const { messages, format = "v1" } = args;
     if (messages.length === 0) return [];
     const threadId = messages[0]?.threadId;
-    if (!threadId) {
-      throw new Error("Thread ID is required");
-    }
-    const thread = await this.getThreadById({ threadId });
-    if (!thread) {
-      throw new Error(`Thread ${threadId} not found`);
+    try {
+      if (!threadId) {
+        throw new Error("Thread ID is required");
+      }
+      const thread = await this.getThreadById({ threadId });
+      if (!thread) {
+        throw new Error(`Thread ${threadId} not found`);
+      }
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_UPSTASH_STORAGE_SAVE_MESSAGES_INVALID_ARGS",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER
+        },
+        error$1
+      );
     }
-    const messagesWithIndex = messages.map((message, index) => ({
-      ...message,
-      _index: index
-    }));
-    const threadKey = this.getKey(storage.TABLE_THREADS, { id: threadId });
-    const existingThread = await this.redis.get(threadKey);
-    const batchSize = 1e3;
-    for (let i = 0; i < messagesWithIndex.length; i += batchSize) {
-      const batch = messagesWithIndex.slice(i, i + batchSize);
-      const pipeline = this.redis.pipeline();
-      for (const message of batch) {
-        const key = this.getMessageKey(message.threadId, message.id);
-        const createdAtScore = new Date(message.createdAt).getTime();
-        const score = message._index !== void 0 ? message._index : createdAtScore;
-        pipeline.set(key, message);
-        pipeline.zadd(this.getThreadMessagesKey(message.threadId), {
-          score,
-          member: message.id
-        });
+    const messagesWithIndex = messages.map((message, index) => {
+      if (!message.threadId) {
+        throw new Error(
+          `Expected to find a threadId for message, but couldn't find one. An unexpected error has occurred.`
+        );
       }
-      if (i === 0 && existingThread) {
-        const updatedThread = {
-          ...existingThread,
-          updatedAt: /* @__PURE__ */ new Date()
-        };
-        pipeline.set(threadKey, this.processRecord(storage.TABLE_THREADS, updatedThread).processedRecord);
+      if (!message.resourceId) {
+        throw new Error(
+          `Expected to find a resourceId for message, but couldn't find one. An unexpected error has occurred.`
+        );
       }
-      await pipeline.exec();
+      return {
+        ...message,
+        _index: index
+      };
+    });
+    const threadKey = getKey(storage.TABLE_THREADS, { id: threadId });
+    const existingThread = await this.client.get(threadKey);
+    try {
+      const batchSize = 1e3;
+      for (let i = 0; i < messagesWithIndex.length; i += batchSize) {
+        const batch = messagesWithIndex.slice(i, i + batchSize);
+        const pipeline = this.client.pipeline();
+        for (const message of batch) {
+          const key = getMessageKey(message.threadId, message.id);
+          const createdAtScore = new Date(message.createdAt).getTime();
+          const score = message._index !== void 0 ? message._index : createdAtScore;
+          const existingKeyPattern = getMessageKey("*", message.id);
+          const keys = await this.operations.scanKeys(existingKeyPattern);
+          if (keys.length > 0) {
+            const pipeline2 = this.client.pipeline();
+            keys.forEach((key2) => pipeline2.get(key2));
+            const results = await pipeline2.exec();
+            const existingMessages = results.filter(
+              (msg) => msg !== null
+            );
+            for (const existingMessage of existingMessages) {
+              const existingMessageKey = getMessageKey(existingMessage.threadId, existingMessage.id);
+              if (existingMessage && existingMessage.threadId !== message.threadId) {
+                pipeline.del(existingMessageKey);
+                pipeline.zrem(getThreadMessagesKey(existingMessage.threadId), existingMessage.id);
+              }
+            }
+          }
+          pipeline.set(key, message);
+          pipeline.zadd(getThreadMessagesKey(message.threadId), {
+            score,
+            member: message.id
+          });
+        }
+        if (i === 0 && existingThread) {
+          const updatedThread = {
+            ...existingThread,
+            updatedAt: /* @__PURE__ */ new Date()
+          };
+          pipeline.set(threadKey, processRecord(storage.TABLE_THREADS, updatedThread).processedRecord);
+        }
+        await pipeline.exec();
+      }
+      const list = new agent.MessageList().add(messages, "memory");
+      if (format === `v2`) return list.get.all.v2();
+      return list.get.all.v1();
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_UPSTASH_STORAGE_SAVE_MESSAGES_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            threadId
+          }
+        },
+        error$1
+      );
     }
-    const list = new agent.MessageList().add(messages, "memory");
-    if (format === `v2`) return list.get.all.v2();
-    return list.get.all.v1();
   }
   async _getIncludedMessages(threadId, selectBy) {
     const messageIds = /* @__PURE__ */ new Set();
@@ -516,29 +592,29 @@ var UpstashStore = class extends storage.MastraStorage {
         messageIds.add(item.id);
         const itemThreadId = item.threadId || threadId;
         messageIdToThreadIds[item.id] = itemThreadId;
-        const itemThreadMessagesKey = this.getThreadMessagesKey(itemThreadId);
-        const rank = await this.redis.zrank(itemThreadMessagesKey, item.id);
+        const itemThreadMessagesKey = getThreadMessagesKey(itemThreadId);
+        const rank = await this.client.zrank(itemThreadMessagesKey, item.id);
         if (rank === null) continue;
         if (item.withPreviousMessages) {
           const start = Math.max(0, rank - item.withPreviousMessages);
-          const prevIds = rank === 0 ? [] : await this.redis.zrange(itemThreadMessagesKey, start, rank - 1);
+          const prevIds = rank === 0 ? [] : await this.client.zrange(itemThreadMessagesKey, start, rank - 1);
           prevIds.forEach((id) => {
             messageIds.add(id);
             messageIdToThreadIds[id] = itemThreadId;
           });
         }
         if (item.withNextMessages) {
-          const nextIds = await this.redis.zrange(itemThreadMessagesKey, rank + 1, rank + item.withNextMessages);
+          const nextIds = await this.client.zrange(itemThreadMessagesKey, rank + 1, rank + item.withNextMessages);
           nextIds.forEach((id) => {
             messageIds.add(id);
             messageIdToThreadIds[id] = itemThreadId;
           });
         }
       }
-      const pipeline = this.redis.pipeline();
+      const pipeline = this.client.pipeline();
       Array.from(messageIds).forEach((id) => {
         const tId = messageIdToThreadIds[id] || threadId;
-        pipeline.get(this.getMessageKey(tId, id));
+        pipeline.get(getMessageKey(tId, id));
       });
       const results = await pipeline.exec();
       return results.filter((result) => result !== null);
@@ -550,69 +626,91 @@ var UpstashStore = class extends storage.MastraStorage {
     selectBy,
     format
   }) {
-    const threadMessagesKey = this.getThreadMessagesKey(threadId);
-    const allMessageIds = await this.redis.zrange(threadMessagesKey, 0, -1);
-    const limit = this.resolveMessageLimit({ last: selectBy?.last, defaultLimit: Number.MAX_SAFE_INTEGER });
-    const messageIds = /* @__PURE__ */ new Set();
-    const messageIdToThreadIds = {};
-    if (limit === 0 && !selectBy?.include) {
-      return [];
-    }
-    if (limit === Number.MAX_SAFE_INTEGER) {
-      const allIds = await this.redis.zrange(threadMessagesKey, 0, -1);
-      allIds.forEach((id) => {
-        messageIds.add(id);
-        messageIdToThreadIds[id] = threadId;
+    const threadMessagesKey = getThreadMessagesKey(threadId);
+    try {
+      const allMessageIds = await this.client.zrange(threadMessagesKey, 0, -1);
+      const limit = storage.resolveMessageLimit({ last: selectBy?.last, defaultLimit: Number.MAX_SAFE_INTEGER });
+      const messageIds = /* @__PURE__ */ new Set();
+      const messageIdToThreadIds = {};
+      if (limit === 0 && !selectBy?.include) {
+        return [];
+      }
+      if (limit === Number.MAX_SAFE_INTEGER) {
+        const allIds = await this.client.zrange(threadMessagesKey, 0, -1);
+        allIds.forEach((id) => {
+          messageIds.add(id);
+          messageIdToThreadIds[id] = threadId;
+        });
+      } else if (limit > 0) {
+        const latestIds = await this.client.zrange(threadMessagesKey, -limit, -1);
+        latestIds.forEach((id) => {
+          messageIds.add(id);
+          messageIdToThreadIds[id] = threadId;
+        });
+      }
+      const includedMessages = await this._getIncludedMessages(threadId, selectBy);
+      const messages = [
+        ...includedMessages,
+        ...(await Promise.all(
+          Array.from(messageIds).map(async (id) => {
+            const tId = messageIdToThreadIds[id] || threadId;
+            const byThreadId = await this.client.get(getMessageKey(tId, id));
+            if (byThreadId) return byThreadId;
+            return null;
+          })
+        )).filter((msg) => msg !== null)
+      ];
+      messages.sort((a, b) => allMessageIds.indexOf(a.id) - allMessageIds.indexOf(b.id));
+      const seen = /* @__PURE__ */ new Set();
+      const dedupedMessages = messages.filter((row) => {
+        if (seen.has(row.id)) return false;
+        seen.add(row.id);
+        return true;
       });
-    } else if (limit > 0) {
-      const latestIds = await this.redis.zrange(threadMessagesKey, -limit, -1);
-      latestIds.forEach((id) => {
-        messageIds.add(id);
-        messageIdToThreadIds[id] = threadId;
+      const prepared = dedupedMessages.filter((message) => message !== null && message !== void 0).map((message) => {
+        const { _index, ...messageWithoutIndex } = message;
+        return messageWithoutIndex;
       });
-    }
-    const includedMessages = await this._getIncludedMessages(threadId, selectBy);
-    const messages = [
-      ...includedMessages,
-      ...(await Promise.all(
-        Array.from(messageIds).map(async (id) => {
-          const tId = messageIdToThreadIds[id] || threadId;
-          const byThreadId = await this.redis.get(this.getMessageKey(tId, id));
-          if (byThreadId) return byThreadId;
-          return null;
-        })
-      )).filter((msg) => msg !== null)
-    ];
-    messages.sort((a, b) => allMessageIds.indexOf(a.id) - allMessageIds.indexOf(b.id));
-    const seen = /* @__PURE__ */ new Set();
-    const dedupedMessages = messages.filter((row) => {
-      if (seen.has(row.id)) return false;
-      seen.add(row.id);
-      return true;
-    });
-    const prepared = dedupedMessages.filter((message) => message !== null && message !== void 0).map((message) => {
-      const { _index, ...messageWithoutIndex } = message;
-      return messageWithoutIndex;
-    });
-    if (format === "v2") {
+      if (format === "v2") {
+        return prepared.map((msg) => ({
+          ...msg,
+          createdAt: new Date(msg.createdAt),
+          content: msg.content || { format: 2, parts: [{ type: "text", text: "" }] }
+        }));
+      }
       return prepared.map((msg) => ({
         ...msg,
-        content: msg.content || { format: 2, parts: [{ type: "text", text: "" }] }
+        createdAt: new Date(msg.createdAt)
       }));
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_UPSTASH_STORAGE_GET_MESSAGES_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            threadId
+          }
+        },
+        error$1
+      );
     }
-    return prepared;
   }
   async getMessagesPaginated(args) {
     const { threadId, selectBy, format } = args;
     const { page = 0, perPage = 40, dateRange } = selectBy?.pagination || {};
     const fromDate = dateRange?.start;
     const toDate = dateRange?.end;
-    const threadMessagesKey = this.getThreadMessagesKey(threadId);
+    const threadMessagesKey = getThreadMessagesKey(threadId);
     const messages = [];
-    const includedMessages = await this._getIncludedMessages(threadId, selectBy);
-    messages.push(...includedMessages);
     try {
-      const allMessageIds = await this.redis.zrange(threadMessagesKey, 0, -1);
+      const includedMessages = await this._getIncludedMessages(threadId, selectBy);
+      messages.push(...includedMessages);
+      const allMessageIds = await this.client.zrange(
+        threadMessagesKey,
+        args?.selectBy?.last ? -args.selectBy.last : 0,
+        -1
+      );
       if (allMessageIds.length === 0) {
         return {
           messages: [],
@@ -622,8 +720,8 @@ var UpstashStore = class extends storage.MastraStorage {
           hasMore: false
         };
       }
-      const pipeline = this.redis.pipeline();
-      allMessageIds.forEach((id) => pipeline.get(this.getMessageKey(threadId, id)));
+      const pipeline = this.client.pipeline();
+      allMessageIds.forEach((id) => pipeline.get(getMessageKey(threadId, id)));
       const results = await pipeline.exec();
       let messagesData = results.filter((msg) => msg !== null);
       if (fromDate) {
@@ -648,8 +746,20 @@ var UpstashStore = class extends storage.MastraStorage {
         perPage,
         hasMore
       };
-    } catch (error) {
-      console.error("Failed to get paginated messages:", error);
+    } catch (error$1) {
+      const mastraError = new error.MastraError(
+        {
+          id: "STORAGE_UPSTASH_STORAGE_GET_MESSAGES_PAGINATED_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            threadId
+          }
+        },
+        error$1
+      );
+      this.logger.error(mastraError.toString());
+      this.logger?.trackException(mastraError);
       return {
         messages: [],
         total: 0,
@@ -659,161 +769,849 @@ var UpstashStore = class extends storage.MastraStorage {
       };
     }
   }
-  async persistWorkflowSnapshot(params) {
-    const { namespace = "workflows", workflowName, runId, snapshot } = params;
-    await this.insert({
-      tableName: storage.TABLE_WORKFLOW_SNAPSHOT,
-      record: {
-        namespace,
-        workflow_name: workflowName,
-        run_id: runId,
-        snapshot,
-        createdAt: /* @__PURE__ */ new Date(),
+  async getResourceById({ resourceId }) {
+    try {
+      const key = `${storage.TABLE_RESOURCES}:${resourceId}`;
+      const data = await this.client.get(key);
+      if (!data) {
+        return null;
+      }
+      return {
+        ...data,
+        createdAt: new Date(data.createdAt),
+        updatedAt: new Date(data.updatedAt),
+        // Ensure workingMemory is always returned as a string, regardless of automatic parsing
+        workingMemory: typeof data.workingMemory === "object" ? JSON.stringify(data.workingMemory) : data.workingMemory,
+        metadata: typeof data.metadata === "string" ? JSON.parse(data.metadata) : data.metadata
+      };
+    } catch (error) {
+      this.logger.error("Error getting resource by ID:", error);
+      throw error;
+    }
+  }
+  async saveResource({ resource }) {
+    try {
+      const key = `${storage.TABLE_RESOURCES}:${resource.id}`;
+      const serializedResource = {
+        ...resource,
+        metadata: JSON.stringify(resource.metadata),
+        createdAt: resource.createdAt.toISOString(),
+        updatedAt: resource.updatedAt.toISOString()
+      };
+      await this.client.set(key, serializedResource);
+      return resource;
+    } catch (error) {
+      this.logger.error("Error saving resource:", error);
+      throw error;
+    }
+  }
+  async updateResource({
+    resourceId,
+    workingMemory,
+    metadata
+  }) {
+    try {
+      const existingResource = await this.getResourceById({ resourceId });
+      if (!existingResource) {
+        const newResource = {
+          id: resourceId,
+          workingMemory,
+          metadata: metadata || {},
+          createdAt: /* @__PURE__ */ new Date(),
+          updatedAt: /* @__PURE__ */ new Date()
+        };
+        return this.saveResource({ resource: newResource });
+      }
+      const updatedResource = {
+        ...existingResource,
+        workingMemory: workingMemory !== void 0 ? workingMemory : existingResource.workingMemory,
+        metadata: {
+          ...existingResource.metadata,
+          ...metadata
+        },
         updatedAt: /* @__PURE__ */ new Date()
+      };
+      await this.saveResource({ resource: updatedResource });
+      return updatedResource;
+    } catch (error) {
+      this.logger.error("Error updating resource:", error);
+      throw error;
+    }
+  }
+  async updateMessages(args) {
+    const { messages } = args;
+    if (messages.length === 0) {
+      return [];
+    }
+    try {
+      const messageIds = messages.map((m) => m.id);
+      const existingMessages = [];
+      const messageIdToKey = {};
+      for (const messageId of messageIds) {
+        const pattern = getMessageKey("*", messageId);
+        const keys = await this.operations.scanKeys(pattern);
+        for (const key of keys) {
+          const message = await this.client.get(key);
+          if (message && message.id === messageId) {
+            existingMessages.push(message);
+            messageIdToKey[messageId] = key;
+            break;
+          }
+        }
       }
-    });
+      if (existingMessages.length === 0) {
+        return [];
+      }
+      const threadIdsToUpdate = /* @__PURE__ */ new Set();
+      const pipeline = this.client.pipeline();
+      for (const existingMessage of existingMessages) {
+        const updatePayload = messages.find((m) => m.id === existingMessage.id);
+        if (!updatePayload) continue;
+        const { id, ...fieldsToUpdate } = updatePayload;
+        if (Object.keys(fieldsToUpdate).length === 0) continue;
+        threadIdsToUpdate.add(existingMessage.threadId);
+        if (updatePayload.threadId && updatePayload.threadId !== existingMessage.threadId) {
+          threadIdsToUpdate.add(updatePayload.threadId);
+        }
+        const updatedMessage = { ...existingMessage };
+        if (fieldsToUpdate.content) {
+          const existingContent = existingMessage.content;
+          const newContent = {
+            ...existingContent,
+            ...fieldsToUpdate.content,
+            // Deep merge metadata if it exists on both
+            ...existingContent?.metadata && fieldsToUpdate.content.metadata ? {
+              metadata: {
+                ...existingContent.metadata,
+                ...fieldsToUpdate.content.metadata
+              }
+            } : {}
+          };
+          updatedMessage.content = newContent;
+        }
+        for (const key2 in fieldsToUpdate) {
+          if (Object.prototype.hasOwnProperty.call(fieldsToUpdate, key2) && key2 !== "content") {
+            updatedMessage[key2] = fieldsToUpdate[key2];
+          }
+        }
+        const key = messageIdToKey[id];
+        if (key) {
+          if (updatePayload.threadId && updatePayload.threadId !== existingMessage.threadId) {
+            const oldThreadMessagesKey = getThreadMessagesKey(existingMessage.threadId);
+            pipeline.zrem(oldThreadMessagesKey, id);
+            pipeline.del(key);
+            const newKey = getMessageKey(updatePayload.threadId, id);
+            pipeline.set(newKey, updatedMessage);
+            const newThreadMessagesKey = getThreadMessagesKey(updatePayload.threadId);
+            const score = updatedMessage._index !== void 0 ? updatedMessage._index : new Date(updatedMessage.createdAt).getTime();
+            pipeline.zadd(newThreadMessagesKey, { score, member: id });
+          } else {
+            pipeline.set(key, updatedMessage);
+          }
+        }
+      }
+      const now = /* @__PURE__ */ new Date();
+      for (const threadId of threadIdsToUpdate) {
+        if (threadId) {
+          const threadKey = getKey(storage.TABLE_THREADS, { id: threadId });
+          const existingThread = await this.client.get(threadKey);
+          if (existingThread) {
+            const updatedThread = {
+              ...existingThread,
+              updatedAt: now
+            };
+            pipeline.set(threadKey, processRecord(storage.TABLE_THREADS, updatedThread).processedRecord);
+          }
+        }
+      }
+      await pipeline.exec();
+      const updatedMessages = [];
+      for (const messageId of messageIds) {
+        const key = messageIdToKey[messageId];
+        if (key) {
+          const updatedMessage = await this.client.get(key);
+          if (updatedMessage) {
+            const v2e = updatedMessage;
+            updatedMessages.push(v2e);
+          }
+        }
+      }
+      return updatedMessages;
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_UPSTASH_STORAGE_UPDATE_MESSAGES_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            messageIds: messages.map((m) => m.id).join(",")
+          }
+        },
+        error$1
+      );
+    }
   }
-  async loadWorkflowSnapshot(params) {
-    const { namespace = "workflows", workflowName, runId } = params;
-    const key = this.getKey(storage.TABLE_WORKFLOW_SNAPSHOT, {
-      namespace,
-      workflow_name: workflowName,
-      run_id: runId
+  async deleteMessages(messageIds) {
+    if (!messageIds || messageIds.length === 0) {
+      return;
+    }
+    try {
+      const threadIds = /* @__PURE__ */ new Set();
+      const messageKeys = [];
+      for (const messageId of messageIds) {
+        const pattern = getMessageKey("*", messageId);
+        const keys = await this.operations.scanKeys(pattern);
+        for (const key of keys) {
+          const message = await this.client.get(key);
+          if (message && message.id === messageId) {
+            messageKeys.push(key);
+            if (message.threadId) {
+              threadIds.add(message.threadId);
+            }
+            break;
+          }
+        }
+      }
+      if (messageKeys.length === 0) {
+        return;
+      }
+      const pipeline = this.client.pipeline();
+      for (const key of messageKeys) {
+        pipeline.del(key);
+      }
+      if (threadIds.size > 0) {
+        for (const threadId of threadIds) {
+          const threadKey = getKey(storage.TABLE_THREADS, { id: threadId });
+          const thread = await this.client.get(threadKey);
+          if (thread) {
+            const updatedThread = {
+              ...thread,
+              updatedAt: /* @__PURE__ */ new Date()
+            };
+            pipeline.set(threadKey, processRecord(storage.TABLE_THREADS, updatedThread).processedRecord);
+          }
+        }
+      }
+      await pipeline.exec();
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_UPSTASH_DELETE_MESSAGES_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { messageIds: messageIds.join(", ") }
+        },
+        error$1
+      );
+    }
+  }
+};
+var StoreOperationsUpstash = class extends storage.StoreOperations {
+  client;
+  constructor({ client }) {
+    super();
+    this.client = client;
+  }
+  async createTable({
+    tableName: _tableName,
+    schema: _schema
+  }) {
+  }
+  async alterTable({
+    tableName: _tableName,
+    schema: _schema,
+    ifNotExists: _ifNotExists
+  }) {
+  }
+  async clearTable({ tableName }) {
+    const pattern = `${tableName}:*`;
+    try {
+      await this.scanAndDelete(pattern);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_UPSTASH_STORAGE_CLEAR_TABLE_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            tableName
+          }
+        },
+        error$1
+      );
+    }
+  }
+  async dropTable({ tableName }) {
+    return this.clearTable({ tableName });
+  }
+  async insert({ tableName, record }) {
+    const { key, processedRecord } = processRecord(tableName, record);
+    try {
+      await this.client.set(key, processedRecord);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_UPSTASH_STORAGE_INSERT_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            tableName
+          }
+        },
+        error$1
+      );
+    }
+  }
+  async batchInsert(input) {
+    const { tableName, records } = input;
+    if (!records.length) return;
+    const batchSize = 1e3;
+    try {
+      for (let i = 0; i < records.length; i += batchSize) {
+        const batch = records.slice(i, i + batchSize);
+        const pipeline = this.client.pipeline();
+        for (const record of batch) {
+          const { key, processedRecord } = processRecord(tableName, record);
+          pipeline.set(key, processedRecord);
+        }
+        await pipeline.exec();
+      }
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_UPSTASH_STORAGE_BATCH_INSERT_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            tableName
+          }
+        },
+        error$1
+      );
+    }
+  }
+  async load({ tableName, keys }) {
+    const key = getKey(tableName, keys);
+    try {
+      const data = await this.client.get(key);
+      return data || null;
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_UPSTASH_STORAGE_LOAD_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            tableName
+          }
+        },
+        error$1
+      );
+    }
+  }
+  async hasColumn(_tableName, _column) {
+    return true;
+  }
+  async scanKeys(pattern, batchSize = 1e4) {
+    let cursor = "0";
+    let keys = [];
+    do {
+      const [nextCursor, batch] = await this.client.scan(cursor, {
+        match: pattern,
+        count: batchSize
+      });
+      keys.push(...batch);
+      cursor = nextCursor;
+    } while (cursor !== "0");
+    return keys;
+  }
+  async scanAndDelete(pattern, batchSize = 1e4) {
+    let cursor = "0";
+    let totalDeleted = 0;
+    do {
+      const [nextCursor, keys] = await this.client.scan(cursor, {
+        match: pattern,
+        count: batchSize
+      });
+      if (keys.length > 0) {
+        await this.client.del(...keys);
+        totalDeleted += keys.length;
+      }
+      cursor = nextCursor;
+    } while (cursor !== "0");
+    return totalDeleted;
+  }
+};
+function transformScoreRow(row) {
+  const parseField = (v) => {
+    if (typeof v === "string") {
+      try {
+        return JSON.parse(v);
+      } catch {
+        return v;
+      }
+    }
+    return v;
+  };
+  return {
+    ...row,
+    scorer: parseField(row.scorer),
+    extractStepResult: parseField(row.extractStepResult),
+    analyzeStepResult: parseField(row.analyzeStepResult),
+    metadata: parseField(row.metadata),
+    input: parseField(row.input),
+    output: parseField(row.output),
+    additionalContext: parseField(row.additionalContext),
+    runtimeContext: parseField(row.runtimeContext),
+    entity: parseField(row.entity),
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt
+  };
+}
+var ScoresUpstash = class extends storage.ScoresStorage {
+  client;
+  operations;
+  constructor({ client, operations }) {
+    super();
+    this.client = client;
+    this.operations = operations;
+  }
+  async getScoreById({ id }) {
+    try {
+      const data = await this.operations.load({
+        tableName: storage.TABLE_SCORERS,
+        keys: { id }
+      });
+      if (!data) return null;
+      return transformScoreRow(data);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_UPSTASH_STORAGE_GET_SCORE_BY_ID_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { id }
+        },
+        error$1
+      );
+    }
+  }
+  async getScoresByScorerId({
+    scorerId,
+    pagination = { page: 0, perPage: 20 }
+  }) {
+    const pattern = `${storage.TABLE_SCORERS}:*`;
+    const keys = await this.operations.scanKeys(pattern);
+    if (keys.length === 0) {
+      return {
+        scores: [],
+        pagination: { total: 0, page: pagination.page, perPage: pagination.perPage, hasMore: false }
+      };
+    }
+    const pipeline = this.client.pipeline();
+    keys.forEach((key) => pipeline.get(key));
+    const results = await pipeline.exec();
+    const filtered = results.map((row) => row).filter((row) => !!row && typeof row === "object" && row.scorerId === scorerId);
+    const total = filtered.length;
+    const { page, perPage } = pagination;
+    const start = page * perPage;
+    const end = start + perPage;
+    const paged = filtered.slice(start, end);
+    const scores = paged.map((row) => transformScoreRow(row));
+    return {
+      scores,
+      pagination: {
+        total,
+        page,
+        perPage,
+        hasMore: end < total
+      }
+    };
+  }
+  async saveScore(score) {
+    const { key, processedRecord } = processRecord(storage.TABLE_SCORERS, score);
+    try {
+      await this.client.set(key, processedRecord);
+      return { score };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_UPSTASH_STORAGE_SAVE_SCORE_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { id: score.id }
+        },
+        error$1
+      );
+    }
+  }
+  async getScoresByRunId({
+    runId,
+    pagination = { page: 0, perPage: 20 }
+  }) {
+    const pattern = `${storage.TABLE_SCORERS}:*`;
+    const keys = await this.operations.scanKeys(pattern);
+    if (keys.length === 0) {
+      return {
+        scores: [],
+        pagination: { total: 0, page: pagination.page, perPage: pagination.perPage, hasMore: false }
+      };
+    }
+    const pipeline = this.client.pipeline();
+    keys.forEach((key) => pipeline.get(key));
+    const results = await pipeline.exec();
+    const filtered = results.map((row) => row).filter((row) => !!row && typeof row === "object" && row.runId === runId);
+    const total = filtered.length;
+    const { page, perPage } = pagination;
+    const start = page * perPage;
+    const end = start + perPage;
+    const paged = filtered.slice(start, end);
+    const scores = paged.map((row) => transformScoreRow(row));
+    return {
+      scores,
+      pagination: {
+        total,
+        page,
+        perPage,
+        hasMore: end < total
+      }
+    };
+  }
+  async getScoresByEntityId({
+    entityId,
+    entityType,
+    pagination = { page: 0, perPage: 20 }
+  }) {
+    const pattern = `${storage.TABLE_SCORERS}:*`;
+    const keys = await this.operations.scanKeys(pattern);
+    if (keys.length === 0) {
+      return {
+        scores: [],
+        pagination: { total: 0, page: pagination.page, perPage: pagination.perPage, hasMore: false }
+      };
+    }
+    const pipeline = this.client.pipeline();
+    keys.forEach((key) => pipeline.get(key));
+    const results = await pipeline.exec();
+    const filtered = results.map((row) => row).filter((row) => {
+      if (!row || typeof row !== "object") return false;
+      if (row.entityId !== entityId) return false;
+      if (entityType && row.entityType !== entityType) return false;
+      return true;
     });
-    const data = await this.redis.get(key);
-    if (!data) return null;
-    return data.snapshot;
+    const total = filtered.length;
+    const { page, perPage } = pagination;
+    const start = page * perPage;
+    const end = start + perPage;
+    const paged = filtered.slice(start, end);
+    const scores = paged.map((row) => transformScoreRow(row));
+    return {
+      scores,
+      pagination: {
+        total,
+        page,
+        perPage,
+        hasMore: end < total
+      }
+    };
+  }
+};
+var TracesUpstash = class extends storage.TracesStorage {
+  client;
+  operations;
+  constructor({ client, operations }) {
+    super();
+    this.client = client;
+    this.operations = operations;
   }
   /**
-   * Get all evaluations with pagination and total count
-   * @param options Pagination and filtering options
-   * @returns Object with evals array and total count
+   * @deprecated use getTracesPaginated instead
    */
-  async getEvals(options) {
+  async getTraces(args) {
+    if (args.fromDate || args.toDate) {
+      args.dateRange = {
+        start: args.fromDate,
+        end: args.toDate
+      };
+    }
     try {
-      const { agentName, type, page = 0, perPage = 100, dateRange } = options || {};
-      const fromDate = dateRange?.start;
-      const toDate = dateRange?.end;
-      const pattern = `${storage.TABLE_EVALS}:*`;
-      const keys = await this.scanKeys(pattern);
+      const { traces } = await this.getTracesPaginated(args);
+      return traces;
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_UPSTASH_STORAGE_GET_TRACES_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  async getTracesPaginated(args) {
+    const { name, scope, page = 0, perPage = 100, attributes, filters, dateRange } = args;
+    const fromDate = dateRange?.start;
+    const toDate = dateRange?.end;
+    try {
+      const pattern = `${storage.TABLE_TRACES}:*`;
+      const keys = await this.operations.scanKeys(pattern);
       if (keys.length === 0) {
         return {
-          evals: [],
+          traces: [],
           total: 0,
           page,
-          perPage,
+          perPage: perPage || 100,
           hasMore: false
         };
       }
-      const pipeline = this.redis.pipeline();
+      const pipeline = this.client.pipeline();
       keys.forEach((key) => pipeline.get(key));
       const results = await pipeline.exec();
-      let filteredEvals = results.map((result) => result).filter((record) => record !== null && typeof record === "object");
-      if (agentName) {
-        filteredEvals = filteredEvals.filter((record) => record.agent_name === agentName);
+      let filteredTraces = results.filter(
+        (record) => record !== null && typeof record === "object"
+      );
+      if (name) {
+        filteredTraces = filteredTraces.filter((record) => record.name?.toLowerCase().startsWith(name.toLowerCase()));
       }
-      if (type === "test") {
-        filteredEvals = filteredEvals.filter((record) => {
-          if (!record.test_info) return false;
-          try {
-            if (typeof record.test_info === "string") {
-              const parsedTestInfo = JSON.parse(record.test_info);
-              return parsedTestInfo && typeof parsedTestInfo === "object" && "testPath" in parsedTestInfo;
-            }
-            return typeof record.test_info === "object" && "testPath" in record.test_info;
-          } catch {
-            return false;
-          }
-        });
-      } else if (type === "live") {
-        filteredEvals = filteredEvals.filter((record) => {
-          if (!record.test_info) return true;
-          try {
-            if (typeof record.test_info === "string") {
-              const parsedTestInfo = JSON.parse(record.test_info);
-              return !(parsedTestInfo && typeof parsedTestInfo === "object" && "testPath" in parsedTestInfo);
-            }
-            return !(typeof record.test_info === "object" && "testPath" in record.test_info);
-          } catch {
-            return true;
-          }
+      if (scope) {
+        filteredTraces = filteredTraces.filter((record) => record.scope === scope);
+      }
+      if (attributes) {
+        filteredTraces = filteredTraces.filter((record) => {
+          const recordAttributes = record.attributes;
+          if (!recordAttributes) return false;
+          const parsedAttributes = typeof recordAttributes === "string" ? JSON.parse(recordAttributes) : recordAttributes;
+          return Object.entries(attributes).every(([key, value]) => parsedAttributes[key] === value);
         });
       }
+      if (filters) {
+        filteredTraces = filteredTraces.filter(
+          (record) => Object.entries(filters).every(([key, value]) => record[key] === value)
+        );
+      }
       if (fromDate) {
-        filteredEvals = filteredEvals.filter((record) => {
-          const createdAt = new Date(record.created_at || record.createdAt || 0);
-          return createdAt.getTime() >= fromDate.getTime();
-        });
+        filteredTraces = filteredTraces.filter(
+          (record) => new Date(record.createdAt).getTime() >= new Date(fromDate).getTime()
+        );
       }
       if (toDate) {
-        filteredEvals = filteredEvals.filter((record) => {
-          const createdAt = new Date(record.created_at || record.createdAt || 0);
-          return createdAt.getTime() <= toDate.getTime();
-        });
+        filteredTraces = filteredTraces.filter(
+          (record) => new Date(record.createdAt).getTime() <= new Date(toDate).getTime()
+        );
       }
-      filteredEvals.sort((a, b) => {
-        const dateA = new Date(a.created_at || a.createdAt || 0).getTime();
-        const dateB = new Date(b.created_at || b.createdAt || 0).getTime();
-        return dateB - dateA;
-      });
-      const total = filteredEvals.length;
-      const start = page * perPage;
-      const end = start + perPage;
-      const paginatedEvals = filteredEvals.slice(start, end);
+      filteredTraces.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+      const transformedTraces = filteredTraces.map((record) => ({
+        id: record.id,
+        parentSpanId: record.parentSpanId,
+        traceId: record.traceId,
+        name: record.name,
+        scope: record.scope,
+        kind: record.kind,
+        status: parseJSON(record.status),
+        events: parseJSON(record.events),
+        links: parseJSON(record.links),
+        attributes: parseJSON(record.attributes),
+        startTime: record.startTime,
+        endTime: record.endTime,
+        other: parseJSON(record.other),
+        createdAt: ensureDate(record.createdAt)
+      }));
+      const total = transformedTraces.length;
+      const resolvedPerPage = perPage || 100;
+      const start = page * resolvedPerPage;
+      const end = start + resolvedPerPage;
+      const paginatedTraces = transformedTraces.slice(start, end);
       const hasMore = end < total;
-      const evals = paginatedEvals.map((record) => this.transformEvalRecord(record));
       return {
-        evals,
+        traces: paginatedTraces,
         total,
         page,
-        perPage,
+        perPage: resolvedPerPage,
         hasMore
       };
-    } catch (error) {
-      const { page = 0, perPage = 100 } = options || {};
-      console.error("Failed to get evals:", error);
+    } catch (error$1) {
+      const mastraError = new error.MastraError(
+        {
+          id: "STORAGE_UPSTASH_STORAGE_GET_TRACES_PAGINATED_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            name: args.name || "",
+            scope: args.scope || ""
+          }
+        },
+        error$1
+      );
+      this.logger?.trackException(mastraError);
+      this.logger.error(mastraError.toString());
       return {
-        evals: [],
+        traces: [],
         total: 0,
         page,
-        perPage,
+        perPage: perPage || 100,
         hasMore: false
       };
     }
   }
+  async batchTraceInsert(args) {
+    return this.operations.batchInsert({
+      tableName: storage.TABLE_TRACES,
+      records: args.records
+    });
+  }
+};
+function parseWorkflowRun(row) {
+  let parsedSnapshot = row.snapshot;
+  if (typeof parsedSnapshot === "string") {
+    try {
+      parsedSnapshot = JSON.parse(row.snapshot);
+    } catch (e) {
+      console.warn(`Failed to parse snapshot for workflow ${row.workflow_name}: ${e}`);
+    }
+  }
+  return {
+    workflowName: row.workflow_name,
+    runId: row.run_id,
+    snapshot: parsedSnapshot,
+    createdAt: ensureDate(row.createdAt),
+    updatedAt: ensureDate(row.updatedAt),
+    resourceId: row.resourceId
+  };
+}
+var WorkflowsUpstash = class extends storage.WorkflowsStorage {
+  client;
+  operations;
+  constructor({ client, operations }) {
+    super();
+    this.client = client;
+    this.operations = operations;
+  }
+  async persistWorkflowSnapshot(params) {
+    const { namespace = "workflows", workflowName, runId, snapshot } = params;
+    try {
+      await this.operations.insert({
+        tableName: storage.TABLE_WORKFLOW_SNAPSHOT,
+        record: {
+          namespace,
+          workflow_name: workflowName,
+          run_id: runId,
+          snapshot,
+          createdAt: /* @__PURE__ */ new Date(),
+          updatedAt: /* @__PURE__ */ new Date()
+        }
+      });
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_UPSTASH_STORAGE_PERSIST_WORKFLOW_SNAPSHOT_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            namespace,
+            workflowName,
+            runId
+          }
+        },
+        error$1
+      );
+    }
+  }
+  async loadWorkflowSnapshot(params) {
+    const { namespace = "workflows", workflowName, runId } = params;
+    const key = getKey(storage.TABLE_WORKFLOW_SNAPSHOT, {
+      namespace,
+      workflow_name: workflowName,
+      run_id: runId
+    });
+    try {
+      const data = await this.client.get(key);
+      if (!data) return null;
+      return data.snapshot;
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_UPSTASH_STORAGE_LOAD_WORKFLOW_SNAPSHOT_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            namespace,
+            workflowName,
+            runId
+          }
+        },
+        error$1
+      );
+    }
+  }
+  async getWorkflowRunById({
+    runId,
+    workflowName
+  }) {
+    try {
+      const key = getKey(storage.TABLE_WORKFLOW_SNAPSHOT, { namespace: "workflows", workflow_name: workflowName, run_id: runId }) + "*";
+      const keys = await this.operations.scanKeys(key);
+      const workflows = await Promise.all(
+        keys.map(async (key2) => {
+          const data2 = await this.client.get(key2);
+          return data2;
+        })
+      );
+      const data = workflows.find((w) => w?.run_id === runId && w?.workflow_name === workflowName);
+      if (!data) return null;
+      return parseWorkflowRun(data);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_UPSTASH_STORAGE_GET_WORKFLOW_RUN_BY_ID_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            namespace: "workflows",
+            runId,
+            workflowName: workflowName || ""
+          }
+        },
+        error$1
+      );
+    }
+  }
   async getWorkflowRuns({
-    namespace,
     workflowName,
     fromDate,
     toDate,
     limit,
     offset,
     resourceId
-  } = { namespace: "workflows" }) {
+  }) {
     try {
-      let pattern = this.getKey(storage.TABLE_WORKFLOW_SNAPSHOT, { namespace }) + ":*";
+      let pattern = getKey(storage.TABLE_WORKFLOW_SNAPSHOT, { namespace: "workflows" }) + ":*";
       if (workflowName && resourceId) {
-        pattern = this.getKey(storage.TABLE_WORKFLOW_SNAPSHOT, {
-          namespace,
+        pattern = getKey(storage.TABLE_WORKFLOW_SNAPSHOT, {
+          namespace: "workflows",
           workflow_name: workflowName,
           run_id: "*",
           resourceId
         });
       } else if (workflowName) {
-        pattern = this.getKey(storage.TABLE_WORKFLOW_SNAPSHOT, { namespace, workflow_name: workflowName }) + ":*";
+        pattern = getKey(storage.TABLE_WORKFLOW_SNAPSHOT, { namespace: "workflows", workflow_name: workflowName }) + ":*";
       } else if (resourceId) {
-        pattern = this.getKey(storage.TABLE_WORKFLOW_SNAPSHOT, { namespace, workflow_name: "*", run_id: "*", resourceId });
+        pattern = getKey(storage.TABLE_WORKFLOW_SNAPSHOT, {
+          namespace: "workflows",
+          workflow_name: "*",
+          run_id: "*",
+          resourceId
+        });
       }
-      const keys = await this.scanKeys(pattern);
+      const keys = await this.operations.scanKeys(pattern);
       if (keys.length === 0) {
         return { runs: [], total: 0 };
       }
-      const pipeline = this.redis.pipeline();
+      const pipeline = this.client.pipeline();
       keys.forEach((key) => pipeline.get(key));
       const results = await pipeline.exec();
       let runs = results.map((result) => result).filter(
         (record) => record !== null && record !== void 0 && typeof record === "object" && "workflow_name" in record
-      ).filter((record) => !workflowName || record.workflow_name === workflowName).map((w) => this.parseWorkflowRun(w)).filter((w) => {
+      ).filter((record) => !workflowName || record.workflow_name === workflowName).map((w) => parseWorkflowRun(w)).filter((w) => {
         if (fromDate && w.createdAt < fromDate) return false;
         if (toDate && w.createdAt > toDate) return false;
         return true;
@@ -823,107 +1621,223 @@ var UpstashStore = class extends storage.MastraStorage {
         runs = runs.slice(offset, offset + limit);
       }
       return { runs, total };
-    } catch (error) {
-      console.error("Error getting workflow runs:", error);
-      throw error;
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_UPSTASH_STORAGE_GET_WORKFLOW_RUNS_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            namespace: "workflows",
+            workflowName: workflowName || "",
+            resourceId: resourceId || ""
+          }
+        },
+        error$1
+      );
     }
   }
+};
+
+// src/storage/index.ts
+var UpstashStore = class extends storage.MastraStorage {
+  redis;
+  stores;
+  constructor(config) {
+    super({ name: "Upstash" });
+    this.redis = new redis.Redis({
+      url: config.url,
+      token: config.token
+    });
+    const operations = new StoreOperationsUpstash({ client: this.redis });
+    const traces = new TracesUpstash({ client: this.redis, operations });
+    const scores = new ScoresUpstash({ client: this.redis, operations });
+    const workflows = new WorkflowsUpstash({ client: this.redis, operations });
+    const memory = new StoreMemoryUpstash({ client: this.redis, operations });
+    const legacyEvals = new StoreLegacyEvalsUpstash({ client: this.redis, operations });
+    this.stores = {
+      operations,
+      traces,
+      scores,
+      workflows,
+      memory,
+      legacyEvals
+    };
+  }
+  get supports() {
+    return {
+      selectByIncludeResourceScope: true,
+      resourceWorkingMemory: true,
+      hasColumn: false,
+      createTable: false,
+      deleteMessages: true
+    };
+  }
+  /**
+   * @deprecated Use getEvals instead
+   */
+  async getEvalsByAgentName(agentName, type) {
+    return this.stores.legacyEvals.getEvalsByAgentName(agentName, type);
+  }
+  /**
+   * Get all evaluations with pagination and total count
+   * @param options Pagination and filtering options
+   * @returns Object with evals array and total count
+   */
+  async getEvals(options) {
+    return this.stores.legacyEvals.getEvals(options);
+  }
+  /**
+   * @deprecated use getTracesPaginated instead
+   */
+  async getTraces(args) {
+    return this.stores.traces.getTraces(args);
+  }
+  async getTracesPaginated(args) {
+    return this.stores.traces.getTracesPaginated(args);
+  }
+  async batchTraceInsert(args) {
+    return this.stores.traces.batchTraceInsert(args);
+  }
+  async createTable({
+    tableName,
+    schema
+  }) {
+    return this.stores.operations.createTable({ tableName, schema });
+  }
+  /**
+   * No-op: This backend is schemaless and does not require schema changes.
+   * @param tableName Name of the table
+   * @param schema Schema of the table
+   * @param ifNotExists Array of column names to add if they don't exist
+   */
+  async alterTable(args) {
+    return this.stores.operations.alterTable(args);
+  }
+  async clearTable({ tableName }) {
+    return this.stores.operations.clearTable({ tableName });
+  }
+  async dropTable({ tableName }) {
+    return this.stores.operations.dropTable({ tableName });
+  }
+  async insert({ tableName, record }) {
+    return this.stores.operations.insert({ tableName, record });
+  }
+  async batchInsert(input) {
+    return this.stores.operations.batchInsert(input);
+  }
+  async load({ tableName, keys }) {
+    return this.stores.operations.load({ tableName, keys });
+  }
+  async getThreadById({ threadId }) {
+    return this.stores.memory.getThreadById({ threadId });
+  }
+  /**
+   * @deprecated use getThreadsByResourceIdPaginated instead
+   */
+  async getThreadsByResourceId({ resourceId }) {
+    return this.stores.memory.getThreadsByResourceId({ resourceId });
+  }
+  async getThreadsByResourceIdPaginated(args) {
+    return this.stores.memory.getThreadsByResourceIdPaginated(args);
+  }
+  async saveThread({ thread }) {
+    return this.stores.memory.saveThread({ thread });
+  }
+  async updateThread({
+    id,
+    title,
+    metadata
+  }) {
+    return this.stores.memory.updateThread({ id, title, metadata });
+  }
+  async deleteThread({ threadId }) {
+    return this.stores.memory.deleteThread({ threadId });
+  }
+  async saveMessages(args) {
+    return this.stores.memory.saveMessages(args);
+  }
+  async getMessages({
+    threadId,
+    selectBy,
+    format
+  }) {
+    return this.stores.memory.getMessages({ threadId, selectBy, format });
+  }
+  async getMessagesPaginated(args) {
+    return this.stores.memory.getMessagesPaginated(args);
+  }
+  async persistWorkflowSnapshot(params) {
+    return this.stores.workflows.persistWorkflowSnapshot(params);
+  }
+  async loadWorkflowSnapshot(params) {
+    return this.stores.workflows.loadWorkflowSnapshot(params);
+  }
+  async getWorkflowRuns({
+    workflowName,
+    fromDate,
+    toDate,
+    limit,
+    offset,
+    resourceId
+  } = {}) {
+    return this.stores.workflows.getWorkflowRuns({ workflowName, fromDate, toDate, limit, offset, resourceId });
+  }
   async getWorkflowRunById({
-    namespace = "workflows",
     runId,
     workflowName
   }) {
-    try {
-      const key = this.getKey(storage.TABLE_WORKFLOW_SNAPSHOT, { namespace, workflow_name: workflowName, run_id: runId }) + "*";
-      const keys = await this.scanKeys(key);
-      const workflows = await Promise.all(
-        keys.map(async (key2) => {
-          const data2 = await this.redis.get(key2);
-          return data2;
-        })
-      );
-      const data = workflows.find((w) => w?.run_id === runId && w?.workflow_name === workflowName);
-      if (!data) return null;
-      return this.parseWorkflowRun(data);
-    } catch (error) {
-      console.error("Error getting workflow run by ID:", error);
-      throw error;
-    }
+    return this.stores.workflows.getWorkflowRunById({ runId, workflowName });
   }
   async close() {
   }
-  async updateMessages(_args) {
-    this.logger.error("updateMessages is not yet implemented in UpstashStore");
-    throw new Error("Method not implemented");
+  async updateMessages(args) {
+    return this.stores.memory.updateMessages(args);
+  }
+  async deleteMessages(messageIds) {
+    return this.stores.memory.deleteMessages(messageIds);
   }
   async getResourceById({ resourceId }) {
-    try {
-      const key = `${storage.TABLE_RESOURCES}:${resourceId}`;
-      const data = await this.redis.get(key);
-      if (!data) {
-        return null;
-      }
-      return {
-        ...data,
-        createdAt: new Date(data.createdAt),
-        updatedAt: new Date(data.updatedAt),
-        // Ensure workingMemory is always returned as a string, regardless of automatic parsing
-        workingMemory: typeof data.workingMemory === "object" ? JSON.stringify(data.workingMemory) : data.workingMemory,
-        metadata: typeof data.metadata === "string" ? JSON.parse(data.metadata) : data.metadata
-      };
-    } catch (error) {
-      this.logger.error("Error getting resource by ID:", error);
-      throw error;
-    }
+    return this.stores.memory.getResourceById({ resourceId });
   }
   async saveResource({ resource }) {
-    try {
-      const key = `${storage.TABLE_RESOURCES}:${resource.id}`;
-      const serializedResource = {
-        ...resource,
-        metadata: JSON.stringify(resource.metadata),
-        createdAt: resource.createdAt.toISOString(),
-        updatedAt: resource.updatedAt.toISOString()
-      };
-      await this.redis.set(key, serializedResource);
-      return resource;
-    } catch (error) {
-      this.logger.error("Error saving resource:", error);
-      throw error;
-    }
+    return this.stores.memory.saveResource({ resource });
   }
   async updateResource({
     resourceId,
     workingMemory,
     metadata
   }) {
-    try {
-      const existingResource = await this.getResourceById({ resourceId });
-      if (!existingResource) {
-        const newResource = {
-          id: resourceId,
-          workingMemory,
-          metadata: metadata || {},
-          createdAt: /* @__PURE__ */ new Date(),
-          updatedAt: /* @__PURE__ */ new Date()
-        };
-        return this.saveResource({ resource: newResource });
-      }
-      const updatedResource = {
-        ...existingResource,
-        workingMemory: workingMemory !== void 0 ? workingMemory : existingResource.workingMemory,
-        metadata: {
-          ...existingResource.metadata,
-          ...metadata
-        },
-        updatedAt: /* @__PURE__ */ new Date()
-      };
-      await this.saveResource({ resource: updatedResource });
-      return updatedResource;
-    } catch (error) {
-      this.logger.error("Error updating resource:", error);
-      throw error;
-    }
+    return this.stores.memory.updateResource({ resourceId, workingMemory, metadata });
+  }
+  async getScoreById({ id: _id }) {
+    return this.stores.scores.getScoreById({ id: _id });
+  }
+  async saveScore(score) {
+    return this.stores.scores.saveScore(score);
+  }
+  async getScoresByRunId({
+    runId,
+    pagination
+  }) {
+    return this.stores.scores.getScoresByRunId({ runId, pagination });
+  }
+  async getScoresByEntityId({
+    entityId,
+    entityType,
+    pagination
+  }) {
+    return this.stores.scores.getScoresByEntityId({
+      entityId,
+      entityType,
+      pagination
+    });
+  }
+  async getScoresByScorerId({
+    scorerId,
+    pagination
+  }) {
+    return this.stores.scores.getScoresByScorerId({ scorerId, pagination });
   }
 };
 var UpstashFilterTranslator = class extends filter.BaseFilterTranslator {
@@ -1139,21 +2053,40 @@ var UpstashVector = class extends vector.MastraVector {
    * @param {UpsertVectorParams} params - The parameters for the upsert operation.
    * @returns {Promise<string[]>} A promise that resolves to the IDs of the upserted vectors.
    */
-  async upsert({ indexName: namespace, vectors, metadata, ids }) {
+  async upsert({
+    indexName: namespace,
+    vectors,
+    metadata,
+    ids,
+    sparseVectors
+  }) {
     const generatedIds = ids || vectors.map(() => crypto.randomUUID());
     const points = vectors.map((vector, index) => ({
       id: generatedIds[index],
       vector,
+      ...sparseVectors?.[index] && { sparseVector: sparseVectors[index] },
       metadata: metadata?.[index]
     }));
-    await this.client.upsert(points, {
-      namespace
-    });
-    return generatedIds;
+    try {
+      await this.client.upsert(points, {
+        namespace
+      });
+      return generatedIds;
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_UPSTASH_VECTOR_UPSERT_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { namespace, vectorCount: vectors.length }
+        },
+        error$1
+      );
+    }
   }
   /**
    * Transforms a Mastra vector filter into an Upstash-compatible filter string.
-   * @param {VectorFilter} [filter] - The filter to transform.
+   * @param {UpstashVectorFilter} [filter] - The filter to transform.
    * @returns {string | undefined} The transformed filter string, or undefined if no filter is provided.
    */
   transformFilter(filter) {
@@ -1178,31 +2111,60 @@ var UpstashVector = class extends vector.MastraVector {
     queryVector,
     topK = 10,
     filter,
-    includeVector = false
+    includeVector = false,
+    sparseVector,
+    fusionAlgorithm,
+    queryMode
   }) {
-    const ns = this.client.namespace(namespace);
-    const filterString = this.transformFilter(filter);
-    const results = await ns.query({
-      topK,
-      vector: queryVector,
-      includeVectors: includeVector,
-      includeMetadata: true,
-      ...filterString ? { filter: filterString } : {}
-    });
-    return (results || []).map((result) => ({
-      id: `${result.id}`,
-      score: result.score,
-      metadata: result.metadata,
-      ...includeVector && { vector: result.vector || [] }
-    }));
+    try {
+      const ns = this.client.namespace(namespace);
+      const filterString = this.transformFilter(filter);
+      const results = await ns.query({
+        topK,
+        vector: queryVector,
+        ...sparseVector && { sparseVector },
+        includeVectors: includeVector,
+        includeMetadata: true,
+        ...filterString ? { filter: filterString } : {},
+        ...fusionAlgorithm && { fusionAlgorithm },
+        ...queryMode && { queryMode }
+      });
+      return (results || []).map((result) => ({
+        id: `${result.id}`,
+        score: result.score,
+        metadata: result.metadata,
+        ...includeVector && { vector: result.vector || [] }
+      }));
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_UPSTASH_VECTOR_QUERY_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { namespace, topK }
+        },
+        error$1
+      );
+    }
   }
   /**
    * Lists all namespaces in the Upstash vector index, which correspond to indexes.
    * @returns {Promise<string[]>} A promise that resolves to a list of index names.
    */
   async listIndexes() {
-    const indexes = await this.client.listNamespaces();
-    return indexes.filter(Boolean);
+    try {
+      const indexes = await this.client.listNamespaces();
+      return indexes.filter(Boolean);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_UPSTASH_VECTOR_LIST_INDEXES_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
   }
   /**
    * Retrieves statistics about a vector index.
@@ -1211,12 +2173,24 @@ var UpstashVector = class extends vector.MastraVector {
    * @returns A promise that resolves to the index statistics including dimension, count and metric
    */
   async describeIndex({ indexName: namespace }) {
-    const info = await this.client.info();
-    return {
-      dimension: info.dimension,
-      count: info.namespaces?.[namespace]?.vectorCount || 0,
-      metric: info?.similarityFunction?.toLowerCase()
-    };
+    try {
+      const info = await this.client.info();
+      return {
+        dimension: info.dimension,
+        count: info.namespaces?.[namespace]?.vectorCount || 0,
+        metric: info?.similarityFunction?.toLowerCase()
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_UPSTASH_VECTOR_DESCRIBE_INDEX_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { namespace }
+        },
+        error$1
+      );
+    }
   }
   /**
    * Deletes an index (namespace).
@@ -1226,8 +2200,16 @@ var UpstashVector = class extends vector.MastraVector {
   async deleteIndex({ indexName: namespace }) {
     try {
       await this.client.deleteNamespace(namespace);
-    } catch (error) {
-      this.logger.error("Failed to delete namespace:", error);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_UPSTASH_VECTOR_DELETE_INDEX_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { namespace }
+        },
+        error$1
+      );
     }
   }
   /**
@@ -1241,30 +2223,40 @@ var UpstashVector = class extends vector.MastraVector {
    * @throws Will throw an error if no updates are provided or if the update operation fails.
    */
   async updateVector({ indexName: namespace, id, update }) {
-    try {
-      if (!update.vector && !update.metadata) {
-        throw new Error("No update data provided");
-      }
-      if (!update.vector && update.metadata) {
-        throw new Error("Both vector and metadata must be provided for an update");
-      }
-      const updatePayload = { id };
-      if (update.vector) {
-        updatePayload.vector = update.vector;
-      }
-      if (update.metadata) {
-        updatePayload.metadata = update.metadata;
-      }
-      const points = {
-        id: updatePayload.id,
-        vector: updatePayload.vector,
-        metadata: updatePayload.metadata
-      };
-      await this.client.upsert(points, {
-        namespace
+    if (!update.vector && !update.metadata && !update.sparseVector) {
+      throw new error.MastraError({
+        id: "STORAGE_UPSTASH_VECTOR_UPDATE_VECTOR_FAILED",
+        domain: error.ErrorDomain.STORAGE,
+        category: error.ErrorCategory.THIRD_PARTY,
+        details: { namespace, id },
+        text: "No update data provided"
       });
-    } catch (error) {
-      throw new Error(`Failed to update vector by id: ${id} for index name: ${namespace}: ${error.message}`);
+    }
+    if (!update.vector && !update.sparseVector && update.metadata) {
+      throw new error.MastraError({
+        id: "STORAGE_UPSTASH_VECTOR_UPDATE_VECTOR_FAILED",
+        domain: error.ErrorDomain.STORAGE,
+        category: error.ErrorCategory.THIRD_PARTY,
+        details: { namespace, id },
+        text: "Both vector and metadata must be provided for an update"
+      });
+    }
+    try {
+      const points = { id };
+      if (update.vector) points.vector = update.vector;
+      if (update.metadata) points.metadata = update.metadata;
+      if (update.sparseVector) points.sparseVector = update.sparseVector;
+      await this.client.upsert(points, { namespace });
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_UPSTASH_VECTOR_UPDATE_VECTOR_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { namespace, id }
+        },
+        error$1
+      );
     }
   }
   /**
@@ -1279,8 +2271,17 @@ var UpstashVector = class extends vector.MastraVector {
       await this.client.delete(id, {
         namespace
       });
-    } catch (error) {
-      this.logger.error(`Failed to delete vector by id: ${id} for namespace: ${namespace}:`, error);
+    } catch (error$1) {
+      const mastraError = new error.MastraError(
+        {
+          id: "STORAGE_UPSTASH_VECTOR_DELETE_VECTOR_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { namespace, id }
+        },
+        error$1
+      );
+      this.logger?.error(mastraError.toString());
     }
   }
 };
@@ -1363,3 +2364,5 @@ Example Complex Query:
 exports.UPSTASH_PROMPT = UPSTASH_PROMPT;
 exports.UpstashStore = UpstashStore;
 exports.UpstashVector = UpstashVector;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map