@mastra/cloudflare 1.0.0-beta.1 → 1.0.0-beta.10

package/dist/index.cjs

@@ -4,6 +4,7 @@ var error = require('@mastra/core/error');
 var storage = require('@mastra/core/storage');
 var Cloudflare = require('cloudflare');
 var agent = require('@mastra/core/agent');
+var base = require('@mastra/core/base');
 var evals = require('@mastra/core/evals');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
@@ -11,1512 +12,1592 @@ function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 var Cloudflare__default = /*#__PURE__*/_interopDefault(Cloudflare);
 
 // src/storage/index.ts
-var MemoryStorageCloudflare = class extends storage.MemoryStorage {
-  operations;
-  constructor({ operations }) {
-    super();
-    this.operations = operations;
+function resolveCloudflareConfig(config) {
+  if ("client" in config) {
+    return {
+      client: config.client,
+      accountId: config.accountId,
+      namespacePrefix: config.namespacePrefix
+    };
   }
-  ensureMetadata(metadata) {
-    if (!metadata) return void 0;
-    return typeof metadata === "string" ? JSON.parse(metadata) : metadata;
+  if ("bindings" in config) {
+    return {
+      bindings: config.bindings,
+      namespacePrefix: config.keyPrefix
+    };
+  }
+  return {
+    client: new Cloudflare__default.default({ apiToken: config.apiToken }),
+    accountId: config.accountId,
+    namespacePrefix: config.namespacePrefix
+  };
+}
+var CloudflareKVDB = class extends base.MastraBase {
+  bindings;
+  client;
+  accountId;
+  namespacePrefix;
+  constructor(config) {
+    super({
+      component: "STORAGE",
+      name: "CLOUDFLARE_KV_DB"
+    });
+    this.bindings = config.bindings;
+    this.namespacePrefix = config.namespacePrefix || "";
+    this.client = config.client;
+    this.accountId = config.accountId;
+  }
+  getBinding(tableName) {
+    if (!this.bindings) {
+      throw new Error(`Cannot use Workers API binding for ${tableName}: Store initialized with REST API configuration`);
+    }
+    const binding = this.bindings[tableName];
+    if (!binding) throw new Error(`No binding found for namespace ${tableName}`);
+    return binding;
+  }
+  getKey(tableName, record) {
+    const prefix = this.namespacePrefix ? `${this.namespacePrefix}:` : "";
+    switch (tableName) {
+      case storage.TABLE_THREADS:
+        if (!record.id) throw new Error("Thread ID is required");
+        return `${prefix}${tableName}:${record.id}`;
+      case storage.TABLE_MESSAGES:
+        if (!record.threadId || !record.id) throw new Error("Thread ID and Message ID are required");
+        return `${prefix}${tableName}:${record.threadId}:${record.id}`;
+      case storage.TABLE_WORKFLOW_SNAPSHOT:
+        if (!record.workflow_name || !record.run_id) {
+          throw new Error("Workflow name, and run ID are required");
+        }
+        let key = `${prefix}${tableName}:${record.workflow_name}:${record.run_id}`;
+        if (record.resourceId) {
+          key = `${key}:${record.resourceId}`;
+        }
+        return key;
+      case storage.TABLE_TRACES:
+        if (!record.id) throw new Error("Trace ID is required");
+        return `${prefix}${tableName}:${record.id}`;
+      case storage.TABLE_SCORERS:
+        if (!record.id) throw new Error("Score ID is required");
+        return `${prefix}${tableName}:${record.id}`;
+      default:
+        throw new Error(`Unsupported table: ${tableName}`);
+    }
+  }
+  getSchemaKey(tableName) {
+    const prefix = this.namespacePrefix ? `${this.namespacePrefix}:` : "";
+    return `${prefix}schema:${tableName}`;
   }
   /**
-   * Summarizes message content without exposing raw data (for logging).
-   * Returns type, length, and keys only to prevent PII leakage.
+   * Helper to safely parse data from KV storage
    */
-  summarizeMessageContent(content) {
-    if (!content) return { type: "undefined" };
-    if (typeof content === "string") return { type: "string", length: content.length };
-    if (Array.isArray(content)) return { type: "array", length: content.length };
-    if (typeof content === "object") return { type: "object", keys: Object.keys(content) };
-    return { type: typeof content };
-  }
-  async getThreadById({ threadId }) {
-    const thread = await this.operations.load({ tableName: storage.TABLE_THREADS, keys: { id: threadId } });
-    if (!thread) return null;
+  safeParse(text) {
+    if (!text) return null;
     try {
-      return {
-        ...thread,
-        createdAt: storage.ensureDate(thread.createdAt),
-        updatedAt: storage.ensureDate(thread.updatedAt),
-        metadata: this.ensureMetadata(thread.metadata)
-      };
-    } catch (error$1) {
-      const mastraError = new error.MastraError(
-        {
-          id: "CLOUDFLARE_STORAGE_GET_THREAD_BY_ID_FAILED",
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: {
-            threadId
+      const data = JSON.parse(text);
+      if (data && typeof data === "object" && "value" in data) {
+        if (typeof data.value === "string") {
+          try {
+            return JSON.parse(data.value);
+          } catch {
+            return data.value;
           }
-        },
-        error$1
-      );
-      this.logger?.trackException(mastraError);
-      this.logger?.error(mastraError.toString());
+        }
+        return null;
+      }
+      return data;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      this.logger.error("Failed to parse text:", { message, text });
       return null;
     }
   }
-  async listThreadsByResourceId(args) {
-    try {
-      const { resourceId, page = 0, perPage: perPageInput, orderBy } = args;
-      const perPage = storage.normalizePerPage(perPageInput, 100);
-      if (page < 0) {
-        throw new error.MastraError(
-          {
-            id: "STORAGE_CLOUDFLARE_LIST_THREADS_BY_RESOURCE_ID_INVALID_PAGE",
-            domain: error.ErrorDomain.STORAGE,
-            category: error.ErrorCategory.USER,
-            details: { page }
-          },
-          new Error("page must be >= 0")
-        );
-      }
-      const { offset, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
-      const { field, direction } = this.parseOrderBy(orderBy);
-      const prefix = this.operations.namespacePrefix ? `${this.operations.namespacePrefix}:` : "";
-      const keyObjs = await this.operations.listKV(storage.TABLE_THREADS, { prefix: `${prefix}${storage.TABLE_THREADS}` });
-      const threads = [];
-      for (const { name: key } of keyObjs) {
-        const data = await this.operations.getKV(storage.TABLE_THREADS, key);
-        if (!data) continue;
-        if (data.resourceId !== resourceId) continue;
-        threads.push(data);
-      }
-      threads.sort((a, b) => {
-        const aTime = new Date(a[field] || 0).getTime();
-        const bTime = new Date(b[field] || 0).getTime();
-        return direction === "ASC" ? aTime - bTime : bTime - aTime;
-      });
-      const end = perPageInput === false ? threads.length : offset + perPage;
-      const paginatedThreads = threads.slice(offset, end);
+  async createNamespaceById(title) {
+    if (this.bindings) {
       return {
-        page,
-        perPage: perPageForResponse,
-        total: threads.length,
-        hasMore: perPageInput === false ? false : offset + perPage < threads.length,
-        threads: paginatedThreads
+        id: title,
+        title,
+        supports_url_encoding: true
       };
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: "CLOUDFLARE_STORAGE_LIST_THREADS_BY_RESOURCE_ID_FAILED",
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          text: "Failed to get threads by resource ID with pagination"
-        },
-        error$1
-      );
     }
+    return await this.client.kv.namespaces.create({
+      account_id: this.accountId,
+      title
+    });
   }
-  async saveThread({ thread }) {
+  async createNamespace(namespaceName) {
     try {
-      await this.operations.insert({ tableName: storage.TABLE_THREADS, record: thread });
-      return thread;
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: "CLOUDFLARE_STORAGE_SAVE_THREAD_FAILED",
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: {
-            threadId: thread.id
-          }
-        },
-        error$1
-      );
+      const response = await this.createNamespaceById(namespaceName);
+      return response.id;
+    } catch (error) {
+      if (error.message && error.message.includes("already exists")) {
+        const namespaces = await this.listNamespaces();
+        const namespace = namespaces.result.find((ns) => ns.title === namespaceName);
+        if (namespace) return namespace.id;
+      }
+      this.logger.error("Error creating namespace:", error);
+      throw new Error(`Failed to create namespace ${namespaceName}: ${error.message}`);
     }
   }
-  async updateThread({
-    id,
-    title,
-    metadata
-  }) {
-    try {
-      const thread = await this.getThreadById({ threadId: id });
-      if (!thread) {
-        throw new Error(`Thread ${id} not found`);
-      }
-      const updatedThread = {
-        ...thread,
-        title,
-        metadata: this.ensureMetadata({
-          ...thread.metadata ?? {},
-          ...metadata
-        }),
-        updatedAt: /* @__PURE__ */ new Date()
+  async listNamespaces() {
+    if (this.bindings) {
+      return {
+        result: Object.keys(this.bindings).map((name) => ({
+          id: name,
+          title: name,
+          supports_url_encoding: true
+        }))
       };
-      await this.operations.insert({ tableName: storage.TABLE_THREADS, record: updatedThread });
-      return updatedThread;
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: "CLOUDFLARE_STORAGE_UPDATE_THREAD_FAILED",
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: {
-            threadId: id,
-            title
-          }
-        },
-        error$1
-      );
     }
-  }
-  getMessageKey(threadId, messageId) {
-    try {
-      return this.operations.getKey(storage.TABLE_MESSAGES, { threadId, id: messageId });
-    } catch (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;
+    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 };
   }
-  getThreadMessagesKey(threadId) {
+  async getNamespaceIdByName(namespaceName) {
     try {
-      return this.operations.getKey(storage.TABLE_MESSAGES, { threadId, id: "messages" });
+      const response = await this.listNamespaces();
+      const namespace = response.result.find((ns) => ns.title === namespaceName);
+      return namespace ? namespace.id : null;
     } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      this.logger?.error(`Error getting thread messages key for thread ${threadId}:`, { message });
-      throw error;
+      this.logger.error(`Failed to get namespace ID for ${namespaceName}:`, error);
+      return null;
     }
   }
-  async deleteThread({ threadId }) {
-    try {
-      const thread = await this.getThreadById({ threadId });
-      if (!thread) {
-        throw new Error(`Thread ${threadId} not found`);
-      }
-      const messageKeys = await this.operations.listKV(storage.TABLE_MESSAGES);
-      const threadMessageKeys = messageKeys.filter((key) => key.name.includes(`${storage.TABLE_MESSAGES}:${threadId}:`));
-      await Promise.all([
-        // Delete message order
-        this.operations.deleteKV(storage.TABLE_MESSAGES, this.getThreadMessagesKey(threadId)),
-        // Delete all messages
-        ...threadMessageKeys.map((key) => this.operations.deleteKV(storage.TABLE_MESSAGES, key.name)),
-        // Delete thread
-        this.operations.deleteKV(storage.TABLE_THREADS, this.operations.getKey(storage.TABLE_THREADS, { id: threadId }))
-      ]);
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: "CLOUDFLARE_STORAGE_DELETE_THREAD_FAILED",
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: {
-            threadId
-          }
-        },
-        error$1
-      );
+  async getOrCreateNamespaceId(namespaceName) {
+    let namespaceId = await this.getNamespaceIdByName(namespaceName);
+    if (!namespaceId) {
+      namespaceId = await this.createNamespace(namespaceName);
     }
+    return namespaceId;
   }
-  async findMessageInAnyThread(messageId) {
+  async getNamespaceId(tableName) {
+    const prefix = this.namespacePrefix ? `${this.namespacePrefix}_` : "";
     try {
-      const prefix = this.operations.namespacePrefix ? `${this.operations.namespacePrefix}:` : "";
-      const threadKeys = await this.operations.listKV(storage.TABLE_THREADS, { prefix: `${prefix}${storage.TABLE_THREADS}` });
-      for (const { name: threadKey } of threadKeys) {
-        const threadId = threadKey.split(":").pop();
-        if (!threadId || threadId === "messages") continue;
-        const messageKey = this.getMessageKey(threadId, messageId);
-        const message = await this.operations.getKV(storage.TABLE_MESSAGES, messageKey);
-        if (message) {
-          return { ...message, threadId };
-        }
-      }
-      return null;
+      return await this.getOrCreateNamespaceId(`${prefix}${tableName}`);
     } catch (error) {
-      this.logger?.error(`Error finding message ${messageId} in any thread:`, error);
-      return null;
+      this.logger.error("Error fetching namespace ID:", error);
+      throw new Error(`Failed to fetch namespace ID for table ${tableName}: ${error.message}`);
     }
   }
-  /**
-   * Queue for serializing sorted order updates.
-   * Updates the sorted order for a given key. This operation is eventually consistent.
-   */
-  updateQueue = /* @__PURE__ */ new Map();
-  async updateSorting(threadMessages) {
-    return threadMessages.map((msg) => ({
-      message: msg,
-      // Use _index if available, otherwise timestamp, matching Upstash
-      score: msg._index !== void 0 ? msg._index : msg.createdAt.getTime()
-    })).sort((a, b) => a.score - b.score).map((item) => ({
-      id: item.message.id,
-      score: item.score
-    }));
-  }
-  /**
-   * Updates the sorted order for a given key. This operation is eventually consistent.
-   * Note: Operations on the same orderKey are serialized using a queue to prevent
-   * concurrent updates from conflicting with each other.
-   */
-  async updateSortedMessages(orderKey, newEntries) {
-    const currentPromise = this.updateQueue.get(orderKey) || Promise.resolve();
-    const nextPromise = currentPromise.then(async () => {
-      try {
-        const currentOrder = await this.getSortedMessages(orderKey);
-        const orderMap = new Map(currentOrder.map((entry) => [entry.id, entry]));
-        for (const entry of newEntries) {
-          orderMap.set(entry.id, entry);
-        }
-        const updatedOrder = Array.from(orderMap.values()).sort((a, b) => a.score - b.score);
-        await this.operations.putKV({
-          tableName: storage.TABLE_MESSAGES,
-          key: orderKey,
-          value: JSON.stringify(updatedOrder)
+  async getNamespaceValue(tableName, key) {
+    try {
+      if (this.bindings) {
+        const binding = this.getBinding(tableName);
+        const result = await binding.getWithMetadata(key, "text");
+        if (!result) return null;
+        return JSON.stringify(result);
+      } else {
+        const namespaceId = await this.getNamespaceId(tableName);
+        const response = await this.client.kv.namespaces.values.get(namespaceId, key, {
+          account_id: this.accountId
         });
-      } catch (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) {
-          this.updateQueue.delete(orderKey);
-        }
+        return await response.text();
       }
-    });
-    this.updateQueue.set(orderKey, nextPromise);
-    return nextPromise;
+    } catch (error) {
+      if (error.message && error.message.includes("key not found")) {
+        return null;
+      }
+      const message = error instanceof Error ? error.message : String(error);
+      this.logger.error(`Failed to get value for ${tableName} ${key}:`, { message });
+      throw error;
+    }
   }
-  async getSortedMessages(orderKey) {
-    const raw = await this.operations.getKV(storage.TABLE_MESSAGES, orderKey);
-    if (!raw) return [];
+  async getKV(tableName, key) {
     try {
-      const arr = JSON.parse(typeof raw === "string" ? raw : JSON.stringify(raw));
-      return Array.isArray(arr) ? arr : [];
-    } catch (e) {
-      this.logger?.error(`Error parsing order data for key ${orderKey}:`, { e });
-      return [];
+      const text = await this.getNamespaceValue(tableName, key);
+      return this.safeParse(text);
+    } catch (error) {
+      this.logger.error(`Failed to get KV value for ${tableName}:${key}:`, error);
+      throw new Error(`Failed to get KV value: ${error.message}`);
     }
   }
-  async migrateMessage(messageId, fromThreadId, toThreadId) {
+  async getTableSchema(tableName) {
     try {
-      const oldMessageKey = this.getMessageKey(fromThreadId, messageId);
-      const message = await this.operations.getKV(storage.TABLE_MESSAGES, oldMessageKey);
-      if (!message) return;
-      const updatedMessage = {
-        ...message,
-        threadId: toThreadId
-      };
-      const newMessageKey = this.getMessageKey(toThreadId, messageId);
-      await this.operations.putKV({ tableName: storage.TABLE_MESSAGES, key: newMessageKey, value: updatedMessage });
-      const oldOrderKey = this.getThreadMessagesKey(fromThreadId);
-      const oldEntries = await this.getSortedMessages(oldOrderKey);
-      const filteredEntries = oldEntries.filter((entry) => entry.id !== messageId);
-      await this.updateSortedMessages(oldOrderKey, filteredEntries);
-      const newOrderKey = this.getThreadMessagesKey(toThreadId);
-      const newEntries = await this.getSortedMessages(newOrderKey);
-      const newEntry = { id: messageId, score: Date.now() };
-      newEntries.push(newEntry);
-      await this.updateSortedMessages(newOrderKey, newEntries);
-      await this.operations.deleteKV(storage.TABLE_MESSAGES, oldMessageKey);
+      const schemaKey = this.getSchemaKey(tableName);
+      return await this.getKV(tableName, schemaKey);
     } catch (error) {
-      this.logger?.error(`Error migrating message ${messageId} from ${fromThreadId} to ${toThreadId}:`, error);
-      throw error;
+      const message = error instanceof Error ? error.message : String(error);
+      this.logger.error(`Failed to get schema for ${tableName}:`, { message });
+      return null;
     }
   }
-  async saveMessages(args) {
-    const { messages } = args;
-    if (!Array.isArray(messages) || messages.length === 0) return { messages: [] };
-    try {
-      const validatedMessages = messages.map((message, index) => {
-        const errors = [];
-        if (!message.id) errors.push("id is required");
-        if (!message.threadId) errors.push("threadId is required");
-        if (!message.content) errors.push("content is required");
-        if (!message.role) errors.push("role is required");
-        if (!message.createdAt) errors.push("createdAt is required");
-        if (message.resourceId === null || message.resourceId === void 0) errors.push("resourceId is required");
-        if (errors.length > 0) {
-          throw new Error(`Invalid message at index ${index}: ${errors.join(", ")}`);
-        }
-        return {
-          ...message,
-          createdAt: storage.ensureDate(message.createdAt),
-          type: message.type || "v2",
-          _index: index
-        };
-      }).filter((m) => !!m);
-      const messageMigrationTasks = [];
-      for (const message of validatedMessages) {
-        const existingMessage = await this.findMessageInAnyThread(message.id);
-        this.logger?.debug(
-          `Checking message ${message.id}: existing=${existingMessage?.threadId}, new=${message.threadId}`
-        );
-        if (existingMessage && existingMessage.threadId && existingMessage.threadId !== message.threadId) {
-          this.logger?.debug(`Migrating message ${message.id} from ${existingMessage.threadId} to ${message.threadId}`);
-          messageMigrationTasks.push(this.migrateMessage(message.id, existingMessage.threadId, message.threadId));
+  validateColumnValue(value, column) {
+    if (value === void 0 || value === null) {
+      return column.nullable ?? false;
+    }
+    switch (column.type) {
+      case "text":
+      case "uuid":
+        return typeof value === "string";
+      case "integer":
+      case "bigint":
+        return typeof value === "number";
+      case "timestamp":
+        return value instanceof Date || typeof value === "string" && !isNaN(Date.parse(value));
+      case "jsonb":
+        if (typeof value !== "object") return false;
+        try {
+          JSON.stringify(value);
+          return true;
+        } catch {
+          return false;
         }
+      default:
+        return false;
+    }
+  }
+  async validateAgainstSchema(record, schema) {
+    try {
+      if (!schema || typeof schema !== "object" || schema.value === null) {
+        throw new Error("Invalid schema format");
       }
-      await Promise.all(messageMigrationTasks);
-      const messagesByThread = validatedMessages.reduce((acc, message) => {
-        if (message.threadId && !acc.has(message.threadId)) {
-          acc.set(message.threadId, []);
+      for (const [columnName, column] of Object.entries(schema)) {
+        const value = record[columnName];
+        if (column.primaryKey && (value === void 0 || value === null)) {
+          throw new Error(`Missing primary key value for column ${columnName}`);
         }
-        if (message.threadId) {
-          acc.get(message.threadId).push(message);
+        if (!this.validateColumnValue(value, column)) {
+          const valueType = value === null ? "null" : typeof value;
+          throw new Error(`Invalid value for column ${columnName}: expected ${column.type}, got ${valueType}`);
         }
-        return acc;
-      }, /* @__PURE__ */ new Map());
-      await Promise.all(
-        Array.from(messagesByThread.entries()).map(async ([threadId, threadMessages]) => {
-          try {
-            const thread = await this.getThreadById({ threadId });
-            if (!thread) {
-              throw new Error(`Thread ${threadId} not found`);
-            }
-            await Promise.all(
-              threadMessages.map(async (message) => {
-                const key = this.getMessageKey(threadId, message.id);
-                const { _index, ...cleanMessage } = message;
-                const serializedMessage = {
-                  ...cleanMessage,
-                  createdAt: storage.serializeDate(cleanMessage.createdAt)
-                };
-                this.logger?.debug(`Saving message ${message.id}`, {
-                  contentSummary: this.summarizeMessageContent(serializedMessage.content)
-                });
-                await this.operations.putKV({ tableName: storage.TABLE_MESSAGES, key, value: serializedMessage });
-              })
-            );
-            const orderKey = this.getThreadMessagesKey(threadId);
-            const entries = await this.updateSorting(threadMessages);
-            await this.updateSortedMessages(orderKey, entries);
-            const updatedThread = {
-              ...thread,
-              updatedAt: /* @__PURE__ */ new Date()
-            };
-            await this.operations.putKV({
-              tableName: storage.TABLE_THREADS,
-              key: this.operations.getKey(storage.TABLE_THREADS, { id: threadId }),
-              value: updatedThread
-            });
-          } catch (error$1) {
-            throw new error.MastraError(
-              {
-                id: "CLOUDFLARE_STORAGE_SAVE_MESSAGES_FAILED",
-                domain: error.ErrorDomain.STORAGE,
-                category: error.ErrorCategory.THIRD_PARTY,
-                details: {
-                  threadId
-                }
-              },
-              error$1
-            );
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      this.logger.error(`Error validating record against schema:`, { message, record, schema });
+      throw error;
+    }
+  }
+  async validateRecord(record, tableName) {
+    try {
+      if (!record || typeof record !== "object") {
+        throw new Error("Record must be an object");
+      }
+      const recordTyped = record;
+      const schema = await this.getTableSchema(tableName);
+      if (schema) {
+        await this.validateAgainstSchema(recordTyped, schema);
+        return;
+      }
+      switch (tableName) {
+        case storage.TABLE_THREADS:
+          if (!("id" in recordTyped) || !("resourceId" in recordTyped) || !("title" in recordTyped)) {
+            throw new Error("Thread record missing required fields");
           }
-        })
-      );
-      const prepared = validatedMessages.map(
-        ({ _index, ...message }) => ({ ...message, type: message.type !== "v2" ? message.type : void 0 })
-      );
-      const list = new agent.MessageList().add(prepared, "memory");
-      return { messages: list.get.all.db() };
+          break;
+        case storage.TABLE_MESSAGES:
+          if (!("id" in recordTyped) || !("threadId" in recordTyped) || !("content" in recordTyped) || !("role" in recordTyped)) {
+            throw new Error("Message record missing required fields");
+          }
+          break;
+        case storage.TABLE_WORKFLOW_SNAPSHOT:
+          if (!("workflow_name" in recordTyped) || !("run_id" in recordTyped)) {
+            throw new Error("Workflow record missing required fields");
+          }
+          break;
+        case storage.TABLE_TRACES:
+          if (!("id" in recordTyped)) {
+            throw new Error("Trace record missing required fields");
+          }
+          break;
+        case storage.TABLE_SCORERS:
+          if (!("id" in recordTyped) || !("scorerId" in recordTyped)) {
+            throw new Error("Score record missing required fields");
+          }
+          break;
+        default:
+          throw new Error(`Unknown table type: ${tableName}`);
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      this.logger.error(`Failed to validate record for ${tableName}:`, { message, record });
+      throw error;
+    }
+  }
+  async insert({ tableName, record }) {
+    try {
+      const key = this.getKey(tableName, record);
+      const processedRecord = { ...record };
+      await this.validateRecord(processedRecord, tableName);
+      await this.putKV({ tableName, key, value: processedRecord });
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "CLOUDFLARE_STORAGE_SAVE_MESSAGES_FAILED",
+          id: storage.createStorageErrorId("CLOUDFLARE", "INSERT", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            tableName
+          }
         },
         error$1
       );
     }
   }
-  async getRank(orderKey, id) {
-    const order = await this.getSortedMessages(orderKey);
-    const index = order.findIndex((item) => item.id === id);
-    return index >= 0 ? index : null;
-  }
-  async getRange(orderKey, start, end) {
-    const order = await this.getSortedMessages(orderKey);
-    const actualStart = start < 0 ? Math.max(0, order.length + start) : start;
-    const actualEnd = end < 0 ? order.length + end : Math.min(end, order.length - 1);
-    const sliced = order.slice(actualStart, actualEnd + 1);
-    return sliced.map((item) => item.id);
-  }
-  async getLastN(orderKey, n) {
-    return this.getRange(orderKey, -n, -1);
-  }
-  async getFullOrder(orderKey) {
-    return this.getRange(orderKey, 0, -1);
-  }
-  async getIncludedMessagesWithContext(threadId, include, messageIds) {
-    await Promise.all(
-      include.map(async (item) => {
-        const targetThreadId = item.threadId || threadId;
-        if (!targetThreadId) return;
-        const threadMessagesKey = this.getThreadMessagesKey(targetThreadId);
-        messageIds.add(item.id);
-        if (!item.withPreviousMessages && !item.withNextMessages) return;
-        const rank = await this.getRank(threadMessagesKey, item.id);
-        if (rank === null) return;
-        if (item.withPreviousMessages) {
-          const prevIds = await this.getRange(
-            threadMessagesKey,
-            Math.max(0, rank - item.withPreviousMessages),
-            rank - 1
-          );
-          prevIds.forEach((id) => messageIds.add(id));
-        }
-        if (item.withNextMessages) {
-          const nextIds = await this.getRange(threadMessagesKey, rank + 1, rank + item.withNextMessages);
-          nextIds.forEach((id) => messageIds.add(id));
-        }
-      })
-    );
-  }
-  async getRecentMessages(threadId, limit, messageIds) {
-    if (!threadId.trim()) throw new Error("threadId must be a non-empty string");
-    if (limit <= 0) return;
-    try {
-      const threadMessagesKey = this.getThreadMessagesKey(threadId);
-      const latestIds = await this.getLastN(threadMessagesKey, limit);
-      latestIds.forEach((id) => messageIds.add(id));
-    } catch {
-      this.logger?.debug(`No message order found for thread ${threadId}, skipping latest messages`);
-    }
-  }
-  async fetchAndParseMessagesFromMultipleThreads(messageIds, include, targetThreadId) {
-    const messageIdToThreadId = /* @__PURE__ */ new Map();
-    if (include) {
-      for (const item of include) {
-        if (item.threadId) {
-          messageIdToThreadId.set(item.id, item.threadId);
-        }
-      }
-    }
-    const messages = await Promise.all(
-      messageIds.map(async (id) => {
-        try {
-          let threadId = messageIdToThreadId.get(id);
-          if (!threadId) {
-            if (targetThreadId) {
-              threadId = targetThreadId;
-            } else {
-              const foundMessage = await this.findMessageInAnyThread(id);
-              if (foundMessage) {
-                threadId = foundMessage.threadId;
-              }
-            }
-          }
-          if (!threadId) return null;
-          const key = this.getMessageKey(threadId, id);
-          const data = await this.operations.getKV(storage.TABLE_MESSAGES, key);
-          if (!data) return null;
-          const parsed = typeof data === "string" ? JSON.parse(data) : data;
-          this.logger?.debug(`Retrieved message ${id} from thread ${threadId}`, {
-            contentSummary: this.summarizeMessageContent(parsed.content)
-          });
-          return parsed;
-        } catch (error) {
-          const message = error instanceof Error ? error.message : String(error);
-          this.logger?.error(`Error retrieving message ${id}:`, { message });
-          return null;
-        }
-      })
-    );
-    return messages.filter((msg) => msg !== null);
-  }
-  async listMessagesById({ messageIds }) {
-    if (messageIds.length === 0) return { messages: [] };
+  async load({ tableName, keys }) {
     try {
-      const messages = (await Promise.all(messageIds.map((id) => this.findMessageInAnyThread(id)))).filter(
-        (result) => !!result
-      );
-      const prepared = messages.map(({ _index, ...message }) => ({
-        ...message,
-        ...message.type !== `v2` && { type: message.type },
-        createdAt: storage.ensureDate(message.createdAt)
-      }));
-      const list = new agent.MessageList().add(prepared, "memory");
-      return { messages: list.get.all.db() };
+      const key = this.getKey(tableName, keys);
+      const data = await this.getKV(tableName, key);
+      if (!data) return null;
+      return data;
     } catch (error$1) {
       const mastraError = new error.MastraError(
         {
-          id: "CLOUDFLARE_STORAGE_LIST_MESSAGES_BY_ID_FAILED",
+          id: storage.createStorageErrorId("CLOUDFLARE", "LOAD", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
-          text: `Error retrieving messages by ID`,
           details: {
-            messageIds: JSON.stringify(messageIds)
+            tableName
           }
         },
         error$1
       );
       this.logger?.trackException(mastraError);
       this.logger?.error(mastraError.toString());
-      return { messages: [] };
+      return null;
     }
   }
-  async listMessages(args) {
-    const { threadId, resourceId, include, filter, perPage: perPageInput, page = 0, orderBy } = args;
-    if (!threadId.trim()) {
+  async batchInsert(input) {
+    if (!input.records || input.records.length === 0) return;
+    try {
+      await Promise.all(
+        input.records.map(async (record) => {
+          const key = this.getKey(input.tableName, record);
+          await this.putKV({ tableName: input.tableName, key, value: record });
+        })
+      );
+    } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "STORAGE_CLOUDFLARE_LIST_MESSAGES_INVALID_THREAD_ID",
+          id: storage.createStorageErrorId("CLOUDFLARE", "BATCH_INSERT", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
-          details: { threadId }
+          text: `Error in batch insert for table ${input.tableName}`,
+          details: {
+            tableName: input.tableName
+          }
         },
-        new Error("threadId must be a non-empty string")
+        error$1
       );
     }
-    const perPage = storage.normalizePerPage(perPageInput, 40);
-    const { offset, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
+  }
+  safeSerialize(data) {
+    return typeof data === "string" ? data : JSON.stringify(data);
+  }
+  async putNamespaceValue({
+    tableName,
+    key,
+    value,
+    metadata
+  }) {
     try {
-      if (page < 0) {
-        throw new error.MastraError(
-          {
-            id: "STORAGE_CLOUDFLARE_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 messageIds = /* @__PURE__ */ new Set();
-      const hasFilters = !!resourceId || !!filter?.dateRange;
-      if (hasFilters || perPage === Number.MAX_SAFE_INTEGER) {
-        try {
-          const threadMessagesKey = this.getThreadMessagesKey(threadId);
-          const allIds = await this.getFullOrder(threadMessagesKey);
-          allIds.forEach((id) => messageIds.add(id));
-        } catch {
-        }
+      const serializedValue = this.safeSerialize(value);
+      const serializedMetadata = metadata ? this.safeSerialize(metadata) : "";
+      if (this.bindings) {
+        const binding = this.getBinding(tableName);
+        await binding.put(key, serializedValue, { metadata: serializedMetadata });
       } else {
-        if (perPage > 0) {
-          try {
-            const threadMessagesKey = this.getThreadMessagesKey(threadId);
-            const fullOrder = await this.getFullOrder(threadMessagesKey);
-            const totalMessages = fullOrder.length;
-            let start;
-            let end;
-            if (direction === "ASC") {
-              start = offset;
-              end = Math.min(offset + perPage - 1, totalMessages - 1);
-            } else {
-              start = Math.max(totalMessages - offset - perPage, 0);
-              end = totalMessages - offset - 1;
-            }
-            const paginatedIds = await this.getRange(threadMessagesKey, start, end);
-            paginatedIds.forEach((id) => messageIds.add(id));
-          } catch {
-          }
-        }
-      }
-      if (include && include.length > 0) {
-        await this.getIncludedMessagesWithContext(threadId, include, messageIds);
-      }
-      const messages = await this.fetchAndParseMessagesFromMultipleThreads(
-        Array.from(messageIds),
-        include,
-        include && include.length > 0 ? void 0 : threadId
-      );
-      let filteredMessages = messages;
-      if (resourceId) {
-        filteredMessages = filteredMessages.filter((msg) => msg.resourceId === resourceId);
-      }
-      const dateRange = filter?.dateRange;
-      if (dateRange) {
-        filteredMessages = filteredMessages.filter((msg) => {
-          const messageDate = new Date(msg.createdAt);
-          if (dateRange.start && messageDate < new Date(dateRange.start)) return false;
-          if (dateRange.end && messageDate > new Date(dateRange.end)) return false;
-          return true;
+        const namespaceId = await this.getNamespaceId(tableName);
+        await this.client.kv.namespaces.values.update(namespaceId, key, {
+          account_id: this.accountId,
+          value: serializedValue,
+          metadata: serializedMetadata
         });
       }
-      let total;
-      if (hasFilters) {
-        total = filteredMessages.length;
-      } else {
-        try {
-          const threadMessagesKey = this.getThreadMessagesKey(threadId);
-          const fullOrder = await this.getFullOrder(threadMessagesKey);
-          total = fullOrder.length;
-        } catch {
-          total = filteredMessages.length;
-        }
-      }
-      if (perPage === 0 && (!include || include.length === 0)) {
-        return {
-          messages: [],
-          total,
-          page,
-          perPage: perPageForResponse,
-          hasMore: offset < total
-        };
-      }
-      if (hasFilters && perPage !== Number.MAX_SAFE_INTEGER && perPage > 0) {
-        if (direction === "ASC") {
-          filteredMessages = filteredMessages.slice(offset, offset + perPage);
-        } else {
-          const start = Math.max(filteredMessages.length - offset - perPage, 0);
-          const end = filteredMessages.length - offset;
-          filteredMessages = filteredMessages.slice(start, end);
-        }
-      }
-      const paginatedCount = hasFilters && perPage !== Number.MAX_SAFE_INTEGER && perPage > 0 ? filteredMessages.length : filteredMessages.length;
-      try {
-        const threadMessagesKey = this.getThreadMessagesKey(threadId);
-        const messageOrder = await this.getFullOrder(threadMessagesKey);
-        const orderMap = new Map(messageOrder.map((id, index) => [id, index]));
-        filteredMessages.sort((a, b) => {
-          const indexA = orderMap.get(a.id);
-          const indexB = orderMap.get(b.id);
-          if (indexA !== void 0 && indexB !== void 0) {
-            return direction === "ASC" ? indexA - indexB : indexB - indexA;
-          }
-          const timeA = new Date(a.createdAt).getTime();
-          const timeB = new Date(b.createdAt).getTime();
-          const timeDiff = direction === "ASC" ? timeA - timeB : timeB - timeA;
-          if (timeDiff === 0) {
-            return a.id.localeCompare(b.id);
-          }
-          return timeDiff;
-        });
-      } catch {
-        filteredMessages.sort((a, b) => {
-          const timeA = new Date(a.createdAt).getTime();
-          const timeB = new Date(b.createdAt).getTime();
-          const timeDiff = direction === "ASC" ? timeA - timeB : timeB - timeA;
-          if (timeDiff === 0) {
-            return a.id.localeCompare(b.id);
-          }
-          return timeDiff;
-        });
-      }
-      if (total === 0 && filteredMessages.length === 0 && (!include || include.length === 0)) {
-        return {
-          messages: [],
-          total: 0,
-          page,
-          perPage: perPageForResponse,
-          hasMore: false
-        };
-      }
-      const prepared = filteredMessages.map(({ _index, ...message }) => ({
-        ...message,
-        type: message.type !== "v2" ? message.type : void 0,
-        createdAt: storage.ensureDate(message.createdAt)
-      }));
-      const list = new agent.MessageList({ threadId, resourceId }).add(prepared, "memory");
-      let finalMessages = list.get.all.db();
-      finalMessages = finalMessages.sort((a, b) => {
-        const isDateField = field === "createdAt" || field === "updatedAt";
-        const aVal = isDateField ? new Date(a[field]).getTime() : a[field];
-        const bVal = isDateField ? new Date(b[field]).getTime() : b[field];
-        if (aVal == null && bVal == null) return a.id.localeCompare(b.id);
-        if (aVal == null) return 1;
-        if (bVal == null) return -1;
-        if (typeof aVal === "number" && typeof bVal === "number") {
-          const cmp2 = direction === "ASC" ? aVal - bVal : bVal - aVal;
-          return cmp2 !== 0 ? cmp2 : a.id.localeCompare(b.id);
-        }
-        const cmp = direction === "ASC" ? String(aVal).localeCompare(String(bVal)) : String(bVal).localeCompare(String(aVal));
-        return cmp !== 0 ? cmp : a.id.localeCompare(b.id);
-      });
-      const returnedThreadMessageIds = new Set(finalMessages.filter((m) => m.threadId === threadId).map((m) => m.id));
-      const allThreadMessagesReturned = returnedThreadMessageIds.size >= total;
-      let hasMore;
-      if (perPageInput === false || allThreadMessagesReturned) {
-        hasMore = false;
-      } else if (direction === "ASC") {
-        hasMore = offset + paginatedCount < total;
-      } else {
-        hasMore = total - offset - perPage > 0;
-      }
-      return {
-        messages: finalMessages,
-        total,
-        page,
-        perPage: perPageForResponse,
-        hasMore
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      this.logger.error(`Failed to put value for ${tableName} ${key}:`, { message });
+      throw error;
+    }
+  }
+  async putKV({
+    tableName,
+    key,
+    value,
+    metadata
+  }) {
+    try {
+      await this.putNamespaceValue({ tableName, key, value, metadata });
+    } catch (error) {
+      this.logger.error(`Failed to put KV value for ${tableName}:${key}:`, error);
+      throw new Error(`Failed to put KV value: ${error.message}`);
+    }
+  }
+  async createTable({
+    tableName,
+    schema
+  }) {
+    try {
+      const schemaKey = this.getSchemaKey(tableName);
+      const metadata = {
+        type: "table_schema",
+        tableName,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
       };
+      await this.putKV({ tableName, key: schemaKey, value: schema, metadata });
     } catch (error$1) {
-      const mastraError = new error.MastraError(
+      throw new error.MastraError(
         {
-          id: "CLOUDFLARE_STORAGE_LIST_MESSAGES_FAILED",
+          id: storage.createStorageErrorId("CLOUDFLARE", "CREATE_TABLE", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
-          text: `Failed to list messages for thread ${threadId}: ${error$1 instanceof Error ? error$1.message : String(error$1)}`,
           details: {
-            threadId,
-            resourceId: resourceId ?? ""
+            tableName
           }
         },
         error$1
       );
-      this.logger?.error?.(mastraError.toString());
-      this.logger?.trackException?.(mastraError);
-      return {
-        messages: [],
-        total: 0,
-        page,
-        perPage: perPageForResponse,
-        hasMore: false
-      };
     }
   }
-  async updateMessages(args) {
+  async clearTable({ tableName }) {
     try {
-      const { messages } = args;
-      const updatedMessages = [];
-      for (const messageUpdate of messages) {
-        const { id, content, ...otherFields } = messageUpdate;
-        const prefix = this.operations.namespacePrefix ? `${this.operations.namespacePrefix}:` : "";
-        const keyObjs = await this.operations.listKV(storage.TABLE_MESSAGES, { prefix: `${prefix}${storage.TABLE_MESSAGES}` });
-        let existingMessage = null;
-        let messageKey = "";
-        for (const { name: key } of keyObjs) {
-          const data = await this.operations.getKV(storage.TABLE_MESSAGES, key);
-          if (data && data.id === id) {
-            existingMessage = data;
-            messageKey = key;
-            break;
-          }
-        }
-        if (!existingMessage) {
-          continue;
-        }
-        const updatedMessage = {
-          ...existingMessage,
-          ...otherFields,
-          id
-        };
-        if (content) {
-          if (content.metadata !== void 0) {
-            updatedMessage.content = {
-              ...updatedMessage.content,
-              metadata: {
-                ...updatedMessage.content?.metadata,
-                ...content.metadata
-              }
-            };
-          }
-          if (content.content !== void 0) {
-            updatedMessage.content = {
-              ...updatedMessage.content,
-              content: content.content
-            };
-          }
-        }
-        if ("threadId" in messageUpdate && messageUpdate.threadId && messageUpdate.threadId !== existingMessage.threadId) {
-          await this.operations.deleteKV(storage.TABLE_MESSAGES, messageKey);
-          updatedMessage.threadId = messageUpdate.threadId;
-          const newMessageKey = this.getMessageKey(messageUpdate.threadId, id);
-          await this.operations.putKV({
-            tableName: storage.TABLE_MESSAGES,
-            key: newMessageKey,
-            value: updatedMessage
-          });
-          if (existingMessage.threadId) {
-            const sourceOrderKey = this.getThreadMessagesKey(existingMessage.threadId);
-            const sourceEntries = await this.getSortedMessages(sourceOrderKey);
-            const filteredEntries = sourceEntries.filter((entry) => entry.id !== id);
-            await this.updateSortedMessages(sourceOrderKey, filteredEntries);
-          }
-          const destOrderKey = this.getThreadMessagesKey(messageUpdate.threadId);
-          const destEntries = await this.getSortedMessages(destOrderKey);
-          const newEntry = { id, score: Date.now() };
-          destEntries.push(newEntry);
-          await this.updateSortedMessages(destOrderKey, destEntries);
-        } else {
-          await this.operations.putKV({
-            tableName: storage.TABLE_MESSAGES,
-            key: messageKey,
-            value: updatedMessage
-          });
-        }
-        const threadsToUpdate = /* @__PURE__ */ new Set();
-        if (updatedMessage.threadId) {
-          threadsToUpdate.add(updatedMessage.threadId);
-        }
-        if ("threadId" in messageUpdate && messageUpdate.threadId && messageUpdate.threadId !== existingMessage.threadId) {
-          if (existingMessage.threadId) {
-            threadsToUpdate.add(existingMessage.threadId);
-          }
-          threadsToUpdate.add(messageUpdate.threadId);
-        }
-        for (const threadId of threadsToUpdate) {
-          const thread = await this.getThreadById({ threadId });
-          if (thread) {
-            const updatedThread = {
-              ...thread,
-              updatedAt: /* @__PURE__ */ new Date()
-            };
-            await this.operations.putKV({
-              tableName: storage.TABLE_THREADS,
-              key: this.operations.getKey(storage.TABLE_THREADS, { id: threadId }),
-              value: updatedThread
-            });
-          }
-        }
-        updatedMessages.push(updatedMessage);
+      const keys = await this.listKV(tableName);
+      if (keys.length > 0) {
+        await Promise.all(keys.map((keyObj) => this.deleteKV(tableName, keyObj.name)));
       }
-      return updatedMessages;
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "CLOUDFLARE_STORAGE_UPDATE_MESSAGES_FAILED",
+          id: storage.createStorageErrorId("CLOUDFLARE", "CLEAR_TABLE", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
-          text: "Failed to update messages"
+          details: {
+            tableName
+          }
         },
         error$1
       );
     }
   }
-  async getResourceById({ resourceId }) {
+  async dropTable({ tableName }) {
     try {
-      const data = await this.operations.getKV(storage.TABLE_RESOURCES, resourceId);
-      if (!data) return null;
-      const resource = typeof data === "string" ? JSON.parse(data) : data;
-      return {
-        ...resource,
-        createdAt: storage.ensureDate(resource.createdAt),
-        updatedAt: storage.ensureDate(resource.updatedAt),
-        metadata: this.ensureMetadata(resource.metadata)
-      };
+      const keys = await this.listKV(tableName);
+      if (keys.length > 0) {
+        await Promise.all(keys.map((keyObj) => this.deleteKV(tableName, keyObj.name)));
+      }
     } catch (error$1) {
-      const mastraError = new error.MastraError(
+      throw new error.MastraError(
         {
-          id: "CLOUDFLARE_STORAGE_GET_RESOURCE_BY_ID_FAILED",
+          id: storage.createStorageErrorId("CLOUDFLARE", "DROP_TABLE", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
           details: {
-            resourceId
+            tableName
           }
         },
         error$1
       );
-      this.logger?.trackException(mastraError);
-      this.logger?.error(mastraError.toString());
-      return null;
     }
   }
-  async saveResource({ resource }) {
+  async listNamespaceKeys(tableName, options) {
     try {
-      const resourceToSave = {
-        ...resource,
-        metadata: resource.metadata ? JSON.stringify(resource.metadata) : null
-      };
-      await this.operations.putKV({
-        tableName: storage.TABLE_RESOURCES,
-        key: resource.id,
-        value: resourceToSave
-      });
-      return resource;
+      if (this.bindings) {
+        const binding = this.getBinding(tableName);
+        const response = await binding.list({
+          limit: options?.limit || 1e3,
+          prefix: options?.prefix
+        });
+        return response.keys;
+      } else {
+        const namespaceId = await this.getNamespaceId(tableName);
+        const response = await this.client.kv.namespaces.keys.list(namespaceId, {
+          account_id: this.accountId,
+          limit: options?.limit || 1e3,
+          prefix: options?.prefix
+        });
+        return response.result;
+      }
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "CLOUDFLARE_STORAGE_SAVE_RESOURCE_FAILED",
+          id: storage.createStorageErrorId("CLOUDFLARE", "LIST_NAMESPACE_KEYS", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
           details: {
-            resourceId: resource.id
+            tableName
           }
         },
         error$1
       );
     }
   }
-  async updateResource({
-    resourceId,
-    workingMemory,
-    metadata
-  }) {
-    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 });
+  async deleteNamespaceValue(tableName, key) {
+    if (this.bindings) {
+      const binding = this.getBinding(tableName);
+      await binding.delete(key);
+    } else {
+      const namespaceId = await this.getNamespaceId(tableName);
+      await this.client.kv.namespaces.values.delete(namespaceId, key, {
+        account_id: this.accountId
+      });
+    }
+  }
+  async deleteKV(tableName, key) {
+    try {
+      await this.deleteNamespaceValue(tableName, key);
+    } catch (error) {
+      this.logger.error(`Failed to delete KV value for ${tableName}:${key}:`, error);
+      throw new Error(`Failed to delete KV value: ${error.message}`);
+    }
+  }
+  async listKV(tableName, options) {
+    try {
+      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}`);
     }
-    const updatedAt = /* @__PURE__ */ new Date();
-    const updatedResource = {
-      ...existingResource,
-      workingMemory: workingMemory !== void 0 ? workingMemory : existingResource.workingMemory,
-      metadata: {
-        ...existingResource.metadata,
-        ...metadata
-      },
-      updatedAt
-    };
-    return this.saveResource({ resource: updatedResource });
   }
 };
-var StoreOperationsCloudflare = class extends storage.StoreOperations {
-  bindings;
-  client;
-  accountId;
-  namespacePrefix;
-  constructor({
-    namespacePrefix,
-    bindings,
-    client,
-    accountId
-  }) {
+
+// src/storage/domains/memory/index.ts
+var MemoryStorageCloudflare = class extends storage.MemoryStorage {
+  #db;
+  constructor(config) {
     super();
-    this.bindings = bindings;
-    this.namespacePrefix = namespacePrefix;
-    this.client = client;
-    this.accountId = accountId;
+    this.#db = new CloudflareKVDB(resolveCloudflareConfig(config));
   }
-  async hasColumn() {
-    return true;
+  async init() {
   }
-  async alterTable(_args) {
+  async dangerouslyClearAll() {
+    await this.#db.clearTable({ tableName: storage.TABLE_MESSAGES });
+    await this.#db.clearTable({ tableName: storage.TABLE_THREADS });
+    await this.#db.clearTable({ tableName: storage.TABLE_RESOURCES });
   }
-  async clearTable({ tableName }) {
+  ensureMetadata(metadata) {
+    if (!metadata) return void 0;
+    return typeof metadata === "string" ? JSON.parse(metadata) : metadata;
+  }
+  /**
+   * Summarizes message content without exposing raw data (for logging).
+   * Returns type, length, and keys only to prevent PII leakage.
+   */
+  summarizeMessageContent(content) {
+    if (!content) return { type: "undefined" };
+    if (typeof content === "string") return { type: "string", length: content.length };
+    if (Array.isArray(content)) return { type: "array", length: content.length };
+    if (typeof content === "object") return { type: "object", keys: Object.keys(content) };
+    return { type: typeof content };
+  }
+  async getThreadById({ threadId }) {
+    const thread = await this.#db.load({ tableName: storage.TABLE_THREADS, keys: { id: threadId } });
+    if (!thread) return null;
     try {
-      const keys = await this.listKV(tableName);
-      if (keys.length > 0) {
-        await Promise.all(keys.map((keyObj) => this.deleteKV(tableName, keyObj.name)));
-      }
+      return {
+        ...thread,
+        createdAt: storage.ensureDate(thread.createdAt),
+        updatedAt: storage.ensureDate(thread.updatedAt),
+        metadata: this.ensureMetadata(thread.metadata)
+      };
     } catch (error$1) {
-      throw new error.MastraError(
+      const mastraError = new error.MastraError(
         {
-          id: "CLOUDFLARE_STORAGE_CLEAR_TABLE_FAILED",
+          id: storage.createStorageErrorId("CLOUDFLARE", "GET_THREAD_BY_ID", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
           details: {
-            tableName
+            threadId
           }
         },
         error$1
       );
+      this.logger?.trackException(mastraError);
+      this.logger?.error(mastraError.toString());
+      return null;
     }
   }
-  async dropTable({ tableName }) {
+  async listThreadsByResourceId(args) {
     try {
-      const keys = await this.listKV(tableName);
-      if (keys.length > 0) {
-        await Promise.all(keys.map((keyObj) => this.deleteKV(tableName, keyObj.name)));
+      const { resourceId, page = 0, perPage: perPageInput, orderBy } = args;
+      const perPage = storage.normalizePerPage(perPageInput, 100);
+      if (page < 0) {
+        throw new error.MastraError(
+          {
+            id: storage.createStorageErrorId("CLOUDFLARE", "LIST_THREADS_BY_RESOURCE_ID", "INVALID_PAGE"),
+            domain: error.ErrorDomain.STORAGE,
+            category: error.ErrorCategory.USER,
+            details: { page }
+          },
+          new Error("page must be >= 0")
+        );
+      }
+      const { offset, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
+      const { field, direction } = this.parseOrderBy(orderBy);
+      const prefix = this.#db.namespacePrefix ? `${this.#db.namespacePrefix}:` : "";
+      const keyObjs = await this.#db.listKV(storage.TABLE_THREADS, { prefix: `${prefix}${storage.TABLE_THREADS}` });
+      const threads = [];
+      for (const { name: key } of keyObjs) {
+        const data = await this.#db.getKV(storage.TABLE_THREADS, key);
+        if (!data) continue;
+        if (data.resourceId !== resourceId) continue;
+        threads.push(data);
       }
+      threads.sort((a, b) => {
+        const aTime = new Date(a[field] || 0).getTime();
+        const bTime = new Date(b[field] || 0).getTime();
+        return direction === "ASC" ? aTime - bTime : bTime - aTime;
+      });
+      const end = perPageInput === false ? threads.length : offset + perPage;
+      const paginatedThreads = threads.slice(offset, end);
+      return {
+        page,
+        perPage: perPageForResponse,
+        total: threads.length,
+        hasMore: perPageInput === false ? false : offset + perPage < threads.length,
+        threads: paginatedThreads
+      };
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "CLOUDFLARE_STORAGE_DROP_TABLE_FAILED",
+          id: storage.createStorageErrorId("CLOUDFLARE", "LIST_THREADS_BY_RESOURCE_ID", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
-          details: {
-            tableName
-          }
+          text: "Failed to get threads by resource ID with pagination"
         },
         error$1
       );
     }
   }
-  getBinding(tableName) {
-    if (!this.bindings) {
-      throw new Error(`Cannot use Workers API binding for ${tableName}: Store initialized with REST API configuration`);
-    }
-    const binding = this.bindings[tableName];
-    if (!binding) throw new Error(`No binding found for namespace ${tableName}`);
-    return binding;
-  }
-  getKey(tableName, record) {
-    const prefix = this.namespacePrefix ? `${this.namespacePrefix}:` : "";
-    switch (tableName) {
-      case storage.TABLE_THREADS:
-        if (!record.id) throw new Error("Thread ID is required");
-        return `${prefix}${tableName}:${record.id}`;
-      case storage.TABLE_MESSAGES:
-        if (!record.threadId || !record.id) throw new Error("Thread ID and Message ID are required");
-        return `${prefix}${tableName}:${record.threadId}:${record.id}`;
-      case storage.TABLE_WORKFLOW_SNAPSHOT:
-        if (!record.workflow_name || !record.run_id) {
-          throw new Error("Workflow name, and run ID are required");
-        }
-        let key = `${prefix}${tableName}:${record.workflow_name}:${record.run_id}`;
-        if (record.resourceId) {
-          key = `${key}:${record.resourceId}`;
-        }
-        return key;
-      case storage.TABLE_TRACES:
-        if (!record.id) throw new Error("Trace ID is required");
-        return `${prefix}${tableName}:${record.id}`;
-      case storage.TABLE_SCORERS:
-        if (!record.id) throw new Error("Score ID is required");
-        return `${prefix}${tableName}:${record.id}`;
-      default:
-        throw new Error(`Unsupported table: ${tableName}`);
-    }
-  }
-  getSchemaKey(tableName) {
-    const prefix = this.namespacePrefix ? `${this.namespacePrefix}:` : "";
-    return `${prefix}schema:${tableName}`;
-  }
-  /**
-   * Helper to safely parse data from KV storage
-   */
-  safeParse(text) {
-    if (!text) return null;
+  async saveThread({ thread }) {
     try {
-      const data = JSON.parse(text);
-      if (data && typeof data === "object" && "value" in data) {
-        if (typeof data.value === "string") {
-          try {
-            return JSON.parse(data.value);
-          } catch {
-            return data.value;
+      await this.#db.insert({ tableName: storage.TABLE_THREADS, record: thread });
+      return thread;
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("CLOUDFLARE", "SAVE_THREAD", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            threadId: thread.id
           }
-        }
-        return null;
-      }
-      return data;
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      this.logger.error("Failed to parse text:", { message, text });
-      return null;
+        },
+        error$1
+      );
     }
   }
-  async createNamespaceById(title) {
-    if (this.bindings) {
-      return {
-        id: title,
-        // Use title as ID since that's what we need
+  async updateThread({
+    id,
+    title,
+    metadata
+  }) {
+    try {
+      const thread = await this.getThreadById({ threadId: id });
+      if (!thread) {
+        throw new Error(`Thread ${id} not found`);
+      }
+      const updatedThread = {
+        ...thread,
         title,
-        supports_url_encoding: true
+        metadata: this.ensureMetadata({
+          ...thread.metadata ?? {},
+          ...metadata
+        }),
+        updatedAt: /* @__PURE__ */ new Date()
       };
+      await this.#db.insert({ tableName: storage.TABLE_THREADS, record: updatedThread });
+      return updatedThread;
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("CLOUDFLARE", "UPDATE_THREAD", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            threadId: id,
+            title
+          }
+        },
+        error$1
+      );
     }
-    return await this.client.kv.namespaces.create({
-      account_id: this.accountId,
-      title
-    });
   }
-  async createNamespace(namespaceName) {
+  getMessageKey(threadId, messageId) {
     try {
-      const response = await this.createNamespaceById(namespaceName);
-      return response.id;
+      return this.#db.getKey(storage.TABLE_MESSAGES, { threadId, id: messageId });
     } catch (error) {
-      if (error.message && error.message.includes("already exists")) {
-        const namespaces = await this.listNamespaces();
-        const namespace = namespaces.result.find((ns) => ns.title === namespaceName);
-        if (namespace) return namespace.id;
-      }
-      this.logger.error("Error creating namespace:", error);
-      throw new Error(`Failed to create namespace ${namespaceName}: ${error.message}`);
+      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;
     }
   }
-  async listNamespaces() {
-    if (this.bindings) {
-      return {
-        result: Object.keys(this.bindings).map((name) => ({
-          id: name,
-          title: name,
-          supports_url_encoding: true
-        }))
-      };
+  getThreadMessagesKey(threadId) {
+    try {
+      return this.#db.getKey(storage.TABLE_MESSAGES, { threadId, id: "messages" });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      this.logger?.error(`Error getting thread messages key for thread ${threadId}:`, { message });
+      throw error;
     }
-    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++;
+  }
+  async deleteThread({ threadId }) {
+    try {
+      const thread = await this.getThreadById({ threadId });
+      if (!thread) {
+        throw new Error(`Thread ${threadId} not found`);
       }
+      const messageKeys = await this.#db.listKV(storage.TABLE_MESSAGES);
+      const threadMessageKeys = messageKeys.filter((key) => key.name.includes(`${storage.TABLE_MESSAGES}:${threadId}:`));
+      await Promise.all([
+        // Delete message order
+        this.#db.deleteKV(storage.TABLE_MESSAGES, this.getThreadMessagesKey(threadId)),
+        // Delete all messages
+        ...threadMessageKeys.map((key) => this.#db.deleteKV(storage.TABLE_MESSAGES, key.name)),
+        // Delete thread
+        this.#db.deleteKV(storage.TABLE_THREADS, this.#db.getKey(storage.TABLE_THREADS, { id: threadId }))
+      ]);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("CLOUDFLARE", "DELETE_THREAD", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            threadId
+          }
+        },
+        error$1
+      );
     }
-    return { result: allNamespaces };
   }
-  async getNamespaceIdByName(namespaceName) {
+  /**
+   * Searches all threads in the KV store to find a message by its ID.
+   *
+   * **Performance Warning**: This method sequentially scans all threads to locate
+   * the message. For stores with many threads, this can result in significant
+   * latency and API calls. When possible, callers should provide the `threadId`
+   * directly to avoid this full scan.
+   *
+   * @param messageId - The globally unique message ID to search for
+   * @returns The message with its threadId if found, null otherwise
+   */
+  async findMessageInAnyThread(messageId) {
     try {
-      const response = await this.listNamespaces();
-      const namespace = response.result.find((ns) => ns.title === namespaceName);
-      return namespace ? namespace.id : null;
+      const prefix = this.#db.namespacePrefix ? `${this.#db.namespacePrefix}:` : "";
+      const threadKeys = await this.#db.listKV(storage.TABLE_THREADS, { prefix: `${prefix}${storage.TABLE_THREADS}` });
+      for (const { name: threadKey } of threadKeys) {
+        const threadId = threadKey.split(":").pop();
+        if (!threadId || threadId === "messages") continue;
+        const messageKey = this.getMessageKey(threadId, messageId);
+        const message = await this.#db.getKV(storage.TABLE_MESSAGES, messageKey);
+        if (message) {
+          return { ...message, threadId };
+        }
+      }
+      return null;
     } catch (error) {
-      this.logger.error(`Failed to get namespace ID for ${namespaceName}:`, error);
+      this.logger?.error(`Error finding message ${messageId} in any thread:`, error);
       return null;
     }
   }
-  async getOrCreateNamespaceId(namespaceName) {
-    let namespaceId = await this.getNamespaceIdByName(namespaceName);
-    if (!namespaceId) {
-      namespaceId = await this.createNamespace(namespaceName);
-    }
-    return namespaceId;
+  /**
+   * Queue for serializing sorted order updates.
+   * Updates the sorted order for a given key. This operation is eventually consistent.
+   */
+  updateQueue = /* @__PURE__ */ new Map();
+  async updateSorting(threadMessages) {
+    return threadMessages.map((msg) => ({
+      message: msg,
+      // Use _index if available, otherwise timestamp, matching Upstash
+      score: msg._index !== void 0 ? msg._index : msg.createdAt.getTime()
+    })).sort((a, b) => a.score - b.score).map((item) => ({
+      id: item.message.id,
+      score: item.score
+    }));
   }
-  async getNamespaceId(tableName) {
-    const prefix = this.namespacePrefix ? `${this.namespacePrefix}_` : "";
+  /**
+   * Updates the sorted order for a given key. This operation is eventually consistent.
+   * Note: Operations on the same orderKey are serialized using a queue to prevent
+   * concurrent updates from conflicting with each other.
+   */
+  async updateSortedMessages(orderKey, newEntries) {
+    const currentPromise = this.updateQueue.get(orderKey) || Promise.resolve();
+    const nextPromise = currentPromise.then(async () => {
+      try {
+        const currentOrder = await this.getSortedMessages(orderKey);
+        const orderMap = new Map(currentOrder.map((entry) => [entry.id, entry]));
+        for (const entry of newEntries) {
+          orderMap.set(entry.id, entry);
+        }
+        const updatedOrder = Array.from(orderMap.values()).sort((a, b) => a.score - b.score);
+        await this.#db.putKV({
+          tableName: storage.TABLE_MESSAGES,
+          key: orderKey,
+          value: JSON.stringify(updatedOrder)
+        });
+      } catch (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) {
+          this.updateQueue.delete(orderKey);
+        }
+      }
+    });
+    this.updateQueue.set(orderKey, nextPromise);
+    return nextPromise;
+  }
+  async getSortedMessages(orderKey) {
+    const raw = await this.#db.getKV(storage.TABLE_MESSAGES, orderKey);
+    if (!raw) return [];
     try {
-      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}`);
+      const arr = JSON.parse(typeof raw === "string" ? raw : JSON.stringify(raw));
+      return Array.isArray(arr) ? arr : [];
+    } catch (e) {
+      this.logger?.error(`Error parsing order data for key ${orderKey}:`, { e });
+      return [];
     }
   }
-  async getNamespaceValue(tableName, key) {
+  async migrateMessage(messageId, fromThreadId, toThreadId) {
     try {
-      if (this.bindings) {
-        const binding = this.getBinding(tableName);
-        const result = await binding.getWithMetadata(key, "text");
-        if (!result) return null;
-        return JSON.stringify(result);
-      } else {
-        const namespaceId = await this.getNamespaceId(tableName);
-        const response = await this.client.kv.namespaces.values.get(namespaceId, key, {
-          account_id: this.accountId
-        });
-        return await response.text();
-      }
+      const oldMessageKey = this.getMessageKey(fromThreadId, messageId);
+      const message = await this.#db.getKV(storage.TABLE_MESSAGES, oldMessageKey);
+      if (!message) return;
+      const updatedMessage = {
+        ...message,
+        threadId: toThreadId
+      };
+      const newMessageKey = this.getMessageKey(toThreadId, messageId);
+      await this.#db.putKV({ tableName: storage.TABLE_MESSAGES, key: newMessageKey, value: updatedMessage });
+      const oldOrderKey = this.getThreadMessagesKey(fromThreadId);
+      const oldEntries = await this.getSortedMessages(oldOrderKey);
+      const filteredEntries = oldEntries.filter((entry) => entry.id !== messageId);
+      await this.updateSortedMessages(oldOrderKey, filteredEntries);
+      const newOrderKey = this.getThreadMessagesKey(toThreadId);
+      const newEntries = await this.getSortedMessages(newOrderKey);
+      const newEntry = { id: messageId, score: Date.now() };
+      newEntries.push(newEntry);
+      await this.updateSortedMessages(newOrderKey, newEntries);
+      await this.#db.deleteKV(storage.TABLE_MESSAGES, oldMessageKey);
     } catch (error) {
-      if (error.message && error.message.includes("key not found")) {
-        return null;
-      }
-      const message = error instanceof Error ? error.message : String(error);
-      this.logger.error(`Failed to get value for ${tableName} ${key}:`, { message });
+      this.logger?.error(`Error migrating message ${messageId} from ${fromThreadId} to ${toThreadId}:`, error);
       throw error;
     }
   }
-  async getKV(tableName, key) {
+  async saveMessages(args) {
+    const { messages } = args;
+    if (!Array.isArray(messages) || messages.length === 0) return { messages: [] };
     try {
-      const text = await this.getNamespaceValue(tableName, key);
-      return this.safeParse(text);
-    } catch (error) {
-      this.logger.error(`Failed to get KV value for ${tableName}:${key}:`, error);
-      throw new Error(`Failed to get KV value: ${error.message}`);
+      const validatedMessages = messages.map((message, index) => {
+        const errors = [];
+        if (!message.id) errors.push("id is required");
+        if (!message.threadId) errors.push("threadId is required");
+        if (!message.content) errors.push("content is required");
+        if (!message.role) errors.push("role is required");
+        if (!message.createdAt) errors.push("createdAt is required");
+        if (message.resourceId === null || message.resourceId === void 0) errors.push("resourceId is required");
+        if (errors.length > 0) {
+          throw new Error(`Invalid message at index ${index}: ${errors.join(", ")}`);
+        }
+        return {
+          ...message,
+          createdAt: storage.ensureDate(message.createdAt),
+          type: message.type || "v2",
+          _index: index
+        };
+      }).filter((m) => !!m);
+      const messageMigrationTasks = [];
+      for (const message of validatedMessages) {
+        const existingMessage = await this.findMessageInAnyThread(message.id);
+        this.logger?.debug(
+          `Checking message ${message.id}: existing=${existingMessage?.threadId}, new=${message.threadId}`
+        );
+        if (existingMessage && existingMessage.threadId && existingMessage.threadId !== message.threadId) {
+          this.logger?.debug(`Migrating message ${message.id} from ${existingMessage.threadId} to ${message.threadId}`);
+          messageMigrationTasks.push(this.migrateMessage(message.id, existingMessage.threadId, message.threadId));
+        }
+      }
+      await Promise.all(messageMigrationTasks);
+      const messagesByThread = validatedMessages.reduce((acc, message) => {
+        if (message.threadId && !acc.has(message.threadId)) {
+          acc.set(message.threadId, []);
+        }
+        if (message.threadId) {
+          acc.get(message.threadId).push(message);
+        }
+        return acc;
+      }, /* @__PURE__ */ new Map());
+      await Promise.all(
+        Array.from(messagesByThread.entries()).map(async ([threadId, threadMessages]) => {
+          try {
+            const thread = await this.getThreadById({ threadId });
+            if (!thread) {
+              throw new Error(`Thread ${threadId} not found`);
+            }
+            await Promise.all(
+              threadMessages.map(async (message) => {
+                const key = this.getMessageKey(threadId, message.id);
+                const { _index, ...cleanMessage } = message;
+                const serializedMessage = {
+                  ...cleanMessage,
+                  createdAt: storage.serializeDate(cleanMessage.createdAt)
+                };
+                this.logger?.debug(`Saving message ${message.id}`, {
+                  contentSummary: this.summarizeMessageContent(serializedMessage.content)
+                });
+                await this.#db.putKV({ tableName: storage.TABLE_MESSAGES, key, value: serializedMessage });
+              })
+            );
+            const orderKey = this.getThreadMessagesKey(threadId);
+            const entries = await this.updateSorting(threadMessages);
+            await this.updateSortedMessages(orderKey, entries);
+            const updatedThread = {
+              ...thread,
+              updatedAt: /* @__PURE__ */ new Date()
+            };
+            await this.#db.putKV({
+              tableName: storage.TABLE_THREADS,
+              key: this.#db.getKey(storage.TABLE_THREADS, { id: threadId }),
+              value: updatedThread
+            });
+          } catch (error$1) {
+            throw new error.MastraError(
+              {
+                id: storage.createStorageErrorId("CLOUDFLARE", "SAVE_MESSAGES", "FAILED"),
+                domain: error.ErrorDomain.STORAGE,
+                category: error.ErrorCategory.THIRD_PARTY,
+                details: {
+                  threadId
+                }
+              },
+              error$1
+            );
+          }
+        })
+      );
+      const prepared = validatedMessages.map(
+        ({ _index, ...message }) => ({ ...message, type: message.type !== "v2" ? message.type : void 0 })
+      );
+      const list = new agent.MessageList().add(prepared, "memory");
+      return { messages: list.get.all.db() };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("CLOUDFLARE", "SAVE_MESSAGES", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
     }
   }
-  async getTableSchema(tableName) {
+  async getRank(orderKey, id) {
+    const order = await this.getSortedMessages(orderKey);
+    const index = order.findIndex((item) => item.id === id);
+    return index >= 0 ? index : null;
+  }
+  async getRange(orderKey, start, end) {
+    const order = await this.getSortedMessages(orderKey);
+    const actualStart = start < 0 ? Math.max(0, order.length + start) : start;
+    const actualEnd = end < 0 ? order.length + end : Math.min(end, order.length - 1);
+    const sliced = order.slice(actualStart, actualEnd + 1);
+    return sliced.map((item) => item.id);
+  }
+  async getLastN(orderKey, n) {
+    return this.getRange(orderKey, -n, -1);
+  }
+  async getFullOrder(orderKey) {
+    return this.getRange(orderKey, 0, -1);
+  }
+  /**
+   * Retrieves messages specified in the include array along with their surrounding context.
+   *
+   * **Performance Note**: When `threadId` is not provided in an include entry, this method
+   * must call `findMessageInAnyThread` which sequentially scans all threads in the KV store.
+   * For optimal performance, callers should provide `threadId` in include entries when known.
+   *
+   * @param include - Array of message IDs to include, optionally with context windows
+   * @param messageIds - Set to accumulate the message IDs that should be fetched
+   */
+  async getIncludedMessagesWithContext(include, messageIds) {
+    await Promise.all(
+      include.map(async (item) => {
+        let targetThreadId = item.threadId;
+        if (!targetThreadId) {
+          const foundMessage = await this.findMessageInAnyThread(item.id);
+          if (!foundMessage) return;
+          targetThreadId = foundMessage.threadId;
+        }
+        if (!targetThreadId) return;
+        const threadMessagesKey = this.getThreadMessagesKey(targetThreadId);
+        messageIds.add(item.id);
+        if (!item.withPreviousMessages && !item.withNextMessages) return;
+        const rank = await this.getRank(threadMessagesKey, item.id);
+        if (rank === null) return;
+        if (item.withPreviousMessages) {
+          const prevIds = await this.getRange(
+            threadMessagesKey,
+            Math.max(0, rank - item.withPreviousMessages),
+            rank - 1
+          );
+          prevIds.forEach((id) => messageIds.add(id));
+        }
+        if (item.withNextMessages) {
+          const nextIds = await this.getRange(threadMessagesKey, rank + 1, rank + item.withNextMessages);
+          nextIds.forEach((id) => messageIds.add(id));
+        }
+      })
+    );
+  }
+  async getRecentMessages(threadId, limit, messageIds) {
+    if (!threadId.trim()) throw new Error("threadId must be a non-empty string");
+    if (limit <= 0) return;
     try {
-      const schemaKey = this.getSchemaKey(tableName);
-      return await this.getKV(tableName, schemaKey);
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      this.logger.error(`Failed to get schema for ${tableName}:`, { message });
-      return null;
+      const threadMessagesKey = this.getThreadMessagesKey(threadId);
+      const latestIds = await this.getLastN(threadMessagesKey, limit);
+      latestIds.forEach((id) => messageIds.add(id));
+    } catch {
+      this.logger?.debug(`No message order found for thread ${threadId}, skipping latest messages`);
     }
   }
-  validateColumnValue(value, column) {
-    if (value === void 0 || value === null) {
-      return column.nullable ?? false;
+  /**
+   * Fetches and parses messages from one or more threads.
+   *
+   * **Performance Note**: When neither `include` entries with `threadId` nor `targetThreadId`
+   * are provided, this method falls back to `findMessageInAnyThread` which scans all threads.
+   * For optimal performance, provide `threadId` in include entries or specify `targetThreadId`.
+   */
+  async fetchAndParseMessagesFromMultipleThreads(messageIds, include, targetThreadId) {
+    const messageIdToThreadId = /* @__PURE__ */ new Map();
+    if (include) {
+      for (const item of include) {
+        if (item.threadId) {
+          messageIdToThreadId.set(item.id, item.threadId);
+        }
+      }
     }
-    switch (column.type) {
-      case "text":
-      case "uuid":
-        return typeof value === "string";
-      case "integer":
-      case "bigint":
-        return typeof value === "number";
-      case "timestamp":
-        return value instanceof Date || typeof value === "string" && !isNaN(Date.parse(value));
-      case "jsonb":
-        if (typeof value !== "object") return false;
+    const messages = await Promise.all(
+      messageIds.map(async (id) => {
         try {
-          JSON.stringify(value);
-          return true;
-        } catch {
-          return false;
+          let threadId = messageIdToThreadId.get(id);
+          if (!threadId) {
+            if (targetThreadId) {
+              threadId = targetThreadId;
+            } else {
+              const foundMessage = await this.findMessageInAnyThread(id);
+              if (foundMessage) {
+                threadId = foundMessage.threadId;
+              }
+            }
+          }
+          if (!threadId) return null;
+          const key = this.getMessageKey(threadId, id);
+          const data = await this.#db.getKV(storage.TABLE_MESSAGES, key);
+          if (!data) return null;
+          const parsed = typeof data === "string" ? JSON.parse(data) : data;
+          this.logger?.debug(`Retrieved message ${id} from thread ${threadId}`, {
+            contentSummary: this.summarizeMessageContent(parsed.content)
+          });
+          return parsed;
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          this.logger?.error(`Error retrieving message ${id}:`, { message });
+          return null;
         }
-      default:
-        return false;
-    }
+      })
+    );
+    return messages.filter((msg) => msg !== null);
   }
-  async validateAgainstSchema(record, schema) {
+  /**
+   * Retrieves messages by their IDs.
+   *
+   * **Performance Warning**: This method calls `findMessageInAnyThread` for each message ID,
+   * which scans all threads in the KV store. For large numbers of messages or threads,
+   * this can result in significant latency. Consider using `listMessages` with specific
+   * thread IDs when the thread context is known.
+   */
+  async listMessagesById({ messageIds }) {
+    if (messageIds.length === 0) return { messages: [] };
     try {
-      if (!schema || typeof schema !== "object" || schema.value === null) {
-        throw new Error("Invalid schema format");
-      }
-      for (const [columnName, column] of Object.entries(schema)) {
-        const value = record[columnName];
-        if (column.primaryKey && (value === void 0 || value === null)) {
-          throw new Error(`Missing primary key value for column ${columnName}`);
-        }
-        if (!this.validateColumnValue(value, column)) {
-          const valueType = value === null ? "null" : typeof value;
-          throw new Error(`Invalid value for column ${columnName}: expected ${column.type}, got ${valueType}`);
-        }
-      }
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      this.logger.error(`Error validating record against schema:`, { message, record, schema });
-      throw error;
+      const messages = (await Promise.all(messageIds.map((id) => this.findMessageInAnyThread(id)))).filter(
+        (result) => !!result
+      );
+      const prepared = messages.map(({ _index, ...message }) => ({
+        ...message,
+        ...message.type !== `v2` && { type: message.type },
+        createdAt: storage.ensureDate(message.createdAt)
+      }));
+      const list = new agent.MessageList().add(prepared, "memory");
+      return { messages: list.get.all.db() };
+    } catch (error$1) {
+      const mastraError = new error.MastraError(
+        {
+          id: storage.createStorageErrorId("CLOUDFLARE", "LIST_MESSAGES_BY_ID", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          text: `Error retrieving messages by ID`,
+          details: {
+            messageIds: JSON.stringify(messageIds)
+          }
+        },
+        error$1
+      );
+      this.logger?.trackException(mastraError);
+      this.logger?.error(mastraError.toString());
+      return { messages: [] };
     }
   }
-  async validateRecord(record, tableName) {
+  async listMessages(args) {
+    const { threadId, resourceId, include, filter, perPage: perPageInput, page = 0, orderBy } = args;
+    const threadIds = Array.isArray(threadId) ? threadId : [threadId];
+    const isValidThreadId = (id) => typeof id === "string" && id.trim().length > 0;
+    if (threadIds.length === 0 || threadIds.some((id) => !isValidThreadId(id))) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("CLOUDFLARE", "LIST_MESSAGES", "INVALID_THREAD_ID"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { threadId: Array.isArray(threadId) ? JSON.stringify(threadId) : String(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 (!record || typeof record !== "object") {
-        throw new Error("Record must be an object");
+      if (page < 0) {
+        throw new error.MastraError(
+          {
+            id: storage.createStorageErrorId("CLOUDFLARE", "LIST_MESSAGES", "INVALID_PAGE"),
+            domain: error.ErrorDomain.STORAGE,
+            category: error.ErrorCategory.USER,
+            details: { page }
+          },
+          new Error("page must be >= 0")
+        );
       }
-      const recordTyped = record;
-      const schema = await this.getTableSchema(tableName);
-      if (schema) {
-        await this.validateAgainstSchema(recordTyped, schema);
-        return;
+      const { field, direction } = this.parseOrderBy(orderBy, "ASC");
+      const threadMessageIds = /* @__PURE__ */ new Set();
+      for (const tid of threadIds) {
+        try {
+          const threadMessagesKey = this.getThreadMessagesKey(tid);
+          const allIds = await this.getFullOrder(threadMessagesKey);
+          allIds.forEach((id) => threadMessageIds.add(id));
+        } catch {
+        }
       }
-      switch (tableName) {
-        case storage.TABLE_THREADS:
-          if (!("id" in recordTyped) || !("resourceId" in recordTyped) || !("title" in recordTyped)) {
-            throw new Error("Thread record missing required fields");
-          }
-          break;
-        case storage.TABLE_MESSAGES:
-          if (!("id" in recordTyped) || !("threadId" in recordTyped) || !("content" in recordTyped) || !("role" in recordTyped)) {
-            throw new Error("Message record missing required fields");
-          }
-          break;
-        case storage.TABLE_WORKFLOW_SNAPSHOT:
-          if (!("workflow_name" in recordTyped) || !("run_id" in recordTyped)) {
-            throw new Error("Workflow record missing required fields");
-          }
-          break;
-        case storage.TABLE_TRACES:
-          if (!("id" in recordTyped)) {
-            throw new Error("Trace record missing required fields");
-          }
-          break;
-        case storage.TABLE_SCORERS:
-          if (!("id" in recordTyped) || !("scorerId" in recordTyped)) {
-            throw new Error("Score record missing required fields");
-          }
-          break;
-        default:
-          throw new Error(`Unknown table type: ${tableName}`);
+      const threadMessages = await this.fetchAndParseMessagesFromMultipleThreads(
+        Array.from(threadMessageIds),
+        void 0,
+        threadIds.length === 1 ? threadIds[0] : void 0
+      );
+      let filteredThreadMessages = threadMessages;
+      if (resourceId) {
+        filteredThreadMessages = filteredThreadMessages.filter((msg) => msg.resourceId === resourceId);
+      }
+      filteredThreadMessages = storage.filterByDateRange(
+        filteredThreadMessages,
+        (msg) => new Date(msg.createdAt),
+        filter?.dateRange
+      );
+      const total = filteredThreadMessages.length;
+      if (perPage === 0 && (!include || include.length === 0)) {
+        return {
+          messages: [],
+          total,
+          page,
+          perPage: perPageForResponse,
+          hasMore: offset < total
+        };
       }
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      this.logger.error(`Failed to validate record for ${tableName}:`, { message, record });
-      throw error;
-    }
-  }
-  async insert({ tableName, record }) {
-    try {
-      const key = this.getKey(tableName, record);
-      const processedRecord = { ...record };
-      await this.validateRecord(processedRecord, tableName);
-      await this.putKV({ tableName, key, value: processedRecord });
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: "CLOUDFLARE_STORAGE_INSERT_FAILED",
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: {
-            tableName
-          }
-        },
-        error$1
+      filteredThreadMessages.sort((a, b) => {
+        const timeA = new Date(a.createdAt).getTime();
+        const timeB = new Date(b.createdAt).getTime();
+        const timeDiff = direction === "ASC" ? timeA - timeB : timeB - timeA;
+        if (timeDiff === 0) {
+          return a.id.localeCompare(b.id);
+        }
+        return timeDiff;
+      });
+      let paginatedMessages;
+      if (perPage === 0) {
+        paginatedMessages = [];
+      } else if (perPage === Number.MAX_SAFE_INTEGER) {
+        paginatedMessages = filteredThreadMessages;
+      } else {
+        paginatedMessages = filteredThreadMessages.slice(offset, offset + perPage);
+      }
+      let includedMessages = [];
+      if (include && include.length > 0) {
+        const includedMessageIds = /* @__PURE__ */ new Set();
+        await this.getIncludedMessagesWithContext(include, includedMessageIds);
+        const paginatedIds = new Set(paginatedMessages.map((m) => m.id));
+        const idsToFetch = Array.from(includedMessageIds).filter((id) => !paginatedIds.has(id));
+        if (idsToFetch.length > 0) {
+          includedMessages = await this.fetchAndParseMessagesFromMultipleThreads(idsToFetch, include, void 0);
+        }
+      }
+      const seenIds = /* @__PURE__ */ new Set();
+      const allMessages = [];
+      for (const msg of paginatedMessages) {
+        if (!seenIds.has(msg.id)) {
+          allMessages.push(msg);
+          seenIds.add(msg.id);
+        }
+      }
+      for (const msg of includedMessages) {
+        if (!seenIds.has(msg.id)) {
+          allMessages.push(msg);
+          seenIds.add(msg.id);
+        }
+      }
+      allMessages.sort((a, b) => {
+        const timeA = new Date(a.createdAt).getTime();
+        const timeB = new Date(b.createdAt).getTime();
+        const timeDiff = direction === "ASC" ? timeA - timeB : timeB - timeA;
+        if (timeDiff === 0) {
+          return a.id.localeCompare(b.id);
+        }
+        return timeDiff;
+      });
+      let filteredMessages = allMessages;
+      const paginatedCount = paginatedMessages.length;
+      if (total === 0 && filteredMessages.length === 0 && (!include || include.length === 0)) {
+        return {
+          messages: [],
+          total: 0,
+          page,
+          perPage: perPageForResponse,
+          hasMore: false
+        };
+      }
+      const prepared = filteredMessages.map(({ _index, ...message }) => ({
+        ...message,
+        type: message.type !== "v2" ? message.type : void 0,
+        createdAt: storage.ensureDate(message.createdAt)
+      }));
+      const primaryThreadId = Array.isArray(threadId) ? threadId[0] : threadId;
+      const list = new agent.MessageList({ threadId: primaryThreadId, resourceId }).add(
+        prepared,
+        "memory"
       );
-    }
-  }
-  async load({ tableName, keys }) {
-    try {
-      const key = this.getKey(tableName, keys);
-      const data = await this.getKV(tableName, key);
-      if (!data) return null;
-      return data;
+      let finalMessages = list.get.all.db();
+      finalMessages = finalMessages.sort((a, b) => {
+        const isDateField = field === "createdAt" || field === "updatedAt";
+        const aVal = isDateField ? new Date(a[field]).getTime() : a[field];
+        const bVal = isDateField ? new Date(b[field]).getTime() : b[field];
+        if (aVal == null && bVal == null) return a.id.localeCompare(b.id);
+        if (aVal == null) return 1;
+        if (bVal == null) return -1;
+        if (typeof aVal === "number" && typeof bVal === "number") {
+          const cmp2 = direction === "ASC" ? aVal - bVal : bVal - aVal;
+          return cmp2 !== 0 ? cmp2 : a.id.localeCompare(b.id);
+        }
+        const cmp = direction === "ASC" ? String(aVal).localeCompare(String(bVal)) : String(bVal).localeCompare(String(aVal));
+        return cmp !== 0 ? cmp : a.id.localeCompare(b.id);
+      });
+      const threadIdSet = new Set(threadIds);
+      const returnedThreadMessageIds = new Set(
+        finalMessages.filter((m) => m.threadId && threadIdSet.has(m.threadId)).map((m) => m.id)
+      );
+      const allThreadMessagesReturned = returnedThreadMessageIds.size >= total;
+      const hasMore = perPageInput !== false && !allThreadMessagesReturned && offset + paginatedCount < total;
+      return {
+        messages: finalMessages,
+        total,
+        page,
+        perPage: perPageForResponse,
+        hasMore
+      };
     } catch (error$1) {
       const mastraError = new error.MastraError(
         {
-          id: "CLOUDFLARE_STORAGE_LOAD_FAILED",
+          id: storage.createStorageErrorId("CLOUDFLARE", "LIST_MESSAGES", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
+          text: `Failed to list messages for thread ${Array.isArray(threadId) ? threadId.join(",") : threadId}: ${error$1 instanceof Error ? error$1.message : String(error$1)}`,
           details: {
-            tableName
+            threadId: Array.isArray(threadId) ? threadId.join(",") : threadId,
+            resourceId: resourceId ?? ""
           }
         },
         error$1
       );
-      this.logger?.trackException(mastraError);
-      this.logger?.error(mastraError.toString());
-      return null;
+      this.logger?.error?.(mastraError.toString());
+      this.logger?.trackException?.(mastraError);
+      return {
+        messages: [],
+        total: 0,
+        page,
+        perPage: perPageForResponse,
+        hasMore: false
+      };
     }
   }
-  async batchInsert(input) {
-    if (!input.records || input.records.length === 0) return;
+  async updateMessages(args) {
     try {
-      await Promise.all(
-        input.records.map(async (record) => {
-          const key = this.getKey(input.tableName, record);
-          await this.putKV({ tableName: input.tableName, key, value: record });
-        })
-      );
+      const { messages } = args;
+      const updatedMessages = [];
+      for (const messageUpdate of messages) {
+        const { id, content, ...otherFields } = messageUpdate;
+        const prefix = this.#db.namespacePrefix ? `${this.#db.namespacePrefix}:` : "";
+        const keyObjs = await this.#db.listKV(storage.TABLE_MESSAGES, { prefix: `${prefix}${storage.TABLE_MESSAGES}` });
+        let existingMessage = null;
+        let messageKey = "";
+        for (const { name: key } of keyObjs) {
+          const data = await this.#db.getKV(storage.TABLE_MESSAGES, key);
+          if (data && data.id === id) {
+            existingMessage = data;
+            messageKey = key;
+            break;
+          }
+        }
+        if (!existingMessage) {
+          continue;
+        }
+        const updatedMessage = {
+          ...existingMessage,
+          ...otherFields,
+          id
+        };
+        if (content) {
+          if (content.metadata !== void 0) {
+            updatedMessage.content = {
+              ...updatedMessage.content,
+              metadata: {
+                ...updatedMessage.content?.metadata,
+                ...content.metadata
+              }
+            };
+          }
+          if (content.content !== void 0) {
+            updatedMessage.content = {
+              ...updatedMessage.content,
+              content: content.content
+            };
+          }
+        }
+        if ("threadId" in messageUpdate && messageUpdate.threadId && messageUpdate.threadId !== existingMessage.threadId) {
+          await this.#db.deleteKV(storage.TABLE_MESSAGES, messageKey);
+          updatedMessage.threadId = messageUpdate.threadId;
+          const newMessageKey = this.getMessageKey(messageUpdate.threadId, id);
+          await this.#db.putKV({
+            tableName: storage.TABLE_MESSAGES,
+            key: newMessageKey,
+            value: updatedMessage
+          });
+          if (existingMessage.threadId) {
+            const sourceOrderKey = this.getThreadMessagesKey(existingMessage.threadId);
+            const sourceEntries = await this.getSortedMessages(sourceOrderKey);
+            const filteredEntries = sourceEntries.filter((entry) => entry.id !== id);
+            await this.updateSortedMessages(sourceOrderKey, filteredEntries);
+          }
+          const destOrderKey = this.getThreadMessagesKey(messageUpdate.threadId);
+          const destEntries = await this.getSortedMessages(destOrderKey);
+          const newEntry = { id, score: Date.now() };
+          destEntries.push(newEntry);
+          await this.updateSortedMessages(destOrderKey, destEntries);
+        } else {
+          await this.#db.putKV({
+            tableName: storage.TABLE_MESSAGES,
+            key: messageKey,
+            value: updatedMessage
+          });
+        }
+        const threadsToUpdate = /* @__PURE__ */ new Set();
+        if (updatedMessage.threadId) {
+          threadsToUpdate.add(updatedMessage.threadId);
+        }
+        if ("threadId" in messageUpdate && messageUpdate.threadId && messageUpdate.threadId !== existingMessage.threadId) {
+          if (existingMessage.threadId) {
+            threadsToUpdate.add(existingMessage.threadId);
+          }
+          threadsToUpdate.add(messageUpdate.threadId);
+        }
+        for (const threadId of threadsToUpdate) {
+          const thread = await this.getThreadById({ threadId });
+          if (thread) {
+            const updatedThread = {
+              ...thread,
+              updatedAt: /* @__PURE__ */ new Date()
+            };
+            await this.#db.putKV({
+              tableName: storage.TABLE_THREADS,
+              key: this.#db.getKey(storage.TABLE_THREADS, { id: threadId }),
+              value: updatedThread
+            });
+          }
+        }
+        updatedMessages.push(updatedMessage);
+      }
+      return updatedMessages;
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "CLOUDFLARE_STORAGE_BATCH_INSERT_FAILED",
+          id: storage.createStorageErrorId("CLOUDFLARE", "UPDATE_MESSAGES", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
-          text: `Error in batch insert for table ${input.tableName}`,
-          details: {
-            tableName: input.tableName
-          }
+          text: "Failed to update messages"
         },
         error$1
       );
     }
   }
-  /**
-   * Helper to safely serialize data for KV storage
-   */
-  safeSerialize(data) {
-    return typeof data === "string" ? data : JSON.stringify(data);
-  }
-  async putNamespaceValue({
-    tableName,
-    key,
-    value,
-    metadata
-  }) {
-    try {
-      const serializedValue = this.safeSerialize(value);
-      const serializedMetadata = metadata ? this.safeSerialize(metadata) : "";
-      if (this.bindings) {
-        const binding = this.getBinding(tableName);
-        await binding.put(key, serializedValue, { metadata: serializedMetadata });
-      } else {
-        const namespaceId = await this.getNamespaceId(tableName);
-        await this.client.kv.namespaces.values.update(namespaceId, key, {
-          account_id: this.accountId,
-          value: serializedValue,
-          metadata: serializedMetadata
-        });
-      }
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      this.logger.error(`Failed to put value for ${tableName} ${key}:`, { message });
-      throw error;
-    }
-  }
-  async putKV({
-    tableName,
-    key,
-    value,
-    metadata
-  }) {
-    try {
-      await this.putNamespaceValue({ tableName, key, value, metadata });
-    } catch (error) {
-      this.logger.error(`Failed to put KV value for ${tableName}:${key}:`, error);
-      throw new Error(`Failed to put KV value: ${error.message}`);
-    }
-  }
-  async createTable({
-    tableName,
-    schema
-  }) {
-    try {
-      const schemaKey = this.getSchemaKey(tableName);
-      const metadata = {
-        type: "table_schema",
-        tableName,
-        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  async getResourceById({ resourceId }) {
+    try {
+      const data = await this.#db.getKV(storage.TABLE_RESOURCES, resourceId);
+      if (!data) return null;
+      const resource = typeof data === "string" ? JSON.parse(data) : data;
+      return {
+        ...resource,
+        createdAt: storage.ensureDate(resource.createdAt),
+        updatedAt: storage.ensureDate(resource.updatedAt),
+        metadata: this.ensureMetadata(resource.metadata)
       };
-      await this.putKV({ tableName, key: schemaKey, value: schema, metadata });
     } catch (error$1) {
-      throw new error.MastraError(
+      const mastraError = new error.MastraError(
         {
-          id: "CLOUDFLARE_STORAGE_CREATE_TABLE_FAILED",
+          id: storage.createStorageErrorId("CLOUDFLARE", "GET_RESOURCE_BY_ID", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
           details: {
-            tableName
+            resourceId
           }
         },
         error$1
       );
+      this.logger?.trackException(mastraError);
+      this.logger?.error(mastraError.toString());
+      return null;
     }
   }
-  async listNamespaceKeys(tableName, options) {
+  async saveResource({ resource }) {
     try {
-      if (this.bindings) {
-        const binding = this.getBinding(tableName);
-        const response = await binding.list({
-          limit: options?.limit || 1e3,
-          prefix: options?.prefix
-        });
-        return response.keys;
-      } else {
-        const namespaceId = await this.getNamespaceId(tableName);
-        const response = await this.client.kv.namespaces.keys.list(namespaceId, {
-          account_id: this.accountId,
-          limit: options?.limit || 1e3,
-          prefix: options?.prefix
-        });
-        return response.result;
-      }
+      const resourceToSave = {
+        ...resource,
+        metadata: resource.metadata ? JSON.stringify(resource.metadata) : null
+      };
+      await this.#db.putKV({
+        tableName: storage.TABLE_RESOURCES,
+        key: resource.id,
+        value: resourceToSave
+      });
+      return resource;
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "CLOUDFLARE_STORAGE_LIST_NAMESPACE_KEYS_FAILED",
+          id: storage.createStorageErrorId("CLOUDFLARE", "SAVE_RESOURCE", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
           details: {
-            tableName
+            resourceId: resource.id
           }
         },
         error$1
       );
     }
   }
-  async deleteNamespaceValue(tableName, key) {
-    if (this.bindings) {
-      const binding = this.getBinding(tableName);
-      await binding.delete(key);
-    } else {
-      const namespaceId = await this.getNamespaceId(tableName);
-      await this.client.kv.namespaces.values.delete(namespaceId, key, {
-        account_id: this.accountId
-      });
-    }
-  }
-  async deleteKV(tableName, key) {
-    try {
-      await this.deleteNamespaceValue(tableName, key);
-    } catch (error) {
-      this.logger.error(`Failed to delete KV value for ${tableName}:${key}:`, error);
-      throw new Error(`Failed to delete KV value: ${error.message}`);
+  async updateResource({
+    resourceId,
+    workingMemory,
+    metadata
+  }) {
+    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 updatedAt = /* @__PURE__ */ new Date();
+    const updatedResource = {
+      ...existingResource,
+      workingMemory: workingMemory !== void 0 ? workingMemory : existingResource.workingMemory,
+      metadata: {
+        ...existingResource.metadata,
+        ...metadata
+      },
+      updatedAt
+    };
+    return this.saveResource({ resource: updatedResource });
   }
-  async listKV(tableName, options) {
+  async deleteMessages(messageIds) {
+    if (messageIds.length === 0) return;
     try {
-      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}`);
+      const threadIds = /* @__PURE__ */ new Set();
+      for (const messageId of messageIds) {
+        const message = await this.findMessageInAnyThread(messageId);
+        if (message?.threadId) {
+          threadIds.add(message.threadId);
+          const messageKey = this.getMessageKey(message.threadId, messageId);
+          await this.#db.deleteKV(storage.TABLE_MESSAGES, messageKey);
+          const orderKey = this.getThreadMessagesKey(message.threadId);
+          const entries = await this.getSortedMessages(orderKey);
+          const filteredEntries = entries.filter((entry) => entry.id !== messageId);
+          if (filteredEntries.length > 0) {
+            await this.#db.putKV({
+              tableName: storage.TABLE_MESSAGES,
+              key: orderKey,
+              value: JSON.stringify(filteredEntries)
+            });
+          } else {
+            await this.#db.deleteKV(storage.TABLE_MESSAGES, orderKey);
+          }
+        }
+      }
+      for (const threadId of threadIds) {
+        const thread = await this.getThreadById({ threadId });
+        if (thread) {
+          const updatedThread = {
+            ...thread,
+            updatedAt: /* @__PURE__ */ new Date()
+          };
+          await this.#db.putKV({
+            tableName: storage.TABLE_THREADS,
+            key: this.#db.getKey(storage.TABLE_THREADS, { id: threadId }),
+            value: updatedThread
+          });
+        }
+      }
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("CLOUDFLARE", "DELETE_MESSAGES", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { messageIds: JSON.stringify(messageIds) }
+        },
+        error$1
+      );
     }
   }
 };
 function transformScoreRow(row) {
-  const deserialized = { ...row };
-  deserialized.input = storage.safelyParseJSON(row.input);
-  deserialized.output = storage.safelyParseJSON(row.output);
-  deserialized.scorer = storage.safelyParseJSON(row.scorer);
-  deserialized.preprocessStepResult = storage.safelyParseJSON(row.preprocessStepResult);
-  deserialized.analyzeStepResult = storage.safelyParseJSON(row.analyzeStepResult);
-  deserialized.metadata = storage.safelyParseJSON(row.metadata);
-  deserialized.additionalContext = storage.safelyParseJSON(row.additionalContext);
-  deserialized.requestContext = storage.safelyParseJSON(row.requestContext);
-  deserialized.entity = storage.safelyParseJSON(row.entity);
-  return deserialized;
+  return storage.transformScoreRow(row);
 }
 var ScoresStorageCloudflare = class extends storage.ScoresStorage {
-  operations;
-  constructor({ operations }) {
+  #db;
+  constructor(config) {
     super();
-    this.operations = operations;
+    this.#db = new CloudflareKVDB(resolveCloudflareConfig(config));
+  }
+  async init() {
+  }
+  async dangerouslyClearAll() {
+    await this.#db.clearTable({ tableName: storage.TABLE_SCORERS });
   }
   async getScoreById({ id }) {
     try {
-      const score = await this.operations.getKV(storage.TABLE_SCORERS, id);
+      const score = await this.#db.getKV(storage.TABLE_SCORERS, id);
       if (!score) {
         return null;
       }
@@ -1524,15 +1605,15 @@ var ScoresStorageCloudflare = class extends storage.ScoresStorage {
     } catch (error$1) {
       const mastraError = new error.MastraError(
         {
-          id: "CLOUDFLARE_STORAGE_SCORES_GET_SCORE_BY_ID_FAILED",
+          id: storage.createStorageErrorId("CLOUDFLARE", "GET_SCORE_BY_ID", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
           text: `Failed to get score by id: ${id}`
         },
         error$1
       );
-      this.logger.trackException(mastraError);
-      this.logger.error(mastraError.toString());
+      this.logger?.trackException(mastraError);
+      this.logger?.error(mastraError.toString());
       return null;
     }
   }
@@ -1543,16 +1624,22 @@ var ScoresStorageCloudflare = class extends storage.ScoresStorage {
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "CLOUDFLARE_STORAGE_SAVE_SCORE_FAILED_INVALID_SCORE_PAYLOAD",
+          id: storage.createStorageErrorId("CLOUDFLARE", "SAVE_SCORE", "VALIDATION_FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.USER,
-          details: { scoreId: score.id }
+          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 id = crypto.randomUUID();
     try {
-      const id = crypto.randomUUID();
       const serializedRecord = {};
       for (const [key, value] of Object.entries(parsedScore)) {
         if (value !== null && value !== void 0) {
@@ -1565,28 +1652,28 @@ var ScoresStorageCloudflare = class extends storage.ScoresStorage {
           serializedRecord[key] = null;
         }
       }
+      const now = /* @__PURE__ */ new Date();
       serializedRecord.id = id;
-      serializedRecord.createdAt = (/* @__PURE__ */ new Date()).toISOString();
-      serializedRecord.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-      await this.operations.putKV({
+      serializedRecord.createdAt = now.toISOString();
+      serializedRecord.updatedAt = now.toISOString();
+      await this.#db.putKV({
         tableName: storage.TABLE_SCORERS,
         key: id,
         value: serializedRecord
       });
-      const scoreFromDb = await this.getScoreById({ id: score.id });
-      return { score: scoreFromDb };
+      return { score: { ...parsedScore, id, createdAt: now, updatedAt: now } };
     } catch (error$1) {
       const mastraError = new error.MastraError(
         {
-          id: "CLOUDFLARE_STORAGE_SCORES_SAVE_SCORE_FAILED",
+          id: storage.createStorageErrorId("CLOUDFLARE", "SAVE_SCORE", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
-          text: `Failed to save score: ${score.id}`
+          details: { id }
         },
         error$1
       );
-      this.logger.trackException(mastraError);
-      this.logger.error(mastraError.toString());
+      this.logger?.trackException(mastraError);
+      this.logger?.error(mastraError.toString());
       throw mastraError;
     }
   }
@@ -1598,10 +1685,10 @@ var ScoresStorageCloudflare = class extends storage.ScoresStorage {
     pagination
   }) {
     try {
-      const keys = await this.operations.listKV(storage.TABLE_SCORERS);
+      const keys = await this.#db.listKV(storage.TABLE_SCORERS);
       const scores = [];
       for (const { name: key } of keys) {
-        const score = await this.operations.getKV(storage.TABLE_SCORERS, key);
+        const score = await this.#db.getKV(storage.TABLE_SCORERS, key);
         if (entityId && score.entityId !== entityId) {
           continue;
         }
@@ -1638,7 +1725,7 @@ var ScoresStorageCloudflare = class extends storage.ScoresStorage {
     } catch (error$1) {
       const mastraError = new error.MastraError(
         {
-          id: "CLOUDFLARE_STORAGE_SCORES_GET_SCORES_BY_SCORER_ID_FAILED",
+          id: storage.createStorageErrorId("CLOUDFLARE", "GET_SCORES_BY_SCORER_ID", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
           text: `Failed to get scores by scorer id: ${scorerId}`
@@ -1655,10 +1742,10 @@ var ScoresStorageCloudflare = class extends storage.ScoresStorage {
     pagination
   }) {
     try {
-      const keys = await this.operations.listKV(storage.TABLE_SCORERS);
+      const keys = await this.#db.listKV(storage.TABLE_SCORERS);
       const scores = [];
       for (const { name: key } of keys) {
-        const score = await this.operations.getKV(storage.TABLE_SCORERS, key);
+        const score = await this.#db.getKV(storage.TABLE_SCORERS, key);
         if (score && score.runId === runId) {
           scores.push(transformScoreRow(score));
         }
@@ -1686,15 +1773,15 @@ var ScoresStorageCloudflare = class extends storage.ScoresStorage {
     } catch (error$1) {
       const mastraError = new error.MastraError(
         {
-          id: "CLOUDFLARE_STORAGE_SCORES_GET_SCORES_BY_RUN_ID_FAILED",
+          id: storage.createStorageErrorId("CLOUDFLARE", "GET_SCORES_BY_RUN_ID", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
           text: `Failed to get scores by run id: ${runId}`
         },
         error$1
       );
-      this.logger.trackException(mastraError);
-      this.logger.error(mastraError.toString());
+      this.logger?.trackException(mastraError);
+      this.logger?.error(mastraError.toString());
       return { pagination: { total: 0, page: 0, perPage: 100, hasMore: false }, scores: [] };
     }
   }
@@ -1704,10 +1791,10 @@ var ScoresStorageCloudflare = class extends storage.ScoresStorage {
     pagination
   }) {
     try {
-      const keys = await this.operations.listKV(storage.TABLE_SCORERS);
+      const keys = await this.#db.listKV(storage.TABLE_SCORERS);
       const scores = [];
       for (const { name: key } of keys) {
-        const score = await this.operations.getKV(storage.TABLE_SCORERS, key);
+        const score = await this.#db.getKV(storage.TABLE_SCORERS, key);
         if (score && score.entityId === entityId && score.entityType === entityType) {
           scores.push(transformScoreRow(score));
         }
@@ -1735,15 +1822,15 @@ var ScoresStorageCloudflare = class extends storage.ScoresStorage {
     } catch (error$1) {
       const mastraError = new error.MastraError(
         {
-          id: "CLOUDFLARE_STORAGE_SCORES_GET_SCORES_BY_ENTITY_ID_FAILED",
+          id: storage.createStorageErrorId("CLOUDFLARE", "GET_SCORES_BY_ENTITY_ID", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
           text: `Failed to get scores by entity id: ${entityId}, type: ${entityType}`
         },
         error$1
       );
-      this.logger.trackException(mastraError);
-      this.logger.error(mastraError.toString());
+      this.logger?.trackException(mastraError);
+      this.logger?.error(mastraError.toString());
       return { pagination: { total: 0, page: 0, perPage: 100, hasMore: false }, scores: [] };
     }
   }
@@ -1753,10 +1840,10 @@ var ScoresStorageCloudflare = class extends storage.ScoresStorage {
     pagination
   }) {
     try {
-      const keys = await this.operations.listKV(storage.TABLE_SCORERS);
+      const keys = await this.#db.listKV(storage.TABLE_SCORERS);
       const scores = [];
       for (const { name: key } of keys) {
-        const score = await this.operations.getKV(storage.TABLE_SCORERS, key);
+        const score = await this.#db.getKV(storage.TABLE_SCORERS, key);
         if (score && score.traceId === traceId && score.spanId === spanId) {
           scores.push(transformScoreRow(score));
         }
@@ -1784,7 +1871,7 @@ var ScoresStorageCloudflare = class extends storage.ScoresStorage {
     } catch (error$1) {
       const mastraError = new error.MastraError(
         {
-          id: "CLOUDFLARE_STORAGE_SCORES_GET_SCORES_BY_SPAN_FAILED",
+          id: storage.createStorageErrorId("CLOUDFLARE", "GET_SCORES_BY_SPAN", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
           text: `Failed to get scores by span: traceId=${traceId}, spanId=${spanId}`
@@ -1798,10 +1885,15 @@ var ScoresStorageCloudflare = class extends storage.ScoresStorage {
   }
 };
 var WorkflowsStorageCloudflare = class extends storage.WorkflowsStorage {
-  operations;
-  constructor({ operations }) {
+  #db;
+  constructor(config) {
     super();
-    this.operations = operations;
+    this.#db = new CloudflareKVDB(resolveCloudflareConfig(config));
+  }
+  async init() {
+  }
+  async dangerouslyClearAll() {
+    await this.#db.clearTable({ tableName: storage.TABLE_WORKFLOW_SNAPSHOT });
   }
   validateWorkflowParams(params) {
     const { workflowName, runId } = params;
@@ -1827,23 +1919,26 @@ var WorkflowsStorageCloudflare = class extends storage.WorkflowsStorage {
   }
   async persistWorkflowSnapshot(params) {
     try {
-      const { workflowName, runId, resourceId, snapshot } = params;
-      await this.operations.putKV({
+      const { workflowName, runId, resourceId, snapshot, createdAt, updatedAt } = params;
+      const now = /* @__PURE__ */ new Date();
+      const existingKey = this.#db.getKey(storage.TABLE_WORKFLOW_SNAPSHOT, { workflow_name: workflowName, run_id: runId });
+      const existing = await this.#db.getKV(storage.TABLE_WORKFLOW_SNAPSHOT, existingKey);
+      await this.#db.putKV({
         tableName: storage.TABLE_WORKFLOW_SNAPSHOT,
-        key: this.operations.getKey(storage.TABLE_WORKFLOW_SNAPSHOT, { workflow_name: workflowName, run_id: runId }),
+        key: existingKey,
         value: {
           workflow_name: workflowName,
           run_id: runId,
           resourceId,
           snapshot: JSON.stringify(snapshot),
-          createdAt: /* @__PURE__ */ new Date(),
-          updatedAt: /* @__PURE__ */ new Date()
+          createdAt: existing?.createdAt ?? createdAt ?? now,
+          updatedAt: updatedAt ?? now
         }
       });
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "CLOUDFLARE_STORAGE_PERSIST_WORKFLOW_SNAPSHOT_FAILED",
+          id: storage.createStorageErrorId("CLOUDFLARE", "PERSIST_WORKFLOW_SNAPSHOT", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
           text: `Error persisting workflow snapshot for workflow ${params.workflowName}, run ${params.runId}`,
@@ -1860,15 +1955,15 @@ var WorkflowsStorageCloudflare = class extends storage.WorkflowsStorage {
     try {
       this.validateWorkflowParams(params);
       const { workflowName, runId } = params;
-      const key = this.operations.getKey(storage.TABLE_WORKFLOW_SNAPSHOT, { workflow_name: workflowName, run_id: runId });
-      const data = await this.operations.getKV(storage.TABLE_WORKFLOW_SNAPSHOT, key);
+      const key = this.#db.getKey(storage.TABLE_WORKFLOW_SNAPSHOT, { workflow_name: workflowName, run_id: runId });
+      const data = await this.#db.getKV(storage.TABLE_WORKFLOW_SNAPSHOT, key);
       if (!data) return null;
       const snapshotData = typeof data.snapshot === "string" ? JSON.parse(data.snapshot) : data.snapshot;
       return snapshotData;
     } catch (error$1) {
       const mastraError = new error.MastraError(
         {
-          id: "CLOUDFLARE_STORAGE_LOAD_WORKFLOW_SNAPSHOT_FAILED",
+          id: storage.createStorageErrorId("CLOUDFLARE", "LOAD_WORKFLOW_SNAPSHOT", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
           text: `Error loading workflow snapshot for workflow ${params.workflowName}, run ${params.runId}`,
@@ -1907,7 +2002,7 @@ var WorkflowsStorageCloudflare = class extends storage.WorkflowsStorage {
     runId,
     resourceId
   }) {
-    const prefix = this.operations.namespacePrefix ? `${this.operations.namespacePrefix}:` : "";
+    const prefix = this.#db.namespacePrefix ? `${this.#db.namespacePrefix}:` : "";
     let key = `${prefix}${storage.TABLE_WORKFLOW_SNAPSHOT}`;
     if (workflowName) key += `:${workflowName}`;
     if (runId) key += `:${runId}`;
@@ -1927,7 +2022,7 @@ var WorkflowsStorageCloudflare = class extends storage.WorkflowsStorage {
       if (page < 0 || !Number.isInteger(page)) {
         throw new error.MastraError(
           {
-            id: "CLOUDFLARE_STORE_INVALID_PAGE",
+            id: storage.createStorageErrorId("CLOUDFLARE", "LIST_WORKFLOW_RUNS", "INVALID_PAGE"),
             domain: error.ErrorDomain.STORAGE,
             category: error.ErrorCategory.USER,
             details: { page }
@@ -1938,7 +2033,7 @@ var WorkflowsStorageCloudflare = class extends storage.WorkflowsStorage {
       const normalizedPerPage = storage.normalizePerPage(perPage, 20);
       const offset = page * normalizedPerPage;
       const prefix = this.buildWorkflowSnapshotPrefix({ workflowName });
-      const keyObjs = await this.operations.listKV(storage.TABLE_WORKFLOW_SNAPSHOT, { prefix });
+      const keyObjs = await this.#db.listKV(storage.TABLE_WORKFLOW_SNAPSHOT, { prefix });
       const runs = [];
       for (const { name: key } of keyObjs) {
         const parts = key.split(":");
@@ -1947,21 +2042,20 @@ var WorkflowsStorageCloudflare = class extends storage.WorkflowsStorage {
         const wfName = parts[idx + 1];
         const keyResourceId = parts.length > idx + 3 ? parts[idx + 3] : void 0;
         if (workflowName && wfName !== workflowName) continue;
-        if (resourceId && keyResourceId !== resourceId) continue;
-        const data = await this.operations.getKV(storage.TABLE_WORKFLOW_SNAPSHOT, key);
+        const data = await this.#db.getKV(storage.TABLE_WORKFLOW_SNAPSHOT, key);
         if (!data) continue;
         try {
-          if (resourceId && !keyResourceId) continue;
+          const effectiveResourceId = keyResourceId || data.resourceId;
+          if (resourceId && effectiveResourceId !== resourceId) continue;
           const snapshotData = typeof data.snapshot === "string" ? JSON.parse(data.snapshot) : data.snapshot;
           if (status && snapshotData.status !== status) continue;
           const createdAt = storage.ensureDate(data.createdAt);
           if (fromDate && createdAt && createdAt < fromDate) continue;
           if (toDate && createdAt && createdAt > toDate) continue;
-          const resourceIdToUse = keyResourceId || data.resourceId;
           const run = this.parseWorkflowRun({
             ...data,
             workflow_name: wfName,
-            resourceId: resourceIdToUse,
+            resourceId: effectiveResourceId,
             snapshot: snapshotData
           });
           runs.push(run);
@@ -1982,7 +2076,7 @@ var WorkflowsStorageCloudflare = class extends storage.WorkflowsStorage {
     } catch (error$1) {
       const mastraError = new error.MastraError(
         {
-          id: "CLOUDFLARE_STORAGE_LIST_WORKFLOW_RUNS_FAILED",
+          id: storage.createStorageErrorId("CLOUDFLARE", "LIST_WORKFLOW_RUNS", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY
         },
@@ -2002,7 +2096,7 @@ var WorkflowsStorageCloudflare = class extends storage.WorkflowsStorage {
         throw new Error("runId, workflowName, are required");
       }
       const prefix = this.buildWorkflowSnapshotPrefix({ workflowName, runId });
-      const keyObjs = await this.operations.listKV(storage.TABLE_WORKFLOW_SNAPSHOT, { prefix });
+      const keyObjs = await this.#db.listKV(storage.TABLE_WORKFLOW_SNAPSHOT, { prefix });
       if (!keyObjs.length) return null;
       const exactKey = keyObjs.find((k) => {
         const parts = k.name.split(":");
@@ -2013,14 +2107,14 @@ var WorkflowsStorageCloudflare = class extends storage.WorkflowsStorage {
         return wfName === workflowName && rId === runId;
       });
       if (!exactKey) return null;
-      const data = await this.operations.getKV(storage.TABLE_WORKFLOW_SNAPSHOT, exactKey.name);
+      const data = await this.#db.getKV(storage.TABLE_WORKFLOW_SNAPSHOT, exactKey.name);
       if (!data) return null;
       const snapshotData = typeof data.snapshot === "string" ? JSON.parse(data.snapshot) : data.snapshot;
       return this.parseWorkflowRun({ ...data, snapshot: snapshotData });
     } catch (error$1) {
       const mastraError = new error.MastraError(
         {
-          id: "CLOUDFLARE_STORAGE_GET_WORKFLOW_RUN_BY_ID_FAILED",
+          id: storage.createStorageErrorId("CLOUDFLARE", "GET_WORKFLOW_RUN_BY_ID", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
           details: {
@@ -2035,6 +2129,28 @@ var WorkflowsStorageCloudflare = class extends storage.WorkflowsStorage {
       return null;
     }
   }
+  async deleteWorkflowRunById({ runId, workflowName }) {
+    try {
+      if (!runId || !workflowName) {
+        throw new Error("runId and workflowName are required");
+      }
+      const key = this.#db.getKey(storage.TABLE_WORKFLOW_SNAPSHOT, { workflow_name: workflowName, run_id: runId });
+      await this.#db.deleteKV(storage.TABLE_WORKFLOW_SNAPSHOT, key);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("CLOUDFLARE", "DELETE_WORKFLOW_RUN_BY_ID", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            workflowName,
+            runId
+          }
+        },
+        error$1
+      );
+    }
+  }
 };
 
 // src/storage/types.ts
@@ -2074,21 +2190,24 @@ var CloudflareStore = class extends storage.MastraStorage {
       throw new Error("apiToken is required for REST API");
     }
   }
-  get supports() {
-    const supports = super.supports;
-    supports.listScoresBySpan = true;
-    supports.resourceWorkingMemory = true;
-    supports.selectByIncludeResourceScope = true;
-    return supports;
-  }
   constructor(config) {
-    super({ id: config.id, name: "Cloudflare" });
+    super({ id: config.id, name: "Cloudflare", disableInit: config.disableInit });
     try {
+      let workflows;
+      let memory;
+      let scores;
       if (isWorkersConfig(config)) {
         this.validateWorkersConfig(config);
         this.bindings = config.bindings;
         this.namespacePrefix = config.keyPrefix?.trim() || "";
         this.logger.info("Using Cloudflare KV Workers Binding API");
+        const domainConfig = {
+          bindings: this.bindings,
+          keyPrefix: this.namespacePrefix
+        };
+        workflows = new WorkflowsStorageCloudflare(domainConfig);
+        memory = new MemoryStorageCloudflare(domainConfig);
+        scores = new ScoresStorageCloudflare(domainConfig);
       } else {
         this.validateRestConfig(config);
         this.accountId = config.accountId.trim();
@@ -2097,24 +2216,16 @@ var CloudflareStore = class extends storage.MastraStorage {
           apiToken: config.apiToken.trim()
         });
         this.logger.info("Using Cloudflare KV REST API");
+        const domainConfig = {
+          client: this.client,
+          accountId: this.accountId,
+          namespacePrefix: this.namespacePrefix
+        };
+        workflows = new WorkflowsStorageCloudflare(domainConfig);
+        memory = new MemoryStorageCloudflare(domainConfig);
+        scores = new ScoresStorageCloudflare(domainConfig);
       }
-      const operations = new StoreOperationsCloudflare({
-        accountId: this.accountId,
-        client: this.client,
-        namespacePrefix: this.namespacePrefix,
-        bindings: this.bindings
-      });
-      const workflows = new WorkflowsStorageCloudflare({
-        operations
-      });
-      const memory = new MemoryStorageCloudflare({
-        operations
-      });
-      const scores = new ScoresStorageCloudflare({
-        operations
-      });
       this.stores = {
-        operations,
         workflows,
         memory,
         scores
@@ -2122,7 +2233,7 @@ var CloudflareStore = class extends storage.MastraStorage {
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "CLOUDFLARE_STORAGE_INIT_FAILED",
+          id: storage.createStorageErrorId("CLOUDFLARE", "INIT", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY
         },
@@ -2130,157 +2241,13 @@ var CloudflareStore = class extends storage.MastraStorage {
       );
     }
   }
-  async createTable({
-    tableName,
-    schema
-  }) {
-    return this.stores.operations.createTable({ tableName, schema });
-  }
-  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 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 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 listMessagesById({ messageIds }) {
-    return this.stores.memory.listMessagesById({ messageIds });
-  }
-  async persistWorkflowSnapshot(params) {
-    return this.stores.workflows.persistWorkflowSnapshot(params);
-  }
-  async loadWorkflowSnapshot(params) {
-    return this.stores.workflows.loadWorkflowSnapshot(params);
-  }
-  async batchInsert(input) {
-    return this.stores.operations.batchInsert(input);
-  }
-  async listWorkflowRuns({
-    workflowName,
-    perPage = 20,
-    page = 0,
-    resourceId,
-    fromDate,
-    toDate,
-    status
-  } = {}) {
-    return this.stores.workflows.listWorkflowRuns({
-      workflowName,
-      perPage,
-      page,
-      resourceId,
-      fromDate,
-      toDate,
-      status
-    });
-  }
-  async getWorkflowRunById({
-    runId,
-    workflowName
-  }) {
-    return this.stores.workflows.getWorkflowRunById({ runId, workflowName });
-  }
-  async updateMessages(args) {
-    return this.stores.memory.updateMessages(args);
-  }
-  async getScoreById({ id }) {
-    return this.stores.scores.getScoreById({ 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,
-    entityId,
-    entityType,
-    source,
-    pagination
-  }) {
-    return this.stores.scores.listScoresByScorerId({ scorerId, entityId, entityType, source, pagination });
-  }
-  async listScoresBySpan({
-    traceId,
-    spanId,
-    pagination
-  }) {
-    return this.stores.scores.listScoresBySpan({ traceId, spanId, pagination });
-  }
-  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 close() {
   }
 };
 
 exports.CloudflareStore = CloudflareStore;
+exports.MemoryStorageCloudflare = MemoryStorageCloudflare;
+exports.ScoresStorageCloudflare = ScoresStorageCloudflare;
+exports.WorkflowsStorageCloudflare = WorkflowsStorageCloudflare;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map