@mastra/upstash 1.0.0-beta.6 → 1.0.0-beta.8

package/dist/index.js

@@ -1,4 +1,4 @@
-import { MastraStorage, createVectorErrorId, StoreOperations, createStorageErrorId, ScoresStorage, TABLE_SCORERS, normalizePerPage, calculatePagination, WorkflowsStorage, TABLE_WORKFLOW_SNAPSHOT, MemoryStorage, TABLE_THREADS, TABLE_RESOURCES, TABLE_MESSAGES, serializeDate, transformScoreRow as transformScoreRow$1 } from '@mastra/core/storage';
+import { MastraStorage, createVectorErrorId, ScoresStorage, TABLE_SCORERS, createStorageErrorId, normalizePerPage, calculatePagination, WorkflowsStorage, TABLE_WORKFLOW_SNAPSHOT, MemoryStorage, TABLE_THREADS, TABLE_MESSAGES, TABLE_RESOURCES, ensureDate, transformScoreRow as transformScoreRow$1, serializeDate } from '@mastra/core/storage';
 import { Redis } from '@upstash/redis';
 import { MessageList } from '@mastra/core/agent';
 import { MastraError, ErrorCategory, ErrorDomain } from '@mastra/core/error';
@@ -9,13 +9,6 @@ import { Index } from '@upstash/vector';
 import { BaseFilterTranslator } from '@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(":")}`;
@@ -44,6 +37,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({
+    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) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("UPSTASH", "INSERT", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: {
+            tableName
+          }
+        },
+        error
+      );
+    }
+  }
+  async get({ tableName, keys }) {
+    const key = getKey(tableName, keys);
+    try {
+      const data = await this.client.get(key);
+      return data || null;
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("UPSTASH", "LOAD", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: {
+            tableName
+          }
+        },
+        error
+      );
+    }
+  }
+  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) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("UPSTASH", "CLEAR_TABLE", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: {
+            tableName
+          }
+        },
+        error
+      );
+    }
+  }
+};
+
 // src/storage/domains/memory/index.ts
 function getThreadMessagesKey(threadId) {
   return `thread:${threadId}:messages`;
@@ -57,15 +151,21 @@ function getMessageIndexKey(messageId) {
 }
 var StoreMemoryUpstash = class extends 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: TABLE_THREADS });
+    await this.#db.deleteData({ tableName: TABLE_MESSAGES });
+    await this.#db.deleteData({ tableName: TABLE_RESOURCES });
   }
   async getThreadById({ threadId }) {
     try {
-      const thread = await this.operations.load({
+      const thread = await this.#db.get({
         tableName: TABLE_THREADS,
         keys: { id: threadId }
       });
@@ -109,7 +209,7 @@ var StoreMemoryUpstash = class extends MemoryStorage {
     try {
       let allThreads = [];
       const pattern = `${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();
@@ -163,7 +263,7 @@ var StoreMemoryUpstash = class extends MemoryStorage {
   }
   async saveThread({ thread }) {
     try {
-      await this.operations.insert({
+      await this.#db.insert({
         tableName: TABLE_THREADS,
         record: thread
       });
@@ -241,7 +341,7 @@ var StoreMemoryUpstash = class extends MemoryStorage {
         pipeline.del(messageKey);
       }
       await pipeline.exec();
-      await this.operations.scanAndDelete(getMessageKey(threadId, "*"));
+      await this.#db.scanAndDelete(getMessageKey(threadId, "*"));
     } catch (error) {
       throw new MastraError(
         {
@@ -306,7 +406,7 @@ var StoreMemoryUpstash = class extends 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));
@@ -361,7 +461,7 @@ var StoreMemoryUpstash = class extends 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;
@@ -702,7 +802,7 @@ var StoreMemoryUpstash = class extends 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) {
@@ -831,7 +931,7 @@ var StoreMemoryUpstash = class extends 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) {
@@ -892,156 +992,24 @@ var StoreMemoryUpstash = class extends MemoryStorage {
     });
   }
 };
-var StoreOperationsUpstash = class extends 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) {
-      throw new MastraError(
-        {
-          id: createStorageErrorId("UPSTASH", "CLEAR_TABLE", "FAILED"),
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-          details: {
-            tableName
-          }
-        },
-        error
-      );
-    }
-  }
-  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) {
-      throw new MastraError(
-        {
-          id: createStorageErrorId("UPSTASH", "INSERT", "FAILED"),
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-          details: {
-            tableName
-          }
-        },
-        error
-      );
-    }
-  }
-  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) {
-      throw new MastraError(
-        {
-          id: createStorageErrorId("UPSTASH", "BATCH_INSERT", "FAILED"),
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-          details: {
-            tableName
-          }
-        },
-        error
-      );
-    }
-  }
-  async load({ tableName, keys }) {
-    const key = getKey(tableName, keys);
-    try {
-      const data = await this.client.get(key);
-      return data || null;
-    } catch (error) {
-      throw new MastraError(
-        {
-          id: createStorageErrorId("UPSTASH", "LOAD", "FAILED"),
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-          details: {
-            tableName
-          }
-        },
-        error
-      );
-    }
-  }
-  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 transformScoreRow$1(row);
 }
 var ScoresUpstash = class extends 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: TABLE_SCORERS });
   }
   async getScoreById({ id }) {
     try {
-      const data = await this.operations.load({
+      const data = await this.#db.get({
         tableName: TABLE_SCORERS,
         keys: { id }
       });
@@ -1069,7 +1037,7 @@ var ScoresUpstash = class extends ScoresStorage {
     pagination = { page: 0, perPage: 20 }
   }) {
     const pattern = `${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 {
@@ -1125,7 +1093,7 @@ var ScoresUpstash = class extends ScoresStorage {
           domain: ErrorDomain.STORAGE,
           category: 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 ?? "",
@@ -1166,7 +1134,7 @@ var ScoresUpstash = class extends ScoresStorage {
     pagination = { page: 0, perPage: 20 }
   }) {
     const pattern = `${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 {
@@ -1210,7 +1178,7 @@ var ScoresUpstash = class extends ScoresStorage {
     pagination = { page: 0, perPage: 20 }
   }) {
     const pattern = `${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 {
@@ -1259,7 +1227,7 @@ var ScoresUpstash = class extends ScoresStorage {
     pagination = { page: 0, perPage: 20 }
   }) {
     const pattern = `${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 {
@@ -1323,32 +1291,109 @@ function parseWorkflowRun(row) {
 }
 var WorkflowsUpstash = class extends 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: 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) {
+      if (error instanceof MastraError) throw error;
+      throw new MastraError(
+        {
+          id: createStorageErrorId("UPSTASH", "UPDATE_WORKFLOW_RESULTS", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { workflowName, runId, stepId }
+        },
+        error
+      );
+    }
   }
-  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) {
+      if (error instanceof MastraError) throw error;
+      throw new MastraError(
+        {
+          id: createStorageErrorId("UPSTASH", "UPDATE_WORKFLOW_STATE", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { workflowName, runId }
+        },
+        error
+      );
+    }
   }
   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: TABLE_WORKFLOW_SNAPSHOT,
         record: {
           namespace,
@@ -1356,8 +1401,8 @@ var WorkflowsUpstash = class extends 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) {
@@ -1409,7 +1454,7 @@ var WorkflowsUpstash = class extends WorkflowsStorage {
   }) {
     try {
       const key = getKey(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);
@@ -1463,7 +1508,7 @@ var WorkflowsUpstash = class extends WorkflowsStorage {
     page,
     resourceId,
     status
-  }) {
+  } = {}) {
     try {
       if (page !== void 0 && page < 0) {
         throw new MastraError(
@@ -1494,7 +1539,7 @@ var WorkflowsUpstash = class extends WorkflowsStorage {
           resourceId
         });
       }
-      const keys = await this.operations.scanKeys(pattern);
+      const keys = await this.#db.scanKeys(pattern);
       if (keys.length === 0) {
         return { runs: [], total: 0 };
       }
@@ -1547,21 +1592,32 @@ var WorkflowsUpstash = class extends WorkflowsStorage {
 };
 
 // src/storage/index.ts
+var isClientConfig = (config) => {
+  return "client" in config;
+};
 var UpstashStore = class extends MastraStorage {
   redis;
   stores;
   constructor(config) {
     super({ id: config.id, name: "Upstash", disableInit: config.disableInit });
-    this.redis = new 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({
+        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
@@ -1574,155 +1630,14 @@ var UpstashStore = class extends MastraStorage {
       hasColumn: false,
       createTable: false,
       deleteMessages: true,
-      listScoresBySpan: true
+      observability: false,
+      indexManagement: false,
+      listScoresBySpan: true,
+      agents: false
     };
   }
-  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 BaseFilterTranslator {
   getSupportedOperators() {