@mastra/cloudflare 1.6.0-alpha.0 → 1.6.0

package/dist/chunk-KF35N26R.cjs

@@ -1,2435 +0,0 @@
-'use strict';
-
-var error = require('@mastra/core/error');
-var storage = require('@mastra/core/storage');
-var Cloudflare = require('cloudflare');
-var base = require('@mastra/core/base');
-var agent = require('@mastra/core/agent');
-var evals = require('@mastra/core/evals');
-
-function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
-
-var Cloudflare__default = /*#__PURE__*/_interopDefault(Cloudflare);
-
-// src/kv/index.ts
-function resolveCloudflareConfig(config) {
-  if ("client" in config) {
-    return {
-      client: config.client,
-      accountId: config.accountId,
-      namespacePrefix: config.namespacePrefix
-    };
-  }
-  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}`;
-  }
-  /**
-   * 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) {
-      const message = error instanceof Error ? error.message : String(error);
-      this.logger.error("Failed to parse text:", { message, text });
-      return null;
-    }
-  }
-  async createNamespaceById(title) {
-    if (this.bindings) {
-      return {
-        id: title,
-        title,
-        supports_url_encoding: true
-      };
-    }
-    return await this.client.kv.namespaces.create({
-      account_id: this.accountId,
-      title
-    });
-  }
-  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 listNamespaces() {
-    if (this.bindings) {
-      return {
-        result: Object.keys(this.bindings).map((name) => ({
-          id: name,
-          title: name,
-          supports_url_encoding: true
-        }))
-      };
-    }
-    let allNamespaces = [];
-    let currentPage = 1;
-    const perPage = 50;
-    let morePagesExist = true;
-    while (morePagesExist) {
-      const response = await this.client.kv.namespaces.list({
-        account_id: this.accountId,
-        page: currentPage,
-        per_page: perPage
-      });
-      if (response.result) {
-        allNamespaces = allNamespaces.concat(response.result);
-      }
-      morePagesExist = response.result ? response.result.length === perPage : false;
-      if (morePagesExist) {
-        currentPage++;
-      }
-    }
-    return { result: allNamespaces };
-  }
-  async 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 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 {
-      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}`);
-    }
-  }
-  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;
-      }
-      const message = error instanceof Error ? error.message : String(error);
-      this.logger.error(`Failed to get value for ${tableName} ${key}:`, { message });
-      throw error;
-    }
-  }
-  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 getTableSchema(tableName) {
-    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;
-    }
-  }
-  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) {
-      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");
-          }
-          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: storage.createStorageErrorId("CLOUDFLARE", "INSERT", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: {
-            tableName
-          }
-        },
-        error$1
-      );
-    }
-  }
-  async load({ tableName, keys }) {
-    try {
-      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: storage.createStorageErrorId("CLOUDFLARE", "LOAD", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: {
-            tableName
-          }
-        },
-        error$1
-      );
-      this.logger?.trackException(mastraError);
-      this.logger?.error(mastraError.toString());
-      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);
-          await this.putKV({ tableName: input.tableName, key, value: record });
-        })
-      );
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: storage.createStorageErrorId("CLOUDFLARE", "BATCH_INSERT", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          text: `Error in batch insert for table ${input.tableName}`,
-          details: {
-            tableName: input.tableName
-          }
-        },
-        error$1
-      );
-    }
-  }
-  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()
-      };
-      await this.putKV({ tableName, key: schemaKey, value: schema, metadata });
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: storage.createStorageErrorId("CLOUDFLARE", "CREATE_TABLE", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: {
-            tableName
-          }
-        },
-        error$1
-      );
-    }
-  }
-  async clearTable({ tableName }) {
-    try {
-      const keys = await this.listKV(tableName);
-      if (keys.length > 0) {
-        await Promise.all(keys.map((keyObj) => this.deleteKV(tableName, keyObj.name)));
-      }
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: storage.createStorageErrorId("CLOUDFLARE", "CLEAR_TABLE", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: {
-            tableName
-          }
-        },
-        error$1
-      );
-    }
-  }
-  async dropTable({ tableName }) {
-    try {
-      const keys = await this.listKV(tableName);
-      if (keys.length > 0) {
-        await Promise.all(keys.map((keyObj) => this.deleteKV(tableName, keyObj.name)));
-      }
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: storage.createStorageErrorId("CLOUDFLARE", "DROP_TABLE", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: {
-            tableName
-          }
-        },
-        error$1
-      );
-    }
-  }
-  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$1) {
-      throw new error.MastraError(
-        {
-          id: storage.createStorageErrorId("CLOUDFLARE", "LIST_NAMESPACE_KEYS", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: {
-            tableName
-          }
-        },
-        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 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}`);
-    }
-  }
-};
-
-// src/kv/storage/domains/background-tasks/index.ts
-function toRecord(task) {
-  return {
-    id: task.id,
-    tool_call_id: task.toolCallId,
-    tool_name: task.toolName,
-    agent_id: task.agentId,
-    thread_id: task.threadId ?? null,
-    resource_id: task.resourceId ?? null,
-    run_id: task.runId,
-    status: task.status,
-    args: task.args,
-    result: task.result ?? null,
-    error: task.error ?? null,
-    suspend_payload: task.suspendPayload ?? null,
-    retry_count: task.retryCount,
-    max_retries: task.maxRetries,
-    timeout_ms: task.timeoutMs,
-    createdAt: task.createdAt.toISOString(),
-    startedAt: task.startedAt?.toISOString() ?? null,
-    suspendedAt: task.suspendedAt?.toISOString() ?? null,
-    completedAt: task.completedAt?.toISOString() ?? null
-  };
-}
-function fromRecord(record) {
-  return {
-    id: record.id,
-    status: record.status,
-    toolName: record.tool_name,
-    toolCallId: record.tool_call_id,
-    args: record.args ?? {},
-    agentId: record.agent_id,
-    threadId: record.thread_id ?? void 0,
-    resourceId: record.resource_id ?? void 0,
-    runId: record.run_id ?? "",
-    result: record.result ?? void 0,
-    error: record.error ?? void 0,
-    suspendPayload: record.suspend_payload ?? void 0,
-    retryCount: Number(record.retry_count ?? 0),
-    maxRetries: Number(record.max_retries ?? 0),
-    timeoutMs: Number(record.timeout_ms ?? 3e5),
-    createdAt: new Date(record.createdAt),
-    startedAt: record.startedAt ? new Date(record.startedAt) : void 0,
-    suspendedAt: record.suspendedAt ? new Date(record.suspendedAt) : void 0,
-    completedAt: record.completedAt ? new Date(record.completedAt) : void 0
-  };
-}
-var BackgroundTasksStorageCloudflare = class extends storage.BackgroundTasksStorage {
-  #db;
-  constructor(config) {
-    super();
-    this.#db = new CloudflareKVDB(resolveCloudflareConfig(config));
-  }
-  async dangerouslyClearAll() {
-    await this.#db.clearTable({ tableName: storage.TABLE_BACKGROUND_TASKS });
-  }
-  async createTask(task) {
-    await this.#db.putKV({ tableName: storage.TABLE_BACKGROUND_TASKS, key: task.id, value: toRecord(task) });
-  }
-  async updateTask(taskId, update) {
-    const existing = await this.getTask(taskId);
-    if (!existing) return;
-    const merged = { ...existing };
-    if ("status" in update) merged.status = update.status;
-    if ("result" in update) merged.result = update.result;
-    if ("error" in update) merged.error = update.error;
-    if ("suspendPayload" in update) merged.suspendPayload = update.suspendPayload;
-    if ("retryCount" in update) merged.retryCount = update.retryCount;
-    if ("startedAt" in update) merged.startedAt = update.startedAt;
-    if ("suspendedAt" in update) merged.suspendedAt = update.suspendedAt;
-    if ("completedAt" in update) merged.completedAt = update.completedAt;
-    await this.#db.putKV({ tableName: storage.TABLE_BACKGROUND_TASKS, key: taskId, value: toRecord(merged) });
-  }
-  async getTask(taskId) {
-    const data = await this.#db.getKV(storage.TABLE_BACKGROUND_TASKS, taskId);
-    return data ? fromRecord(data) : null;
-  }
-  async listTasks(filter) {
-    const keys = await this.#db.listKV(storage.TABLE_BACKGROUND_TASKS);
-    if (keys.length === 0) return { tasks: [], total: 0 };
-    const records = await Promise.all(keys.map((k) => this.#db.getKV(storage.TABLE_BACKGROUND_TASKS, k.name)));
-    let tasks = records.filter(Boolean).map((r) => fromRecord(r));
-    if (filter.status) {
-      const s = Array.isArray(filter.status) ? filter.status : [filter.status];
-      tasks = tasks.filter((t) => s.includes(t.status));
-    }
-    if (filter.agentId) tasks = tasks.filter((t) => t.agentId === filter.agentId);
-    if (filter.threadId) tasks = tasks.filter((t) => t.threadId === filter.threadId);
-    if (filter.toolName) tasks = tasks.filter((t) => t.toolName === filter.toolName);
-    if (filter.toolCallId) tasks = tasks.filter((t) => t.toolCallId === filter.toolCallId);
-    if (filter.runId) tasks = tasks.filter((t) => t.runId === filter.runId);
-    const dateCol = filter.dateFilterBy ?? "createdAt";
-    if (filter.fromDate) {
-      tasks = tasks.filter((t) => {
-        const val = t[dateCol];
-        return val != null && val >= filter.fromDate;
-      });
-    }
-    if (filter.toDate) {
-      tasks = tasks.filter((t) => {
-        const val = t[dateCol];
-        return val != null && val < filter.toDate;
-      });
-    }
-    const orderBy = filter.orderBy ?? "createdAt";
-    const dir = filter.orderDirection === "desc" ? -1 : 1;
-    tasks.sort((a, b) => ((a[orderBy]?.getTime() ?? 0) - (b[orderBy]?.getTime() ?? 0)) * dir);
-    const total = tasks.length;
-    if (filter.page != null && filter.perPage != null) {
-      const start = filter.page * filter.perPage;
-      tasks = tasks.slice(start, start + filter.perPage);
-    } else if (filter.perPage != null) {
-      tasks = tasks.slice(0, filter.perPage);
-    }
-    return { tasks, total };
-  }
-  async deleteTask(taskId) {
-    await this.#db.deleteKV(storage.TABLE_BACKGROUND_TASKS, taskId);
-  }
-  async deleteTasks(filter) {
-    const { tasks } = await this.listTasks(filter);
-    await Promise.all(tasks.map((t) => this.#db.deleteKV(storage.TABLE_BACKGROUND_TASKS, t.id)));
-  }
-  async getRunningCount() {
-    const { total } = await this.listTasks({ status: "running" });
-    return total;
-  }
-  async getRunningCountByAgent(agentId) {
-    const { total } = await this.listTasks({ status: "running", agentId });
-    return total;
-  }
-};
-var MemoryStorageCloudflare = class extends storage.MemoryStorage {
-  #db;
-  constructor(config) {
-    super();
-    this.#db = new CloudflareKVDB(resolveCloudflareConfig(config));
-  }
-  async init() {
-  }
-  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 });
-  }
-  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,
-    resourceId
-  }) {
-    const thread = await this.#db.load({ tableName: storage.TABLE_THREADS, keys: { id: threadId } });
-    if (!thread || resourceId !== void 0 && thread.resourceId !== resourceId) 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: storage.createStorageErrorId("CLOUDFLARE", "GET_THREAD_BY_ID", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: {
-            threadId
-          }
-        },
-        error$1
-      );
-      this.logger?.trackException(mastraError);
-      this.logger?.error(mastraError.toString());
-      return null;
-    }
-  }
-  async listThreads(args) {
-    const { page = 0, perPage: perPageInput, orderBy, filter } = args;
-    try {
-      this.validatePaginationInput(page, perPageInput ?? 100);
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: storage.createStorageErrorId("CLOUDFLARE", "LIST_THREADS", "INVALID_PAGE"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.USER,
-          details: { page, ...perPageInput !== void 0 && { perPage: perPageInput } }
-        },
-        error$1 instanceof Error ? error$1 : new Error("Invalid pagination parameters")
-      );
-    }
-    const perPage = storage.normalizePerPage(perPageInput, 100);
-    try {
-      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 (filter?.resourceId && data.resourceId !== filter.resourceId) {
-          continue;
-        }
-        if (filter?.metadata && Object.keys(filter.metadata).length > 0) {
-          const metadata = this.ensureMetadata(data.metadata);
-          if (!metadata) continue;
-          const matches = Object.entries(filter.metadata).every(([key2, value]) => metadata[key2] === value);
-          if (!matches) 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: storage.createStorageErrorId("CLOUDFLARE", "LIST_THREADS", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          text: "Failed to list threads with filters"
-        },
-        error$1
-      );
-    }
-  }
-  async saveThread({ thread }) {
-    try {
-      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
-          }
-        },
-        error$1
-      );
-    }
-  }
-  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.#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
-      );
-    }
-  }
-  getMessageKey(threadId, messageId) {
-    try {
-      return this.#db.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;
-    }
-  }
-  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;
-    }
-  }
-  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
-      );
-    }
-  }
-  /**
-   * 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 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(`Error finding message ${messageId} in any thread:`, error);
-      return null;
-    }
-  }
-  /**
-   * 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.#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 {
-      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 migrateMessage(messageId, fromThreadId, toThreadId) {
-    try {
-      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) {
-      this.logger?.error(`Error migrating message ${messageId} from ${fromThreadId} to ${toThreadId}:`, error);
-      throw error;
-    }
-  }
-  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));
-        }
-      }
-      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 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
-   */
-  _sortMessages(messages, field, direction) {
-    return messages.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);
-    });
-  }
-  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 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`);
-    }
-  }
-  /**
-   * 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);
-        }
-      }
-    }
-    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.#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;
-        }
-      })
-    );
-    return messages.filter((msg) => msg !== null);
-  }
-  /**
-   * 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 {
-      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 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);
-    const metadataFilter = storage.validateStorageMetadataFilter(filter?.metadata);
-    try {
-      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 { field, direction } = this.parseOrderBy(orderBy, "ASC");
-      if (perPage === 0 && include && include.length > 0) {
-        const includedMessageIds = /* @__PURE__ */ new Set();
-        await this.getIncludedMessagesWithContext(include, includedMessageIds);
-        const includedMessages2 = await this.fetchAndParseMessagesFromMultipleThreads(
-          Array.from(includedMessageIds),
-          include,
-          void 0
-        );
-        const list2 = new agent.MessageList().add(includedMessages2, "memory");
-        return {
-          messages: this._sortMessages(list2.get.all.db(), field, direction),
-          total: 0,
-          page,
-          perPage: perPageForResponse,
-          hasMore: false
-        };
-      }
-      if (perPage === 0 && (!include || include.length === 0)) {
-        return { messages: [], total: 0, page, perPage: perPageForResponse, hasMore: false };
-      }
-      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 {
-        }
-      }
-      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
-      );
-      filteredThreadMessages = filteredThreadMessages.filter(
-        (message) => storage.storageMessageMatchesMetadataFilter(message.content, metadataFilter)
-      );
-      const total = filteredThreadMessages.length;
-      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"
-      );
-      const finalMessages = this._sortMessages(list.get.all.db(), field, direction);
-      const threadIdSet = new Set(threadIds);
-      const returnedThreadMessageIds = new Set(
-        finalMessages.filter((message) => message.threadId && threadIdSet.has(message.threadId)).map((message) => message.id)
-      );
-      const hasMore = perPageInput !== false && (metadataFilter || returnedThreadMessageIds.size < total) && offset + paginatedCount < total;
-      return {
-        messages: finalMessages,
-        total,
-        page,
-        perPage: perPageForResponse,
-        hasMore
-      };
-    } catch (error$1) {
-      const mastraError = new error.MastraError(
-        {
-          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: {
-            threadId: Array.isArray(threadId) ? threadId.join(",") : threadId,
-            resourceId: resourceId ?? ""
-          }
-        },
-        error$1
-      );
-      this.logger?.error?.(mastraError.toString());
-      this.logger?.trackException?.(mastraError);
-      return {
-        messages: [],
-        total: 0,
-        page,
-        perPage: perPageForResponse,
-        hasMore: false
-      };
-    }
-  }
-  async updateMessages(args) {
-    try {
-      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: storage.createStorageErrorId("CLOUDFLARE", "UPDATE_MESSAGES", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          text: "Failed to update messages"
-        },
-        error$1
-      );
-    }
-  }
-  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)
-      };
-    } catch (error$1) {
-      const mastraError = new error.MastraError(
-        {
-          id: storage.createStorageErrorId("CLOUDFLARE", "GET_RESOURCE_BY_ID", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: {
-            resourceId
-          }
-        },
-        error$1
-      );
-      this.logger?.trackException(mastraError);
-      this.logger?.error(mastraError.toString());
-      return null;
-    }
-  }
-  async saveResource({ resource }) {
-    try {
-      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: storage.createStorageErrorId("CLOUDFLARE", "SAVE_RESOURCE", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: {
-            resourceId: resource.id
-          }
-        },
-        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 });
-    }
-    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 deleteMessages(messageIds) {
-    if (messageIds.length === 0) return;
-    try {
-      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) {
-  return storage.transformScoreRow(row);
-}
-function matchesTenancy(score, filters) {
-  if (filters?.organizationId !== void 0 && score.organizationId !== filters.organizationId) return false;
-  if (filters?.projectId !== void 0 && score.projectId !== filters.projectId) return false;
-  return true;
-}
-var ScoresStorageCloudflare = class extends storage.ScoresStorage {
-  #db;
-  constructor(config) {
-    super();
-    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.#db.getKV(storage.TABLE_SCORERS, id);
-      if (!score) {
-        return null;
-      }
-      return transformScoreRow(score);
-    } catch (error$1) {
-      const mastraError = new error.MastraError(
-        {
-          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());
-      return null;
-    }
-  }
-  async saveScore(score) {
-    let parsedScore;
-    try {
-      parsedScore = evals.saveScorePayloadSchema.parse(score);
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: storage.createStorageErrorId("CLOUDFLARE", "SAVE_SCORE", "VALIDATION_FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.USER,
-          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 serializedRecord = {};
-      for (const [key, value] of Object.entries(parsedScore)) {
-        if (value !== null && value !== void 0) {
-          if (typeof value === "object") {
-            serializedRecord[key] = JSON.stringify(value);
-          } else {
-            serializedRecord[key] = value;
-          }
-        } else {
-          serializedRecord[key] = null;
-        }
-      }
-      const now = /* @__PURE__ */ new Date();
-      serializedRecord.id = id;
-      serializedRecord.createdAt = now.toISOString();
-      serializedRecord.updatedAt = now.toISOString();
-      await this.#db.putKV({
-        tableName: storage.TABLE_SCORERS,
-        key: id,
-        value: serializedRecord
-      });
-      return { score: { ...parsedScore, id, createdAt: now, updatedAt: now } };
-    } catch (error$1) {
-      const mastraError = new error.MastraError(
-        {
-          id: storage.createStorageErrorId("CLOUDFLARE", "SAVE_SCORE", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: { id }
-        },
-        error$1
-      );
-      this.logger?.trackException(mastraError);
-      this.logger?.error(mastraError.toString());
-      throw mastraError;
-    }
-  }
-  async listScoresByScorerId({
-    scorerId,
-    entityId,
-    entityType,
-    source,
-    pagination,
-    filters
-  }) {
-    try {
-      const keys = await this.#db.listKV(storage.TABLE_SCORERS);
-      const scores = [];
-      for (const { name: key } of keys) {
-        const score = await this.#db.getKV(storage.TABLE_SCORERS, key);
-        if (entityId && score.entityId !== entityId) {
-          continue;
-        }
-        if (entityType && score.entityType !== entityType) {
-          continue;
-        }
-        if (source && score.source !== source) {
-          continue;
-        }
-        if (!matchesTenancy(score, filters)) {
-          continue;
-        }
-        if (score && score.scorerId === scorerId) {
-          scores.push(transformScoreRow(score));
-        }
-      }
-      scores.sort((a, b) => {
-        const dateA = new Date(a.createdAt || 0).getTime();
-        const dateB = new Date(b.createdAt || 0).getTime();
-        return dateB - dateA;
-      });
-      const { page, perPage: perPageInput } = pagination;
-      const perPage = storage.normalizePerPage(perPageInput, 100);
-      const { offset: start, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
-      const total = scores.length;
-      const end = perPageInput === false ? scores.length : start + perPage;
-      const pagedScores = scores.slice(start, end);
-      return {
-        pagination: {
-          total,
-          page,
-          perPage: perPageForResponse,
-          hasMore: end < total
-        },
-        scores: pagedScores
-      };
-    } catch (error$1) {
-      const mastraError = new error.MastraError(
-        {
-          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}`
-        },
-        error$1
-      );
-      this.logger?.trackException(mastraError);
-      this.logger?.error(mastraError.toString());
-      return { pagination: { total: 0, page: 0, perPage: 100, hasMore: false }, scores: [] };
-    }
-  }
-  async listScoresByRunId({
-    runId,
-    pagination,
-    filters
-  }) {
-    try {
-      const keys = await this.#db.listKV(storage.TABLE_SCORERS);
-      const scores = [];
-      for (const { name: key } of keys) {
-        const score = await this.#db.getKV(storage.TABLE_SCORERS, key);
-        if (score && score.runId === runId && matchesTenancy(score, filters)) {
-          scores.push(transformScoreRow(score));
-        }
-      }
-      scores.sort((a, b) => {
-        const dateA = new Date(a.createdAt || 0).getTime();
-        const dateB = new Date(b.createdAt || 0).getTime();
-        return dateB - dateA;
-      });
-      const { page, perPage: perPageInput } = pagination;
-      const perPage = storage.normalizePerPage(perPageInput, 100);
-      const { offset: start, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
-      const total = scores.length;
-      const end = perPageInput === false ? scores.length : start + perPage;
-      const pagedScores = scores.slice(start, end);
-      return {
-        pagination: {
-          total,
-          page,
-          perPage: perPageForResponse,
-          hasMore: end < total
-        },
-        scores: pagedScores
-      };
-    } catch (error$1) {
-      const mastraError = new error.MastraError(
-        {
-          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());
-      return { pagination: { total: 0, page: 0, perPage: 100, hasMore: false }, scores: [] };
-    }
-  }
-  async listScoresByEntityId({
-    entityId,
-    entityType,
-    pagination,
-    filters
-  }) {
-    try {
-      const keys = await this.#db.listKV(storage.TABLE_SCORERS);
-      const scores = [];
-      for (const { name: key } of keys) {
-        const score = await this.#db.getKV(storage.TABLE_SCORERS, key);
-        if (score && score.entityId === entityId && score.entityType === entityType && matchesTenancy(score, filters)) {
-          scores.push(transformScoreRow(score));
-        }
-      }
-      scores.sort((a, b) => {
-        const dateA = new Date(a.createdAt || 0).getTime();
-        const dateB = new Date(b.createdAt || 0).getTime();
-        return dateB - dateA;
-      });
-      const { page, perPage: perPageInput } = pagination;
-      const perPage = storage.normalizePerPage(perPageInput, 100);
-      const { offset: start, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
-      const total = scores.length;
-      const end = perPageInput === false ? scores.length : start + perPage;
-      const pagedScores = scores.slice(start, end);
-      return {
-        pagination: {
-          total,
-          page,
-          perPage: perPageForResponse,
-          hasMore: end < total
-        },
-        scores: pagedScores
-      };
-    } catch (error$1) {
-      const mastraError = new error.MastraError(
-        {
-          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());
-      return { pagination: { total: 0, page: 0, perPage: 100, hasMore: false }, scores: [] };
-    }
-  }
-  async listScoresBySpan({
-    traceId,
-    spanId,
-    pagination,
-    filters
-  }) {
-    try {
-      const keys = await this.#db.listKV(storage.TABLE_SCORERS);
-      const scores = [];
-      for (const { name: key } of keys) {
-        const score = await this.#db.getKV(storage.TABLE_SCORERS, key);
-        if (score && score.traceId === traceId && score.spanId === spanId && matchesTenancy(score, filters)) {
-          scores.push(transformScoreRow(score));
-        }
-      }
-      scores.sort((a, b) => {
-        const dateA = new Date(a.createdAt || 0).getTime();
-        const dateB = new Date(b.createdAt || 0).getTime();
-        return dateB - dateA;
-      });
-      const { page, perPage: perPageInput } = pagination;
-      const perPage = storage.normalizePerPage(perPageInput, 100);
-      const { offset: start, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
-      const total = scores.length;
-      const end = perPageInput === false ? scores.length : start + perPage;
-      const pagedScores = scores.slice(start, end);
-      return {
-        pagination: {
-          total,
-          page,
-          perPage: perPageForResponse,
-          hasMore: end < total
-        },
-        scores: pagedScores
-      };
-    } catch (error$1) {
-      const mastraError = new error.MastraError(
-        {
-          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}`
-        },
-        error$1
-      );
-      this.logger?.trackException(mastraError);
-      this.logger?.error(mastraError.toString());
-      return { pagination: { total: 0, page: 0, perPage: 100, hasMore: false }, scores: [] };
-    }
-  }
-};
-var WorkflowsStorageCloudflare = class extends storage.WorkflowsStorage {
-  #db;
-  constructor(config) {
-    super();
-    this.#db = new CloudflareKVDB(resolveCloudflareConfig(config));
-  }
-  supportsConcurrentUpdates() {
-    return false;
-  }
-  async init() {
-  }
-  async dangerouslyClearAll() {
-    await this.#db.clearTable({ tableName: storage.TABLE_WORKFLOW_SNAPSHOT });
-  }
-  validateWorkflowParams(params) {
-    const { workflowName, runId } = params;
-    if (!workflowName || !runId) {
-      throw new Error("Invalid workflow snapshot parameters");
-    }
-  }
-  async updateWorkflowResults(_args) {
-    throw new Error(
-      "updateWorkflowResults is not implemented for Cloudflare KV storage. Cloudflare KV is eventually-consistent and does not support atomic read-modify-write operations needed for concurrent workflow updates."
-    );
-  }
-  async updateWorkflowState(_args) {
-    throw new Error(
-      "updateWorkflowState is not implemented for Cloudflare KV storage. Cloudflare KV is eventually-consistent and does not support atomic read-modify-write operations needed for concurrent workflow updates."
-    );
-  }
-  async persistWorkflowSnapshot(params) {
-    try {
-      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: existingKey,
-        value: {
-          workflow_name: workflowName,
-          run_id: runId,
-          resourceId,
-          snapshot: JSON.stringify(snapshot),
-          createdAt: existing?.createdAt ?? createdAt ?? now,
-          updatedAt: updatedAt ?? now
-        }
-      });
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          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}`,
-          details: {
-            workflowName: params.workflowName,
-            runId: params.runId
-          }
-        },
-        error$1
-      );
-    }
-  }
-  async loadWorkflowSnapshot(params) {
-    try {
-      this.validateWorkflowParams(params);
-      const { workflowName, runId } = params;
-      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: 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}`,
-          details: {
-            workflowName: params.workflowName,
-            runId: params.runId
-          }
-        },
-        error$1
-      );
-      this.logger.trackException?.(mastraError);
-      this.logger.error(mastraError.toString());
-      return null;
-    }
-  }
-  parseWorkflowRun(row) {
-    let parsedSnapshot = row.snapshot;
-    if (typeof parsedSnapshot === "string") {
-      try {
-        parsedSnapshot = JSON.parse(row.snapshot);
-      } catch (e) {
-        this.logger.warn(`Failed to parse snapshot for workflow ${row.workflow_name}: ${e}`);
-      }
-    }
-    return {
-      workflowName: row.workflow_name,
-      runId: row.run_id,
-      snapshot: parsedSnapshot,
-      createdAt: storage.ensureDate(row.createdAt),
-      updatedAt: storage.ensureDate(row.updatedAt),
-      resourceId: row.resourceId
-    };
-  }
-  buildWorkflowSnapshotPrefix({
-    workflowName,
-    runId,
-    resourceId
-  }) {
-    const prefix = this.#db.namespacePrefix ? `${this.#db.namespacePrefix}:` : "";
-    let key = `${prefix}${storage.TABLE_WORKFLOW_SNAPSHOT}`;
-    if (workflowName) key += `:${workflowName}`;
-    if (runId) key += `:${runId}`;
-    if (resourceId) key += `:${resourceId}`;
-    return key;
-  }
-  async listWorkflowRuns({
-    workflowName,
-    page = 0,
-    perPage = 20,
-    resourceId,
-    fromDate,
-    toDate,
-    status
-  } = {}) {
-    try {
-      if (page < 0 || !Number.isInteger(page)) {
-        throw new error.MastraError(
-          {
-            id: storage.createStorageErrorId("CLOUDFLARE", "LIST_WORKFLOW_RUNS", "INVALID_PAGE"),
-            domain: error.ErrorDomain.STORAGE,
-            category: error.ErrorCategory.USER,
-            details: { page }
-          },
-          new Error("page must be a non-negative integer")
-        );
-      }
-      const normalizedPerPage = storage.normalizePerPage(perPage, 20);
-      const offset = page * normalizedPerPage;
-      const prefix = this.buildWorkflowSnapshotPrefix({ workflowName });
-      const keyObjs = await this.#db.listKV(storage.TABLE_WORKFLOW_SNAPSHOT, { prefix });
-      const runs = [];
-      for (const { name: key } of keyObjs) {
-        const parts = key.split(":");
-        const idx = parts.indexOf(storage.TABLE_WORKFLOW_SNAPSHOT);
-        if (idx === -1 || parts.length < idx + 3) continue;
-        const wfName = parts[idx + 1];
-        const keyResourceId = parts.length > idx + 3 ? parts[idx + 3] : void 0;
-        if (workflowName && wfName !== workflowName) continue;
-        const data = await this.#db.getKV(storage.TABLE_WORKFLOW_SNAPSHOT, key);
-        if (!data) continue;
-        try {
-          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 run = this.parseWorkflowRun({
-            ...data,
-            workflow_name: wfName,
-            resourceId: effectiveResourceId,
-            snapshot: snapshotData
-          });
-          runs.push(run);
-        } catch (err) {
-          this.logger.error("Failed to parse workflow snapshot:", { key, error: err });
-        }
-      }
-      runs.sort((a, b) => {
-        const aDate = a.createdAt ? new Date(a.createdAt).getTime() : 0;
-        const bDate = b.createdAt ? new Date(b.createdAt).getTime() : 0;
-        return bDate - aDate;
-      });
-      const pagedRuns = runs.slice(offset, offset + normalizedPerPage);
-      return {
-        runs: pagedRuns,
-        total: runs.length
-      };
-    } catch (error$1) {
-      const mastraError = new error.MastraError(
-        {
-          id: storage.createStorageErrorId("CLOUDFLARE", "LIST_WORKFLOW_RUNS", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY
-        },
-        error$1
-      );
-      this.logger.trackException?.(mastraError);
-      this.logger.error(mastraError.toString());
-      return { runs: [], total: 0 };
-    }
-  }
-  async getWorkflowRunById({
-    runId,
-    workflowName
-  }) {
-    try {
-      if (!runId || !workflowName) {
-        throw new Error("runId, workflowName, are required");
-      }
-      const prefix = this.buildWorkflowSnapshotPrefix({ workflowName, runId });
-      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(":");
-        const idx = parts.indexOf(storage.TABLE_WORKFLOW_SNAPSHOT);
-        if (idx === -1 || parts.length < idx + 3) return false;
-        const wfName = parts[idx + 1];
-        const rId = parts[idx + 2];
-        return wfName === workflowName && rId === runId;
-      });
-      if (!exactKey) return null;
-      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: storage.createStorageErrorId("CLOUDFLARE", "GET_WORKFLOW_RUN_BY_ID", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: {
-            workflowName,
-            runId
-          }
-        },
-        error$1
-      );
-      this.logger.trackException?.(mastraError);
-      this.logger.error(mastraError.toString());
-      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/kv/storage/types.ts
-function isWorkersConfig(config) {
-  return "bindings" in config;
-}
-
-// src/kv/index.ts
-var CloudflareKVStorage = class extends storage.MastraCompositeStore {
-  stores;
-  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_SCORERS,
-      storage.TABLE_BACKGROUND_TASKS
-    ];
-    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({ id: config.id, name: "Cloudflare", disableInit: config.disableInit });
-    try {
-      let workflows;
-      let memory;
-      let scores;
-      let backgroundTasks;
-      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);
-        backgroundTasks = new BackgroundTasksStorageCloudflare(domainConfig);
-      } 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");
-        const domainConfig = {
-          client: this.client,
-          accountId: this.accountId,
-          namespacePrefix: this.namespacePrefix
-        };
-        workflows = new WorkflowsStorageCloudflare(domainConfig);
-        memory = new MemoryStorageCloudflare(domainConfig);
-        scores = new ScoresStorageCloudflare(domainConfig);
-        backgroundTasks = new BackgroundTasksStorageCloudflare(domainConfig);
-      }
-      this.stores = {
-        workflows,
-        memory,
-        scores,
-        backgroundTasks
-      };
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: storage.createStorageErrorId("CLOUDFLARE", "INIT", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY
-        },
-        error$1
-      );
-    }
-  }
-  async close() {
-  }
-};
-var CloudflareStore = CloudflareKVStorage;
-
-exports.BackgroundTasksStorageCloudflare = BackgroundTasksStorageCloudflare;
-exports.CloudflareKVStorage = CloudflareKVStorage;
-exports.CloudflareStore = CloudflareStore;
-exports.MemoryStorageCloudflare = MemoryStorageCloudflare;
-exports.ScoresStorageCloudflare = ScoresStorageCloudflare;
-exports.WorkflowsStorageCloudflare = WorkflowsStorageCloudflare;
-//# sourceMappingURL=chunk-KF35N26R.cjs.map
-//# sourceMappingURL=chunk-KF35N26R.cjs.map