@mastra/cloudflare 0.0.0-commonjs-20250414101718

package/dist/index.cjs

@@ -0,0 +1,1011 @@
+'use strict';
+
+var storage = require('@mastra/core/storage');
+var Cloudflare = require('cloudflare');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var Cloudflare__default = /*#__PURE__*/_interopDefault(Cloudflare);
+
+// src/storage/index.ts
+
+// src/storage/types.ts
+function isWorkersConfig(config) {
+  return "bindings" in config;
+}
+
+// src/storage/index.ts
+var CloudflareStore = class extends storage.MastraStorage {
+  client;
+  accountId;
+  namespacePrefix;
+  bindings;
+  validateWorkersConfig(config) {
+    if (!isWorkersConfig(config)) {
+      throw new Error("Invalid Workers API configuration");
+    }
+    if (!config.bindings) {
+      throw new Error("KV bindings are required when using Workers Binding API");
+    }
+    const requiredTables = [storage.TABLE_THREADS, storage.TABLE_MESSAGES, storage.TABLE_WORKFLOW_SNAPSHOT, storage.TABLE_EVALS, storage.TABLE_TRACES];
+    for (const table of requiredTables) {
+      if (!(table in config.bindings)) {
+        throw new Error(`Missing KV binding for table: ${table}`);
+      }
+    }
+  }
+  validateRestConfig(config) {
+    if (isWorkersConfig(config)) {
+      throw new Error("Invalid REST API configuration");
+    }
+    if (!config.accountId?.trim()) {
+      throw new Error("accountId is required for REST API");
+    }
+    if (!config.apiToken?.trim()) {
+      throw new Error("apiToken is required for REST API");
+    }
+  }
+  constructor(config) {
+    super({ name: "Cloudflare" });
+    try {
+      if (isWorkersConfig(config)) {
+        this.validateWorkersConfig(config);
+        this.bindings = config.bindings;
+        this.namespacePrefix = config.keyPrefix?.trim() || "";
+        this.logger.info("Using Cloudflare KV Workers Binding API");
+      } else {
+        this.validateRestConfig(config);
+        this.accountId = config.accountId.trim();
+        this.namespacePrefix = config.namespacePrefix?.trim() || "";
+        this.client = new Cloudflare__default.default({
+          apiToken: config.apiToken.trim()
+        });
+        this.logger.info("Using Cloudflare KV REST API");
+      }
+    } catch (error) {
+      this.logger.error("Failed to initialize CloudflareStore:", { error });
+      throw error;
+    }
+  }
+  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;
+  }
+  async listNamespaces() {
+    if (this.bindings) {
+      return {
+        result: Object.keys(this.bindings).map((name) => ({
+          id: name,
+          title: name,
+          supports_url_encoding: true
+        }))
+      };
+    }
+    return await this.client.kv.namespaces.list({ account_id: this.accountId });
+  }
+  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
+        });
+        return await response.text();
+      }
+    } catch (error) {
+      if (error.message && error.message.includes("key not found")) {
+        return null;
+      }
+      this.logger.error(`Failed to get value for ${tableName} ${key}:`, { error });
+      throw error;
+    }
+  }
+  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) {
+      this.logger.error(`Failed to put value for ${tableName} ${key}:`, { error });
+      throw error;
+    }
+  }
+  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 listNamespaceKeys(tableName, options) {
+    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;
+      }
+    } catch (error) {
+      this.logger.error(`Failed to list keys for ${tableName}:`, error);
+      throw new Error(`Failed to list keys: ${error.message}`);
+    }
+  }
+  async createNamespaceById(title) {
+    if (this.bindings) {
+      return {
+        id: title,
+        // Use title as ID since that's what we need
+        title,
+        supports_url_encoding: true
+      };
+    }
+    return await this.client.kv.namespaces.create({
+      account_id: this.accountId,
+      title
+    });
+  }
+  async getNamespaceIdByName(namespaceName) {
+    try {
+      const response = await this.listNamespaces();
+      const namespace = response.result.find((ns) => ns.title === namespaceName);
+      return namespace ? namespace.id : null;
+    } catch (error) {
+      this.logger.error(`Failed to get namespace ID for ${namespaceName}:`, error);
+      return null;
+    }
+  }
+  async createNamespace(namespaceName) {
+    try {
+      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 getOrCreateNamespaceId(namespaceName) {
+    let namespaceId = await this.getNamespaceIdByName(namespaceName);
+    if (!namespaceId) {
+      namespaceId = await this.createNamespace(namespaceName);
+    }
+    return namespaceId;
+  }
+  async getNamespaceId(tableName) {
+    const prefix = this.namespacePrefix ? `${this.namespacePrefix}_` : "";
+    try {
+      if (tableName === storage.TABLE_MESSAGES || tableName === storage.TABLE_THREADS) {
+        return await this.getOrCreateNamespaceId(`${prefix}mastra_threads`);
+      } else if (tableName === storage.TABLE_WORKFLOW_SNAPSHOT) {
+        return await this.getOrCreateNamespaceId(`${prefix}mastra_workflows`);
+      } else {
+        return await this.getOrCreateNamespaceId(`${prefix}mastra_evals`);
+      }
+    } catch (error) {
+      this.logger.error("Error fetching namespace ID:", error);
+      throw new Error(`Failed to fetch namespace ID for table ${tableName}: ${error.message}`);
+    }
+  }
+  /**
+   * Helper to safely serialize data for KV storage
+   */
+  safeSerialize(data) {
+    return typeof data === "string" ? data : JSON.stringify(data);
+  }
+  /**
+   * Helper to safely parse data from KV storage
+   */
+  safeParse(text) {
+    if (!text) return null;
+    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;
+          }
+        }
+        return null;
+      }
+      return data;
+    } catch (error) {
+      this.logger.error("Failed to parse text:", { error, text });
+      return null;
+    }
+  }
+  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 getKV(tableName, key) {
+    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}`);
+    }
+  }
+  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) {
+    try {
+      return await this.listNamespaceKeys(tableName);
+    } catch (error) {
+      this.logger.error(`Failed to list KV for ${tableName}:`, error);
+      throw new Error(`Failed to list KV: ${error.message}`);
+    }
+  }
+  /*---------------------------------------------------------------------------
+    Sorted set simulation helpers for message ordering.
+    We store an array of objects { id, score } as JSON under a dedicated key.
+  ---------------------------------------------------------------------------*/
+  async getSortedMessages(orderKey) {
+    const raw = await this.getKV(storage.TABLE_MESSAGES, orderKey);
+    if (!raw) return [];
+    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 [];
+    }
+  }
+  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 getIncludedMessagesWithContext(threadId, include, messageIds) {
+    const threadMessagesKey = this.getThreadMessagesKey(threadId);
+    await Promise.all(
+      include.map(async (item) => {
+        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 (limit <= 0) return;
+    try {
+      const threadMessagesKey = this.getThreadMessagesKey(threadId);
+      const latestIds = await this.getLastN(threadMessagesKey, limit);
+      latestIds.forEach((id) => messageIds.add(id));
+    } catch {
+      console.log(`No message order found for thread ${threadId}, skipping latest messages`);
+    }
+  }
+  async fetchAndParseMessages(threadId, messageIds) {
+    const messages = await Promise.all(
+      messageIds.map(async (id) => {
+        try {
+          const key = this.getMessageKey(threadId, id);
+          const data = await this.getKV(storage.TABLE_MESSAGES, key);
+          if (!data) return null;
+          return typeof data === "string" ? JSON.parse(data) : data;
+        } catch (error) {
+          this.logger.error(`Error retrieving message ${id}:`, { error });
+          return null;
+        }
+      })
+    );
+    return messages.filter((msg) => msg !== null);
+  }
+  /**
+   * Queue for serializing sorted order updates.
+   * Updates the sorted order for a given key. This operation is eventually consistent.
+   */
+  updateQueue = /* @__PURE__ */ new Map();
+  /**
+   * 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.putKV({
+          tableName: storage.TABLE_MESSAGES,
+          key: orderKey,
+          value: JSON.stringify(updatedOrder)
+        });
+      } catch (error) {
+        this.logger.error(`Error updating sorted order for key ${orderKey}:`, { error });
+        throw error;
+      } finally {
+        if (this.updateQueue.get(orderKey) === nextPromise) {
+          this.updateQueue.delete(orderKey);
+        }
+      }
+    });
+    this.updateQueue.set(orderKey, nextPromise);
+    return nextPromise;
+  }
+  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);
+  }
+  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.namespace || !record.workflow_name || !record.run_id) {
+          throw new Error("Namespace, workflow name, and run ID are required");
+        }
+        return `${prefix}${tableName}:${record.namespace}:${record.workflow_name}:${record.run_id}`;
+      case storage.TABLE_TRACES:
+        if (!record.id) throw new Error("Trace 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}`;
+  }
+  async getTableSchema(tableName) {
+    try {
+      const schemaKey = this.getSchemaKey(tableName);
+      return await this.getKV(tableName, schemaKey);
+    } catch (error) {
+      this.logger.error(`Failed to get schema for ${tableName}:`, { error });
+      return null;
+    }
+  }
+  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");
+      }
+      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) {
+      this.logger.error(`Error validating record against schema:`, { error, 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");
+          }
+          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 (!("namespace" in recordTyped) || !("workflowName" in recordTyped) || !("runId" 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;
+        default:
+          throw new Error(`Unknown table type: ${tableName}`);
+      }
+    } catch (error) {
+      this.logger.error(`Failed to validate record for ${tableName}:`, { error, record });
+      throw error;
+    }
+  }
+  ensureDate(date) {
+    if (!date) return void 0;
+    return date instanceof Date ? date : new Date(date);
+  }
+  serializeDate(date) {
+    if (!date) return void 0;
+    const dateObj = this.ensureDate(date);
+    return dateObj?.toISOString();
+  }
+  ensureMetadata(metadata) {
+    if (!metadata) return {};
+    return typeof metadata === "string" ? JSON.parse(metadata) : metadata;
+  }
+  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) {
+      this.logger.error(`Failed to store schema for ${tableName}:`, error);
+      throw new Error(`Failed to store schema: ${error.message}`);
+    }
+  }
+  async clearTable({ tableName }) {
+    const keys = await this.listKV(tableName);
+    if (keys.length > 0) {
+      await Promise.all(keys.map((keyObj) => this.deleteKV(tableName, keyObj.name)));
+    }
+  }
+  async insert({ tableName, record }) {
+    try {
+      const key = this.getKey(tableName, record);
+      const processedRecord = {
+        ...record,
+        createdAt: record.createdAt ? this.serializeDate(record.createdAt) : void 0,
+        updatedAt: record.updatedAt ? this.serializeDate(record.updatedAt) : void 0,
+        metadata: record.metadata ? JSON.stringify(record.metadata) : ""
+      };
+      await this.validateRecord(processedRecord, tableName);
+      await this.putKV({ tableName, key, value: processedRecord });
+    } catch (error) {
+      this.logger.error(`Failed to insert record for ${tableName}:`, { error });
+      throw error;
+    }
+  }
+  async load({ tableName, keys }) {
+    try {
+      const key = this.getKey(tableName, keys);
+      const data = await this.getKV(tableName, key);
+      if (!data) return null;
+      const processed = {
+        ...data,
+        createdAt: this.ensureDate(data.createdAt),
+        updatedAt: this.ensureDate(data.updatedAt),
+        metadata: this.ensureMetadata(data.metadata)
+      };
+      return processed;
+    } catch (error) {
+      this.logger.error(`Failed to load data for ${tableName}:`, { error });
+      return null;
+    }
+  }
+  async getThreadById({ threadId }) {
+    const thread = await this.load({ tableName: storage.TABLE_THREADS, keys: { id: threadId } });
+    if (!thread) return null;
+    try {
+      return {
+        ...thread,
+        createdAt: this.ensureDate(thread.createdAt),
+        updatedAt: this.ensureDate(thread.updatedAt),
+        metadata: this.ensureMetadata(thread.metadata)
+      };
+    } catch (error) {
+      this.logger.error(`Error processing thread ${threadId}:`, { error });
+      return null;
+    }
+  }
+  async getThreadsByResourceId({ resourceId }) {
+    try {
+      const keyList = await this.listKV(storage.TABLE_THREADS);
+      const threads = await Promise.all(
+        keyList.map(async (keyObj) => {
+          try {
+            const data = await this.getKV(storage.TABLE_THREADS, keyObj.name);
+            if (!data) return null;
+            const thread = typeof data === "string" ? JSON.parse(data) : data;
+            if (!thread || !thread.resourceId || thread.resourceId !== resourceId) return null;
+            return {
+              ...thread,
+              createdAt: this.ensureDate(thread.createdAt),
+              updatedAt: this.ensureDate(thread.updatedAt),
+              metadata: this.ensureMetadata(thread.metadata)
+            };
+          } catch (error) {
+            this.logger.error(`Error processing thread from key ${keyObj.name}:`, { error });
+            return null;
+          }
+        })
+      );
+      return threads.filter((thread) => thread !== null);
+    } catch (error) {
+      this.logger.error(`Error getting threads for resourceId ${resourceId}:`, { error });
+      return [];
+    }
+  }
+  async saveThread({ thread }) {
+    try {
+      await this.insert({ tableName: storage.TABLE_THREADS, record: thread });
+      return thread;
+    } catch (error) {
+      this.logger.error("Error saving thread:", { error });
+      throw error;
+    }
+  }
+  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()
+      };
+      await this.insert({ tableName: storage.TABLE_THREADS, record: updatedThread });
+      return updatedThread;
+    } catch (error) {
+      this.logger.error(`Error updating thread ${id}:`, { error });
+      throw error;
+    }
+  }
+  async deleteThread({ threadId }) {
+    try {
+      const thread = await this.getThreadById({ threadId });
+      if (!thread) {
+        throw new Error(`Thread ${threadId} not found`);
+      }
+      const messageKeys = await this.listKV(storage.TABLE_MESSAGES);
+      const threadMessageKeys = messageKeys.filter((key) => key.name.includes(`${storage.TABLE_MESSAGES}:${threadId}:`));
+      await Promise.all([
+        // Delete message order
+        this.deleteKV(storage.TABLE_MESSAGES, this.getThreadMessagesKey(threadId)),
+        // Delete all messages
+        ...threadMessageKeys.map((key) => this.deleteKV(storage.TABLE_MESSAGES, key.name)),
+        // Delete thread
+        this.deleteKV(storage.TABLE_THREADS, this.getKey(storage.TABLE_THREADS, { id: threadId }))
+      ]);
+    } catch (error) {
+      this.logger.error(`Error deleting thread ${threadId}:`, { error });
+      throw error;
+    }
+  }
+  getMessageKey(threadId, messageId) {
+    try {
+      return this.getKey(storage.TABLE_MESSAGES, { threadId, id: messageId });
+    } catch (error) {
+      this.logger.error(`Error getting message key for thread ${threadId} and message ${messageId}:`, { error });
+      throw error;
+    }
+  }
+  getThreadMessagesKey(threadId) {
+    try {
+      return this.getKey(storage.TABLE_MESSAGES, { threadId, id: "messages" });
+    } catch (error) {
+      this.logger.error(`Error getting thread messages key for thread ${threadId}:`, { error });
+      throw error;
+    }
+  }
+  async saveMessages({ messages }) {
+    if (!Array.isArray(messages) || messages.length === 0) return [];
+    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 (errors.length > 0) {
+          throw new Error(`Invalid message at index ${index}: ${errors.join(", ")}`);
+        }
+        return {
+          ...message,
+          createdAt: this.ensureDate(message.createdAt),
+          type: message.type || "text",
+          _index: index
+        };
+      });
+      const messagesByThread = validatedMessages.reduce((acc, message) => {
+        if (!acc.has(message.threadId)) {
+          acc.set(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 = await this.getMessageKey(threadId, message.id);
+                const { _index, ...cleanMessage } = message;
+                const serializedMessage = {
+                  ...cleanMessage,
+                  createdAt: this.serializeDate(cleanMessage.createdAt)
+                };
+                await this.putKV({ tableName: storage.TABLE_MESSAGES, key, value: serializedMessage });
+              })
+            );
+            const orderKey = this.getThreadMessagesKey(threadId);
+            const entries = await this.updateSorting(threadMessages);
+            await this.updateSortedMessages(orderKey, entries);
+          } catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            this.logger.error(`Error processing messages for thread ${threadId}: ${errorMessage}`);
+            throw error;
+          }
+        })
+      );
+      return validatedMessages.map(({ _index, ...message }) => message);
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      this.logger.error(`Error saving messages: ${errorMessage}`);
+      throw error;
+    }
+  }
+  async getMessages({ threadId, selectBy }) {
+    if (!threadId) throw new Error("threadId is required");
+    let limit = 40;
+    if (typeof selectBy?.last === "number") {
+      limit = Math.max(0, selectBy.last);
+    } else if (selectBy?.last === false) {
+      limit = 0;
+    }
+    const messageIds = /* @__PURE__ */ new Set();
+    if (limit === 0 && !selectBy?.include?.length) return [];
+    try {
+      await Promise.all([
+        selectBy?.include?.length ? this.getIncludedMessagesWithContext(threadId, selectBy.include, messageIds) : Promise.resolve(),
+        limit > 0 && !selectBy?.include?.length ? this.getRecentMessages(threadId, limit, messageIds) : Promise.resolve()
+      ]);
+      const messages = await this.fetchAndParseMessages(threadId, Array.from(messageIds));
+      if (!messages.length) return [];
+      try {
+        const threadMessagesKey = this.getThreadMessagesKey(threadId);
+        const messageOrder = await this.getFullOrder(threadMessagesKey);
+        const orderMap = new Map(messageOrder.map((id, index) => [id, index]));
+        messages.sort((a, b) => {
+          const indexA = orderMap.get(a.id);
+          const indexB = orderMap.get(b.id);
+          if (indexA !== void 0 && indexB !== void 0) return orderMap.get(a.id) - orderMap.get(b.id);
+          return new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime();
+        });
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        this.logger.warn(`Error sorting messages, falling back to creation time: ${errorMessage}`);
+        messages.sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime());
+      }
+      return messages.map(({ _index, ...message }) => ({
+        ...message,
+        createdAt: this.ensureDate(message.createdAt)
+      }));
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      this.logger.error(`Error retrieving messages for thread ${threadId}: ${errorMessage}`);
+      return [];
+    }
+  }
+  validateWorkflowParams(params) {
+    const { namespace, workflowName, runId } = params;
+    if (!namespace || !workflowName || !runId) {
+      throw new Error("Invalid workflow snapshot parameters");
+    }
+  }
+  validateWorkflowState(state) {
+    if (!state?.runId || !state?.value || !state?.context?.steps || !state?.context?.triggerData || !state?.context?.attempts || !state?.activePaths) {
+      throw new Error("Invalid workflow state structure");
+    }
+  }
+  normalizeSteps(steps) {
+    const normalizedSteps = {};
+    for (const [stepId, step] of Object.entries(steps)) {
+      normalizedSteps[stepId] = {
+        status: step.status,
+        payload: step.payload || step.result,
+        error: step.error
+      };
+    }
+    return normalizedSteps;
+  }
+  normalizeWorkflowState(data) {
+    const steps = data.context?.stepResults || data.context?.steps || {};
+    return {
+      runId: data.runId,
+      value: data.value,
+      context: {
+        steps: this.normalizeSteps(steps),
+        triggerData: data.context?.triggerData || {},
+        attempts: data.context?.attempts || {}
+      },
+      activePaths: data.activePaths || [],
+      timestamp: data.timestamp || Date.now()
+    };
+  }
+  async persistWorkflowSnapshot(params) {
+    try {
+      this.validateWorkflowParams(params);
+      const { namespace, workflowName, runId, snapshot } = params;
+      const normalizedState = this.normalizeWorkflowState(snapshot);
+      this.validateWorkflowState(normalizedState);
+      const key = this.getKey(storage.TABLE_WORKFLOW_SNAPSHOT, { namespace, workflow_name: workflowName, run_id: runId });
+      await this.putKV({ tableName: storage.TABLE_WORKFLOW_SNAPSHOT, key, value: normalizedState });
+    } catch (error) {
+      this.logger.error("Error persisting workflow snapshot:", { error });
+      throw error;
+    }
+  }
+  async loadWorkflowSnapshot(params) {
+    try {
+      this.validateWorkflowParams(params);
+      const { namespace, workflowName, runId } = params;
+      const key = this.getKey(storage.TABLE_WORKFLOW_SNAPSHOT, { namespace, workflow_name: workflowName, run_id: runId });
+      const data = await this.getKV(storage.TABLE_WORKFLOW_SNAPSHOT, key);
+      if (!data) return null;
+      const state = this.normalizeWorkflowState(data);
+      this.validateWorkflowState(state);
+      return state;
+    } catch (error) {
+      this.logger.error("Error loading workflow snapshot:", { error });
+      return null;
+    }
+  }
+  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);
+          const processedRecord = {
+            ...record,
+            createdAt: record.createdAt ? this.serializeDate(record.createdAt) : void 0,
+            updatedAt: record.updatedAt ? this.serializeDate(record.updatedAt) : void 0,
+            metadata: record.metadata ? JSON.stringify(record.metadata) : void 0
+          };
+          await this.putKV({ tableName: input.tableName, key, value: processedRecord });
+        })
+      );
+    } catch (error) {
+      this.logger.error("Error in batch insert:", { error });
+      throw error;
+    }
+  }
+  async getTraces({
+    name,
+    scope,
+    page = 0,
+    perPage = 100,
+    attributes
+  }) {
+    try {
+      let keys;
+      if (this.bindings) {
+        keys = (await this.listKV(storage.TABLE_TRACES))?.map((k) => k.name) || [];
+      } else {
+        const namespaceId = await this.getNamespaceId(storage.TABLE_TRACES);
+        const result = await this.client.kv.namespaces.keys.list(namespaceId, {
+          prefix: "",
+          limit: 1e3,
+          account_id: this.accountId
+        });
+        keys = result.result?.map((k) => k.name) || [];
+      }
+      const traceRecords = await Promise.all(
+        keys.map(async (key) => {
+          const record = await this.getKV(storage.TABLE_TRACES, key);
+          if (!record) return null;
+          return record;
+        })
+      );
+      let filteredTraces = traceRecords.filter(
+        (record) => record !== null && typeof record === "object"
+      );
+      if (name) {
+        filteredTraces = filteredTraces.filter((record) => record.name?.toLowerCase().startsWith(name.toLowerCase()));
+      }
+      if (scope) {
+        filteredTraces = filteredTraces.filter((record) => record.scope === scope);
+      }
+      if (attributes) {
+        filteredTraces = filteredTraces.filter((record) => {
+          if (!record.attributes) return false;
+          const recordAttrs = this.parseJSON(record.attributes);
+          if (!recordAttrs) return false;
+          return Object.entries(attributes).every(([key, value]) => recordAttrs[key] === value);
+        });
+      }
+      filteredTraces.sort((a, b) => {
+        const dateA = new Date(a.createdAt).getTime();
+        const dateB = new Date(b.createdAt).getTime();
+        return dateB - dateA;
+      });
+      const start = page * perPage;
+      const end = start + perPage;
+      const paginatedTraces = filteredTraces.slice(start, end);
+      return paginatedTraces.map((record) => ({
+        id: record.id,
+        parentSpanId: record.parentSpanId,
+        traceId: record.traceId,
+        name: record.name,
+        scope: record.scope,
+        kind: record.kind,
+        status: this.parseJSON(record.status),
+        events: this.parseJSON(record.events) || [],
+        links: this.parseJSON(record.links) || [],
+        attributes: this.parseJSON(record?.attributes) || {},
+        startTime: record.startTime,
+        endTime: record.endTime,
+        other: this.parseJSON(record.other) || {},
+        createdAt: record.createdAt
+      }));
+    } catch (error) {
+      this.logger.error("Failed to get traces:", { message: error instanceof Error ? error.message : String(error) });
+      return [];
+    }
+  }
+  parseJSON(value) {
+    if (typeof value === "string") {
+      try {
+        return JSON.parse(value);
+      } catch {
+        return value;
+      }
+    }
+    return value;
+  }
+  getEvalsByAgentName(_agentName, _type) {
+    throw new Error("Method not implemented.");
+  }
+  getWorkflowRuns(_args) {
+    throw new Error("Method not implemented.");
+  }
+  async close() {
+  }
+};
+
+exports.CloudflareStore = CloudflareStore;