@mastra/upstash 1.0.0-beta.7 → 1.0.0-beta.9

package/dist/index.cjs

@@ -11,13 +11,6 @@ var vector$1 = require('@upstash/vector');
 var filter = require('@mastra/core/vector/filter');
 
 // src/storage/index.ts
-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 getKey(tableName, keys) {
   const keyParts = Object.entries(keys).filter(([_, value]) => value !== void 0).map(([key, value]) => `${key}:${value}`);
   return `${tableName}:${keyParts.join(":")}`;
@@ -46,6 +39,107 @@ function processRecord(tableName, record) {
   return { key, processedRecord };
 }
 
+// src/storage/db/index.ts
+function resolveUpstashConfig(config) {
+  if ("client" in config) {
+    return config.client;
+  }
+  return new redis.Redis({
+    url: config.url,
+    token: config.token
+  });
+}
+var UpstashDB = class {
+  client;
+  constructor({ client }) {
+    this.client = client;
+  }
+  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.createStorageErrorId("UPSTASH", "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);
+      return data || null;
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("UPSTASH", "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 [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;
+  }
+  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 deleteData({ tableName }) {
+    const pattern = `${tableName}:*`;
+    try {
+      await this.scanAndDelete(pattern);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("UPSTASH", "CLEAR_TABLE", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            tableName
+          }
+        },
+        error$1
+      );
+    }
+  }
+};
+
 // src/storage/domains/memory/index.ts
 function getThreadMessagesKey(threadId) {
   return `thread:${threadId}:messages`;
@@ -59,23 +153,29 @@ function getMessageIndexKey(messageId) {
 }
 var StoreMemoryUpstash = class extends storage.MemoryStorage {
   client;
-  operations;
-  constructor({ client, operations }) {
+  #db;
+  constructor(config) {
     super();
+    const client = resolveUpstashConfig(config);
     this.client = client;
-    this.operations = operations;
+    this.#db = new UpstashDB({ 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 });
   }
   async getThreadById({ threadId }) {
     try {
-      const thread = await this.operations.load({
+      const thread = await this.#db.get({
         tableName: storage.TABLE_THREADS,
         keys: { id: threadId }
       });
       if (!thread) return null;
       return {
         ...thread,
-        createdAt: ensureDate(thread.createdAt),
-        updatedAt: ensureDate(thread.updatedAt),
+        createdAt: storage.ensureDate(thread.createdAt),
+        updatedAt: storage.ensureDate(thread.updatedAt),
         metadata: typeof thread.metadata === "string" ? JSON.parse(thread.metadata) : thread.metadata
       };
     } catch (error$1) {
@@ -111,7 +211,7 @@ var StoreMemoryUpstash = class extends storage.MemoryStorage {
     try {
       let allThreads = [];
       const pattern = `${storage.TABLE_THREADS}:*`;
-      const keys = await this.operations.scanKeys(pattern);
+      const keys = await this.#db.scanKeys(pattern);
       const pipeline = this.client.pipeline();
       keys.forEach((key) => pipeline.get(key));
       const results = await pipeline.exec();
@@ -120,8 +220,8 @@ var StoreMemoryUpstash = class extends storage.MemoryStorage {
         if (thread && thread.resourceId === resourceId) {
           allThreads.push({
             ...thread,
-            createdAt: ensureDate(thread.createdAt),
-            updatedAt: ensureDate(thread.updatedAt),
+            createdAt: storage.ensureDate(thread.createdAt),
+            updatedAt: storage.ensureDate(thread.updatedAt),
             metadata: typeof thread.metadata === "string" ? JSON.parse(thread.metadata) : thread.metadata
           });
         }
@@ -165,7 +265,7 @@ var StoreMemoryUpstash = class extends storage.MemoryStorage {
   }
   async saveThread({ thread }) {
     try {
-      await this.operations.insert({
+      await this.#db.insert({
         tableName: storage.TABLE_THREADS,
         record: thread
       });
@@ -243,7 +343,7 @@ var StoreMemoryUpstash = class extends storage.MemoryStorage {
         pipeline.del(messageKey);
       }
       await pipeline.exec();
-      await this.operations.scanAndDelete(getMessageKey(threadId, "*"));
+      await this.#db.scanAndDelete(getMessageKey(threadId, "*"));
     } catch (error$1) {
       throw new error.MastraError(
         {
@@ -308,7 +408,7 @@ var StoreMemoryUpstash = class extends storage.MemoryStorage {
           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);
+          const keys = await this.#db.scanKeys(existingKeyPattern);
           if (keys.length > 0) {
             const pipeline2 = this.client.pipeline();
             keys.forEach((key2) => pipeline2.get(key2));
@@ -363,7 +463,7 @@ var StoreMemoryUpstash = class extends storage.MemoryStorage {
       return indexedThreadId;
     }
     const existingKeyPattern = getMessageKey("*", messageId);
-    const keys = await this.operations.scanKeys(existingKeyPattern);
+    const keys = await this.#db.scanKeys(existingKeyPattern);
     if (keys.length === 0) return null;
     const messageData = await this.client.get(keys[0]);
     if (!messageData) return null;
@@ -704,7 +804,7 @@ var StoreMemoryUpstash = class extends storage.MemoryStorage {
       const messageIdToKey = {};
       for (const messageId of messageIds) {
         const pattern = getMessageKey("*", messageId);
-        const keys = await this.operations.scanKeys(pattern);
+        const keys = await this.#db.scanKeys(pattern);
         for (const key of keys) {
           const message = await this.client.get(key);
           if (message && message.id === messageId) {
@@ -833,7 +933,7 @@ var StoreMemoryUpstash = class extends storage.MemoryStorage {
       }
       for (const messageId of unindexedMessageIds) {
         const pattern = getMessageKey("*", messageId);
-        const keys = await this.operations.scanKeys(pattern);
+        const keys = await this.#db.scanKeys(pattern);
         for (const key of keys) {
           const message = await this.client.get(key);
           if (message && message.id === messageId) {
@@ -894,156 +994,24 @@ var StoreMemoryUpstash = class extends storage.MemoryStorage {
     });
   }
 };
-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.createStorageErrorId("UPSTASH", "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.createStorageErrorId("UPSTASH", "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.createStorageErrorId("UPSTASH", "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.createStorageErrorId("UPSTASH", "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) {
   return storage.transformScoreRow(row);
 }
 var ScoresUpstash = class extends storage.ScoresStorage {
   client;
-  operations;
-  constructor({ client, operations }) {
+  #db;
+  constructor(config) {
     super();
+    const client = resolveUpstashConfig(config);
     this.client = client;
-    this.operations = operations;
+    this.#db = new UpstashDB({ client });
+  }
+  async dangerouslyClearAll() {
+    await this.#db.deleteData({ tableName: storage.TABLE_SCORERS });
   }
   async getScoreById({ id }) {
     try {
-      const data = await this.operations.load({
+      const data = await this.#db.get({
         tableName: storage.TABLE_SCORERS,
         keys: { id }
       });
@@ -1071,7 +1039,7 @@ var ScoresUpstash = class extends storage.ScoresStorage {
     pagination = { page: 0, perPage: 20 }
   }) {
     const pattern = `${storage.TABLE_SCORERS}:*`;
-    const keys = await this.operations.scanKeys(pattern);
+    const keys = await this.#db.scanKeys(pattern);
     const { page, perPage: perPageInput } = pagination;
     if (keys.length === 0) {
       return {
@@ -1127,7 +1095,7 @@ var ScoresUpstash = class extends storage.ScoresStorage {
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.USER,
           details: {
-            scorer: score.scorer?.id ?? "unknown",
+            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 ?? "",
@@ -1168,7 +1136,7 @@ var ScoresUpstash = class extends storage.ScoresStorage {
     pagination = { page: 0, perPage: 20 }
   }) {
     const pattern = `${storage.TABLE_SCORERS}:*`;
-    const keys = await this.operations.scanKeys(pattern);
+    const keys = await this.#db.scanKeys(pattern);
     const { page, perPage: perPageInput } = pagination;
     if (keys.length === 0) {
       return {
@@ -1212,7 +1180,7 @@ var ScoresUpstash = class extends storage.ScoresStorage {
     pagination = { page: 0, perPage: 20 }
   }) {
     const pattern = `${storage.TABLE_SCORERS}:*`;
-    const keys = await this.operations.scanKeys(pattern);
+    const keys = await this.#db.scanKeys(pattern);
     const { page, perPage: perPageInput } = pagination;
     if (keys.length === 0) {
       return {
@@ -1261,7 +1229,7 @@ var ScoresUpstash = class extends storage.ScoresStorage {
     pagination = { page: 0, perPage: 20 }
   }) {
     const pattern = `${storage.TABLE_SCORERS}:*`;
-    const keys = await this.operations.scanKeys(pattern);
+    const keys = await this.#db.scanKeys(pattern);
     const { page, perPage: perPageInput } = pagination;
     if (keys.length === 0) {
       return {
@@ -1318,39 +1286,116 @@ function parseWorkflowRun(row) {
     workflowName: row.workflow_name,
     runId: row.run_id,
     snapshot: parsedSnapshot,
-    createdAt: ensureDate(row.createdAt),
-    updatedAt: ensureDate(row.updatedAt),
+    createdAt: storage.ensureDate(row.createdAt),
+    updatedAt: storage.ensureDate(row.updatedAt),
     resourceId: row.resourceId
   };
 }
 var WorkflowsUpstash = class extends storage.WorkflowsStorage {
   client;
-  operations;
-  constructor({ client, operations }) {
+  #db;
+  constructor(config) {
     super();
+    const client = resolveUpstashConfig(config);
     this.client = client;
-    this.operations = operations;
-  }
-  updateWorkflowResults({
-    // workflowName,
-    // runId,
-    // stepId,
-    // result,
-    // requestContext,
+    this.#db = new UpstashDB({ client });
+  }
+  async dangerouslyClearAll() {
+    await this.#db.deleteData({ tableName: storage.TABLE_WORKFLOW_SNAPSHOT });
+  }
+  async updateWorkflowResults({
+    workflowName,
+    runId,
+    stepId,
+    result,
+    requestContext
   }) {
-    throw new Error("Method not implemented.");
+    try {
+      const existingSnapshot = await this.loadWorkflowSnapshot({
+        namespace: "workflows",
+        workflowName,
+        runId
+      });
+      let snapshot;
+      if (!existingSnapshot) {
+        snapshot = {
+          context: {},
+          activePaths: [],
+          timestamp: Date.now(),
+          suspendedPaths: {},
+          activeStepsPath: {},
+          resumeLabels: {},
+          serializedStepGraph: [],
+          status: "pending",
+          value: {},
+          waitingPaths: {},
+          runId,
+          requestContext: {}
+        };
+      } else {
+        snapshot = existingSnapshot;
+      }
+      snapshot.context[stepId] = result;
+      snapshot.requestContext = { ...snapshot.requestContext, ...requestContext };
+      await this.persistWorkflowSnapshot({
+        namespace: "workflows",
+        workflowName,
+        runId,
+        snapshot
+      });
+      return snapshot.context;
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) throw error$1;
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("UPSTASH", "UPDATE_WORKFLOW_RESULTS", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { workflowName, runId, stepId }
+        },
+        error$1
+      );
+    }
   }
-  updateWorkflowState({
-    // workflowName,
-    // runId,
-    // opts,
+  async updateWorkflowState({
+    workflowName,
+    runId,
+    opts
   }) {
-    throw new Error("Method not implemented.");
+    try {
+      const existingSnapshot = await this.loadWorkflowSnapshot({
+        namespace: "workflows",
+        workflowName,
+        runId
+      });
+      if (!existingSnapshot || !existingSnapshot.context) {
+        return void 0;
+      }
+      const updatedSnapshot = { ...existingSnapshot, ...opts };
+      await this.persistWorkflowSnapshot({
+        namespace: "workflows",
+        workflowName,
+        runId,
+        snapshot: updatedSnapshot
+      });
+      return updatedSnapshot;
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) throw error$1;
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("UPSTASH", "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 } = params;
+    const { namespace = "workflows", workflowName, runId, resourceId, snapshot, createdAt, updatedAt } = params;
     try {
-      await this.operations.insert({
+      await this.#db.insert({
         tableName: storage.TABLE_WORKFLOW_SNAPSHOT,
         record: {
           namespace,
@@ -1358,8 +1403,8 @@ var WorkflowsUpstash = class extends storage.WorkflowsStorage {
           run_id: runId,
           resourceId,
           snapshot,
-          createdAt: /* @__PURE__ */ new Date(),
-          updatedAt: /* @__PURE__ */ new Date()
+          createdAt: createdAt ?? /* @__PURE__ */ new Date(),
+          updatedAt: updatedAt ?? /* @__PURE__ */ new Date()
         }
       });
     } catch (error$1) {
@@ -1411,7 +1456,7 @@ var WorkflowsUpstash = class extends storage.WorkflowsStorage {
   }) {
     try {
       const key = getKey(storage.TABLE_WORKFLOW_SNAPSHOT, { namespace: "workflows", workflow_name: workflowName, run_id: runId }) + "*";
-      const keys = await this.operations.scanKeys(key);
+      const keys = await this.#db.scanKeys(key);
       const workflows = await Promise.all(
         keys.map(async (key2) => {
           const data2 = await this.client.get(key2);
@@ -1465,7 +1510,7 @@ var WorkflowsUpstash = class extends storage.WorkflowsStorage {
     page,
     resourceId,
     status
-  }) {
+  } = {}) {
     try {
       if (page !== void 0 && page < 0) {
         throw new error.MastraError(
@@ -1496,7 +1541,7 @@ var WorkflowsUpstash = class extends storage.WorkflowsStorage {
           resourceId
         });
       }
-      const keys = await this.operations.scanKeys(pattern);
+      const keys = await this.#db.scanKeys(pattern);
       if (keys.length === 0) {
         return { runs: [], total: 0 };
       }
@@ -1549,182 +1594,39 @@ var WorkflowsUpstash = class extends storage.WorkflowsStorage {
 };
 
 // src/storage/index.ts
+var isClientConfig = (config) => {
+  return "client" in config;
+};
 var UpstashStore = class extends storage.MastraStorage {
   redis;
   stores;
   constructor(config) {
     super({ id: config.id, name: "Upstash", disableInit: config.disableInit });
-    this.redis = new redis.Redis({
-      url: config.url,
-      token: config.token
-    });
-    const operations = new StoreOperationsUpstash({ client: this.redis });
-    const scores = new ScoresUpstash({ client: this.redis, operations });
-    const workflows = new WorkflowsUpstash({ client: this.redis, operations });
-    const memory = new StoreMemoryUpstash({ client: this.redis, operations });
+    if (isClientConfig(config)) {
+      this.redis = config.client;
+    } else {
+      if (!config.url || typeof config.url !== "string" || config.url.trim() === "") {
+        throw new Error("UpstashStore: url is required and cannot be empty.");
+      }
+      if (!config.token || typeof config.token !== "string" || config.token.trim() === "") {
+        throw new Error("UpstashStore: token is required and cannot be empty.");
+      }
+      this.redis = new redis.Redis({
+        url: config.url,
+        token: config.token
+      });
+    }
+    const scores = new ScoresUpstash({ client: this.redis });
+    const workflows = new WorkflowsUpstash({ client: this.redis });
+    const memory = new StoreMemoryUpstash({ client: this.redis });
     this.stores = {
-      operations,
       scores,
       workflows,
       memory
     };
   }
-  get supports() {
-    return {
-      selectByIncludeResourceScope: true,
-      resourceWorkingMemory: true,
-      hasColumn: false,
-      createTable: false,
-      deleteMessages: true,
-      listScoresBySpan: true
-    };
-  }
-  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 });
-  }
-  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 listMessagesById({ messageIds }) {
-    return this.stores.memory.listMessagesById({ messageIds });
-  }
-  async updateWorkflowResults({
-    workflowName,
-    runId,
-    stepId,
-    result,
-    requestContext
-  }) {
-    return this.stores.workflows.updateWorkflowResults({ workflowName, runId, stepId, result, requestContext });
-  }
-  async updateWorkflowState({
-    workflowName,
-    runId,
-    opts
-  }) {
-    return this.stores.workflows.updateWorkflowState({ workflowName, runId, opts });
-  }
-  async persistWorkflowSnapshot(params) {
-    return this.stores.workflows.persistWorkflowSnapshot(params);
-  }
-  async loadWorkflowSnapshot(params) {
-    return this.stores.workflows.loadWorkflowSnapshot(params);
-  }
-  async deleteWorkflowRunById({ runId, workflowName }) {
-    return this.stores.workflows.deleteWorkflowRunById({ runId, workflowName });
-  }
-  async listWorkflowRuns(args = {}) {
-    return this.stores.workflows.listWorkflowRuns(args);
-  }
-  async getWorkflowRunById({
-    runId,
-    workflowName
-  }) {
-    return this.stores.workflows.getWorkflowRunById({ runId, workflowName });
-  }
   async close() {
   }
-  async updateMessages(args) {
-    return this.stores.memory.updateMessages(args);
-  }
-  async deleteMessages(messageIds) {
-    return this.stores.memory.deleteMessages(messageIds);
-  }
-  async getResourceById({ resourceId }) {
-    return this.stores.memory.getResourceById({ resourceId });
-  }
-  async saveResource({ resource }) {
-    return this.stores.memory.saveResource({ resource });
-  }
-  async updateResource({
-    resourceId,
-    workingMemory,
-    metadata
-  }) {
-    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 listScoresByRunId({
-    runId,
-    pagination
-  }) {
-    return this.stores.scores.listScoresByRunId({ runId, pagination });
-  }
-  async listScoresByEntityId({
-    entityId,
-    entityType,
-    pagination
-  }) {
-    return this.stores.scores.listScoresByEntityId({
-      entityId,
-      entityType,
-      pagination
-    });
-  }
-  async listScoresByScorerId({
-    scorerId,
-    pagination,
-    entityId,
-    entityType,
-    source
-  }) {
-    return this.stores.scores.listScoresByScorerId({ scorerId, pagination, entityId, entityType, source });
-  }
-  async listScoresBySpan({
-    traceId,
-    spanId,
-    pagination
-  }) {
-    return this.stores.scores.listScoresBySpan({ traceId, spanId, pagination });
-  }
 };
 var UpstashFilterTranslator = class extends filter.BaseFilterTranslator {
   getSupportedOperators() {
@@ -2417,8 +2319,11 @@ Example Complex Query:
   ]
 }`;
 
+exports.ScoresUpstash = ScoresUpstash;
+exports.StoreMemoryUpstash = StoreMemoryUpstash;
 exports.UPSTASH_PROMPT = UPSTASH_PROMPT;
 exports.UpstashStore = UpstashStore;
 exports.UpstashVector = UpstashVector;
+exports.WorkflowsUpstash = WorkflowsUpstash;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map