@mastra/redis 1.0.1 → 1.0.2-alpha.0

package/dist/index.cjs

@@ -0,0 +1,1804 @@
+'use strict';
+
+var agent = require('@mastra/core/agent');
+var error = require('@mastra/core/error');
+var storage = require('@mastra/core/storage');
+var crypto2 = require('crypto');
+var evals = require('@mastra/core/evals');
+var redis = require('redis');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var crypto2__default = /*#__PURE__*/_interopDefault(crypto2);
+
+// src/storage/domains/memory/index.ts
+function getKey(tableName, keys) {
+  const keyParts = Object.entries(keys).filter(([_, value]) => value !== void 0).map(([key, value]) => {
+    if (value && typeof value === "object") {
+      return `${key}:${JSON.stringify(value)}`;
+    }
+    return `${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 {
+    key = getKey(tableName, { id: record.id });
+  }
+  const processedRecord = {
+    ...record,
+    createdAt: storage.serializeDate(record.createdAt),
+    updatedAt: storage.serializeDate(record.updatedAt)
+  };
+  return { key, processedRecord };
+}
+
+// src/storage/db/index.ts
+var RedisDB = class {
+  client;
+  constructor({ client }) {
+    this.client = client;
+  }
+  getClient() {
+    return this.client;
+  }
+  async insert({ tableName, record }) {
+    const { key, processedRecord } = processRecord(tableName, record);
+    try {
+      await this.client.set(key, JSON.stringify(processedRecord));
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("REDIS", "INSERT", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            tableName
+          }
+        },
+        error$1
+      );
+    }
+  }
+  async get({ tableName, keys }) {
+    const key = getKey(tableName, keys);
+    try {
+      const data = await this.client.get(key);
+      if (!data) {
+        return null;
+      }
+      return JSON.parse(data);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("REDIS", "LOAD", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            tableName
+          }
+        },
+        error$1
+      );
+    }
+  }
+  async scanAndDelete(pattern, batchSize = 1e4) {
+    let cursor = "0";
+    let totalDeleted = 0;
+    do {
+      const result = await this.client.scan(cursor, { MATCH: pattern, COUNT: batchSize });
+      if (result.keys.length > 0) {
+        await this.client.del(result.keys);
+        totalDeleted += result.keys.length;
+      }
+      cursor = result.cursor;
+    } while (cursor !== "0");
+    return totalDeleted;
+  }
+  async scanKeys(pattern, batchSize = 1e4) {
+    let cursor = "0";
+    const keys = [];
+    do {
+      const result = await this.client.scan(cursor, { MATCH: pattern, COUNT: batchSize });
+      keys.push(...result.keys);
+      cursor = result.cursor;
+    } while (cursor !== "0");
+    return keys;
+  }
+  async deleteData({ tableName }) {
+    const pattern = `${tableName}:*`;
+    try {
+      await this.scanAndDelete(pattern);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("REDIS", "CLEAR_TABLE", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            tableName
+          }
+        },
+        error$1
+      );
+    }
+  }
+};
+
+// src/storage/domains/memory/index.ts
+var StoreMemoryRedis = class extends storage.MemoryStorage {
+  client;
+  db;
+  constructor(config) {
+    super();
+    this.client = config.client;
+    this.db = new RedisDB({ client: config.client });
+  }
+  async dangerouslyClearAll() {
+    await this.db.deleteData({ tableName: storage.TABLE_THREADS });
+    await this.db.deleteData({ tableName: storage.TABLE_MESSAGES });
+    await this.db.deleteData({ tableName: storage.TABLE_RESOURCES });
+    await this.db.scanAndDelete("msg-idx:*");
+    await this.db.scanAndDelete("thread:*:messages");
+  }
+  async getThreadById({ threadId }) {
+    try {
+      const thread = await this.db.get({
+        tableName: storage.TABLE_THREADS,
+        keys: { id: threadId }
+      });
+      if (!thread) {
+        return null;
+      }
+      return {
+        ...thread,
+        createdAt: storage.ensureDate(thread.createdAt),
+        updatedAt: storage.ensureDate(thread.updatedAt),
+        metadata: typeof thread.metadata === "string" ? JSON.parse(thread.metadata) : thread.metadata
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("REDIS", "GET_THREAD_BY_ID", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            threadId
+          }
+        },
+        error$1
+      );
+    }
+  }
+  async listThreadsByResourceId(args) {
+    return this.listThreads(args);
+  }
+  async listThreads(args) {
+    const { page = 0, perPage: perPageInput, orderBy, filter } = args;
+    const { field, direction } = this.parseOrderBy(orderBy);
+    try {
+      this.validatePaginationInput(page, perPageInput ?? 100);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("REDIS", "LIST_THREADS", "INVALID_PAGE"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: { page, ...perPageInput !== void 0 && { perPage: perPageInput } }
+        },
+        error$1 instanceof Error ? error$1 : new Error("Invalid pagination parameters")
+      );
+    }
+    const perPage = storage.normalizePerPage(perPageInput, 100);
+    try {
+      this.validateMetadataKeys(filter?.metadata);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("REDIS", "LIST_THREADS", "INVALID_METADATA_KEY"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: { metadataKeys: filter?.metadata ? Object.keys(filter.metadata).join(", ") : "" }
+        },
+        error$1 instanceof Error ? error$1 : new Error("Invalid metadata key")
+      );
+    }
+    const { offset, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
+    try {
+      let allThreads = [];
+      const pattern = `${storage.TABLE_THREADS}:*`;
+      const keys = await this.db.scanKeys(pattern);
+      if (keys.length === 0) {
+        return {
+          threads: [],
+          total: 0,
+          page,
+          perPage: perPageForResponse,
+          hasMore: false
+        };
+      }
+      const results = await this.client.mGet(keys);
+      for (let i = 0; i < results.length; i++) {
+        const data = results[i];
+        if (!data) {
+          continue;
+        }
+        const thread = JSON.parse(data);
+        if (filter?.resourceId && thread.resourceId !== filter.resourceId) {
+          continue;
+        }
+        if (filter?.metadata && Object.keys(filter.metadata).length > 0) {
+          const threadMetadata = typeof thread.metadata === "string" ? JSON.parse(thread.metadata) : thread.metadata;
+          const matches = Object.entries(filter.metadata).every(
+            ([key, value]) => storage.jsonValueEquals(threadMetadata?.[key], value)
+          );
+          if (!matches) {
+            continue;
+          }
+        }
+        allThreads.push({
+          ...thread,
+          createdAt: storage.ensureDate(thread.createdAt),
+          updatedAt: storage.ensureDate(thread.updatedAt),
+          metadata: typeof thread.metadata === "string" ? JSON.parse(thread.metadata) : thread.metadata
+        });
+      }
+      const sortedThreads = this.sortThreads(allThreads, field, direction);
+      const total = sortedThreads.length;
+      const end = perPageInput === false ? total : offset + perPage;
+      const paginatedThreads = sortedThreads.slice(offset, end);
+      const hasMore = perPageInput === false ? false : end < total;
+      return {
+        threads: paginatedThreads,
+        total,
+        page,
+        perPage: perPageForResponse,
+        hasMore
+      };
+    } catch (error$1) {
+      const mastraError = new error.MastraError(
+        {
+          id: storage.createStorageErrorId("REDIS", "LIST_THREADS", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            ...filter?.resourceId && { resourceId: filter.resourceId },
+            hasMetadataFilter: !!filter?.metadata,
+            page,
+            perPage
+          }
+        },
+        error$1
+      );
+      this.logger.trackException(mastraError);
+      this.logger.error(mastraError.toString());
+      return {
+        threads: [],
+        total: 0,
+        page,
+        perPage: perPageForResponse,
+        hasMore: false
+      };
+    }
+  }
+  async saveThread({ thread }) {
+    try {
+      await this.db.insert({
+        tableName: storage.TABLE_THREADS,
+        record: thread
+      });
+      return thread;
+    } catch (error$1) {
+      const mastraError = new error.MastraError(
+        {
+          id: storage.createStorageErrorId("REDIS", "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,
+    title,
+    metadata
+  }) {
+    const thread = await this.getThreadById({ threadId: id });
+    if (!thread) {
+      throw new error.MastraError({
+        id: storage.createStorageErrorId("REDIS", "UPDATE_THREAD", "FAILED"),
+        domain: error.ErrorDomain.STORAGE,
+        category: error.ErrorCategory.USER,
+        text: `Thread ${id} not found`,
+        details: {
+          threadId: id
+        }
+      });
+    }
+    const updatedThread = {
+      ...thread,
+      title,
+      metadata: {
+        ...thread.metadata,
+        ...metadata
+      },
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+    try {
+      await this.saveThread({ thread: updatedThread });
+      return updatedThread;
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("REDIS", "UPDATE_THREAD", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            threadId: id
+          }
+        },
+        error$1
+      );
+    }
+  }
+  async deleteThread({ threadId }) {
+    const threadKey = getKey(storage.TABLE_THREADS, { id: threadId });
+    const threadMessagesKey = getThreadMessagesKey(threadId);
+    try {
+      const messageIds = await this.client.zRange(threadMessagesKey, 0, -1);
+      const multi = this.client.multi();
+      multi.del(threadKey);
+      multi.del(threadMessagesKey);
+      for (const messageId of messageIds) {
+        const messageKey = getMessageKey(threadId, messageId);
+        multi.del(messageKey);
+        multi.del(getMessageIndexKey(messageId));
+      }
+      await multi.exec();
+      await this.db.scanAndDelete(getMessageKey(threadId, "*"));
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("REDIS", "DELETE_THREAD", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            threadId
+          }
+        },
+        error$1
+      );
+    }
+  }
+  async saveMessages(args) {
+    const { messages } = args;
+    if (messages.length === 0) {
+      return { messages: [] };
+    }
+    const threadId = messages[0]?.threadId;
+    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.createStorageErrorId("REDIS", "SAVE_MESSAGES", "INVALID_ARGS"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER
+        },
+        error$1
+      );
+    }
+    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 (!message.resourceId) {
+        throw new Error(
+          `Expected to find a resourceId for message, but couldn't find one. An unexpected error has occurred.`
+        );
+      }
+      return {
+        ...message,
+        _index: index
+      };
+    });
+    const threadKey = getKey(storage.TABLE_THREADS, { id: threadId });
+    const existingThreadData = await this.client.get(threadKey);
+    const existingThread = existingThreadData ? JSON.parse(existingThreadData) : null;
+    try {
+      const batchSize = 1e3;
+      const existingThreadIds = await this.client.mGet(
+        messagesWithIndex.map((message) => getMessageIndexKey(message.id))
+      );
+      for (let i = 0; i < messagesWithIndex.length; i += batchSize) {
+        const batch = messagesWithIndex.slice(i, i + batchSize);
+        const batchExistingThreadIds = existingThreadIds.slice(i, i + batch.length);
+        const multi = this.client.multi();
+        for (const [batchIndex, message] of batch.entries()) {
+          const key = getMessageKey(message.threadId, message.id);
+          const score = getMessageScore(message);
+          const existingThreadId = batchExistingThreadIds[batchIndex];
+          if (existingThreadId && existingThreadId !== message.threadId) {
+            const existingMessageKey = getMessageKey(existingThreadId, message.id);
+            multi.del(existingMessageKey);
+            multi.zRem(getThreadMessagesKey(existingThreadId), message.id);
+          }
+          multi.set(key, JSON.stringify(message));
+          multi.set(getMessageIndexKey(message.id), message.threadId);
+          multi.zAdd(getThreadMessagesKey(message.threadId), { score, value: message.id });
+        }
+        if (i === 0 && existingThread) {
+          const updatedThread = {
+            ...existingThread,
+            updatedAt: /* @__PURE__ */ new Date()
+          };
+          multi.set(threadKey, JSON.stringify(processRecord(storage.TABLE_THREADS, updatedThread).processedRecord));
+        }
+        await multi.exec();
+      }
+      const list = new agent.MessageList().add(messages, "memory");
+      return { messages: list.get.all.db() };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("REDIS", "SAVE_MESSAGES", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            threadId
+          }
+        },
+        error$1
+      );
+    }
+  }
+  async getThreadIdForMessage(messageId) {
+    const indexedThreadId = await this.client.get(getMessageIndexKey(messageId));
+    if (indexedThreadId) {
+      return indexedThreadId;
+    }
+    const keys = await this.db.scanKeys(getMessageKey("*", messageId));
+    if (keys.length === 0) {
+      return null;
+    }
+    const messageData = await this.client.get(keys[0]);
+    if (!messageData) {
+      return null;
+    }
+    const message = JSON.parse(messageData);
+    if (message.threadId) {
+      await this.client.set(getMessageIndexKey(messageId), message.threadId);
+    }
+    return message.threadId || null;
+  }
+  async getIncludedMessages(include) {
+    if (!include?.length) {
+      return [];
+    }
+    const messageIds = /* @__PURE__ */ new Set();
+    const messageIdToThreadIds = {};
+    for (const item of include) {
+      const itemThreadId = await this.getThreadIdForMessage(item.id);
+      if (!itemThreadId) {
+        continue;
+      }
+      messageIds.add(item.id);
+      messageIdToThreadIds[item.id] = itemThreadId;
+      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.client.zRange(itemThreadMessagesKey, start, rank - 1);
+        prevIds.forEach((id) => {
+          messageIds.add(id);
+          messageIdToThreadIds[id] = itemThreadId;
+        });
+      }
+      if (item.withNextMessages) {
+        const nextIds = await this.client.zRange(itemThreadMessagesKey, rank + 1, rank + item.withNextMessages);
+        nextIds.forEach((id) => {
+          messageIds.add(id);
+          messageIdToThreadIds[id] = itemThreadId;
+        });
+      }
+    }
+    if (messageIds.size === 0) {
+      return [];
+    }
+    const keysToFetch = Array.from(messageIds).map((id) => getMessageKey(messageIdToThreadIds[id], id));
+    const results = await this.client.mGet(keysToFetch);
+    return results.filter((data) => data !== null).map((data) => JSON.parse(data));
+  }
+  parseStoredMessage(storedMessage) {
+    const defaultMessageContent = { format: 2, parts: [{ type: "text", text: "" }] };
+    const { _index, ...rest } = storedMessage;
+    return {
+      ...rest,
+      createdAt: new Date(rest.createdAt),
+      content: rest.content || defaultMessageContent
+    };
+  }
+  async listMessagesById({ messageIds }) {
+    if (messageIds.length === 0) {
+      return { messages: [] };
+    }
+    try {
+      const rawMessages = [];
+      const indexKeys = messageIds.map((id) => getMessageIndexKey(id));
+      const indexResults = await this.client.mGet(indexKeys);
+      const indexedIds = [];
+      const unindexedIds = [];
+      messageIds.forEach((id, i) => {
+        const threadId = indexResults[i];
+        if (threadId) {
+          indexedIds.push({ messageId: id, threadId });
+          return;
+        }
+        unindexedIds.push(id);
+      });
+      if (indexedIds.length > 0) {
+        const messageKeys = indexedIds.map(({ messageId, threadId }) => getMessageKey(threadId, messageId));
+        const messageResults = await this.client.mGet(messageKeys);
+        for (const data of messageResults) {
+          if (data) {
+            rawMessages.push(JSON.parse(data));
+          }
+        }
+      }
+      if (unindexedIds.length > 0) {
+        const threadKeys = await this.db.scanKeys("thread:*:messages");
+        const result = await Promise.all(
+          threadKeys.map(async (threadKey) => {
+            const threadId = threadKey.split(":")[1];
+            if (!threadId) {
+              throw new Error(`Failed to parse thread ID from thread key "${threadKey}"`);
+            }
+            const msgKeys = unindexedIds.map((id) => getMessageKey(threadId, id));
+            return this.client.mGet(msgKeys);
+          })
+        );
+        const foundMessages = result.flat(1).filter((data) => !!data).map((data) => JSON.parse(data));
+        rawMessages.push(...foundMessages);
+        if (foundMessages.length > 0) {
+          const multi = this.client.multi();
+          foundMessages.forEach((msg) => {
+            if (msg.threadId) {
+              multi.set(getMessageIndexKey(msg.id), msg.threadId);
+            }
+          });
+          await multi.exec();
+        }
+      }
+      const list = new agent.MessageList().add(rawMessages.map(this.parseStoredMessage), "memory");
+      return { messages: list.get.all.db() };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("REDIS", "LIST_MESSAGES_BY_ID", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            messageIds: JSON.stringify(messageIds)
+          }
+        },
+        error$1
+      );
+    }
+  }
+  async listMessages(args) {
+    const { threadId, resourceId, include, filter, perPage: perPageInput, page = 0, orderBy } = args;
+    const threadIds = Array.isArray(threadId) ? threadId : [threadId];
+    const threadIdsSet = new Set(threadIds);
+    if (threadIds.length === 0 || threadIds.some((id) => !id.trim())) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("REDIS", "LIST_MESSAGES", "INVALID_THREAD_ID"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: { threadId: Array.isArray(threadId) ? threadId.join(",") : threadId }
+        },
+        new Error("threadId must be a non-empty string or array of non-empty strings")
+      );
+    }
+    const perPage = storage.normalizePerPage(perPageInput, 40);
+    const { offset, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
+    try {
+      if (page < 0) {
+        throw new error.MastraError(
+          {
+            id: storage.createStorageErrorId("REDIS", "LIST_MESSAGES", "INVALID_PAGE"),
+            domain: error.ErrorDomain.STORAGE,
+            category: error.ErrorCategory.USER,
+            details: { page }
+          },
+          new Error("page must be >= 0")
+        );
+      }
+      const { field, direction } = this.parseOrderBy(orderBy, "ASC");
+      const getFieldValue = (msg) => {
+        if (field === "createdAt") {
+          return new Date(msg.createdAt).getTime();
+        }
+        const value = msg[field];
+        if (typeof value === "number") {
+          return value;
+        }
+        if (value instanceof Date) {
+          return value.getTime();
+        }
+        return 0;
+      };
+      if (perPage === 0 && (!include || include.length === 0)) {
+        return {
+          messages: [],
+          total: 0,
+          page,
+          perPage: perPageForResponse,
+          hasMore: false
+        };
+      }
+      let includedMessages = [];
+      if (include && include.length > 0) {
+        const included = await this.getIncludedMessages(include);
+        includedMessages = included.map(this.parseStoredMessage);
+      }
+      if (perPage === 0 && include && include.length > 0) {
+        const list2 = new agent.MessageList().add(includedMessages, "memory");
+        const messages = list2.get.all.db().sort((a, b) => {
+          const aValue = getFieldValue(a);
+          const bValue = getFieldValue(b);
+          return direction === "ASC" ? aValue - bValue : bValue - aValue;
+        });
+        return {
+          messages,
+          total: 0,
+          page,
+          perPage: perPageForResponse,
+          hasMore: false
+        };
+      }
+      const allMessageIdsWithThreads = [];
+      for (const tid of threadIds) {
+        const threadMessagesKey = getThreadMessagesKey(tid);
+        const msgIds = await this.client.zRange(threadMessagesKey, 0, -1);
+        for (const mid of msgIds) {
+          allMessageIdsWithThreads.push({ threadId: tid, messageId: mid });
+        }
+      }
+      if (allMessageIdsWithThreads.length === 0) {
+        return {
+          messages: [],
+          total: 0,
+          page,
+          perPage: perPageForResponse,
+          hasMore: false
+        };
+      }
+      const messageKeys = allMessageIdsWithThreads.map(({ threadId: tid, messageId }) => getMessageKey(tid, messageId));
+      const results = await this.client.mGet(messageKeys);
+      let messagesData = results.filter((data) => data !== null).map((data) => JSON.parse(data)).map(this.parseStoredMessage);
+      if (resourceId) {
+        messagesData = messagesData.filter((msg) => msg.resourceId === resourceId);
+      }
+      messagesData = storage.filterByDateRange(
+        messagesData,
+        (msg) => new Date(msg.createdAt),
+        filter?.dateRange
+      );
+      messagesData.sort((a, b) => {
+        const aValue = getFieldValue(a);
+        const bValue = getFieldValue(b);
+        return direction === "ASC" ? aValue - bValue : bValue - aValue;
+      });
+      const total = messagesData.length;
+      const start = offset;
+      const end = perPageInput === false ? total : start + perPage;
+      const paginatedMessages = messagesData.slice(start, end);
+      const messageIdsSet = /* @__PURE__ */ new Set();
+      const allMessages = [];
+      for (const msg of paginatedMessages) {
+        if (messageIdsSet.has(msg.id)) {
+          continue;
+        }
+        allMessages.push(msg);
+        messageIdsSet.add(msg.id);
+      }
+      for (const msg of includedMessages) {
+        if (messageIdsSet.has(msg.id)) {
+          continue;
+        }
+        allMessages.push(msg);
+        messageIdsSet.add(msg.id);
+      }
+      const list = new agent.MessageList().add(allMessages, "memory");
+      let finalMessages = list.get.all.db();
+      finalMessages = finalMessages.sort((a, b) => {
+        const aValue = getFieldValue(a);
+        const bValue = getFieldValue(b);
+        return direction === "ASC" ? aValue - bValue : bValue - aValue;
+      });
+      const returnedThreadMessageIds = new Set(
+        finalMessages.filter((m) => {
+          return m.threadId && threadIdsSet.has(m.threadId);
+        }).map((m) => m.id)
+      );
+      const allThreadMessagesReturned = returnedThreadMessageIds.size >= total;
+      const hasMore = perPageInput !== false && !allThreadMessagesReturned && end < total;
+      return {
+        messages: finalMessages,
+        total,
+        page,
+        perPage: perPageForResponse,
+        hasMore
+      };
+    } catch (error$1) {
+      const mastraError = new error.MastraError(
+        {
+          id: storage.createStorageErrorId("REDIS", "LIST_MESSAGES", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            threadId: Array.isArray(threadId) ? threadId.join(",") : threadId,
+            resourceId: resourceId ?? ""
+          }
+        },
+        error$1
+      );
+      this.logger.error(mastraError.toString());
+      this.logger.trackException(mastraError);
+      return {
+        messages: [],
+        total: 0,
+        page,
+        perPage: perPageForResponse,
+        hasMore: false
+      };
+    }
+  }
+  async getResourceById({ resourceId }) {
+    try {
+      const key = `${storage.TABLE_RESOURCES}:${resourceId}`;
+      const data = await this.client.get(key);
+      if (!data) {
+        return null;
+      }
+      const resource = JSON.parse(data);
+      return {
+        ...resource,
+        createdAt: new Date(resource.createdAt),
+        updatedAt: new Date(resource.updatedAt),
+        workingMemory: typeof resource.workingMemory === "object" ? JSON.stringify(resource.workingMemory) : resource.workingMemory,
+        metadata: typeof resource.metadata === "string" ? JSON.parse(resource.metadata) : resource.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, JSON.stringify(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.db.scanKeys(pattern);
+        for (const key of keys) {
+          const data = await this.client.get(key);
+          if (!data) {
+            continue;
+          }
+          const message = JSON.parse(data);
+          if (message && message.id === messageId) {
+            existingMessages.push(message);
+            messageIdToKey[messageId] = key;
+            break;
+          }
+        }
+      }
+      if (existingMessages.length === 0) {
+        return [];
+      }
+      const threadIdsToUpdate = /* @__PURE__ */ new Set();
+      const multi = this.client.multi();
+      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,
+            ...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) {
+          continue;
+        }
+        if (updatePayload.threadId && updatePayload.threadId !== existingMessage.threadId) {
+          multi.zRem(getThreadMessagesKey(existingMessage.threadId), id);
+          multi.del(key);
+          const newKey = getMessageKey(updatePayload.threadId, id);
+          multi.set(newKey, JSON.stringify(updatedMessage));
+          multi.set(getMessageIndexKey(id), updatePayload.threadId);
+          const score = getMessageScore(updatedMessage);
+          multi.zAdd(getThreadMessagesKey(updatePayload.threadId), { score, value: id });
+          messageIdToKey[id] = newKey;
+          continue;
+        }
+        multi.set(key, JSON.stringify(updatedMessage));
+      }
+      const now = /* @__PURE__ */ new Date();
+      for (const threadId of threadIdsToUpdate) {
+        if (threadId) {
+          const threadKey = getKey(storage.TABLE_THREADS, { id: threadId });
+          const existingThreadData = await this.client.get(threadKey);
+          if (existingThreadData) {
+            const existingThread = JSON.parse(existingThreadData);
+            const updatedThread = {
+              ...existingThread,
+              updatedAt: now
+            };
+            multi.set(threadKey, JSON.stringify(processRecord(storage.TABLE_THREADS, updatedThread).processedRecord));
+          }
+        }
+      }
+      await multi.exec();
+      const updatedMessages = [];
+      for (const messageId of messageIds) {
+        const key = messageIdToKey[messageId];
+        if (key) {
+          const data = await this.client.get(key);
+          if (data) {
+            updatedMessages.push(JSON.parse(data));
+          }
+        }
+      }
+      return updatedMessages;
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("REDIS", "UPDATE_MESSAGES", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            messageIds: messages.map((m) => m.id).join(",")
+          }
+        },
+        error$1
+      );
+    }
+  }
+  async deleteMessages(messageIds) {
+    if (!messageIds || messageIds.length === 0) {
+      return;
+    }
+    try {
+      const threadIds = /* @__PURE__ */ new Set();
+      const messageKeys = [];
+      const foundMessageIds = [];
+      const messageIdToThreadId = /* @__PURE__ */ new Map();
+      const indexKeys = messageIds.map((id) => getMessageIndexKey(id));
+      const indexResults = await this.client.mGet(indexKeys);
+      const indexedMessages = [];
+      const unindexedMessageIds = [];
+      messageIds.forEach((id, i) => {
+        const threadId = indexResults[i];
+        if (threadId) {
+          indexedMessages.push({ messageId: id, threadId });
+          return;
+        }
+        unindexedMessageIds.push(id);
+      });
+      for (const { messageId, threadId } of indexedMessages) {
+        messageKeys.push(getMessageKey(threadId, messageId));
+        foundMessageIds.push(messageId);
+        messageIdToThreadId.set(messageId, threadId);
+        threadIds.add(threadId);
+      }
+      for (const messageId of unindexedMessageIds) {
+        const pattern = getMessageKey("*", messageId);
+        const keys = await this.db.scanKeys(pattern);
+        for (const key of keys) {
+          const data = await this.client.get(key);
+          if (!data) {
+            continue;
+          }
+          const message = JSON.parse(data);
+          if (message && message.id === messageId) {
+            messageKeys.push(key);
+            foundMessageIds.push(messageId);
+            if (message.threadId) {
+              messageIdToThreadId.set(messageId, message.threadId);
+              threadIds.add(message.threadId);
+            }
+            break;
+          }
+        }
+      }
+      if (messageKeys.length === 0) {
+        return;
+      }
+      const multi = this.client.multi();
+      for (const key of messageKeys) {
+        multi.del(key);
+      }
+      for (const messageId of foundMessageIds) {
+        multi.del(getMessageIndexKey(messageId));
+      }
+      if (threadIds.size > 0) {
+        for (const threadId of threadIds) {
+          for (const [msgId, msgThreadId] of messageIdToThreadId) {
+            if (msgThreadId === threadId) {
+              multi.zRem(getThreadMessagesKey(threadId), msgId);
+            }
+          }
+          const threadKey = getKey(storage.TABLE_THREADS, { id: threadId });
+          const threadData = await this.client.get(threadKey);
+          if (!threadData) {
+            continue;
+          }
+          const thread = JSON.parse(threadData);
+          const updatedThread = { ...thread, updatedAt: /* @__PURE__ */ new Date() };
+          multi.set(threadKey, JSON.stringify(processRecord(storage.TABLE_THREADS, updatedThread).processedRecord));
+        }
+      }
+      await multi.exec();
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("REDIS", "DELETE_MESSAGES", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { messageIds: messageIds.join(", ") }
+        },
+        error$1
+      );
+    }
+  }
+  sortThreads(threads, field, direction) {
+    return threads.sort((a, b) => {
+      const aValue = new Date(a[field]).getTime();
+      const bValue = new Date(b[field]).getTime();
+      return direction === "ASC" ? aValue - bValue : bValue - aValue;
+    });
+  }
+  async cloneThread(args) {
+    const { sourceThreadId, newThreadId: providedThreadId, resourceId, title, metadata, options } = args;
+    const sourceThread = await this.getThreadById({ threadId: sourceThreadId });
+    if (!sourceThread) {
+      throw new error.MastraError({
+        id: storage.createStorageErrorId("REDIS", "CLONE_THREAD", "SOURCE_NOT_FOUND"),
+        domain: error.ErrorDomain.STORAGE,
+        category: error.ErrorCategory.USER,
+        text: `Source thread with id ${sourceThreadId} not found`,
+        details: { sourceThreadId }
+      });
+    }
+    const newThreadId = providedThreadId || crypto.randomUUID();
+    const existingThread = await this.getThreadById({ threadId: newThreadId });
+    if (existingThread) {
+      throw new error.MastraError({
+        id: storage.createStorageErrorId("REDIS", "CLONE_THREAD", "THREAD_EXISTS"),
+        domain: error.ErrorDomain.STORAGE,
+        category: error.ErrorCategory.USER,
+        text: `Thread with id ${newThreadId} already exists`,
+        details: { newThreadId }
+      });
+    }
+    try {
+      const threadMessagesKey = getThreadMessagesKey(sourceThreadId);
+      const msgIds = await this.client.zRange(threadMessagesKey, 0, -1);
+      const messageKeys = msgIds.map((mid) => getMessageKey(sourceThreadId, mid));
+      let sourceMessages = [];
+      if (messageKeys.length > 0) {
+        const results = await this.client.mGet(messageKeys);
+        sourceMessages = results.filter((data) => data !== null).map((data) => {
+          const msg = JSON.parse(data);
+          return { ...msg, createdAt: new Date(msg.createdAt) };
+        });
+      }
+      if (options?.messageFilter?.startDate || options?.messageFilter?.endDate) {
+        sourceMessages = storage.filterByDateRange(sourceMessages, (msg) => new Date(msg.createdAt), {
+          start: options.messageFilter?.startDate,
+          end: options.messageFilter?.endDate
+        });
+      }
+      if (options?.messageFilter?.messageIds && options.messageFilter.messageIds.length > 0) {
+        const messageIdSet = new Set(options.messageFilter.messageIds);
+        sourceMessages = sourceMessages.filter((msg) => messageIdSet.has(msg.id));
+      }
+      sourceMessages.sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime());
+      if (options?.messageLimit && options.messageLimit > 0 && sourceMessages.length > options.messageLimit) {
+        sourceMessages = sourceMessages.slice(-options.messageLimit);
+      }
+      const now = /* @__PURE__ */ new Date();
+      const lastMessageId = sourceMessages.length > 0 ? sourceMessages[sourceMessages.length - 1].id : void 0;
+      const cloneMetadata = {
+        sourceThreadId,
+        clonedAt: now,
+        ...lastMessageId && { lastMessageId }
+      };
+      const newThread = {
+        id: newThreadId,
+        resourceId: resourceId || sourceThread.resourceId,
+        title: title || (sourceThread.title ? `Clone of ${sourceThread.title}` : void 0),
+        metadata: { ...metadata, clone: cloneMetadata },
+        createdAt: now,
+        updatedAt: now
+      };
+      const multi = this.client.multi();
+      const threadKey = getKey(storage.TABLE_THREADS, { id: newThreadId });
+      multi.set(threadKey, JSON.stringify(processRecord(storage.TABLE_THREADS, newThread).processedRecord));
+      const clonedMessages = [];
+      const targetResourceId = resourceId || sourceThread.resourceId;
+      const newThreadMessagesKey = getThreadMessagesKey(newThreadId);
+      for (let i = 0; i < sourceMessages.length; i++) {
+        const sourceMsg = sourceMessages[i];
+        const newMessageId = crypto.randomUUID();
+        const { _index, ...restMsg } = sourceMsg;
+        const newMessage = {
+          ...restMsg,
+          id: newMessageId,
+          threadId: newThreadId,
+          resourceId: targetResourceId
+        };
+        const messageKey = getMessageKey(newThreadId, newMessageId);
+        multi.set(messageKey, JSON.stringify(newMessage));
+        multi.set(getMessageIndexKey(newMessageId), newThreadId);
+        const score = getMessageScore({ createdAt: newMessage.createdAt, _index: i });
+        multi.zAdd(newThreadMessagesKey, { score, value: newMessageId });
+        clonedMessages.push(newMessage);
+      }
+      await multi.exec();
+      return {
+        thread: newThread,
+        clonedMessages
+      };
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) {
+        throw error$1;
+      }
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("REDIS", "CLONE_THREAD", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { sourceThreadId, newThreadId }
+        },
+        error$1
+      );
+    }
+  }
+};
+function getThreadMessagesKey(threadId) {
+  return `thread:${threadId}:messages`;
+}
+function getMessageKey(threadId, messageId) {
+  return getKey(storage.TABLE_MESSAGES, { threadId, id: messageId });
+}
+function getMessageIndexKey(messageId) {
+  return `msg-idx:${messageId}`;
+}
+function getMessageScore(message) {
+  const createdAtScore = new Date(message.createdAt).getTime();
+  const index = typeof message._index === "number" ? message._index : 0;
+  return createdAtScore * 1e3 + index;
+}
+var ScoresRedis = class extends storage.ScoresStorage {
+  client;
+  db;
+  constructor(config) {
+    super();
+    this.client = config.client;
+    this.db = new RedisDB({ client: config.client });
+  }
+  async dangerouslyClearAll() {
+    await this.db.deleteData({ tableName: storage.TABLE_SCORERS });
+  }
+  async getScoreById({ id }) {
+    try {
+      const data = await this.db.get({
+        tableName: storage.TABLE_SCORERS,
+        keys: { id }
+      });
+      if (!data) {
+        return null;
+      }
+      return storage.transformScoreRow(data);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("REDIS", "GET_SCORE_BY_ID", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            ...id && { id }
+          }
+        },
+        error$1
+      );
+    }
+  }
+  async listScoresByScorerId({
+    scorerId,
+    entityId,
+    entityType,
+    source,
+    pagination = { page: 0, perPage: 20 }
+  }) {
+    return this.fetchAndFilterScores(pagination, (row) => {
+      if (row.scorerId !== scorerId) {
+        return false;
+      }
+      if (entityId && row.entityId !== entityId) {
+        return false;
+      }
+      if (entityType && row.entityType !== entityType) {
+        return false;
+      }
+      if (source && row.source !== source) {
+        return false;
+      }
+      return true;
+    });
+  }
+  async saveScore(score) {
+    let validatedScore;
+    try {
+      validatedScore = evals.saveScorePayloadSchema.parse(score);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("REDIS", "SAVE_SCORE", "VALIDATION_FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: {
+            scorer: typeof score.scorer?.id === "string" ? score.scorer.id : String(score.scorer?.id ?? "unknown"),
+            entityId: score.entityId ?? "unknown",
+            entityType: score.entityType ?? "unknown",
+            traceId: score.traceId ?? "",
+            spanId: score.spanId ?? ""
+          }
+        },
+        error$1
+      );
+    }
+    const now = /* @__PURE__ */ new Date();
+    const id = crypto2__default.default.randomUUID();
+    const scoreWithId = {
+      ...validatedScore,
+      id,
+      createdAt: now,
+      updatedAt: now
+    };
+    const { key, processedRecord } = processRecord(storage.TABLE_SCORERS, scoreWithId);
+    try {
+      await this.client.set(key, JSON.stringify(processedRecord));
+      return { score: { ...validatedScore, id, createdAt: now, updatedAt: now } };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("REDIS", "SAVE_SCORE", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { id }
+        },
+        error$1
+      );
+    }
+  }
+  async listScoresByRunId({
+    runId,
+    pagination = { page: 0, perPage: 20 }
+  }) {
+    return this.fetchAndFilterScores(pagination, (row) => row.runId === runId);
+  }
+  async listScoresByEntityId({
+    entityId,
+    entityType,
+    pagination = { page: 0, perPage: 20 }
+  }) {
+    return this.fetchAndFilterScores(pagination, (row) => {
+      if (row.entityId !== entityId) {
+        return false;
+      }
+      if (entityType && row.entityType !== entityType) {
+        return false;
+      }
+      return true;
+    });
+  }
+  async listScoresBySpan({
+    traceId,
+    spanId,
+    pagination = { page: 0, perPage: 20 }
+  }) {
+    return this.fetchAndFilterScores(pagination, (row) => row.traceId === traceId && row.spanId === spanId);
+  }
+  async fetchAndFilterScores(pagination, filterFn) {
+    const { page, perPage: perPageInput } = pagination;
+    const keys = await this.db.scanKeys(`${storage.TABLE_SCORERS}:*`);
+    if (keys.length === 0) {
+      return {
+        scores: [],
+        pagination: { total: 0, page, perPage: perPageInput, hasMore: false }
+      };
+    }
+    const results = await this.client.mGet(keys);
+    const filtered = results.map((data) => {
+      if (!data) {
+        return null;
+      }
+      try {
+        return JSON.parse(data);
+      } catch {
+        return null;
+      }
+    }).filter((row) => !!row && typeof row === "object" && filterFn(row));
+    const total = filtered.length;
+    const perPage = storage.normalizePerPage(perPageInput, 100);
+    const { offset: start, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
+    const end = perPageInput === false ? total : start + perPage;
+    const scores = filtered.slice(start, end).map((row) => storage.transformScoreRow(row));
+    return {
+      scores,
+      pagination: {
+        total,
+        page,
+        perPage: perPageForResponse,
+        hasMore: end < total
+      }
+    };
+  }
+};
+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: storage.ensureDate(row.createdAt),
+    updatedAt: storage.ensureDate(row.updatedAt),
+    resourceId: row.resourceId
+  };
+}
+var WorkflowsRedis = class extends storage.WorkflowsStorage {
+  client;
+  db;
+  constructor(config) {
+    super();
+    this.client = config.client;
+    this.db = new RedisDB({ client: config.client });
+  }
+  supportsConcurrentUpdates() {
+    return false;
+  }
+  async dangerouslyClearAll() {
+    await this.db.deleteData({ tableName: storage.TABLE_WORKFLOW_SNAPSHOT });
+  }
+  async updateWorkflowResults({
+    workflowName,
+    runId,
+    stepId,
+    result,
+    requestContext
+  }) {
+    try {
+      const existingRecord = await this.db.get({
+        tableName: storage.TABLE_WORKFLOW_SNAPSHOT,
+        keys: {
+          namespace: "workflows",
+          workflow_name: workflowName,
+          run_id: runId
+        }
+      });
+      const existingSnapshot = existingRecord?.snapshot;
+      let snapshot = existingSnapshot;
+      if (!snapshot) {
+        snapshot = {
+          context: {},
+          activePaths: [],
+          timestamp: Date.now(),
+          suspendedPaths: {},
+          activeStepsPath: {},
+          resumeLabels: {},
+          serializedStepGraph: [],
+          status: "pending",
+          value: {},
+          waitingPaths: {},
+          runId,
+          requestContext: {}
+        };
+      }
+      snapshot.context[stepId] = result;
+      snapshot.requestContext = { ...snapshot.requestContext, ...requestContext };
+      await this.persistWorkflowSnapshot({
+        namespace: "workflows",
+        workflowName,
+        runId,
+        snapshot,
+        createdAt: existingRecord?.createdAt ? storage.ensureDate(existingRecord.createdAt) : void 0
+      });
+      return snapshot.context;
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) {
+        throw error$1;
+      }
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("REDIS", "UPDATE_WORKFLOW_RESULTS", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { workflowName, runId, stepId }
+        },
+        error$1
+      );
+    }
+  }
+  async updateWorkflowState({
+    workflowName,
+    runId,
+    opts
+  }) {
+    try {
+      const existingRecord = await this.db.get({
+        tableName: storage.TABLE_WORKFLOW_SNAPSHOT,
+        keys: {
+          namespace: "workflows",
+          workflow_name: workflowName,
+          run_id: runId
+        }
+      });
+      const existingSnapshot = existingRecord?.snapshot;
+      if (!existingSnapshot || !existingSnapshot.context) {
+        return void 0;
+      }
+      const updatedSnapshot = { ...existingSnapshot, ...opts };
+      await this.persistWorkflowSnapshot({
+        namespace: "workflows",
+        workflowName,
+        runId,
+        snapshot: updatedSnapshot,
+        createdAt: existingRecord?.createdAt ? storage.ensureDate(existingRecord.createdAt) : void 0
+      });
+      return updatedSnapshot;
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) {
+        throw error$1;
+      }
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("REDIS", "UPDATE_WORKFLOW_STATE", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { workflowName, runId }
+        },
+        error$1
+      );
+    }
+  }
+  async persistWorkflowSnapshot(params) {
+    const { namespace = "workflows", workflowName, runId, resourceId, snapshot, createdAt, updatedAt } = params;
+    try {
+      let finalCreatedAt = createdAt;
+      if (!finalCreatedAt) {
+        const existing = await this.db.get({
+          tableName: storage.TABLE_WORKFLOW_SNAPSHOT,
+          keys: {
+            namespace,
+            workflow_name: workflowName,
+            run_id: runId
+          }
+        });
+        finalCreatedAt = existing?.createdAt ? storage.ensureDate(existing.createdAt) : /* @__PURE__ */ new Date();
+      }
+      await this.db.insert({
+        tableName: storage.TABLE_WORKFLOW_SNAPSHOT,
+        record: {
+          namespace,
+          workflow_name: workflowName,
+          run_id: runId,
+          resourceId,
+          snapshot,
+          createdAt: finalCreatedAt,
+          updatedAt: updatedAt ?? /* @__PURE__ */ new Date()
+        }
+      });
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("REDIS", "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;
+      }
+      const parsed = JSON.parse(data);
+      return parsed.snapshot;
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("REDIS", "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.db.scanKeys(key);
+      if (keys.length === 0) {
+        return null;
+      }
+      const results = await this.client.mGet(keys);
+      const workflows = results.filter((data2) => data2 !== null).map(
+        (data2) => JSON.parse(data2)
+      );
+      const data = workflows.find((workflow) => {
+        if (!workflow) {
+          return false;
+        }
+        const runIdMatch = workflow.run_id === runId;
+        if (workflowName) {
+          return runIdMatch && workflow.workflow_name === workflowName;
+        }
+        return runIdMatch;
+      });
+      if (!data) {
+        return null;
+      }
+      return parseWorkflowRun(data);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("REDIS", "GET_WORKFLOW_RUN_BY_ID", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            namespace: "workflows",
+            runId,
+            workflowName: workflowName || ""
+          }
+        },
+        error$1
+      );
+    }
+  }
+  async deleteWorkflowRunById({ runId, workflowName }) {
+    const key = getKey(storage.TABLE_WORKFLOW_SNAPSHOT, { namespace: "workflows", workflow_name: workflowName, run_id: runId });
+    try {
+      await this.client.del(key);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("REDIS", "DELETE_WORKFLOW_RUN_BY_ID", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            namespace: "workflows",
+            runId,
+            workflowName
+          }
+        },
+        error$1
+      );
+    }
+  }
+  async listWorkflowRuns({
+    workflowName,
+    fromDate,
+    toDate,
+    perPage,
+    page,
+    resourceId,
+    status
+  } = {}) {
+    try {
+      if (page !== void 0 && page < 0) {
+        throw new error.MastraError(
+          {
+            id: storage.createStorageErrorId("REDIS", "LIST_WORKFLOW_RUNS", "INVALID_PAGE"),
+            domain: error.ErrorDomain.STORAGE,
+            category: error.ErrorCategory.USER,
+            details: { page }
+          },
+          new Error("page must be >= 0")
+        );
+      }
+      const normalizedFrom = fromDate ? storage.ensureDate(fromDate) : void 0;
+      const normalizedTo = toDate ? storage.ensureDate(toDate) : void 0;
+      let pattern = getKey(storage.TABLE_WORKFLOW_SNAPSHOT, { namespace: "workflows" }) + ":*";
+      if (workflowName && resourceId) {
+        pattern = getKey(storage.TABLE_WORKFLOW_SNAPSHOT, {
+          namespace: "workflows",
+          workflow_name: workflowName,
+          run_id: "*",
+          resourceId
+        });
+      } else if (workflowName) {
+        pattern = getKey(storage.TABLE_WORKFLOW_SNAPSHOT, { namespace: "workflows", workflow_name: workflowName }) + ":*";
+      } else if (resourceId) {
+        pattern = getKey(storage.TABLE_WORKFLOW_SNAPSHOT, {
+          namespace: "workflows",
+          workflow_name: "*",
+          run_id: "*",
+          resourceId
+        });
+      }
+      const keys = await this.db.scanKeys(pattern);
+      if (keys.length === 0) {
+        return { runs: [], total: 0 };
+      }
+      const results = await this.client.mGet(keys);
+      let runs = results.filter((data) => data !== null).map((data) => JSON.parse(data)).filter(
+        (record) => record !== null && record !== void 0 && typeof record === "object" && "workflow_name" in record
+      ).filter((record) => !workflowName || record.workflow_name === workflowName).map((w) => parseWorkflowRun(w)).filter((w) => {
+        if (normalizedFrom && w.createdAt < normalizedFrom) {
+          return false;
+        }
+        if (normalizedTo && w.createdAt > normalizedTo) {
+          return false;
+        }
+        if (status) {
+          let snapshot = w.snapshot;
+          if (typeof snapshot === "string") {
+            try {
+              snapshot = JSON.parse(snapshot);
+            } catch (e) {
+              console.warn(`Failed to parse snapshot for workflow ${w.workflowName}: ${e}`);
+              return false;
+            }
+          }
+          return snapshot.status === status;
+        }
+        return true;
+      }).sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
+      const total = runs.length;
+      if (typeof perPage === "number" && typeof page === "number") {
+        const normalizedPerPage = storage.normalizePerPage(perPage, Number.MAX_SAFE_INTEGER);
+        const offset = page * normalizedPerPage;
+        runs = runs.slice(offset, offset + normalizedPerPage);
+      }
+      return { runs, total };
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) {
+        throw error$1;
+      }
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("REDIS", "LIST_WORKFLOW_RUNS", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            namespace: "workflows",
+            workflowName: workflowName || "",
+            resourceId: resourceId || ""
+          }
+        },
+        error$1
+      );
+    }
+  }
+};
+
+// src/storage/utils.ts
+function isClientConfig(config) {
+  return "client" in config;
+}
+function isConnectionStringConfig(config) {
+  return "connectionString" in config;
+}
+
+// src/storage/store.ts
+var RedisStore = class extends storage.MastraStorage {
+  client;
+  shouldManageConnection;
+  stores;
+  constructor(config) {
+    super({ id: config.id, name: "Redis", disableInit: config.disableInit });
+    const { client, shouldManageConnection } = this.createClient(config);
+    this.client = client;
+    this.shouldManageConnection = shouldManageConnection;
+    this.stores = {
+      scores: new ScoresRedis({ client: this.client }),
+      workflows: new WorkflowsRedis({ client: this.client }),
+      memory: new StoreMemoryRedis({ client: this.client })
+    };
+  }
+  async init() {
+    if (this.shouldManageConnection && !this.client.isOpen) {
+      await this.client.connect();
+    }
+    await super.init();
+  }
+  getClient() {
+    return this.client;
+  }
+  async close() {
+    if (this.shouldManageConnection && this.client.isOpen) {
+      await this.client.quit();
+    }
+  }
+  createClient(config) {
+    if (isClientConfig(config)) {
+      return { client: config.client, shouldManageConnection: false };
+    }
+    if (isConnectionStringConfig(config)) {
+      if (!config.connectionString?.trim()) {
+        throw new Error("RedisStore: connectionString is required and cannot be empty.");
+      }
+      return {
+        client: redis.createClient({ url: config.connectionString }),
+        shouldManageConnection: true
+      };
+    }
+    if (!config.host?.trim()) {
+      throw new Error("RedisStore: host is required and cannot be empty.");
+    }
+    const url = this.createClientUrl({
+      ...config,
+      db: config.db ?? 0,
+      port: config.port ?? 6379
+    });
+    return {
+      client: redis.createClient({ url }),
+      shouldManageConnection: true
+    };
+  }
+  createClientUrl(config) {
+    const encodedPassword = config.password ? encodeURIComponent(config.password) : null;
+    if (config.password) {
+      return `redis://:${encodedPassword}@${config.host}:${config.port || 6379}/${config.db || 0}`;
+    }
+    return `redis://${config.host}:${config.port || 6379}/${config.db || 0}`;
+  }
+};
+
+exports.RedisStore = RedisStore;
+exports.ScoresRedis = ScoresRedis;
+exports.StoreMemoryRedis = StoreMemoryRedis;
+exports.WorkflowsRedis = WorkflowsRedis;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map