@mastra/cloudflare 0.0.0-vnextWorkflows-20250422142014 → 0.0.0-working-memory-per-user-20250620161509

package/dist/index.js

@@ -1,4 +1,5 @@
-import { MastraStorage, TABLE_THREADS, TABLE_MESSAGES, TABLE_WORKFLOW_SNAPSHOT, TABLE_EVALS, TABLE_TRACES } from '@mastra/core/storage';
+import { MessageList } from '@mastra/core/agent';
+import { MastraStorage, TABLE_THREADS, TABLE_MESSAGES, TABLE_WORKFLOW_SNAPSHOT, TABLE_EVALS, TABLE_TRACES, TABLE_RESOURCES } from '@mastra/core/storage';
 import Cloudflare from 'cloudflare';
 
 // src/storage/index.ts
@@ -21,7 +22,7 @@ var CloudflareStore = class extends MastraStorage {
     if (!config.bindings) {
       throw new Error("KV bindings are required when using Workers Binding API");
     }
-    const requiredTables = [TABLE_THREADS, TABLE_MESSAGES, TABLE_WORKFLOW_SNAPSHOT, TABLE_EVALS, TABLE_TRACES];
+    const requiredTables = [TABLE_THREADS, TABLE_MESSAGES, TABLE_WORKFLOW_SNAPSHOT, TABLE_EVALS, TABLE_TRACES, TABLE_RESOURCES];
     for (const table of requiredTables) {
       if (!(table in config.bindings)) {
         throw new Error(`Missing KV binding for table: ${table}`);
@@ -57,7 +58,8 @@ var CloudflareStore = class extends MastraStorage {
         this.logger.info("Using Cloudflare KV REST API");
       }
     } catch (error) {
-      this.logger.error("Failed to initialize CloudflareStore:", { error });
+      const message = error instanceof Error ? error.message : String(error);
+      this.logger.error("Failed to initialize CloudflareStore:", { message });
       throw error;
     }
   }
@@ -79,7 +81,25 @@ var CloudflareStore = class extends MastraStorage {
         }))
       };
     }
-    return await this.client.kv.namespaces.list({ account_id: this.accountId });
+    let allNamespaces = [];
+    let currentPage = 1;
+    const perPage = 50;
+    let morePagesExist = true;
+    while (morePagesExist) {
+      const response = await this.client.kv.namespaces.list({
+        account_id: this.accountId,
+        page: currentPage,
+        per_page: perPage
+      });
+      if (response.result) {
+        allNamespaces = allNamespaces.concat(response.result);
+      }
+      morePagesExist = response.result ? response.result.length === perPage : false;
+      if (morePagesExist) {
+        currentPage++;
+      }
+    }
+    return { result: allNamespaces };
   }
   async getNamespaceValue(tableName, key) {
     try {
@@ -99,7 +119,8 @@ var CloudflareStore = class extends MastraStorage {
       if (error.message && error.message.includes("key not found")) {
         return null;
       }
-      this.logger.error(`Failed to get value for ${tableName} ${key}:`, { error });
+      const message = error instanceof Error ? error.message : String(error);
+      this.logger.error(`Failed to get value for ${tableName} ${key}:`, { message });
       throw error;
     }
   }
@@ -124,7 +145,8 @@ var CloudflareStore = class extends MastraStorage {
         });
       }
     } catch (error) {
-      this.logger.error(`Failed to put value for ${tableName} ${key}:`, { error });
+      const message = error instanceof Error ? error.message : String(error);
+      this.logger.error(`Failed to put value for ${tableName} ${key}:`, { message });
       throw error;
     }
   }
@@ -210,18 +232,57 @@ var CloudflareStore = class extends MastraStorage {
   async getNamespaceId(tableName) {
     const prefix = this.namespacePrefix ? `${this.namespacePrefix}_` : "";
     try {
-      if (tableName === TABLE_MESSAGES || tableName === TABLE_THREADS) {
-        return await this.getOrCreateNamespaceId(`${prefix}mastra_threads`);
-      } else if (tableName === TABLE_WORKFLOW_SNAPSHOT) {
-        return await this.getOrCreateNamespaceId(`${prefix}mastra_workflows`);
-      } else {
-        return await this.getOrCreateNamespaceId(`${prefix}mastra_evals`);
+      const legacyNamespaceId = await this.checkLegacyNamespace(tableName, prefix);
+      if (legacyNamespaceId) {
+        return legacyNamespaceId;
       }
+      return await this.getOrCreateNamespaceId(`${prefix}${tableName}`);
     } catch (error) {
       this.logger.error("Error fetching namespace ID:", error);
       throw new Error(`Failed to fetch namespace ID for table ${tableName}: ${error.message}`);
     }
   }
+  LEGACY_NAMESPACE_MAP = {
+    [TABLE_MESSAGES]: TABLE_THREADS,
+    [TABLE_WORKFLOW_SNAPSHOT]: "mastra_workflows",
+    [TABLE_TRACES]: TABLE_EVALS
+  };
+  /**
+   * There were a few legacy mappings for tables such as
+   * - messages -> threads
+   * - workflow_snapshot -> mastra_workflows
+   * - traces -> evals
+   * This has been updated to use dedicated namespaces for each table.
+   * In the case of data for a table existing in the legacy namespace, warn the user to migrate to the new namespace.
+   *
+   * @param tableName The table name to check for legacy data
+   * @param prefix The namespace prefix
+   * @returns The legacy namespace ID if data exists; otherwise, null
+   */
+  async checkLegacyNamespace(tableName, prefix) {
+    const legacyNamespaceBase = this.LEGACY_NAMESPACE_MAP[tableName];
+    if (legacyNamespaceBase) {
+      const legacyNamespace = `${prefix}${legacyNamespaceBase}`;
+      const keyPrefix = this.namespacePrefix ? `${this.namespacePrefix}:` : "";
+      const prefixKey = `${keyPrefix}${tableName}:`;
+      const legacyId = await this.getNamespaceIdByName(legacyNamespace);
+      if (legacyId) {
+        const response = await this.client.kv.namespaces.keys.list(legacyId, {
+          account_id: this.accountId,
+          prefix: prefixKey
+        });
+        const keys = response.result;
+        const hasTableData = keys.length > 0;
+        if (hasTableData) {
+          this.logger.warn(
+            `Using legacy namespace "${legacyNamespace}" for ${tableName}. Consider migrating to a dedicated namespace "${prefix}${tableName}".`
+          );
+          return legacyId;
+        }
+      }
+    }
+    return null;
+  }
   /**
    * Helper to safely serialize data for KV storage
    */
@@ -247,7 +308,8 @@ var CloudflareStore = class extends MastraStorage {
       }
       return data;
     } catch (error) {
-      this.logger.error("Failed to parse text:", { error, text });
+      const message = error instanceof Error ? error.message : String(error);
+      this.logger.error("Failed to parse text:", { message, text });
       return null;
     }
   }
@@ -281,9 +343,9 @@ var CloudflareStore = class extends MastraStorage {
       throw new Error(`Failed to delete KV value: ${error.message}`);
     }
   }
-  async listKV(tableName) {
+  async listKV(tableName, options) {
     try {
-      return await this.listNamespaceKeys(tableName);
+      return await this.listNamespaceKeys(tableName, options);
     } catch (error) {
       this.logger.error(`Failed to list KV for ${tableName}:`, error);
       throw new Error(`Failed to list KV: ${error.message}`);
@@ -356,7 +418,8 @@ var CloudflareStore = class extends MastraStorage {
           if (!data) return null;
           return typeof data === "string" ? JSON.parse(data) : data;
         } catch (error) {
-          this.logger.error(`Error retrieving message ${id}:`, { error });
+          const message = error instanceof Error ? error.message : String(error);
+          this.logger.error(`Error retrieving message ${id}:`, { message });
           return null;
         }
       })
@@ -389,7 +452,8 @@ var CloudflareStore = class extends MastraStorage {
           value: JSON.stringify(updatedOrder)
         });
       } catch (error) {
-        this.logger.error(`Error updating sorted order for key ${orderKey}:`, { error });
+        const message = error instanceof Error ? error.message : String(error);
+        this.logger.error(`Error updating sorted order for key ${orderKey}:`, { message });
         throw error;
       } finally {
         if (this.updateQueue.get(orderKey) === nextPromise) {
@@ -431,7 +495,11 @@ var CloudflareStore = class extends MastraStorage {
         if (!record.namespace || !record.workflow_name || !record.run_id) {
           throw new Error("Namespace, workflow name, and run ID are required");
         }
-        return `${prefix}${tableName}:${record.namespace}:${record.workflow_name}:${record.run_id}`;
+        let key = `${prefix}${tableName}:${record.namespace}:${record.workflow_name}:${record.run_id}`;
+        if (record.resourceId) {
+          key = `${key}:${record.resourceId}`;
+        }
+        return key;
       case TABLE_TRACES:
         if (!record.id) throw new Error("Trace ID is required");
         return `${prefix}${tableName}:${record.id}`;
@@ -448,7 +516,8 @@ var CloudflareStore = class extends MastraStorage {
       const schemaKey = this.getSchemaKey(tableName);
       return await this.getKV(tableName, schemaKey);
     } catch (error) {
-      this.logger.error(`Failed to get schema for ${tableName}:`, { error });
+      const message = error instanceof Error ? error.message : String(error);
+      this.logger.error(`Failed to get schema for ${tableName}:`, { message });
       return null;
     }
   }
@@ -493,7 +562,8 @@ var CloudflareStore = class extends MastraStorage {
         }
       }
     } catch (error) {
-      this.logger.error(`Error validating record against schema:`, { error, record, schema });
+      const message = error instanceof Error ? error.message : String(error);
+      this.logger.error(`Error validating record against schema:`, { message, record, schema });
       throw error;
     }
   }
@@ -520,7 +590,7 @@ var CloudflareStore = class extends MastraStorage {
           }
           break;
         case TABLE_WORKFLOW_SNAPSHOT:
-          if (!("namespace" in recordTyped) || !("workflowName" in recordTyped) || !("runId" in recordTyped)) {
+          if (!("namespace" in recordTyped) || !("workflow_name" in recordTyped) || !("run_id" in recordTyped)) {
             throw new Error("Workflow record missing required fields");
           }
           break;
@@ -533,19 +603,11 @@ var CloudflareStore = class extends MastraStorage {
           throw new Error(`Unknown table type: ${tableName}`);
       }
     } catch (error) {
-      this.logger.error(`Failed to validate record for ${tableName}:`, { error, record });
+      const message = error instanceof Error ? error.message : String(error);
+      this.logger.error(`Failed to validate record for ${tableName}:`, { message, record });
       throw error;
     }
   }
-  ensureDate(date) {
-    if (!date) return void 0;
-    return date instanceof Date ? date : new Date(date);
-  }
-  serializeDate(date) {
-    if (!date) return void 0;
-    const dateObj = this.ensureDate(date);
-    return dateObj?.toISOString();
-  }
   ensureMetadata(metadata) {
     if (!metadata) return {};
     return typeof metadata === "string" ? JSON.parse(metadata) : metadata;
@@ -567,13 +629,24 @@ var CloudflareStore = class extends MastraStorage {
       throw new Error(`Failed to store schema: ${error.message}`);
     }
   }
+  /**
+   * No-op: This backend is schemaless and does not require schema changes.
+   * @param tableName Name of the table
+   * @param schema Schema of the table
+   * @param ifNotExists Array of column names to add if they don't exist
+   */
+  async alterTable(_args) {
+  }
   async clearTable({ tableName }) {
     const keys = await this.listKV(tableName);
     if (keys.length > 0) {
       await Promise.all(keys.map((keyObj) => this.deleteKV(tableName, keyObj.name)));
     }
   }
-  async insert({ tableName, record }) {
+  async insert({
+    tableName,
+    record
+  }) {
     try {
       const key = this.getKey(tableName, record);
       const processedRecord = {
@@ -585,7 +658,8 @@ var CloudflareStore = class extends MastraStorage {
       await this.validateRecord(processedRecord, tableName);
       await this.putKV({ tableName, key, value: processedRecord });
     } catch (error) {
-      this.logger.error(`Failed to insert record for ${tableName}:`, { error });
+      const message = error instanceof Error ? error.message : String(error);
+      this.logger.error(`Failed to insert record for ${tableName}:`, { message });
       throw error;
     }
   }
@@ -602,7 +676,9 @@ var CloudflareStore = class extends MastraStorage {
       };
       return processed;
     } catch (error) {
-      this.logger.error(`Failed to load data for ${tableName}:`, { error });
+      this.logger.error(`Failed to load data for ${tableName}:`, {
+        error: error instanceof Error ? error.message : String(error)
+      });
       return null;
     }
   }
@@ -617,7 +693,9 @@ var CloudflareStore = class extends MastraStorage {
         metadata: this.ensureMetadata(thread.metadata)
       };
     } catch (error) {
-      this.logger.error(`Error processing thread ${threadId}:`, { error });
+      this.logger.error(`Error processing thread ${threadId}:`, {
+        error: error instanceof Error ? error.message : String(error)
+      });
       return null;
     }
   }
@@ -638,14 +716,16 @@ var CloudflareStore = class extends MastraStorage {
               metadata: this.ensureMetadata(thread.metadata)
             };
           } catch (error) {
-            this.logger.error(`Error processing thread from key ${keyObj.name}:`, { error });
+            const message = error instanceof Error ? error.message : String(error);
+            this.logger.error(`Error processing thread from key ${keyObj.name}:`, { message });
             return null;
           }
         })
       );
       return threads.filter((thread) => thread !== null);
     } catch (error) {
-      this.logger.error(`Error getting threads for resourceId ${resourceId}:`, { error });
+      const message = error instanceof Error ? error.message : String(error);
+      this.logger.error(`Error getting threads for resourceId ${resourceId}:`, { message });
       return [];
     }
   }
@@ -654,7 +734,8 @@ var CloudflareStore = class extends MastraStorage {
       await this.insert({ tableName: TABLE_THREADS, record: thread });
       return thread;
     } catch (error) {
-      this.logger.error("Error saving thread:", { error });
+      const message = error instanceof Error ? error.message : String(error);
+      this.logger.error("Error saving thread:", { message });
       throw error;
     }
   }
@@ -680,7 +761,8 @@ var CloudflareStore = class extends MastraStorage {
       await this.insert({ tableName: TABLE_THREADS, record: updatedThread });
       return updatedThread;
     } catch (error) {
-      this.logger.error(`Error updating thread ${id}:`, { error });
+      const message = error instanceof Error ? error.message : String(error);
+      this.logger.error(`Error updating thread ${id}:`, { message });
       throw error;
     }
   }
@@ -701,7 +783,8 @@ var CloudflareStore = class extends MastraStorage {
         this.deleteKV(TABLE_THREADS, this.getKey(TABLE_THREADS, { id: threadId }))
       ]);
     } catch (error) {
-      this.logger.error(`Error deleting thread ${threadId}:`, { error });
+      const message = error instanceof Error ? error.message : String(error);
+      this.logger.error(`Error deleting thread ${threadId}:`, { message });
       throw error;
     }
   }
@@ -709,7 +792,8 @@ var CloudflareStore = class extends MastraStorage {
     try {
       return this.getKey(TABLE_MESSAGES, { threadId, id: messageId });
     } catch (error) {
-      this.logger.error(`Error getting message key for thread ${threadId} and message ${messageId}:`, { error });
+      const message = error instanceof Error ? error.message : String(error);
+      this.logger.error(`Error getting message key for thread ${threadId} and message ${messageId}:`, { message });
       throw error;
     }
   }
@@ -717,11 +801,13 @@ var CloudflareStore = class extends MastraStorage {
     try {
       return this.getKey(TABLE_MESSAGES, { threadId, id: "messages" });
     } catch (error) {
-      this.logger.error(`Error getting thread messages key for thread ${threadId}:`, { error });
+      const message = error instanceof Error ? error.message : String(error);
+      this.logger.error(`Error getting thread messages key for thread ${threadId}:`, { message });
       throw error;
     }
   }
-  async saveMessages({ messages }) {
+  async saveMessages(args) {
+    const { messages, format = "v1" } = args;
     if (!Array.isArray(messages) || messages.length === 0) return [];
     try {
       const validatedMessages = messages.map((message, index) => {
@@ -737,15 +823,17 @@ var CloudflareStore = class extends MastraStorage {
         return {
           ...message,
           createdAt: this.ensureDate(message.createdAt),
-          type: message.type || "text",
+          type: message.type || "v2",
           _index: index
         };
       });
       const messagesByThread = validatedMessages.reduce((acc, message) => {
-        if (!acc.has(message.threadId)) {
+        if (message.threadId && !acc.has(message.threadId)) {
           acc.set(message.threadId, []);
         }
-        acc.get(message.threadId).push(message);
+        if (message.threadId) {
+          acc.get(message.threadId).push(message);
+        }
         return acc;
       }, /* @__PURE__ */ new Map());
       await Promise.all(
@@ -757,7 +845,7 @@ var CloudflareStore = class extends MastraStorage {
             }
             await Promise.all(
               threadMessages.map(async (message) => {
-                const key = await this.getMessageKey(threadId, message.id);
+                const key = this.getMessageKey(threadId, message.id);
                 const { _index, ...cleanMessage } = message;
                 const serializedMessage = {
                   ...cleanMessage,
@@ -776,21 +864,26 @@ var CloudflareStore = class extends MastraStorage {
           }
         })
       );
-      return validatedMessages.map(({ _index, ...message }) => message);
+      const prepared = validatedMessages.map(
+        ({ _index, ...message }) => ({ ...message, type: message.type !== "v2" ? message.type : void 0 })
+      );
+      const list = new MessageList().add(prepared, "memory");
+      if (format === `v2`) return list.get.all.v2();
+      return list.get.all.v1();
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
       this.logger.error(`Error saving messages: ${errorMessage}`);
       throw error;
     }
   }
-  async getMessages({ threadId, selectBy }) {
+  async getMessages({
+    threadId,
+    resourceId,
+    selectBy,
+    format
+  }) {
     if (!threadId) throw new Error("threadId is required");
-    let limit = 40;
-    if (typeof selectBy?.last === "number") {
-      limit = Math.max(0, selectBy.last);
-    } else if (selectBy?.last === false) {
-      limit = 0;
-    }
+    const limit = this.resolveMessageLimit({ last: selectBy?.last, defaultLimit: 40 });
     const messageIds = /* @__PURE__ */ new Set();
     if (limit === 0 && !selectBy?.include?.length) return [];
     try {
@@ -815,10 +908,14 @@ var CloudflareStore = class extends MastraStorage {
         this.logger.warn(`Error sorting messages, falling back to creation time: ${errorMessage}`);
         messages.sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime());
       }
-      return messages.map(({ _index, ...message }) => ({
+      const prepared = messages.map(({ _index, ...message }) => ({
         ...message,
+        type: message.type === `v2` ? void 0 : message.type,
         createdAt: this.ensureDate(message.createdAt)
       }));
+      const list = new MessageList({ threadId, resourceId }).add(prepared, "memory");
+      if (format === `v1`) return list.get.all.v1();
+      return list.get.all.v2();
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
       this.logger.error(`Error retrieving messages for thread ${threadId}: ${errorMessage}`);
@@ -832,7 +929,7 @@ var CloudflareStore = class extends MastraStorage {
     }
   }
   validateWorkflowState(state) {
-    if (!state?.runId || !state?.value || !state?.context?.steps || !state?.context?.triggerData || !state?.context?.attempts || !state?.activePaths) {
+    if (!state?.runId || !state?.value || !state?.context?.input || !state?.activePaths) {
       throw new Error("Invalid workflow state structure");
     }
   }
@@ -848,18 +945,17 @@ var CloudflareStore = class extends MastraStorage {
     return normalizedSteps;
   }
   normalizeWorkflowState(data) {
-    const steps = data.context?.stepResults || data.context?.steps || {};
     return {
       runId: data.runId,
       value: data.value,
-      context: {
-        steps: this.normalizeSteps(steps),
-        triggerData: data.context?.triggerData || {},
-        attempts: data.context?.attempts || {}
-      },
-      suspendedPaths: data.suspendedPaths || [],
+      context: data.context,
+      serializedStepGraph: data.serializedStepGraph,
+      suspendedPaths: data.suspendedPaths || {},
       activePaths: data.activePaths || [],
-      timestamp: data.timestamp || Date.now()
+      timestamp: data.timestamp || Date.now(),
+      status: data.status,
+      result: data.result,
+      error: data.error
     };
   }
   async persistWorkflowSnapshot(params) {
@@ -868,10 +964,20 @@ var CloudflareStore = class extends MastraStorage {
       const { namespace, workflowName, runId, snapshot } = params;
       const normalizedState = this.normalizeWorkflowState(snapshot);
       this.validateWorkflowState(normalizedState);
-      const key = this.getKey(TABLE_WORKFLOW_SNAPSHOT, { namespace, workflow_name: workflowName, run_id: runId });
-      await this.putKV({ tableName: TABLE_WORKFLOW_SNAPSHOT, key, value: normalizedState });
+      await this.insert({
+        tableName: TABLE_WORKFLOW_SNAPSHOT,
+        record: {
+          namespace,
+          workflow_name: workflowName,
+          run_id: runId,
+          snapshot: normalizedState,
+          createdAt: /* @__PURE__ */ new Date(),
+          updatedAt: /* @__PURE__ */ new Date()
+        }
+      });
     } catch (error) {
-      this.logger.error("Error persisting workflow snapshot:", { error });
+      const message = error instanceof Error ? error.message : String(error);
+      this.logger.error("Error persisting workflow snapshot:", { message });
       throw error;
     }
   }
@@ -882,11 +988,13 @@ var CloudflareStore = class extends MastraStorage {
       const key = this.getKey(TABLE_WORKFLOW_SNAPSHOT, { namespace, workflow_name: workflowName, run_id: runId });
       const data = await this.getKV(TABLE_WORKFLOW_SNAPSHOT, key);
       if (!data) return null;
-      const state = this.normalizeWorkflowState(data);
+      const state = this.normalizeWorkflowState(data.snapshot || data);
       this.validateWorkflowState(state);
       return state;
     } catch (error) {
-      this.logger.error("Error loading workflow snapshot:", { error });
+      this.logger.error("Error loading workflow snapshot:", {
+        error: error instanceof Error ? error.message : String(error)
+      });
       return null;
     }
   }
@@ -906,7 +1014,8 @@ var CloudflareStore = class extends MastraStorage {
         })
       );
     } catch (error) {
-      this.logger.error("Error in batch insert:", { error });
+      const message = error instanceof Error ? error.message : String(error);
+      this.logger.error("Error in batch insert:", { message });
       throw error;
     }
   }
@@ -915,7 +1024,9 @@ var CloudflareStore = class extends MastraStorage {
     scope,
     page = 0,
     perPage = 100,
-    attributes
+    attributes,
+    fromDate,
+    toDate
   }) {
     try {
       let keys;
@@ -954,6 +1065,12 @@ var CloudflareStore = class extends MastraStorage {
           return Object.entries(attributes).every(([key, value]) => recordAttrs[key] === value);
         });
       }
+      if (fromDate) {
+        filteredTraces = filteredTraces.filter((record) => new Date(record.createdAt).getTime() >= fromDate.getTime());
+      }
+      if (toDate) {
+        filteredTraces = filteredTraces.filter((record) => new Date(record.createdAt).getTime() <= toDate.getTime());
+      }
       filteredTraces.sort((a, b) => {
         const dateA = new Date(a.createdAt).getTime();
         const dateB = new Date(b.createdAt).getTime();
@@ -979,7 +1096,8 @@ var CloudflareStore = class extends MastraStorage {
         createdAt: record.createdAt
       }));
     } catch (error) {
-      this.logger.error("Failed to get traces:", { message: error instanceof Error ? error.message : String(error) });
+      const message = error instanceof Error ? error.message : String(error);
+      this.logger.error("Failed to get traces:", { message });
       return [];
     }
   }
@@ -996,11 +1114,131 @@ var CloudflareStore = class extends MastraStorage {
   getEvalsByAgentName(_agentName, _type) {
     throw new Error("Method not implemented.");
   }
-  getWorkflowRuns(_args) {
+  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: this.ensureDate(row.createdAt),
+      updatedAt: this.ensureDate(row.updatedAt),
+      resourceId: row.resourceId
+    };
+  }
+  buildWorkflowSnapshotPrefix({
+    namespace,
+    workflowName,
+    runId,
+    resourceId
+  }) {
+    const prefix = this.namespacePrefix ? `${this.namespacePrefix}:` : "";
+    let key = `${prefix}${TABLE_WORKFLOW_SNAPSHOT}`;
+    if (namespace) key += `:${namespace}`;
+    if (workflowName) key += `:${workflowName}`;
+    if (runId) key += `:${runId}`;
+    if (resourceId) key += `:${resourceId}`;
+    if (!resourceId && (runId || workflowName || namespace)) key += ":";
+    return key;
+  }
+  async getWorkflowRuns({
+    namespace,
+    workflowName,
+    limit = 20,
+    offset = 0,
+    resourceId,
+    fromDate,
+    toDate
+  } = {}) {
+    try {
+      const prefix = this.buildWorkflowSnapshotPrefix({ namespace, workflowName });
+      const keyObjs = await this.listKV(TABLE_WORKFLOW_SNAPSHOT, { prefix });
+      const runs = [];
+      for (const { name: key } of keyObjs) {
+        const parts = key.split(":");
+        const idx = parts.indexOf(TABLE_WORKFLOW_SNAPSHOT);
+        if (idx === -1 || parts.length < idx + 4) continue;
+        const ns = parts[idx + 1];
+        const wfName = parts[idx + 2];
+        const keyResourceId = parts.length > idx + 4 ? parts[idx + 4] : void 0;
+        if (namespace && ns !== namespace || workflowName && wfName !== workflowName) continue;
+        if (resourceId && keyResourceId && keyResourceId !== resourceId) continue;
+        const data = await this.getKV(TABLE_WORKFLOW_SNAPSHOT, key);
+        if (!data) continue;
+        try {
+          if (resourceId && data.resourceId && data.resourceId !== resourceId) continue;
+          const createdAt = this.ensureDate(data.createdAt);
+          if (fromDate && createdAt && createdAt < fromDate) continue;
+          if (toDate && createdAt && createdAt > toDate) continue;
+          const state = this.normalizeWorkflowState(data.snapshot || data);
+          this.validateWorkflowState(state);
+          const run = this.parseWorkflowRun({ ...data, snapshot: state });
+          runs.push(run);
+        } catch (err) {
+          this.logger.error("Failed to parse workflow snapshot:", { key, error: err });
+        }
+      }
+      runs.sort((a, b) => {
+        const aDate = a.createdAt ? new Date(a.createdAt).getTime() : 0;
+        const bDate = b.createdAt ? new Date(b.createdAt).getTime() : 0;
+        return bDate - aDate;
+      });
+      const pagedRuns = runs.slice(offset, offset + limit);
+      return {
+        runs: pagedRuns,
+        total: runs.length
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      this.logger.error("Error in getWorkflowRuns:", { message });
+      return { runs: [], total: 0 };
+    }
+  }
+  async getWorkflowRunById({
+    namespace,
+    runId,
+    workflowName
+  }) {
+    try {
+      if (!runId || !workflowName || !namespace) {
+        throw new Error("runId, workflowName, and namespace are required");
+      }
+      const prefix = this.buildWorkflowSnapshotPrefix({ namespace, workflowName, runId });
+      const keyObjs = await this.listKV(TABLE_WORKFLOW_SNAPSHOT, { prefix });
+      if (!keyObjs.length) return null;
+      const key = keyObjs[0]?.name;
+      const data = await this.getKV(TABLE_WORKFLOW_SNAPSHOT, key);
+      if (!data) return null;
+      const state = this.normalizeWorkflowState(data.snapshot || data);
+      this.validateWorkflowState(state);
+      return this.parseWorkflowRun({ ...data, snapshot: state });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      this.logger.error("Error in getWorkflowRunById:", { message });
+      return null;
+    }
+  }
+  async getTracesPaginated(_args) {
+    throw new Error("Method not implemented.");
+  }
+  async getThreadsByResourceIdPaginated(_args) {
+    throw new Error("Method not implemented.");
+  }
+  async getMessagesPaginated(_args) {
     throw new Error("Method not implemented.");
   }
   async close() {
   }
+  async updateMessages(_args) {
+    this.logger.error("updateMessages is not yet implemented in CloudflareStore");
+    throw new Error("Method not implemented");
+  }
 };
 
 export { CloudflareStore };