@mastra/cloudflare-d1 1.0.0-beta.1 → 1.0.0-beta.11

package/dist/index.cjs

@@ -4,6 +4,7 @@ var error = require('@mastra/core/error');
 var storage = require('@mastra/core/storage');
 var Cloudflare = require('cloudflare');
 var agent = require('@mastra/core/agent');
+var base = require('@mastra/core/base');
 var utils = require('@mastra/core/utils');
 var evals = require('@mastra/core/evals');
 
@@ -12,6 +13,22 @@ function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 var Cloudflare__default = /*#__PURE__*/_interopDefault(Cloudflare);
 
 // src/storage/index.ts
+
+// src/storage/domains/utils.ts
+function isArrayOfRecords(value) {
+  return value && Array.isArray(value) && value.length > 0;
+}
+function deserializeValue(value, type) {
+  if (value === null || value === void 0) return null;
+  if (typeof value === "string" && (value.startsWith("{") || value.startsWith("["))) {
+    try {
+      return JSON.parse(value);
+    } catch {
+      return value;
+    }
+  }
+  return value;
+}
 var SqlBuilder = class {
   sql = "";
   params = [];
@@ -242,1127 +259,1262 @@ function parseSelectIdentifier(column) {
   return column;
 }
 
-// src/storage/domains/utils.ts
-function isArrayOfRecords(value) {
-  return value && Array.isArray(value) && value.length > 0;
-}
-function deserializeValue(value, type) {
-  if (value === null || value === void 0) return null;
-  if (typeof value === "string" && (value.startsWith("{") || value.startsWith("["))) {
-    try {
-      return JSON.parse(value);
-    } catch {
-      return value;
-    }
+// src/storage/db/index.ts
+function resolveD1Config(config) {
+  if ("client" in config) {
+    return {
+      client: config.client,
+      tablePrefix: config.tablePrefix
+    };
   }
-  return value;
-}
-
-// src/storage/domains/memory/index.ts
-var MemoryStorageD1 = class extends storage.MemoryStorage {
-  operations;
-  constructor({ operations }) {
-    super();
-    this.operations = operations;
+  if ("binding" in config) {
+    return {
+      binding: config.binding,
+      tablePrefix: config.tablePrefix
+    };
   }
-  async getResourceById({ resourceId }) {
-    const resource = await this.operations.load({
-      tableName: storage.TABLE_RESOURCES,
-      keys: { id: resourceId }
+  const cfClient = new Cloudflare__default.default({ apiToken: config.apiToken });
+  return {
+    client: {
+      query: ({ sql, params }) => {
+        return cfClient.d1.database.query(config.databaseId, {
+          account_id: config.accountId,
+          sql,
+          params
+        });
+      }
+    },
+    tablePrefix: config.tablePrefix
+  };
+}
+var D1DB = class extends base.MastraBase {
+  client;
+  binding;
+  tablePrefix;
+  constructor(config) {
+    super({
+      component: "STORAGE",
+      name: "D1_DB"
     });
-    if (!resource) return null;
+    this.client = config.client;
+    this.binding = config.binding;
+    this.tablePrefix = config.tablePrefix || "";
+  }
+  async hasColumn(table, column) {
+    const fullTableName = table.startsWith(this.tablePrefix) ? table : `${this.tablePrefix}${table}`;
+    const sql = `PRAGMA table_info(${fullTableName});`;
+    const result = await this.executeQuery({ sql, params: [] });
+    if (!result || !Array.isArray(result)) return false;
+    return result.some((col) => col.name === column || col.name === column.toLowerCase());
+  }
+  getTableName(tableName) {
+    return `${this.tablePrefix}${tableName}`;
+  }
+  formatSqlParams(params) {
+    return params.map((p) => p === void 0 || p === null ? null : p);
+  }
+  async executeWorkersBindingQuery({
+    sql,
+    params = [],
+    first = false
+  }) {
+    if (!this.binding) {
+      throw new Error("Workers binding is not configured");
+    }
     try {
-      return {
-        ...resource,
-        createdAt: storage.ensureDate(resource.createdAt),
-        updatedAt: storage.ensureDate(resource.updatedAt),
-        metadata: typeof resource.metadata === "string" ? JSON.parse(resource.metadata || "{}") : resource.metadata
-      };
+      const statement = this.binding.prepare(sql);
+      const formattedParams = this.formatSqlParams(params);
+      let result;
+      if (formattedParams.length > 0) {
+        if (first) {
+          result = await statement.bind(...formattedParams).first();
+          if (!result) return null;
+          return result;
+        } else {
+          result = await statement.bind(...formattedParams).all();
+          const results = result.results || [];
+          return results;
+        }
+      } else {
+        if (first) {
+          result = await statement.first();
+          if (!result) return null;
+          return result;
+        } else {
+          result = await statement.all();
+          const results = result.results || [];
+          return results;
+        }
+      }
     } catch (error$1) {
-      const mastraError = new error.MastraError(
+      throw new error.MastraError(
         {
-          id: "CLOUDFLARE_D1_STORAGE_GET_RESOURCE_BY_ID_ERROR",
+          id: storage.createStorageErrorId("CLOUDFLARE_D1", "WORKERS_BINDING_QUERY", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
-          text: `Error processing resource ${resourceId}: ${error$1 instanceof Error ? error$1.message : String(error$1)}`,
-          details: { resourceId }
+          details: { sql }
         },
         error$1
       );
-      this.logger?.error(mastraError.toString());
-      this.logger?.trackException(mastraError);
-      return null;
     }
   }
-  async saveResource({ resource }) {
-    const fullTableName = this.operations.getTableName(storage.TABLE_RESOURCES);
-    const resourceToSave = {
-      id: resource.id,
-      workingMemory: resource.workingMemory,
-      metadata: resource.metadata ? JSON.stringify(resource.metadata) : null,
-      createdAt: resource.createdAt,
-      updatedAt: resource.updatedAt
-    };
-    const processedRecord = await this.operations.processRecord(resourceToSave);
-    const columns = Object.keys(processedRecord);
-    const values = Object.values(processedRecord);
-    const updateMap = {
-      workingMemory: "excluded.workingMemory",
-      metadata: "excluded.metadata",
-      createdAt: "excluded.createdAt",
-      updatedAt: "excluded.updatedAt"
-    };
-    const query = createSqlBuilder().insert(fullTableName, columns, values, ["id"], updateMap);
-    const { sql, params } = query.build();
+  async executeRestQuery({
+    sql,
+    params = [],
+    first = false
+  }) {
+    if (!this.client) {
+      throw new Error("D1 client is not configured");
+    }
     try {
-      await this.operations.executeQuery({ sql, params });
-      return resource;
+      const formattedParams = this.formatSqlParams(params);
+      const response = await this.client.query({
+        sql,
+        params: formattedParams
+      });
+      const result = response.result || [];
+      const results = result.flatMap((r) => r.results || []);
+      if (first) {
+        return results[0] || null;
+      }
+      return results;
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "CLOUDFLARE_D1_STORAGE_SAVE_RESOURCE_ERROR",
+          id: storage.createStorageErrorId("CLOUDFLARE_D1", "REST_QUERY", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
-          text: `Failed to save resource to ${fullTableName}: ${error$1 instanceof Error ? error$1.message : String(error$1)}`,
-          details: { resourceId: resource.id }
+          details: { sql }
         },
         error$1
       );
     }
   }
-  async updateResource({
-    resourceId,
-    workingMemory,
-    metadata
-  }) {
-    const existingResource = await this.getResourceById({ resourceId });
-    if (!existingResource) {
-      const newResource = {
-        id: resourceId,
-        workingMemory,
-        metadata: metadata || {},
-        createdAt: /* @__PURE__ */ new Date(),
-        updatedAt: /* @__PURE__ */ new Date()
-      };
-      return this.saveResource({ resource: newResource });
+  async executeQuery(options) {
+    if (this.binding) {
+      return this.executeWorkersBindingQuery(options);
+    } else if (this.client) {
+      return this.executeRestQuery(options);
+    } else {
+      throw new Error("Neither binding nor client is configured");
     }
-    const updatedAt = /* @__PURE__ */ new Date();
-    const updatedResource = {
-      ...existingResource,
-      workingMemory: workingMemory !== void 0 ? workingMemory : existingResource.workingMemory,
-      metadata: {
-        ...existingResource.metadata,
-        ...metadata
-      },
-      updatedAt
-    };
-    const fullTableName = this.operations.getTableName(storage.TABLE_RESOURCES);
-    const columns = ["workingMemory", "metadata", "updatedAt"];
-    const values = [updatedResource.workingMemory, JSON.stringify(updatedResource.metadata), updatedAt.toISOString()];
-    const query = createSqlBuilder().update(fullTableName, columns, values).where("id = ?", resourceId);
-    const { sql, params } = query.build();
+  }
+  async getTableColumns(tableName) {
     try {
-      await this.operations.executeQuery({ sql, params });
-      return updatedResource;
+      const sql = `PRAGMA table_info(${tableName})`;
+      const result = await this.executeQuery({ sql });
+      if (!result || !Array.isArray(result)) {
+        return [];
+      }
+      return result.map((row) => ({
+        name: row.name,
+        type: row.type
+      }));
+    } catch (error) {
+      this.logger.warn(`Failed to get table columns for ${tableName}:`, error);
+      return [];
+    }
+  }
+  serializeValue(value) {
+    if (value === null || value === void 0) {
+      return null;
+    }
+    if (value instanceof Date) {
+      return value.toISOString();
+    }
+    if (typeof value === "object") {
+      return JSON.stringify(value);
+    }
+    return value;
+  }
+  getSqlType(type) {
+    switch (type) {
+      case "bigint":
+        return "INTEGER";
+      // SQLite uses INTEGER for all integer sizes
+      case "jsonb":
+        return "TEXT";
+      // Store JSON as TEXT in SQLite
+      case "boolean":
+        return "INTEGER";
+      // SQLite uses 0/1 for booleans
+      default:
+        return storage.getSqlType(type);
+    }
+  }
+  getDefaultValue(type) {
+    return storage.getDefaultValue(type);
+  }
+  async createTable({
+    tableName,
+    schema
+  }) {
+    try {
+      const fullTableName = this.getTableName(tableName);
+      const columnDefinitions = Object.entries(schema).map(([colName, colDef]) => {
+        const type = this.getSqlType(colDef.type);
+        const nullable = colDef.nullable === false ? "NOT NULL" : "";
+        const primaryKey = colDef.primaryKey ? "PRIMARY KEY" : "";
+        return `${colName} ${type} ${nullable} ${primaryKey}`.trim();
+      });
+      const tableConstraints = [];
+      if (tableName === storage.TABLE_WORKFLOW_SNAPSHOT) {
+        tableConstraints.push("UNIQUE (workflow_name, run_id)");
+      }
+      const query = createSqlBuilder().createTable(fullTableName, columnDefinitions, tableConstraints);
+      const { sql, params } = query.build();
+      await this.executeQuery({ sql, params });
+      this.logger.debug(`Created table ${fullTableName}`);
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "CLOUDFLARE_D1_STORAGE_UPDATE_RESOURCE_ERROR",
+          id: storage.createStorageErrorId("CLOUDFLARE_D1", "CREATE_TABLE", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
-          text: `Failed to update resource ${resourceId}: ${error$1 instanceof Error ? error$1.message : String(error$1)}`,
-          details: { resourceId }
+          details: { tableName }
         },
         error$1
       );
     }
   }
-  async getThreadById({ threadId }) {
-    const thread = await this.operations.load({
-      tableName: storage.TABLE_THREADS,
-      keys: { id: threadId }
-    });
-    if (!thread) return null;
+  async clearTable({ tableName }) {
     try {
-      return {
-        ...thread,
-        createdAt: storage.ensureDate(thread.createdAt),
-        updatedAt: storage.ensureDate(thread.updatedAt),
-        metadata: typeof thread.metadata === "string" ? JSON.parse(thread.metadata || "{}") : thread.metadata || {}
-      };
+      const fullTableName = this.getTableName(tableName);
+      const query = createSqlBuilder().delete(fullTableName);
+      const { sql, params } = query.build();
+      await this.executeQuery({ sql, params });
+      this.logger.debug(`Cleared table ${fullTableName}`);
     } catch (error$1) {
-      const mastraError = new error.MastraError(
+      throw new error.MastraError(
         {
-          id: "CLOUDFLARE_D1_STORAGE_GET_THREAD_BY_ID_ERROR",
+          id: storage.createStorageErrorId("CLOUDFLARE_D1", "CLEAR_TABLE", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
-          text: `Error processing thread ${threadId}: ${error$1 instanceof Error ? error$1.message : String(error$1)}`,
-          details: { threadId }
+          details: { tableName }
         },
         error$1
       );
-      this.logger?.error(mastraError.toString());
-      this.logger?.trackException(mastraError);
-      return null;
     }
   }
-  async listThreadsByResourceId(args) {
-    const { resourceId, page = 0, perPage: perPageInput, orderBy } = args;
-    const perPage = storage.normalizePerPage(perPageInput, 100);
-    if (page < 0) {
-      throw new error.MastraError(
-        {
-          id: "STORAGE_CLOUDFLARE_D1_LIST_THREADS_BY_RESOURCE_ID_INVALID_PAGE",
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.USER,
-          details: { page }
-        },
-        new Error("page must be >= 0")
-      );
-    }
-    const { offset, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
-    const { field, direction } = this.parseOrderBy(orderBy);
-    const fullTableName = this.operations.getTableName(storage.TABLE_THREADS);
-    const mapRowToStorageThreadType = (row) => ({
-      ...row,
-      createdAt: storage.ensureDate(row.createdAt),
-      updatedAt: storage.ensureDate(row.updatedAt),
-      metadata: typeof row.metadata === "string" ? JSON.parse(row.metadata || "{}") : row.metadata || {}
-    });
+  async dropTable({ tableName }) {
     try {
-      const countQuery = createSqlBuilder().count().from(fullTableName).where("resourceId = ?", resourceId);
-      const countResult = await this.operations.executeQuery(countQuery.build());
-      const total = Number(countResult?.[0]?.count ?? 0);
-      const limitValue = perPageInput === false ? total : perPage;
-      const selectQuery = createSqlBuilder().select("*").from(fullTableName).where("resourceId = ?", resourceId).orderBy(field, direction).limit(limitValue).offset(offset);
-      const results = await this.operations.executeQuery(selectQuery.build());
-      const threads = results.map(mapRowToStorageThreadType);
-      return {
-        threads,
-        total,
-        page,
-        perPage: perPageForResponse,
-        hasMore: perPageInput === false ? false : offset + perPage < total
-      };
+      const fullTableName = this.getTableName(tableName);
+      const sql = `DROP TABLE IF EXISTS ${fullTableName}`;
+      await this.executeQuery({ sql });
+      this.logger.debug(`Dropped table ${fullTableName}`);
     } catch (error$1) {
-      const mastraError = new error.MastraError(
+      throw new error.MastraError(
         {
-          id: "CLOUDFLARE_D1_STORAGE_LIST_THREADS_BY_RESOURCE_ID_ERROR",
+          id: storage.createStorageErrorId("CLOUDFLARE_D1", "DROP_TABLE", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
-          text: `Error getting threads by resourceId ${resourceId}: ${error$1 instanceof Error ? error$1.message : String(error$1)}`,
-          details: { resourceId }
+          details: { tableName }
         },
         error$1
       );
-      this.logger?.error(mastraError.toString());
-      this.logger?.trackException(mastraError);
-      return {
-        threads: [],
-        total: 0,
-        page,
-        perPage: perPageForResponse,
-        hasMore: false
-      };
     }
   }
-  async saveThread({ thread }) {
-    const fullTableName = this.operations.getTableName(storage.TABLE_THREADS);
-    const threadToSave = {
-      id: thread.id,
-      resourceId: thread.resourceId,
-      title: thread.title,
-      metadata: thread.metadata ? JSON.stringify(thread.metadata) : null,
-      createdAt: thread.createdAt.toISOString(),
-      updatedAt: thread.updatedAt.toISOString()
-    };
-    const processedRecord = await this.operations.processRecord(threadToSave);
-    const columns = Object.keys(processedRecord);
-    const values = Object.values(processedRecord);
-    const updateMap = {
-      resourceId: "excluded.resourceId",
-      title: "excluded.title",
-      metadata: "excluded.metadata",
-      createdAt: "excluded.createdAt",
-      updatedAt: "excluded.updatedAt"
-    };
-    const query = createSqlBuilder().insert(fullTableName, columns, values, ["id"], updateMap);
-    const { sql, params } = query.build();
+  async alterTable(args) {
     try {
-      await this.operations.executeQuery({ sql, params });
-      return thread;
+      const fullTableName = this.getTableName(args.tableName);
+      const existingColumns = await this.getTableColumns(fullTableName);
+      const existingColumnNames = new Set(existingColumns.map((col) => col.name));
+      for (const [columnName, column] of Object.entries(args.schema)) {
+        if (!existingColumnNames.has(columnName) && args.ifNotExists.includes(columnName)) {
+          const sqlType = this.getSqlType(column.type);
+          const defaultValue = this.getDefaultValue(column.type);
+          const sql = `ALTER TABLE ${fullTableName} ADD COLUMN ${columnName} ${sqlType} ${defaultValue}`;
+          await this.executeQuery({ sql });
+          this.logger.debug(`Added column ${columnName} to table ${fullTableName}`);
+        }
+      }
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "CLOUDFLARE_D1_STORAGE_SAVE_THREAD_ERROR",
+          id: storage.createStorageErrorId("CLOUDFLARE_D1", "ALTER_TABLE", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
-          text: `Failed to save thread to ${fullTableName}: ${error$1 instanceof Error ? error$1.message : String(error$1)}`,
-          details: { threadId: thread.id }
+          details: { tableName: args.tableName }
         },
         error$1
       );
     }
   }
-  async updateThread({
-    id,
-    title,
-    metadata
-  }) {
-    const thread = await this.getThreadById({ threadId: id });
+  async insert({ tableName, record }) {
     try {
-      if (!thread) {
-        throw new Error(`Thread ${id} not found`);
-      }
-      const fullTableName = this.operations.getTableName(storage.TABLE_THREADS);
-      const mergedMetadata = {
-        ...typeof thread.metadata === "string" ? JSON.parse(thread.metadata) : thread.metadata,
-        ...metadata
-      };
-      const updatedAt = /* @__PURE__ */ new Date();
-      const columns = ["title", "metadata", "updatedAt"];
-      const values = [title, JSON.stringify(mergedMetadata), updatedAt.toISOString()];
-      const query = createSqlBuilder().update(fullTableName, columns, values).where("id = ?", id);
+      const fullTableName = this.getTableName(tableName);
+      const processedRecord = await this.processRecord(record);
+      const columns = Object.keys(processedRecord);
+      const values = Object.values(processedRecord);
+      const query = createSqlBuilder().insert(fullTableName, columns, values);
       const { sql, params } = query.build();
-      await this.operations.executeQuery({ sql, params });
-      return {
-        ...thread,
-        title,
-        metadata: {
-          ...typeof thread.metadata === "string" ? JSON.parse(thread.metadata) : thread.metadata,
-          ...metadata
-        },
-        updatedAt
-      };
+      await this.executeQuery({ sql, params });
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "CLOUDFLARE_D1_STORAGE_UPDATE_THREAD_ERROR",
+          id: storage.createStorageErrorId("CLOUDFLARE_D1", "INSERT", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
-          text: `Failed to update thread ${id}: ${error$1 instanceof Error ? error$1.message : String(error$1)}`,
-          details: { threadId: id }
+          details: { tableName }
         },
         error$1
       );
     }
   }
-  async deleteThread({ threadId }) {
-    const fullTableName = this.operations.getTableName(storage.TABLE_THREADS);
+  async batchInsert({ tableName, records }) {
     try {
-      const deleteThreadQuery = createSqlBuilder().delete(fullTableName).where("id = ?", threadId);
-      const { sql: threadSql, params: threadParams } = deleteThreadQuery.build();
-      await this.operations.executeQuery({ sql: threadSql, params: threadParams });
-      const messagesTableName = this.operations.getTableName(storage.TABLE_MESSAGES);
-      const deleteMessagesQuery = createSqlBuilder().delete(messagesTableName).where("thread_id = ?", threadId);
-      const { sql: messagesSql, params: messagesParams } = deleteMessagesQuery.build();
-      await this.operations.executeQuery({ sql: messagesSql, params: messagesParams });
+      if (records.length === 0) return;
+      const fullTableName = this.getTableName(tableName);
+      const processedRecords = await Promise.all(records.map((record) => this.processRecord(record)));
+      const columns = Object.keys(processedRecords[0] || {});
+      for (const record of processedRecords) {
+        const values = Object.values(record);
+        const query = createSqlBuilder().insert(fullTableName, columns, values);
+        const { sql, params } = query.build();
+        await this.executeQuery({ sql, params });
+      }
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "CLOUDFLARE_D1_STORAGE_DELETE_THREAD_ERROR",
+          id: storage.createStorageErrorId("CLOUDFLARE_D1", "BATCH_INSERT", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
-          text: `Failed to delete thread ${threadId}: ${error$1 instanceof Error ? error$1.message : String(error$1)}`,
-          details: { threadId }
+          details: { tableName }
         },
         error$1
       );
     }
   }
-  async saveMessages(args) {
-    const { messages } = args;
-    if (messages.length === 0) return { messages: [] };
+  async load({ tableName, keys }) {
     try {
-      const now = /* @__PURE__ */ new Date();
-      const threadId = messages[0]?.threadId;
-      for (const [i, message] of messages.entries()) {
-        if (!message.id) throw new Error(`Message at index ${i} missing id`);
-        if (!message.threadId) {
-          throw new Error(`Message at index ${i} missing threadId`);
-        }
-        if (!message.content) {
-          throw new Error(`Message at index ${i} missing content`);
-        }
-        if (!message.role) {
-          throw new Error(`Message at index ${i} missing role`);
-        }
-        if (!message.resourceId) {
-          throw new Error(`Message at index ${i} missing resourceId`);
-        }
-        const thread = await this.getThreadById({ threadId: message.threadId });
-        if (!thread) {
-          throw new Error(`Thread ${message.threadId} not found`);
+      const fullTableName = this.getTableName(tableName);
+      const query = createSqlBuilder().select("*").from(fullTableName);
+      let firstKey = true;
+      for (const [key, value] of Object.entries(keys)) {
+        if (firstKey) {
+          query.where(`${key} = ?`, value);
+          firstKey = false;
+        } else {
+          query.andWhere(`${key} = ?`, value);
         }
       }
-      const messagesToInsert = messages.map((message) => {
-        const createdAt = message.createdAt ? new Date(message.createdAt) : now;
-        return {
-          id: message.id,
-          thread_id: message.threadId,
-          content: typeof message.content === "string" ? message.content : JSON.stringify(message.content),
-          createdAt: createdAt.toISOString(),
-          role: message.role,
-          type: message.type || "v2",
-          resourceId: message.resourceId
-        };
-      });
-      await Promise.all([
-        this.operations.batchUpsert({
-          tableName: storage.TABLE_MESSAGES,
-          records: messagesToInsert
-        }),
-        // Update thread's updatedAt timestamp
-        this.operations.executeQuery({
-          sql: `UPDATE ${this.operations.getTableName(storage.TABLE_THREADS)} SET updatedAt = ? WHERE id = ?`,
-          params: [now.toISOString(), threadId]
-        })
-      ]);
-      this.logger.debug(`Saved ${messages.length} messages`);
-      const list = new agent.MessageList().add(messages, "memory");
-      return { messages: list.get.all.db() };
+      query.orderBy("createdAt", "DESC");
+      query.limit(1);
+      const { sql, params } = query.build();
+      const result = await this.executeQuery({ sql, params, first: true });
+      if (!result) {
+        return null;
+      }
+      const deserializedResult = {};
+      for (const [key, value] of Object.entries(result)) {
+        deserializedResult[key] = deserializeValue(value);
+      }
+      return deserializedResult;
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "CLOUDFLARE_D1_STORAGE_SAVE_MESSAGES_ERROR",
+          id: storage.createStorageErrorId("CLOUDFLARE_D1", "LOAD", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
-          text: `Failed to save messages: ${error$1 instanceof Error ? error$1.message : String(error$1)}`
+          details: { tableName }
         },
         error$1
       );
     }
   }
-  async _getIncludedMessages(threadId, include) {
-    if (!threadId.trim()) throw new Error("threadId must be a non-empty string");
-    if (!include) return null;
-    const unionQueries = [];
-    const params = [];
-    let paramIdx = 1;
-    for (const inc of include) {
-      const { id, withPreviousMessages = 0, withNextMessages = 0 } = inc;
-      const searchId = inc.threadId || threadId;
-      unionQueries.push(`
-                SELECT * FROM (
-                  WITH ordered_messages AS (
-                    SELECT
-                      *,
-                      ROW_NUMBER() OVER (ORDER BY createdAt ASC) AS row_num
-                    FROM ${this.operations.getTableName(storage.TABLE_MESSAGES)}
-                    WHERE thread_id = ?
-                  )
-                  SELECT
-                    m.id,
-                    m.content,
-                    m.role,
-                    m.type,
-                    m.createdAt,
-                    m.thread_id AS threadId,
-                    m.resourceId
-                  FROM ordered_messages m
-                  WHERE m.id = ?
-                  OR EXISTS (
-                    SELECT 1 FROM ordered_messages target
-                    WHERE target.id = ?
-                    AND (
-                      (m.row_num <= target.row_num + ? AND m.row_num > target.row_num)
-                      OR
-                      (m.row_num >= target.row_num - ? AND m.row_num < target.row_num)
-                    )
-                  )
-                ) AS query_${paramIdx}
-            `);
-      params.push(searchId, id, id, withNextMessages, withPreviousMessages);
-      paramIdx++;
-    }
-    const finalQuery = unionQueries.join(" UNION ALL ") + " ORDER BY createdAt ASC";
-    const messages = await this.operations.executeQuery({ sql: finalQuery, params });
-    if (!Array.isArray(messages)) {
-      return [];
+  async processRecord(record) {
+    const processed = {};
+    for (const [key, value] of Object.entries(record)) {
+      processed[key] = this.serializeValue(value);
     }
-    const processedMessages = messages.map((message) => {
-      const processedMsg = {};
-      for (const [key, value] of Object.entries(message)) {
-        if (key === `type` && value === `v2`) continue;
-        processedMsg[key] = deserializeValue(value);
+    return processed;
+  }
+  /**
+   * Upsert multiple records in a batch operation
+   * @param tableName The table to insert into
+   * @param records The records to insert
+   */
+  async batchUpsert({ tableName, records }) {
+    if (records.length === 0) return;
+    const fullTableName = this.getTableName(tableName);
+    try {
+      const batchSize = 50;
+      for (let i = 0; i < records.length; i += batchSize) {
+        const batch = records.slice(i, i + batchSize);
+        const recordsToInsert = batch;
+        if (recordsToInsert.length > 0) {
+          const firstRecord = recordsToInsert[0];
+          const columns = Object.keys(firstRecord || {});
+          for (const record of recordsToInsert) {
+            const values = columns.map((col) => {
+              if (!record) return null;
+              const value = typeof col === "string" ? record[col] : null;
+              return this.serializeValue(value);
+            });
+            const recordToUpsert = columns.reduce(
+              (acc, col) => {
+                if (col !== "createdAt") acc[col] = `excluded.${col}`;
+                return acc;
+              },
+              {}
+            );
+            const query = createSqlBuilder().insert(fullTableName, columns, values, ["id"], recordToUpsert);
+            const { sql, params } = query.build();
+            await this.executeQuery({ sql, params });
+          }
+        }
+        this.logger.debug(
+          `Processed batch ${Math.floor(i / batchSize) + 1} of ${Math.ceil(records.length / batchSize)}`
+        );
       }
-      return processedMsg;
+      this.logger.debug(`Successfully batch upserted ${records.length} records into ${tableName}`);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("CLOUDFLARE_D1", "BATCH_UPSERT", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          text: `Failed to batch upsert into ${tableName}: ${error$1 instanceof Error ? error$1.message : String(error$1)}`,
+          details: { tableName }
+        },
+        error$1
+      );
+    }
+  }
+};
+
+// src/storage/domains/memory/index.ts
+var MemoryStorageD1 = class extends storage.MemoryStorage {
+  #db;
+  constructor(config) {
+    super();
+    this.#db = new D1DB(resolveD1Config(config));
+  }
+  async init() {
+    await this.#db.createTable({ tableName: storage.TABLE_THREADS, schema: storage.TABLE_SCHEMAS[storage.TABLE_THREADS] });
+    await this.#db.createTable({ tableName: storage.TABLE_MESSAGES, schema: storage.TABLE_SCHEMAS[storage.TABLE_MESSAGES] });
+    await this.#db.createTable({ tableName: storage.TABLE_RESOURCES, schema: storage.TABLE_SCHEMAS[storage.TABLE_RESOURCES] });
+    await this.#db.alterTable({
+      tableName: storage.TABLE_MESSAGES,
+      schema: storage.TABLE_SCHEMAS[storage.TABLE_MESSAGES],
+      ifNotExists: ["resourceId"]
     });
-    return processedMessages;
   }
-  async listMessagesById({ messageIds }) {
-    if (messageIds.length === 0) return { messages: [] };
-    const fullTableName = this.operations.getTableName(storage.TABLE_MESSAGES);
-    const messages = [];
+  async dangerouslyClearAll() {
+    await this.#db.clearTable({ tableName: storage.TABLE_MESSAGES });
+    await this.#db.clearTable({ tableName: storage.TABLE_THREADS });
+    await this.#db.clearTable({ tableName: storage.TABLE_RESOURCES });
+  }
+  async getResourceById({ resourceId }) {
+    const resource = await this.#db.load({
+      tableName: storage.TABLE_RESOURCES,
+      keys: { id: resourceId }
+    });
+    if (!resource) return null;
     try {
-      const query = createSqlBuilder().select(["id", "content", "role", "type", "createdAt", "thread_id AS threadId", "resourceId"]).from(fullTableName).where(`id in (${messageIds.map(() => "?").join(",")})`, ...messageIds);
-      query.orderBy("createdAt", "DESC");
-      const { sql, params } = query.build();
-      const result = await this.operations.executeQuery({ sql, params });
-      if (Array.isArray(result)) messages.push(...result);
-      const processedMessages = messages.map((message) => {
-        const processedMsg = {};
-        for (const [key, value] of Object.entries(message)) {
-          if (key === `type` && value === `v2`) continue;
-          processedMsg[key] = deserializeValue(value);
-        }
-        return processedMsg;
-      });
-      this.logger.debug(`Retrieved ${messages.length} messages`);
-      const list = new agent.MessageList().add(processedMessages, "memory");
-      return { messages: list.get.all.db() };
+      return {
+        ...resource,
+        createdAt: storage.ensureDate(resource.createdAt),
+        updatedAt: storage.ensureDate(resource.updatedAt),
+        metadata: typeof resource.metadata === "string" ? JSON.parse(resource.metadata || "{}") : resource.metadata
+      };
     } catch (error$1) {
       const mastraError = new error.MastraError(
         {
-          id: "CLOUDFLARE_D1_STORAGE_LIST_MESSAGES_BY_ID_ERROR",
+          id: storage.createStorageErrorId("CLOUDFLARE_D1", "GET_RESOURCE_BY_ID", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
-          text: `Failed to retrieve messages by ID: ${error$1 instanceof Error ? error$1.message : String(error$1)}`,
-          details: { messageIds: JSON.stringify(messageIds) }
+          text: `Error processing resource ${resourceId}: ${error$1 instanceof Error ? error$1.message : String(error$1)}`,
+          details: { resourceId }
         },
         error$1
       );
       this.logger?.error(mastraError.toString());
       this.logger?.trackException(mastraError);
-      throw mastraError;
+      return null;
     }
   }
-  async listMessages(args) {
-    const { threadId, resourceId, include, filter, perPage: perPageInput, page = 0, orderBy } = args;
-    if (!threadId.trim()) {
+  async saveResource({ resource }) {
+    const fullTableName = this.#db.getTableName(storage.TABLE_RESOURCES);
+    const resourceToSave = {
+      id: resource.id,
+      workingMemory: resource.workingMemory,
+      metadata: resource.metadata ? JSON.stringify(resource.metadata) : null,
+      createdAt: resource.createdAt,
+      updatedAt: resource.updatedAt
+    };
+    const processedRecord = await this.#db.processRecord(resourceToSave);
+    const columns = Object.keys(processedRecord);
+    const values = Object.values(processedRecord);
+    const updateMap = {
+      workingMemory: "excluded.workingMemory",
+      metadata: "excluded.metadata",
+      createdAt: "excluded.createdAt",
+      updatedAt: "excluded.updatedAt"
+    };
+    const query = createSqlBuilder().insert(fullTableName, columns, values, ["id"], updateMap);
+    const { sql, params } = query.build();
+    try {
+      await this.#db.executeQuery({ sql, params });
+      return resource;
+    } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "STORAGE_CLOUDFLARE_D1_LIST_MESSAGES_INVALID_THREAD_ID",
+          id: storage.createStorageErrorId("CLOUDFLARE_D1", "SAVE_RESOURCE", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
-          details: { threadId }
+          text: `Failed to save resource to ${fullTableName}: ${error$1 instanceof Error ? error$1.message : String(error$1)}`,
+          details: { resourceId: resource.id }
         },
-        new Error("threadId must be a non-empty string")
+        error$1
       );
     }
-    if (page < 0) {
+  }
+  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
+    };
+    const fullTableName = this.#db.getTableName(storage.TABLE_RESOURCES);
+    const columns = ["workingMemory", "metadata", "updatedAt"];
+    const values = [updatedResource.workingMemory, JSON.stringify(updatedResource.metadata), updatedAt.toISOString()];
+    const query = createSqlBuilder().update(fullTableName, columns, values).where("id = ?", resourceId);
+    const { sql, params } = query.build();
+    try {
+      await this.#db.executeQuery({ sql, params });
+      return updatedResource;
+    } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "STORAGE_CLOUDFLARE_D1_LIST_MESSAGES_INVALID_PAGE",
+          id: storage.createStorageErrorId("CLOUDFLARE_D1", "UPDATE_RESOURCE", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.USER,
-          details: { page }
+          category: error.ErrorCategory.THIRD_PARTY,
+          text: `Failed to update resource ${resourceId}: ${error$1 instanceof Error ? error$1.message : String(error$1)}`,
+          details: { resourceId }
         },
-        new Error("page must be >= 0")
+        error$1
       );
     }
-    const perPage = storage.normalizePerPage(perPageInput, 40);
-    const { offset, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
+  }
+  async getThreadById({ threadId }) {
+    const thread = await this.#db.load({
+      tableName: storage.TABLE_THREADS,
+      keys: { id: threadId }
+    });
+    if (!thread) return null;
     try {
-      const fullTableName = this.operations.getTableName(storage.TABLE_MESSAGES);
-      let query = `
-        SELECT id, content, role, type, createdAt, thread_id AS threadId, resourceId
-        FROM ${fullTableName}
-        WHERE thread_id = ?
-      `;
-      const queryParams = [threadId];
-      if (resourceId) {
-        query += ` AND resourceId = ?`;
-        queryParams.push(resourceId);
-      }
-      const dateRange = filter?.dateRange;
-      if (dateRange?.start) {
-        const startDate = dateRange.start instanceof Date ? storage.serializeDate(dateRange.start) : storage.serializeDate(new Date(dateRange.start));
-        query += ` AND createdAt >= ?`;
-        queryParams.push(startDate);
-      }
-      if (dateRange?.end) {
-        const endDate = dateRange.end instanceof Date ? storage.serializeDate(dateRange.end) : storage.serializeDate(new Date(dateRange.end));
-        query += ` AND createdAt <= ?`;
-        queryParams.push(endDate);
-      }
-      const { field, direction } = this.parseOrderBy(orderBy, "ASC");
-      query += ` ORDER BY "${field}" ${direction}`;
-      if (perPage !== Number.MAX_SAFE_INTEGER) {
-        query += ` LIMIT ? OFFSET ?`;
-        queryParams.push(perPage, offset);
-      }
-      const results = await this.operations.executeQuery({ sql: query, params: queryParams });
-      const paginatedMessages = (isArrayOfRecords(results) ? results : []).map((message) => {
-        const processedMsg = {};
-        for (const [key, value] of Object.entries(message)) {
-          if (key === `type` && value === `v2`) continue;
-          processedMsg[key] = deserializeValue(value);
-        }
-        return processedMsg;
-      });
-      const paginatedCount = paginatedMessages.length;
-      let countQuery = `SELECT count() as count FROM ${fullTableName} WHERE thread_id = ?`;
-      const countParams = [threadId];
-      if (resourceId) {
-        countQuery += ` AND resourceId = ?`;
-        countParams.push(resourceId);
-      }
-      if (dateRange?.start) {
-        const startDate = dateRange.start instanceof Date ? storage.serializeDate(dateRange.start) : storage.serializeDate(new Date(dateRange.start));
-        countQuery += ` AND createdAt >= ?`;
-        countParams.push(startDate);
-      }
-      if (dateRange?.end) {
-        const endDate = dateRange.end instanceof Date ? storage.serializeDate(dateRange.end) : storage.serializeDate(new Date(dateRange.end));
-        countQuery += ` AND createdAt <= ?`;
-        countParams.push(endDate);
-      }
-      const countResult = await this.operations.executeQuery({ sql: countQuery, params: countParams });
-      const total = Number(countResult[0]?.count ?? 0);
-      if (total === 0 && paginatedCount === 0 && (!include || include.length === 0)) {
-        return {
-          messages: [],
-          total: 0,
-          page,
-          perPage: perPageForResponse,
-          hasMore: false
-        };
-      }
-      const messageIds = new Set(paginatedMessages.map((m) => m.id));
-      let includeMessages = [];
-      if (include && include.length > 0) {
-        const includeResult = await this._getIncludedMessages(threadId, include);
-        if (Array.isArray(includeResult)) {
-          includeMessages = includeResult;
-          for (const includeMsg of includeMessages) {
-            if (!messageIds.has(includeMsg.id)) {
-              paginatedMessages.push(includeMsg);
-              messageIds.add(includeMsg.id);
-            }
-          }
-        }
-      }
-      const list = new agent.MessageList().add(paginatedMessages, "memory");
-      let finalMessages = list.get.all.db();
-      finalMessages = finalMessages.sort((a, b) => {
-        const isDateField = field === "createdAt" || field === "updatedAt";
-        const aValue = isDateField ? new Date(a[field]).getTime() : a[field];
-        const bValue = isDateField ? new Date(b[field]).getTime() : b[field];
-        if (aValue === bValue) {
-          return a.id.localeCompare(b.id);
-        }
-        if (typeof aValue === "number" && typeof bValue === "number") {
-          return direction === "ASC" ? aValue - bValue : bValue - aValue;
-        }
-        return direction === "ASC" ? String(aValue).localeCompare(String(bValue)) : String(bValue).localeCompare(String(aValue));
-      });
-      const returnedThreadMessageIds = new Set(finalMessages.filter((m) => m.threadId === threadId).map((m) => m.id));
-      const allThreadMessagesReturned = returnedThreadMessageIds.size >= total;
-      const hasMore = perPageInput === false ? false : allThreadMessagesReturned ? false : offset + paginatedCount < total;
       return {
-        messages: finalMessages,
-        total,
-        page,
-        perPage: perPageForResponse,
-        hasMore
+        ...thread,
+        createdAt: storage.ensureDate(thread.createdAt),
+        updatedAt: storage.ensureDate(thread.updatedAt),
+        metadata: typeof thread.metadata === "string" ? JSON.parse(thread.metadata || "{}") : thread.metadata || {}
       };
     } catch (error$1) {
       const mastraError = new error.MastraError(
         {
-          id: "CLOUDFLARE_D1_STORAGE_LIST_MESSAGES_ERROR",
+          id: storage.createStorageErrorId("CLOUDFLARE_D1", "GET_THREAD_BY_ID", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
-          text: `Failed to list messages for thread ${threadId}: ${error$1 instanceof Error ? error$1.message : String(error$1)}`,
-          details: {
-            threadId,
-            resourceId: resourceId ?? ""
-          }
+          text: `Error processing thread ${threadId}: ${error$1 instanceof Error ? error$1.message : String(error$1)}`,
+          details: { threadId }
         },
         error$1
       );
-      this.logger?.error?.(mastraError.toString());
-      this.logger?.trackException?.(mastraError);
-      return {
-        messages: [],
-        total: 0,
-        page,
-        perPage: perPageForResponse,
-        hasMore: false
-      };
+      this.logger?.error(mastraError.toString());
+      this.logger?.trackException(mastraError);
+      return null;
     }
   }
-  async updateMessages(args) {
-    const { messages } = args;
-    this.logger.debug("Updating messages", { count: messages.length });
-    if (!messages.length) {
-      return [];
-    }
-    const messageIds = messages.map((m) => m.id);
-    const fullTableName = this.operations.getTableName(storage.TABLE_MESSAGES);
-    const threadsTableName = this.operations.getTableName(storage.TABLE_THREADS);
+  async listThreads(args) {
+    const { page = 0, perPage: perPageInput, orderBy, filter } = args;
     try {
-      const placeholders = messageIds.map(() => "?").join(",");
-      const selectQuery = `SELECT id, content, role, type, createdAt, thread_id AS threadId, resourceId FROM ${fullTableName} WHERE id IN (${placeholders})`;
-      const existingMessages = await this.operations.executeQuery({ sql: selectQuery, params: messageIds });
-      if (existingMessages.length === 0) {
-        return [];
-      }
-      const parsedExistingMessages = existingMessages.map((msg) => {
-        if (typeof msg.content === "string") {
-          try {
-            msg.content = JSON.parse(msg.content);
-          } catch {
-          }
-        }
-        return msg;
-      });
-      const threadIdsToUpdate = /* @__PURE__ */ new Set();
-      const updateQueries = [];
-      for (const existingMessage of parsedExistingMessages) {
-        const updatePayload = messages.find((m) => m.id === existingMessage.id);
-        if (!updatePayload) continue;
-        const { id, ...fieldsToUpdate } = updatePayload;
-        if (Object.keys(fieldsToUpdate).length === 0) continue;
-        threadIdsToUpdate.add(existingMessage.threadId);
-        if ("threadId" in updatePayload && updatePayload.threadId && updatePayload.threadId !== existingMessage.threadId) {
-          threadIdsToUpdate.add(updatePayload.threadId);
-        }
-        const setClauses = [];
-        const values = [];
-        const updatableFields = { ...fieldsToUpdate };
-        if (updatableFields.content) {
-          const existingContent = existingMessage.content || {};
-          const newContent = {
-            ...existingContent,
-            ...updatableFields.content,
-            // Deep merge metadata if it exists on both
-            ...existingContent?.metadata && updatableFields.content.metadata ? {
-              metadata: {
-                ...existingContent.metadata,
-                ...updatableFields.content.metadata
-              }
-            } : {}
-          };
-          setClauses.push(`content = ?`);
-          values.push(JSON.stringify(newContent));
-          delete updatableFields.content;
-        }
-        for (const key in updatableFields) {
-          if (Object.prototype.hasOwnProperty.call(updatableFields, key)) {
-            const dbColumn = key === "threadId" ? "thread_id" : key;
-            setClauses.push(`${dbColumn} = ?`);
-            values.push(updatableFields[key]);
-          }
-        }
-        if (setClauses.length > 0) {
-          values.push(id);
-          const updateQuery = `UPDATE ${fullTableName} SET ${setClauses.join(", ")} WHERE id = ?`;
-          updateQueries.push({ sql: updateQuery, params: values });
-        }
-      }
-      for (const query of updateQueries) {
-        await this.operations.executeQuery(query);
-      }
-      if (threadIdsToUpdate.size > 0) {
-        const threadPlaceholders = Array.from(threadIdsToUpdate).map(() => "?").join(",");
-        const threadUpdateQuery = `UPDATE ${threadsTableName} SET updatedAt = ? WHERE id IN (${threadPlaceholders})`;
-        const threadUpdateParams = [(/* @__PURE__ */ new Date()).toISOString(), ...Array.from(threadIdsToUpdate)];
-        await this.operations.executeQuery({ sql: threadUpdateQuery, params: threadUpdateParams });
-      }
-      const updatedMessages = await this.operations.executeQuery({ sql: selectQuery, params: messageIds });
-      return updatedMessages.map((message) => {
-        if (typeof message.content === "string") {
-          try {
-            message.content = JSON.parse(message.content);
-          } catch {
-          }
-        }
-        return message;
-      });
+      this.validatePaginationInput(page, perPageInput ?? 100);
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "CLOUDFLARE_D1_STORAGE_UPDATE_MESSAGES_FAILED",
+          id: storage.createStorageErrorId("CLOUDFLARE_D1", "LIST_THREADS", "INVALID_PAGE"),
           domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: { count: messages.length }
+          category: error.ErrorCategory.USER,
+          details: { page, ...perPageInput !== void 0 && { perPage: perPageInput } }
         },
-        error$1
-      );
-    }
-  }
-};
-var StoreOperationsD1 = class extends storage.StoreOperations {
-  client;
-  binding;
-  tablePrefix;
-  constructor(config) {
-    super();
-    this.client = config.client;
-    this.binding = config.binding;
-    this.tablePrefix = config.tablePrefix || "";
-  }
-  async hasColumn(table, column) {
-    const fullTableName = table.startsWith(this.tablePrefix) ? table : `${this.tablePrefix}${table}`;
-    const sql = `PRAGMA table_info(${fullTableName});`;
-    const result = await this.executeQuery({ sql, params: [] });
-    if (!result || !Array.isArray(result)) return false;
-    return result.some((col) => col.name === column || col.name === column.toLowerCase());
-  }
-  getTableName(tableName) {
-    return `${this.tablePrefix}${tableName}`;
-  }
-  formatSqlParams(params) {
-    return params.map((p) => p === void 0 || p === null ? null : p);
-  }
-  async executeWorkersBindingQuery({
-    sql,
-    params = [],
-    first = false
-  }) {
-    if (!this.binding) {
-      throw new Error("Workers binding is not configured");
-    }
-    try {
-      const statement = this.binding.prepare(sql);
-      const formattedParams = this.formatSqlParams(params);
-      let result;
-      if (formattedParams.length > 0) {
-        if (first) {
-          result = await statement.bind(...formattedParams).first();
-          if (!result) return null;
-          return result;
-        } else {
-          result = await statement.bind(...formattedParams).all();
-          const results = result.results || [];
-          return results;
-        }
-      } else {
-        if (first) {
-          result = await statement.first();
-          if (!result) return null;
-          return result;
-        } else {
-          result = await statement.all();
-          const results = result.results || [];
-          return results;
+        error$1 instanceof Error ? error$1 : new Error("Invalid pagination parameters")
+      );
+    }
+    const perPage = storage.normalizePerPage(perPageInput, 100);
+    try {
+      this.validateMetadataKeys(filter?.metadata);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("CLOUDFLARE_D1", "LIST_THREADS", "INVALID_METADATA_KEY"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: { metadataKeys: filter?.metadata ? Object.keys(filter.metadata).join(", ") : "" }
+        },
+        error$1 instanceof Error ? error$1 : new Error("Invalid metadata key")
+      );
+    }
+    const { offset, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
+    const { field, direction } = this.parseOrderBy(orderBy);
+    const fullTableName = this.#db.getTableName(storage.TABLE_THREADS);
+    const mapRowToStorageThreadType = (row) => ({
+      ...row,
+      createdAt: storage.ensureDate(row.createdAt),
+      updatedAt: storage.ensureDate(row.updatedAt),
+      metadata: typeof row.metadata === "string" ? JSON.parse(row.metadata || "{}") : row.metadata || {}
+    });
+    try {
+      let countQuery = createSqlBuilder().count().from(fullTableName);
+      let selectQuery = createSqlBuilder().select("*").from(fullTableName);
+      if (filter?.resourceId) {
+        countQuery = countQuery.whereAnd("resourceId = ?", filter.resourceId);
+        selectQuery = selectQuery.whereAnd("resourceId = ?", filter.resourceId);
+      }
+      if (filter?.metadata && Object.keys(filter.metadata).length > 0) {
+        for (const [key, value] of Object.entries(filter.metadata)) {
+          if (value !== null && typeof value === "object") {
+            throw new error.MastraError(
+              {
+                id: storage.createStorageErrorId("CLOUDFLARE_D1", "LIST_THREADS", "INVALID_METADATA_VALUE"),
+                domain: error.ErrorDomain.STORAGE,
+                category: error.ErrorCategory.USER,
+                text: `Metadata filter value for key "${key}" must be a scalar type (string, number, boolean, or null), got ${Array.isArray(value) ? "array" : "object"}`,
+                details: { key, valueType: Array.isArray(value) ? "array" : "object" }
+              },
+              new Error("Invalid metadata filter value type")
+            );
+          }
+          if (value === null) {
+            const condition = `json_extract(metadata, '$.${key}') IS NULL`;
+            countQuery = countQuery.whereAnd(condition);
+            selectQuery = selectQuery.whereAnd(condition);
+          } else {
+            const condition = `json_extract(metadata, '$.${key}') = ?`;
+            const filterValue = value;
+            countQuery = countQuery.whereAnd(condition, filterValue);
+            selectQuery = selectQuery.whereAnd(condition, filterValue);
+          }
         }
       }
+      const countResult = await this.#db.executeQuery(countQuery.build());
+      const total = Number(countResult?.[0]?.count ?? 0);
+      if (total === 0) {
+        return {
+          threads: [],
+          total: 0,
+          page,
+          perPage: perPageForResponse,
+          hasMore: false
+        };
+      }
+      const limitValue = perPageInput === false ? total : perPage;
+      selectQuery = selectQuery.orderBy(field, direction).limit(limitValue).offset(offset);
+      const results = await this.#db.executeQuery(selectQuery.build());
+      const threads = results.map(mapRowToStorageThreadType);
+      return {
+        threads,
+        total,
+        page,
+        perPage: perPageForResponse,
+        hasMore: perPageInput === false ? false : offset + perPage < total
+      };
     } catch (error$1) {
-      throw new error.MastraError(
+      if (error$1 instanceof error.MastraError && error$1.category === error.ErrorCategory.USER) {
+        throw error$1;
+      }
+      const mastraError = new error.MastraError(
         {
-          id: "CLOUDFLARE_D1_STORE_OPERATIONS_WORKERS_BINDING_QUERY_FAILED",
+          id: storage.createStorageErrorId("CLOUDFLARE_D1", "LIST_THREADS", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
-          details: { sql }
+          text: `Error listing threads: ${error$1 instanceof Error ? error$1.message : String(error$1)}`,
+          details: {
+            ...filter?.resourceId && { resourceId: filter.resourceId },
+            hasMetadataFilter: !!filter?.metadata
+          }
         },
         error$1
       );
+      this.logger?.error(mastraError.toString());
+      this.logger?.trackException(mastraError);
+      return {
+        threads: [],
+        total: 0,
+        page,
+        perPage: perPageForResponse,
+        hasMore: false
+      };
     }
   }
-  async executeRestQuery({
-    sql,
-    params = [],
-    first = false
-  }) {
-    if (!this.client) {
-      throw new Error("D1 client is not configured");
-    }
+  async saveThread({ thread }) {
+    const fullTableName = this.#db.getTableName(storage.TABLE_THREADS);
+    const threadToSave = {
+      id: thread.id,
+      resourceId: thread.resourceId,
+      title: thread.title,
+      metadata: thread.metadata ? JSON.stringify(thread.metadata) : null,
+      createdAt: thread.createdAt.toISOString(),
+      updatedAt: thread.updatedAt.toISOString()
+    };
+    const processedRecord = await this.#db.processRecord(threadToSave);
+    const columns = Object.keys(processedRecord);
+    const values = Object.values(processedRecord);
+    const updateMap = {
+      resourceId: "excluded.resourceId",
+      title: "excluded.title",
+      metadata: "excluded.metadata",
+      createdAt: "excluded.createdAt",
+      updatedAt: "excluded.updatedAt"
+    };
+    const query = createSqlBuilder().insert(fullTableName, columns, values, ["id"], updateMap);
+    const { sql, params } = query.build();
     try {
-      const formattedParams = this.formatSqlParams(params);
-      const response = await this.client.query({
-        sql,
-        params: formattedParams
-      });
-      const result = response.result || [];
-      const results = result.flatMap((r) => r.results || []);
-      if (first) {
-        return results[0] || null;
-      }
-      return results;
+      await this.#db.executeQuery({ sql, params });
+      return thread;
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "CLOUDFLARE_D1_STORE_OPERATIONS_REST_QUERY_FAILED",
+          id: storage.createStorageErrorId("CLOUDFLARE_D1", "SAVE_THREAD", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
-          details: { sql }
+          text: `Failed to save thread to ${fullTableName}: ${error$1 instanceof Error ? error$1.message : String(error$1)}`,
+          details: { threadId: thread.id }
         },
         error$1
       );
     }
   }
-  async executeQuery(options) {
-    if (this.binding) {
-      return this.executeWorkersBindingQuery(options);
-    } else if (this.client) {
-      return this.executeRestQuery(options);
-    } else {
-      throw new Error("Neither binding nor client is configured");
-    }
-  }
-  async getTableColumns(tableName) {
-    try {
-      const sql = `PRAGMA table_info(${tableName})`;
-      const result = await this.executeQuery({ sql });
-      if (!result || !Array.isArray(result)) {
-        return [];
-      }
-      return result.map((row) => ({
-        name: row.name,
-        type: row.type
-      }));
-    } catch (error) {
-      this.logger.warn(`Failed to get table columns for ${tableName}:`, error);
-      return [];
-    }
-  }
-  serializeValue(value) {
-    if (value === null || value === void 0) {
-      return null;
-    }
-    if (value instanceof Date) {
-      return value.toISOString();
-    }
-    if (typeof value === "object") {
-      return JSON.stringify(value);
-    }
-    return value;
-  }
-  getSqlType(type) {
-    switch (type) {
-      case "bigint":
-        return "INTEGER";
-      // SQLite uses INTEGER for all integer sizes
-      case "jsonb":
-        return "TEXT";
-      // Store JSON as TEXT in SQLite
-      default:
-        return super.getSqlType(type);
-    }
-  }
-  async createTable({
-    tableName,
-    schema
+  async updateThread({
+    id,
+    title,
+    metadata
   }) {
+    const thread = await this.getThreadById({ threadId: id });
     try {
-      const fullTableName = this.getTableName(tableName);
-      const columnDefinitions = Object.entries(schema).map(([colName, colDef]) => {
-        const type = this.getSqlType(colDef.type);
-        const nullable = colDef.nullable === false ? "NOT NULL" : "";
-        const primaryKey = colDef.primaryKey ? "PRIMARY KEY" : "";
-        return `${colName} ${type} ${nullable} ${primaryKey}`.trim();
-      });
-      const tableConstraints = [];
-      if (tableName === storage.TABLE_WORKFLOW_SNAPSHOT) {
-        tableConstraints.push("UNIQUE (workflow_name, run_id)");
+      if (!thread) {
+        throw new Error(`Thread ${id} not found`);
       }
-      const query = createSqlBuilder().createTable(fullTableName, columnDefinitions, tableConstraints);
+      const fullTableName = this.#db.getTableName(storage.TABLE_THREADS);
+      const mergedMetadata = {
+        ...typeof thread.metadata === "string" ? JSON.parse(thread.metadata) : thread.metadata,
+        ...metadata
+      };
+      const updatedAt = /* @__PURE__ */ new Date();
+      const columns = ["title", "metadata", "updatedAt"];
+      const values = [title, JSON.stringify(mergedMetadata), updatedAt.toISOString()];
+      const query = createSqlBuilder().update(fullTableName, columns, values).where("id = ?", id);
       const { sql, params } = query.build();
-      await this.executeQuery({ sql, params });
-      this.logger.debug(`Created table ${fullTableName}`);
+      await this.#db.executeQuery({ sql, params });
+      return {
+        ...thread,
+        title,
+        metadata: {
+          ...typeof thread.metadata === "string" ? JSON.parse(thread.metadata) : thread.metadata,
+          ...metadata
+        },
+        updatedAt
+      };
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "CLOUDFLARE_D1_STORE_OPERATIONS_CREATE_TABLE_FAILED",
+          id: storage.createStorageErrorId("CLOUDFLARE_D1", "UPDATE_THREAD", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
-          details: { tableName }
+          text: `Failed to update thread ${id}: ${error$1 instanceof Error ? error$1.message : String(error$1)}`,
+          details: { threadId: id }
         },
         error$1
       );
     }
   }
-  async clearTable({ tableName }) {
+  async deleteThread({ threadId }) {
+    const fullTableName = this.#db.getTableName(storage.TABLE_THREADS);
     try {
-      const fullTableName = this.getTableName(tableName);
-      const query = createSqlBuilder().delete(fullTableName);
-      const { sql, params } = query.build();
-      await this.executeQuery({ sql, params });
-      this.logger.debug(`Cleared table ${fullTableName}`);
+      const deleteThreadQuery = createSqlBuilder().delete(fullTableName).where("id = ?", threadId);
+      const { sql: threadSql, params: threadParams } = deleteThreadQuery.build();
+      await this.#db.executeQuery({ sql: threadSql, params: threadParams });
+      const messagesTableName = this.#db.getTableName(storage.TABLE_MESSAGES);
+      const deleteMessagesQuery = createSqlBuilder().delete(messagesTableName).where("thread_id = ?", threadId);
+      const { sql: messagesSql, params: messagesParams } = deleteMessagesQuery.build();
+      await this.#db.executeQuery({ sql: messagesSql, params: messagesParams });
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "CLOUDFLARE_D1_STORE_OPERATIONS_CLEAR_TABLE_FAILED",
+          id: storage.createStorageErrorId("CLOUDFLARE_D1", "DELETE_THREAD", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
-          details: { tableName }
+          text: `Failed to delete thread ${threadId}: ${error$1 instanceof Error ? error$1.message : String(error$1)}`,
+          details: { threadId }
         },
         error$1
       );
     }
   }
-  async dropTable({ tableName }) {
+  async saveMessages(args) {
+    const { messages } = args;
+    if (messages.length === 0) return { messages: [] };
     try {
-      const fullTableName = this.getTableName(tableName);
-      const sql = `DROP TABLE IF EXISTS ${fullTableName}`;
-      await this.executeQuery({ sql });
-      this.logger.debug(`Dropped table ${fullTableName}`);
+      const now = /* @__PURE__ */ new Date();
+      const threadId = messages[0]?.threadId;
+      for (const [i, message] of messages.entries()) {
+        if (!message.id) throw new Error(`Message at index ${i} missing id`);
+        if (!message.threadId) {
+          throw new Error(`Message at index ${i} missing threadId`);
+        }
+        if (!message.content) {
+          throw new Error(`Message at index ${i} missing content`);
+        }
+        if (!message.role) {
+          throw new Error(`Message at index ${i} missing role`);
+        }
+        if (!message.resourceId) {
+          throw new Error(`Message at index ${i} missing resourceId`);
+        }
+        const thread = await this.getThreadById({ threadId: message.threadId });
+        if (!thread) {
+          throw new Error(`Thread ${message.threadId} not found`);
+        }
+      }
+      const messagesToInsert = messages.map((message) => {
+        const createdAt = message.createdAt ? new Date(message.createdAt) : now;
+        return {
+          id: message.id,
+          thread_id: message.threadId,
+          content: typeof message.content === "string" ? message.content : JSON.stringify(message.content),
+          createdAt: createdAt.toISOString(),
+          role: message.role,
+          type: message.type || "v2",
+          resourceId: message.resourceId
+        };
+      });
+      await Promise.all([
+        this.#db.batchUpsert({
+          tableName: storage.TABLE_MESSAGES,
+          records: messagesToInsert
+        }),
+        // Update thread's updatedAt timestamp
+        this.#db.executeQuery({
+          sql: `UPDATE ${this.#db.getTableName(storage.TABLE_THREADS)} SET updatedAt = ? WHERE id = ?`,
+          params: [now.toISOString(), threadId]
+        })
+      ]);
+      this.logger.debug(`Saved ${messages.length} messages`);
+      const list = new agent.MessageList().add(messages, "memory");
+      return { messages: list.get.all.db() };
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "CLOUDFLARE_D1_STORE_OPERATIONS_DROP_TABLE_FAILED",
+          id: storage.createStorageErrorId("CLOUDFLARE_D1", "SAVE_MESSAGES", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
-          details: { tableName }
+          text: `Failed to save messages: ${error$1 instanceof Error ? error$1.message : String(error$1)}`
         },
         error$1
       );
     }
   }
-  async alterTable(args) {
+  async _getIncludedMessages(include) {
+    if (!include || include.length === 0) return null;
+    const unionQueries = [];
+    const params = [];
+    let paramIdx = 1;
+    const tableName = this.#db.getTableName(storage.TABLE_MESSAGES);
+    for (const inc of include) {
+      const { id, withPreviousMessages = 0, withNextMessages = 0 } = inc;
+      unionQueries.push(`
+                SELECT * FROM (
+                  WITH target_thread AS (
+                    SELECT thread_id FROM ${tableName} WHERE id = ?
+                  ),
+                  ordered_messages AS (
+                    SELECT
+                      *,
+                      ROW_NUMBER() OVER (ORDER BY createdAt ASC) AS row_num
+                    FROM ${tableName}
+                    WHERE thread_id = (SELECT thread_id FROM target_thread)
+                  )
+                  SELECT
+                    m.id,
+                    m.content,
+                    m.role,
+                    m.type,
+                    m.createdAt,
+                    m.thread_id AS threadId,
+                    m.resourceId
+                  FROM ordered_messages m
+                  WHERE m.id = ?
+                  OR EXISTS (
+                    SELECT 1 FROM ordered_messages target
+                    WHERE target.id = ?
+                    AND (
+                      (m.row_num <= target.row_num + ? AND m.row_num > target.row_num)
+                      OR
+                      (m.row_num >= target.row_num - ? AND m.row_num < target.row_num)
+                    )
+                  )
+                ) AS query_${paramIdx}
+            `);
+      params.push(id, id, id, withNextMessages, withPreviousMessages);
+      paramIdx++;
+    }
+    const finalQuery = unionQueries.join(" UNION ALL ") + " ORDER BY createdAt ASC";
+    const messages = await this.#db.executeQuery({ sql: finalQuery, params });
+    if (!Array.isArray(messages)) {
+      return [];
+    }
+    const processedMessages = messages.map((message) => {
+      const processedMsg = {};
+      for (const [key, value] of Object.entries(message)) {
+        if (key === `type` && value === `v2`) continue;
+        processedMsg[key] = deserializeValue(value);
+      }
+      return processedMsg;
+    });
+    return processedMessages;
+  }
+  async listMessagesById({ messageIds }) {
+    if (messageIds.length === 0) return { messages: [] };
+    const fullTableName = this.#db.getTableName(storage.TABLE_MESSAGES);
+    const messages = [];
     try {
-      const fullTableName = this.getTableName(args.tableName);
-      const existingColumns = await this.getTableColumns(fullTableName);
-      const existingColumnNames = new Set(existingColumns.map((col) => col.name));
-      for (const [columnName, column] of Object.entries(args.schema)) {
-        if (!existingColumnNames.has(columnName) && args.ifNotExists.includes(columnName)) {
-          const sqlType = this.getSqlType(column.type);
-          const defaultValue = this.getDefaultValue(column.type);
-          const sql = `ALTER TABLE ${fullTableName} ADD COLUMN ${columnName} ${sqlType} ${defaultValue}`;
-          await this.executeQuery({ sql });
-          this.logger.debug(`Added column ${columnName} to table ${fullTableName}`);
+      const query = createSqlBuilder().select(["id", "content", "role", "type", "createdAt", "thread_id AS threadId", "resourceId"]).from(fullTableName).where(`id in (${messageIds.map(() => "?").join(",")})`, ...messageIds);
+      query.orderBy("createdAt", "DESC");
+      const { sql, params } = query.build();
+      const result = await this.#db.executeQuery({ sql, params });
+      if (Array.isArray(result)) messages.push(...result);
+      const processedMessages = messages.map((message) => {
+        const processedMsg = {};
+        for (const [key, value] of Object.entries(message)) {
+          if (key === `type` && value === `v2`) continue;
+          processedMsg[key] = deserializeValue(value);
         }
-      }
+        return processedMsg;
+      });
+      this.logger.debug(`Retrieved ${messages.length} messages`);
+      const list = new agent.MessageList().add(processedMessages, "memory");
+      return { messages: list.get.all.db() };
     } catch (error$1) {
-      throw new error.MastraError(
+      const mastraError = new error.MastraError(
         {
-          id: "CLOUDFLARE_D1_STORE_OPERATIONS_ALTER_TABLE_FAILED",
+          id: storage.createStorageErrorId("CLOUDFLARE_D1", "LIST_MESSAGES_BY_ID", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
-          details: { tableName: args.tableName }
+          text: `Failed to retrieve messages by ID: ${error$1 instanceof Error ? error$1.message : String(error$1)}`,
+          details: { messageIds: JSON.stringify(messageIds) }
         },
         error$1
       );
+      this.logger?.error(mastraError.toString());
+      this.logger?.trackException(mastraError);
+      throw mastraError;
     }
   }
-  async insert({ tableName, record }) {
-    try {
-      const fullTableName = this.getTableName(tableName);
-      const processedRecord = await this.processRecord(record);
-      const columns = Object.keys(processedRecord);
-      const values = Object.values(processedRecord);
-      const query = createSqlBuilder().insert(fullTableName, columns, values);
-      const { sql, params } = query.build();
-      await this.executeQuery({ sql, params });
-    } catch (error$1) {
+  async listMessages(args) {
+    const { threadId, resourceId, include, filter, perPage: perPageInput, page = 0, orderBy } = args;
+    const threadIds = Array.isArray(threadId) ? threadId : [threadId];
+    if (threadIds.length === 0 || threadIds.some((id) => !id.trim())) {
       throw new error.MastraError(
         {
-          id: "CLOUDFLARE_D1_STORE_OPERATIONS_INSERT_FAILED",
+          id: storage.createStorageErrorId("CLOUDFLARE_D1", "LIST_MESSAGES", "INVALID_THREAD_ID"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
-          details: { tableName }
+          details: { threadId: Array.isArray(threadId) ? threadId.join(",") : threadId }
         },
-        error$1
+        new Error("threadId must be a non-empty string or array of non-empty strings")
       );
     }
-  }
-  async batchInsert({ tableName, records }) {
+    if (page < 0) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("CLOUDFLARE_D1", "LIST_MESSAGES", "INVALID_PAGE"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: { page }
+        },
+        new Error("page must be >= 0")
+      );
+    }
+    const perPage = storage.normalizePerPage(perPageInput, 40);
+    const { offset, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
     try {
-      if (records.length === 0) return;
-      const fullTableName = this.getTableName(tableName);
-      const processedRecords = await Promise.all(records.map((record) => this.processRecord(record)));
-      const columns = Object.keys(processedRecords[0] || {});
-      for (const record of processedRecords) {
-        const values = Object.values(record);
-        const query = createSqlBuilder().insert(fullTableName, columns, values);
-        const { sql, params } = query.build();
-        await this.executeQuery({ sql, params });
+      const fullTableName = this.#db.getTableName(storage.TABLE_MESSAGES);
+      let query = `
+        SELECT id, content, role, type, createdAt, thread_id AS threadId, resourceId
+        FROM ${fullTableName}
+        WHERE thread_id = ?
+      `;
+      const queryParams = [threadId];
+      if (resourceId) {
+        query += ` AND resourceId = ?`;
+        queryParams.push(resourceId);
+      }
+      const dateRange = filter?.dateRange;
+      if (dateRange?.start) {
+        const startDate = dateRange.start instanceof Date ? storage.serializeDate(dateRange.start) : storage.serializeDate(new Date(dateRange.start));
+        const startOp = dateRange.startExclusive ? ">" : ">=";
+        query += ` AND createdAt ${startOp} ?`;
+        queryParams.push(startDate);
+      }
+      if (dateRange?.end) {
+        const endDate = dateRange.end instanceof Date ? storage.serializeDate(dateRange.end) : storage.serializeDate(new Date(dateRange.end));
+        const endOp = dateRange.endExclusive ? "<" : "<=";
+        query += ` AND createdAt ${endOp} ?`;
+        queryParams.push(endDate);
+      }
+      const { field, direction } = this.parseOrderBy(orderBy, "ASC");
+      query += ` ORDER BY "${field}" ${direction}`;
+      if (perPage !== Number.MAX_SAFE_INTEGER) {
+        query += ` LIMIT ? OFFSET ?`;
+        queryParams.push(perPage, offset);
+      }
+      const results = await this.#db.executeQuery({ sql: query, params: queryParams });
+      const paginatedMessages = (isArrayOfRecords(results) ? results : []).map((message) => {
+        const processedMsg = {};
+        for (const [key, value] of Object.entries(message)) {
+          if (key === `type` && value === `v2`) continue;
+          processedMsg[key] = deserializeValue(value);
+        }
+        return processedMsg;
+      });
+      const paginatedCount = paginatedMessages.length;
+      let countQuery = `SELECT count() as count FROM ${fullTableName} WHERE thread_id = ?`;
+      const countParams = [threadId];
+      if (resourceId) {
+        countQuery += ` AND resourceId = ?`;
+        countParams.push(resourceId);
+      }
+      if (dateRange?.start) {
+        const startDate = dateRange.start instanceof Date ? storage.serializeDate(dateRange.start) : storage.serializeDate(new Date(dateRange.start));
+        const startOp = dateRange.startExclusive ? ">" : ">=";
+        countQuery += ` AND createdAt ${startOp} ?`;
+        countParams.push(startDate);
+      }
+      if (dateRange?.end) {
+        const endDate = dateRange.end instanceof Date ? storage.serializeDate(dateRange.end) : storage.serializeDate(new Date(dateRange.end));
+        const endOp = dateRange.endExclusive ? "<" : "<=";
+        countQuery += ` AND createdAt ${endOp} ?`;
+        countParams.push(endDate);
+      }
+      const countResult = await this.#db.executeQuery({ sql: countQuery, params: countParams });
+      const total = Number(countResult[0]?.count ?? 0);
+      if (total === 0 && paginatedCount === 0 && (!include || include.length === 0)) {
+        return {
+          messages: [],
+          total: 0,
+          page,
+          perPage: perPageForResponse,
+          hasMore: false
+        };
+      }
+      const messageIds = new Set(paginatedMessages.map((m) => m.id));
+      let includeMessages = [];
+      if (include && include.length > 0) {
+        const includeResult = await this._getIncludedMessages(include);
+        if (Array.isArray(includeResult)) {
+          includeMessages = includeResult;
+          for (const includeMsg of includeMessages) {
+            if (!messageIds.has(includeMsg.id)) {
+              paginatedMessages.push(includeMsg);
+              messageIds.add(includeMsg.id);
+            }
+          }
+        }
       }
+      const list = new agent.MessageList().add(paginatedMessages, "memory");
+      let finalMessages = list.get.all.db();
+      finalMessages = finalMessages.sort((a, b) => {
+        const isDateField = field === "createdAt" || field === "updatedAt";
+        const aValue = isDateField ? new Date(a[field]).getTime() : a[field];
+        const bValue = isDateField ? new Date(b[field]).getTime() : b[field];
+        if (aValue === bValue) {
+          return a.id.localeCompare(b.id);
+        }
+        if (typeof aValue === "number" && typeof bValue === "number") {
+          return direction === "ASC" ? aValue - bValue : bValue - aValue;
+        }
+        return direction === "ASC" ? String(aValue).localeCompare(String(bValue)) : String(bValue).localeCompare(String(aValue));
+      });
+      const returnedThreadMessageIds = new Set(finalMessages.filter((m) => m.threadId === threadId).map((m) => m.id));
+      const allThreadMessagesReturned = returnedThreadMessageIds.size >= total;
+      const hasMore = perPageInput === false ? false : allThreadMessagesReturned ? false : offset + paginatedCount < total;
+      return {
+        messages: finalMessages,
+        total,
+        page,
+        perPage: perPageForResponse,
+        hasMore
+      };
     } catch (error$1) {
-      throw new error.MastraError(
+      const mastraError = new error.MastraError(
         {
-          id: "CLOUDFLARE_D1_STORE_OPERATIONS_BATCH_INSERT_FAILED",
+          id: storage.createStorageErrorId("CLOUDFLARE_D1", "LIST_MESSAGES", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
-          details: { tableName }
+          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 load({ tableName, keys }) {
+  async updateMessages(args) {
+    const { messages } = args;
+    this.logger.debug("Updating messages", { count: messages.length });
+    if (!messages.length) {
+      return [];
+    }
+    const messageIds = messages.map((m) => m.id);
+    const fullTableName = this.#db.getTableName(storage.TABLE_MESSAGES);
+    const threadsTableName = this.#db.getTableName(storage.TABLE_THREADS);
     try {
-      const fullTableName = this.getTableName(tableName);
-      const query = createSqlBuilder().select("*").from(fullTableName);
-      let firstKey = true;
-      for (const [key, value] of Object.entries(keys)) {
-        if (firstKey) {
-          query.where(`${key} = ?`, value);
-          firstKey = false;
-        } else {
-          query.andWhere(`${key} = ?`, value);
+      const placeholders = messageIds.map(() => "?").join(",");
+      const selectQuery = `SELECT id, content, role, type, createdAt, thread_id AS threadId, resourceId FROM ${fullTableName} WHERE id IN (${placeholders})`;
+      const existingMessages = await this.#db.executeQuery({ sql: selectQuery, params: messageIds });
+      if (existingMessages.length === 0) {
+        return [];
+      }
+      const parsedExistingMessages = existingMessages.map((msg) => {
+        if (typeof msg.content === "string") {
+          try {
+            msg.content = JSON.parse(msg.content);
+          } catch {
+          }
+        }
+        return msg;
+      });
+      const threadIdsToUpdate = /* @__PURE__ */ new Set();
+      const updateQueries = [];
+      for (const existingMessage of parsedExistingMessages) {
+        const updatePayload = messages.find((m) => m.id === existingMessage.id);
+        if (!updatePayload) continue;
+        const { id, ...fieldsToUpdate } = updatePayload;
+        if (Object.keys(fieldsToUpdate).length === 0) continue;
+        threadIdsToUpdate.add(existingMessage.threadId);
+        if ("threadId" in updatePayload && updatePayload.threadId && updatePayload.threadId !== existingMessage.threadId) {
+          threadIdsToUpdate.add(updatePayload.threadId);
+        }
+        const setClauses = [];
+        const values = [];
+        const updatableFields = { ...fieldsToUpdate };
+        if (updatableFields.content) {
+          const existingContent = existingMessage.content || {};
+          const newContent = {
+            ...existingContent,
+            ...updatableFields.content,
+            // Deep merge metadata if it exists on both
+            ...existingContent?.metadata && updatableFields.content.metadata ? {
+              metadata: {
+                ...existingContent.metadata,
+                ...updatableFields.content.metadata
+              }
+            } : {}
+          };
+          setClauses.push(`content = ?`);
+          values.push(JSON.stringify(newContent));
+          delete updatableFields.content;
+        }
+        for (const key in updatableFields) {
+          if (Object.prototype.hasOwnProperty.call(updatableFields, key)) {
+            const dbColumn = key === "threadId" ? "thread_id" : key;
+            setClauses.push(`${dbColumn} = ?`);
+            values.push(updatableFields[key]);
+          }
+        }
+        if (setClauses.length > 0) {
+          values.push(id);
+          const updateQuery = `UPDATE ${fullTableName} SET ${setClauses.join(", ")} WHERE id = ?`;
+          updateQueries.push({ sql: updateQuery, params: values });
         }
       }
-      query.orderBy("createdAt", "DESC");
-      query.limit(1);
-      const { sql, params } = query.build();
-      const result = await this.executeQuery({ sql, params, first: true });
-      if (!result) {
-        return null;
+      for (const query of updateQueries) {
+        await this.#db.executeQuery(query);
       }
-      const deserializedResult = {};
-      for (const [key, value] of Object.entries(result)) {
-        deserializedResult[key] = deserializeValue(value);
+      if (threadIdsToUpdate.size > 0) {
+        const threadPlaceholders = Array.from(threadIdsToUpdate).map(() => "?").join(",");
+        const threadUpdateQuery = `UPDATE ${threadsTableName} SET updatedAt = ? WHERE id IN (${threadPlaceholders})`;
+        const threadUpdateParams = [(/* @__PURE__ */ new Date()).toISOString(), ...Array.from(threadIdsToUpdate)];
+        await this.#db.executeQuery({ sql: threadUpdateQuery, params: threadUpdateParams });
       }
-      return deserializedResult;
+      const updatedMessages = await this.#db.executeQuery({ sql: selectQuery, params: messageIds });
+      return updatedMessages.map((message) => {
+        if (typeof message.content === "string") {
+          try {
+            message.content = JSON.parse(message.content);
+          } catch {
+          }
+        }
+        return message;
+      });
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "CLOUDFLARE_D1_STORE_OPERATIONS_LOAD_FAILED",
+          id: storage.createStorageErrorId("CLOUDFLARE_D1", "UPDATE_MESSAGES", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
-          details: { tableName }
+          details: { count: messages.length }
         },
         error$1
       );
     }
   }
-  async processRecord(record) {
-    const processed = {};
-    for (const [key, value] of Object.entries(record)) {
-      processed[key] = this.serializeValue(value);
-    }
-    return processed;
-  }
-  /**
-   * Upsert multiple records in a batch operation
-   * @param tableName The table to insert into
-   * @param records The records to insert
-   */
-  async batchUpsert({ tableName, records }) {
-    if (records.length === 0) return;
-    const fullTableName = this.getTableName(tableName);
+  async deleteMessages(messageIds) {
+    if (messageIds.length === 0) return;
+    const fullTableName = this.#db.getTableName(storage.TABLE_MESSAGES);
+    const threadsTableName = this.#db.getTableName(storage.TABLE_THREADS);
     try {
-      const batchSize = 50;
-      for (let i = 0; i < records.length; i += batchSize) {
-        const batch = records.slice(i, i + batchSize);
-        const recordsToInsert = batch;
-        if (recordsToInsert.length > 0) {
-          const firstRecord = recordsToInsert[0];
-          const columns = Object.keys(firstRecord || {});
-          for (const record of recordsToInsert) {
-            const values = columns.map((col) => {
-              if (!record) return null;
-              const value = typeof col === "string" ? record[col] : null;
-              return this.serializeValue(value);
-            });
-            const recordToUpsert = columns.reduce(
-              (acc, col) => {
-                if (col !== "createdAt") acc[col] = `excluded.${col}`;
-                return acc;
-              },
-              {}
-            );
-            const query = createSqlBuilder().insert(fullTableName, columns, values, ["id"], recordToUpsert);
-            const { sql, params } = query.build();
-            await this.executeQuery({ sql, params });
-          }
-        }
-        this.logger.debug(
-          `Processed batch ${Math.floor(i / batchSize) + 1} of ${Math.ceil(records.length / batchSize)}`
-        );
+      const placeholders = messageIds.map(() => "?").join(",");
+      const selectQuery = `SELECT DISTINCT thread_id FROM ${fullTableName} WHERE id IN (${placeholders})`;
+      const threadResults = await this.#db.executeQuery({ sql: selectQuery, params: messageIds });
+      const threadIds = threadResults.map((r) => r.thread_id).filter(Boolean);
+      const deleteQuery = createSqlBuilder().delete(fullTableName).where(`id IN (${placeholders})`, ...messageIds);
+      const { sql, params } = deleteQuery.build();
+      await this.#db.executeQuery({ sql, params });
+      if (threadIds.length > 0) {
+        const threadPlaceholders = threadIds.map(() => "?").join(",");
+        const threadUpdateQuery = `UPDATE ${threadsTableName} SET updatedAt = ? WHERE id IN (${threadPlaceholders})`;
+        const threadUpdateParams = [(/* @__PURE__ */ new Date()).toISOString(), ...threadIds];
+        await this.#db.executeQuery({ sql: threadUpdateQuery, params: threadUpdateParams });
       }
-      this.logger.debug(`Successfully batch upserted ${records.length} records into ${tableName}`);
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "CLOUDFLARE_D1_STORAGE_BATCH_UPSERT_ERROR",
+          id: storage.createStorageErrorId("CLOUDFLARE_D1", "DELETE_MESSAGES", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
-          text: `Failed to batch upsert into ${tableName}: ${error$1 instanceof Error ? error$1.message : String(error$1)}`,
-          details: { tableName }
+          details: { messageIds: JSON.stringify(messageIds) }
         },
         error$1
       );
@@ -1370,32 +1522,31 @@ var StoreOperationsD1 = class extends storage.StoreOperations {
   }
 };
 function transformScoreRow(row) {
-  const deserialized = { ...row };
-  deserialized.input = storage.safelyParseJSON(row.input);
-  deserialized.output = storage.safelyParseJSON(row.output);
-  deserialized.scorer = storage.safelyParseJSON(row.scorer);
-  deserialized.preprocessStepResult = storage.safelyParseJSON(row.preprocessStepResult);
-  deserialized.analyzeStepResult = storage.safelyParseJSON(row.analyzeStepResult);
-  deserialized.metadata = storage.safelyParseJSON(row.metadata);
-  deserialized.additionalContext = storage.safelyParseJSON(row.additionalContext);
-  deserialized.requestContext = storage.safelyParseJSON(row.requestContext);
-  deserialized.entity = storage.safelyParseJSON(row.entity);
-  deserialized.createdAt = row.createdAtZ || row.createdAt;
-  deserialized.updatedAt = row.updatedAtZ || row.updatedAt;
-  return deserialized;
+  return storage.transformScoreRow(row, {
+    preferredTimestampFields: {
+      createdAt: "createdAtZ",
+      updatedAt: "updatedAtZ"
+    }
+  });
 }
 var ScoresStorageD1 = class extends storage.ScoresStorage {
-  operations;
-  constructor({ operations }) {
+  #db;
+  constructor(config) {
     super();
-    this.operations = operations;
+    this.#db = new D1DB(resolveD1Config(config));
+  }
+  async init() {
+    await this.#db.createTable({ tableName: storage.TABLE_SCORERS, schema: storage.TABLE_SCHEMAS[storage.TABLE_SCORERS] });
+  }
+  async dangerouslyClearAll() {
+    await this.#db.clearTable({ tableName: storage.TABLE_SCORERS });
   }
   async getScoreById({ id }) {
     try {
-      const fullTableName = this.operations.getTableName(storage.TABLE_SCORERS);
+      const fullTableName = this.#db.getTableName(storage.TABLE_SCORERS);
       const query = createSqlBuilder().select("*").from(fullTableName).where("id = ?", id);
       const { sql, params } = query.build();
-      const result = await this.operations.executeQuery({ sql, params, first: true });
+      const result = await this.#db.executeQuery({ sql, params, first: true });
       if (!result) {
         return null;
       }
@@ -1403,7 +1554,7 @@ var ScoresStorageD1 = class extends storage.ScoresStorage {
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "CLOUDFLARE_D1_STORE_SCORES_GET_SCORE_BY_ID_FAILED",
+          id: storage.createStorageErrorId("CLOUDFLARE_D1", "GET_SCORE_BY_ID", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY
         },
@@ -1418,17 +1569,23 @@ var ScoresStorageD1 = class extends storage.ScoresStorage {
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "CLOUDFLARE_D1_STORE_SCORES_SAVE_SCORE_FAILED_INVALID_SCORE_PAYLOAD",
+          id: storage.createStorageErrorId("CLOUDFLARE_D1", "SAVE_SCORE", "VALIDATION_FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.USER,
-          details: { scoreId: score.id }
+          details: {
+            scorer: typeof score.scorer?.id === "string" ? score.scorer.id : String(score.scorer?.id ?? "unknown"),
+            entityId: score.entityId ?? "unknown",
+            entityType: score.entityType ?? "unknown",
+            traceId: score.traceId ?? "",
+            spanId: score.spanId ?? ""
+          }
         },
         error$1
       );
     }
+    const id = crypto.randomUUID();
     try {
-      const id = crypto.randomUUID();
-      const fullTableName = this.operations.getTableName(storage.TABLE_SCORERS);
+      const fullTableName = this.#db.getTableName(storage.TABLE_SCORERS);
       const serializedRecord = {};
       for (const [key, value] of Object.entries(parsedScore)) {
         if (value !== null && value !== void 0) {
@@ -1441,22 +1598,23 @@ var ScoresStorageD1 = class extends storage.ScoresStorage {
           serializedRecord[key] = null;
         }
       }
+      const now = /* @__PURE__ */ new Date();
       serializedRecord.id = id;
-      serializedRecord.createdAt = (/* @__PURE__ */ new Date()).toISOString();
-      serializedRecord.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      serializedRecord.createdAt = now.toISOString();
+      serializedRecord.updatedAt = now.toISOString();
       const columns = Object.keys(serializedRecord);
       const values = Object.values(serializedRecord);
       const query = createSqlBuilder().insert(fullTableName, columns, values);
       const { sql, params } = query.build();
-      await this.operations.executeQuery({ sql, params });
-      const scoreFromDb = await this.getScoreById({ id });
-      return { score: scoreFromDb };
+      await this.#db.executeQuery({ sql, params });
+      return { score: { ...parsedScore, id, createdAt: now, updatedAt: now } };
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "CLOUDFLARE_D1_STORE_SCORES_SAVE_SCORE_FAILED",
+          id: storage.createStorageErrorId("CLOUDFLARE_D1", "SAVE_SCORE", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { id }
         },
         error$1
       );
@@ -1473,7 +1631,7 @@ var ScoresStorageD1 = class extends storage.ScoresStorage {
       const { page, perPage: perPageInput } = pagination;
       const perPage = storage.normalizePerPage(perPageInput, 100);
       const { offset: start, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
-      const fullTableName = this.operations.getTableName(storage.TABLE_SCORERS);
+      const fullTableName = this.#db.getTableName(storage.TABLE_SCORERS);
       const countQuery = createSqlBuilder().count().from(fullTableName).where("scorerId = ?", scorerId);
       if (entityId) {
         countQuery.andWhere("entityId = ?", entityId);
@@ -1484,7 +1642,7 @@ var ScoresStorageD1 = class extends storage.ScoresStorage {
       if (source) {
         countQuery.andWhere("source = ?", source);
       }
-      const countResult = await this.operations.executeQuery(countQuery.build());
+      const countResult = await this.#db.executeQuery(countQuery.build());
       const total = Array.isArray(countResult) ? Number(countResult?.[0]?.count ?? 0) : Number(countResult?.count ?? 0);
       if (total === 0) {
         return {
@@ -1511,7 +1669,7 @@ var ScoresStorageD1 = class extends storage.ScoresStorage {
       }
       selectQuery.limit(limitValue).offset(start);
       const { sql, params } = selectQuery.build();
-      const results = await this.operations.executeQuery({ sql, params });
+      const results = await this.#db.executeQuery({ sql, params });
       const scores = Array.isArray(results) ? results.map(transformScoreRow) : [];
       return {
         pagination: {
@@ -1525,7 +1683,7 @@ var ScoresStorageD1 = class extends storage.ScoresStorage {
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "CLOUDFLARE_D1_STORE_SCORES_GET_SCORES_BY_SCORER_ID_FAILED",
+          id: storage.createStorageErrorId("CLOUDFLARE_D1", "GET_SCORES_BY_SCORER_ID", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY
         },
@@ -1541,9 +1699,9 @@ var ScoresStorageD1 = class extends storage.ScoresStorage {
       const { page, perPage: perPageInput } = pagination;
       const perPage = storage.normalizePerPage(perPageInput, 100);
       const { offset: start, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
-      const fullTableName = this.operations.getTableName(storage.TABLE_SCORERS);
+      const fullTableName = this.#db.getTableName(storage.TABLE_SCORERS);
       const countQuery = createSqlBuilder().count().from(fullTableName).where("runId = ?", runId);
-      const countResult = await this.operations.executeQuery(countQuery.build());
+      const countResult = await this.#db.executeQuery(countQuery.build());
       const total = Array.isArray(countResult) ? Number(countResult?.[0]?.count ?? 0) : Number(countResult?.count ?? 0);
       if (total === 0) {
         return {
@@ -1560,7 +1718,7 @@ var ScoresStorageD1 = class extends storage.ScoresStorage {
       const limitValue = perPageInput === false ? total : perPage;
       const selectQuery = createSqlBuilder().select("*").from(fullTableName).where("runId = ?", runId).limit(limitValue).offset(start);
       const { sql, params } = selectQuery.build();
-      const results = await this.operations.executeQuery({ sql, params });
+      const results = await this.#db.executeQuery({ sql, params });
       const scores = Array.isArray(results) ? results.map(transformScoreRow) : [];
       return {
         pagination: {
@@ -1574,7 +1732,7 @@ var ScoresStorageD1 = class extends storage.ScoresStorage {
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "CLOUDFLARE_D1_STORE_SCORES_GET_SCORES_BY_RUN_ID_FAILED",
+          id: storage.createStorageErrorId("CLOUDFLARE_D1", "GET_SCORES_BY_RUN_ID", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY
         },
@@ -1591,9 +1749,9 @@ var ScoresStorageD1 = class extends storage.ScoresStorage {
       const { page, perPage: perPageInput } = pagination;
       const perPage = storage.normalizePerPage(perPageInput, 100);
       const { offset: start, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
-      const fullTableName = this.operations.getTableName(storage.TABLE_SCORERS);
+      const fullTableName = this.#db.getTableName(storage.TABLE_SCORERS);
       const countQuery = createSqlBuilder().count().from(fullTableName).where("entityId = ?", entityId).andWhere("entityType = ?", entityType);
-      const countResult = await this.operations.executeQuery(countQuery.build());
+      const countResult = await this.#db.executeQuery(countQuery.build());
       const total = Array.isArray(countResult) ? Number(countResult?.[0]?.count ?? 0) : Number(countResult?.count ?? 0);
       if (total === 0) {
         return {
@@ -1610,7 +1768,7 @@ var ScoresStorageD1 = class extends storage.ScoresStorage {
       const limitValue = perPageInput === false ? total : perPage;
       const selectQuery = createSqlBuilder().select("*").from(fullTableName).where("entityId = ?", entityId).andWhere("entityType = ?", entityType).limit(limitValue).offset(start);
       const { sql, params } = selectQuery.build();
-      const results = await this.operations.executeQuery({ sql, params });
+      const results = await this.#db.executeQuery({ sql, params });
       const scores = Array.isArray(results) ? results.map(transformScoreRow) : [];
       return {
         pagination: {
@@ -1624,7 +1782,7 @@ var ScoresStorageD1 = class extends storage.ScoresStorage {
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "CLOUDFLARE_D1_STORE_SCORES_GET_SCORES_BY_ENTITY_ID_FAILED",
+          id: storage.createStorageErrorId("CLOUDFLARE_D1", "GET_SCORES_BY_ENTITY_ID", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY
         },
@@ -1641,9 +1799,9 @@ var ScoresStorageD1 = class extends storage.ScoresStorage {
       const { page, perPage: perPageInput } = pagination;
       const perPage = storage.normalizePerPage(perPageInput, 100);
       const { offset: start, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
-      const fullTableName = this.operations.getTableName(storage.TABLE_SCORERS);
+      const fullTableName = this.#db.getTableName(storage.TABLE_SCORERS);
       const countQuery = createSqlBuilder().count().from(fullTableName).where("traceId = ?", traceId).andWhere("spanId = ?", spanId);
-      const countResult = await this.operations.executeQuery(countQuery.build());
+      const countResult = await this.#db.executeQuery(countQuery.build());
       const total = Array.isArray(countResult) ? Number(countResult?.[0]?.count ?? 0) : Number(countResult?.count ?? 0);
       if (total === 0) {
         return {
@@ -1660,7 +1818,7 @@ var ScoresStorageD1 = class extends storage.ScoresStorage {
       const limitValue = perPageInput === false ? total : perPage;
       const selectQuery = createSqlBuilder().select("*").from(fullTableName).where("traceId = ?", traceId).andWhere("spanId = ?", spanId).orderBy("createdAt", "DESC").limit(limitValue).offset(start);
       const { sql, params } = selectQuery.build();
-      const results = await this.operations.executeQuery({ sql, params });
+      const results = await this.#db.executeQuery({ sql, params });
       const scores = Array.isArray(results) ? results.map(transformScoreRow) : [];
       return {
         pagination: {
@@ -1674,7 +1832,7 @@ var ScoresStorageD1 = class extends storage.ScoresStorage {
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "CLOUDFLARE_D1_STORE_SCORES_GET_SCORES_BY_SPAN_FAILED",
+          id: storage.createStorageErrorId("CLOUDFLARE_D1", "GET_SCORES_BY_SPAN", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY
         },
@@ -1684,10 +1842,16 @@ var ScoresStorageD1 = class extends storage.ScoresStorage {
   }
 };
 var WorkflowsStorageD1 = class extends storage.WorkflowsStorage {
-  operations;
-  constructor({ operations }) {
+  #db;
+  constructor(config) {
     super();
-    this.operations = operations;
+    this.#db = new D1DB(resolveD1Config(config));
+  }
+  async init() {
+    await this.#db.createTable({ tableName: storage.TABLE_WORKFLOW_SNAPSHOT, schema: storage.TABLE_SCHEMAS[storage.TABLE_WORKFLOW_SNAPSHOT] });
+  }
+  async dangerouslyClearAll() {
+    await this.#db.clearTable({ tableName: storage.TABLE_WORKFLOW_SNAPSHOT });
   }
   updateWorkflowResults({
     // workflowName,
@@ -1709,11 +1873,13 @@ var WorkflowsStorageD1 = class extends storage.WorkflowsStorage {
     workflowName,
     runId,
     resourceId,
-    snapshot
+    snapshot,
+    createdAt,
+    updatedAt
   }) {
-    const fullTableName = this.operations.getTableName(storage.TABLE_WORKFLOW_SNAPSHOT);
+    const fullTableName = this.#db.getTableName(storage.TABLE_WORKFLOW_SNAPSHOT);
     const now = (/* @__PURE__ */ new Date()).toISOString();
-    const currentSnapshot = await this.operations.load({
+    const currentSnapshot = await this.#db.load({
       tableName: storage.TABLE_WORKFLOW_SNAPSHOT,
       keys: { workflow_name: workflowName, run_id: runId }
     });
@@ -1721,16 +1887,16 @@ var WorkflowsStorageD1 = class extends storage.WorkflowsStorage {
       ...currentSnapshot,
       resourceId,
       snapshot: JSON.stringify(snapshot),
-      updatedAt: now
+      updatedAt: updatedAt ? updatedAt.toISOString() : now
     } : {
       workflow_name: workflowName,
       run_id: runId,
       resourceId,
       snapshot,
-      createdAt: now,
-      updatedAt: now
+      createdAt: createdAt ? createdAt.toISOString() : now,
+      updatedAt: updatedAt ? updatedAt.toISOString() : now
     };
-    const processedRecord = await this.operations.processRecord(persisting);
+    const processedRecord = await this.#db.processRecord(persisting);
     const columns = Object.keys(processedRecord);
     const values = Object.values(processedRecord);
     const updateMap = {
@@ -1741,11 +1907,11 @@ var WorkflowsStorageD1 = class extends storage.WorkflowsStorage {
     const query = createSqlBuilder().insert(fullTableName, columns, values, ["workflow_name", "run_id"], updateMap);
     const { sql, params } = query.build();
     try {
-      await this.operations.executeQuery({ sql, params });
+      await this.#db.executeQuery({ sql, params });
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "CLOUDFLARE_D1_STORAGE_PERSIST_WORKFLOW_SNAPSHOT_ERROR",
+          id: storage.createStorageErrorId("CLOUDFLARE_D1", "PERSIST_WORKFLOW_SNAPSHOT", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
           text: `Failed to persist workflow snapshot: ${error$1 instanceof Error ? error$1.message : String(error$1)}`,
@@ -1759,7 +1925,7 @@ var WorkflowsStorageD1 = class extends storage.WorkflowsStorage {
     const { workflowName, runId } = params;
     this.logger.debug("Loading workflow snapshot", { workflowName, runId });
     try {
-      const d = await this.operations.load({
+      const d = await this.#db.load({
         tableName: storage.TABLE_WORKFLOW_SNAPSHOT,
         keys: {
           workflow_name: workflowName,
@@ -1770,7 +1936,7 @@ var WorkflowsStorageD1 = class extends storage.WorkflowsStorage {
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "CLOUDFLARE_D1_STORAGE_LOAD_WORKFLOW_SNAPSHOT_ERROR",
+          id: storage.createStorageErrorId("CLOUDFLARE_D1", "LOAD_WORKFLOW_SNAPSHOT", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
           text: `Failed to load workflow snapshot: ${error$1 instanceof Error ? error$1.message : String(error$1)}`,
@@ -1786,7 +1952,7 @@ var WorkflowsStorageD1 = class extends storage.WorkflowsStorage {
       try {
         parsedSnapshot = JSON.parse(row.snapshot);
       } catch (e) {
-        console.warn(`Failed to parse snapshot for workflow ${row.workflow_name}: ${e}`);
+        this.logger.warn(`Failed to parse snapshot for workflow ${row.workflow_name}: ${e}`);
       }
     }
     return {
@@ -1807,7 +1973,7 @@ var WorkflowsStorageD1 = class extends storage.WorkflowsStorage {
     resourceId,
     status
   } = {}) {
-    const fullTableName = this.operations.getTableName(storage.TABLE_WORKFLOW_SNAPSHOT);
+    const fullTableName = this.#db.getTableName(storage.TABLE_WORKFLOW_SNAPSHOT);
     try {
       const builder = createSqlBuilder().select().from(fullTableName);
       const countBuilder = createSqlBuilder().count().from(fullTableName);
@@ -1817,12 +1983,12 @@ var WorkflowsStorageD1 = class extends storage.WorkflowsStorage {
         countBuilder.whereAnd("json_extract(snapshot, '$.status') = ?", status);
       }
       if (resourceId) {
-        const hasResourceId = await this.operations.hasColumn(fullTableName, "resourceId");
+        const hasResourceId = await this.#db.hasColumn(fullTableName, "resourceId");
         if (hasResourceId) {
           builder.whereAnd("resourceId = ?", resourceId);
           countBuilder.whereAnd("resourceId = ?", resourceId);
         } else {
-          console.warn(`[${fullTableName}] resourceId column not found. Skipping resourceId filter.`);
+          this.logger.warn(`[${fullTableName}] resourceId column not found. Skipping resourceId filter.`);
         }
       }
       if (fromDate) {
@@ -1843,20 +2009,20 @@ var WorkflowsStorageD1 = class extends storage.WorkflowsStorage {
       let total = 0;
       if (perPage !== void 0 && page !== void 0) {
         const { sql: countSql, params: countParams } = countBuilder.build();
-        const countResult = await this.operations.executeQuery({
+        const countResult = await this.#db.executeQuery({
           sql: countSql,
           params: countParams,
           first: true
         });
         total = Number(countResult?.count ?? 0);
       }
-      const results = await this.operations.executeQuery({ sql, params });
+      const results = await this.#db.executeQuery({ sql, params });
       const runs = (isArrayOfRecords(results) ? results : []).map((row) => this.parseWorkflowRun(row));
       return { runs, total: total || runs.length };
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "CLOUDFLARE_D1_STORAGE_LIST_WORKFLOW_RUNS_ERROR",
+          id: storage.createStorageErrorId("CLOUDFLARE_D1", "LIST_WORKFLOW_RUNS", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
           text: `Failed to retrieve workflow runs: ${error$1 instanceof Error ? error$1.message : String(error$1)}`,
@@ -1873,7 +2039,7 @@ var WorkflowsStorageD1 = class extends storage.WorkflowsStorage {
     runId,
     workflowName
   }) {
-    const fullTableName = this.operations.getTableName(storage.TABLE_WORKFLOW_SNAPSHOT);
+    const fullTableName = this.#db.getTableName(storage.TABLE_WORKFLOW_SNAPSHOT);
     try {
       const conditions = [];
       const params = [];
@@ -1887,13 +2053,13 @@ var WorkflowsStorageD1 = class extends storage.WorkflowsStorage {
       }
       const whereClause = conditions.length > 0 ? "WHERE " + conditions.join(" AND ") : "";
       const sql = `SELECT * FROM ${fullTableName} ${whereClause} ORDER BY createdAt DESC LIMIT 1`;
-      const result = await this.operations.executeQuery({ sql, params, first: true });
+      const result = await this.#db.executeQuery({ sql, params, first: true });
       if (!result) return null;
       return this.parseWorkflowRun(result);
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "CLOUDFLARE_D1_STORAGE_GET_WORKFLOW_RUN_BY_ID_ERROR",
+          id: storage.createStorageErrorId("CLOUDFLARE_D1", "GET_WORKFLOW_RUN_BY_ID", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
           text: `Failed to retrieve workflow run by ID: ${error$1 instanceof Error ? error$1.message : String(error$1)}`,
@@ -1903,13 +2069,31 @@ var WorkflowsStorageD1 = class extends storage.WorkflowsStorage {
       );
     }
   }
+  async deleteWorkflowRunById({ runId, workflowName }) {
+    const fullTableName = this.#db.getTableName(storage.TABLE_WORKFLOW_SNAPSHOT);
+    try {
+      const sql = `DELETE FROM ${fullTableName} WHERE workflow_name = ? AND run_id = ?`;
+      const params = [workflowName, runId];
+      await this.#db.executeQuery({ sql, params });
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("CLOUDFLARE_D1", "DELETE_WORKFLOW_RUN_BY_ID", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          text: `Failed to delete workflow run by ID: ${error$1 instanceof Error ? error$1.message : String(error$1)}`,
+          details: { runId, workflowName }
+        },
+        error$1
+      );
+    }
+  }
 };
 
 // src/storage/index.ts
 var D1Store = class extends storage.MastraStorage {
   client;
   binding;
-  // D1Database binding
   tablePrefix;
   stores;
   /**
@@ -1918,7 +2102,7 @@ var D1Store = class extends storage.MastraStorage {
    */
   constructor(config) {
     try {
-      super({ id: config.id, name: "D1" });
+      super({ id: config.id, name: "D1", disableInit: config.disableInit });
       if (config.tablePrefix && !/^[a-zA-Z0-9_]*$/.test(config.tablePrefix)) {
         throw new Error("Invalid tablePrefix: only letters, numbers, and underscores are allowed.");
       }
@@ -1956,7 +2140,7 @@ var D1Store = class extends storage.MastraStorage {
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "CLOUDFLARE_D1_STORAGE_INITIALIZATION_ERROR",
+          id: storage.createStorageErrorId("CLOUDFLARE_D1", "INITIALIZATION", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.SYSTEM,
           text: "Error initializing D1Store"
@@ -1964,189 +2148,26 @@ var D1Store = class extends storage.MastraStorage {
         error$1
       );
     }
-    const operations = new StoreOperationsD1({
-      client: this.client,
-      binding: this.binding,
-      tablePrefix: this.tablePrefix
-    });
-    const scores = new ScoresStorageD1({
-      operations
-    });
-    const workflows = new WorkflowsStorageD1({
-      operations
-    });
-    const memory = new MemoryStorageD1({
-      operations
-    });
+    let scores;
+    let workflows;
+    let memory;
+    if (this.binding) {
+      const domainConfig = { binding: this.binding, tablePrefix: this.tablePrefix };
+      scores = new ScoresStorageD1(domainConfig);
+      workflows = new WorkflowsStorageD1(domainConfig);
+      memory = new MemoryStorageD1(domainConfig);
+    } else {
+      const domainConfig = { client: this.client, tablePrefix: this.tablePrefix };
+      scores = new ScoresStorageD1(domainConfig);
+      workflows = new WorkflowsStorageD1(domainConfig);
+      memory = new MemoryStorageD1(domainConfig);
+    }
     this.stores = {
-      operations,
       scores,
       workflows,
       memory
     };
   }
-  get supports() {
-    return {
-      selectByIncludeResourceScope: true,
-      resourceWorkingMemory: true,
-      hasColumn: true,
-      createTable: true,
-      deleteMessages: false,
-      listScoresBySpan: true
-    };
-  }
-  async createTable({
-    tableName,
-    schema
-  }) {
-    return this.stores.operations.createTable({ tableName, schema });
-  }
-  /**
-   * Alters table schema to add columns if they don't exist
-   * @param tableName Name of the table
-   * @param schema Schema of the table
-   * @param ifNotExists Array of column names to add if they don't exist
-   */
-  async alterTable({
-    tableName,
-    schema,
-    ifNotExists
-  }) {
-    return this.stores.operations.alterTable({ tableName, schema, ifNotExists });
-  }
-  async clearTable({ tableName }) {
-    return this.stores.operations.clearTable({ tableName });
-  }
-  async dropTable({ tableName }) {
-    return this.stores.operations.dropTable({ tableName });
-  }
-  async hasColumn(table, column) {
-    return this.stores.operations.hasColumn(table, column);
-  }
-  async insert({ tableName, record }) {
-    return this.stores.operations.insert({ tableName, record });
-  }
-  async load({ tableName, keys }) {
-    return this.stores.operations.load({ tableName, keys });
-  }
-  async getThreadById({ threadId }) {
-    return this.stores.memory.getThreadById({ threadId });
-  }
-  async saveThread({ thread }) {
-    return this.stores.memory.saveThread({ thread });
-  }
-  async updateThread({
-    id,
-    title,
-    metadata
-  }) {
-    return this.stores.memory.updateThread({ id, title, metadata });
-  }
-  async deleteThread({ threadId }) {
-    return this.stores.memory.deleteThread({ threadId });
-  }
-  async saveMessages(args) {
-    return this.stores.memory.saveMessages(args);
-  }
-  async updateWorkflowResults({
-    workflowName,
-    runId,
-    stepId,
-    result,
-    requestContext
-  }) {
-    return this.stores.workflows.updateWorkflowResults({ workflowName, runId, stepId, result, requestContext });
-  }
-  async updateWorkflowState({
-    workflowName,
-    runId,
-    opts
-  }) {
-    return this.stores.workflows.updateWorkflowState({ workflowName, runId, opts });
-  }
-  async persistWorkflowSnapshot({
-    workflowName,
-    runId,
-    resourceId,
-    snapshot
-  }) {
-    return this.stores.workflows.persistWorkflowSnapshot({ workflowName, runId, resourceId, snapshot });
-  }
-  async loadWorkflowSnapshot(params) {
-    return this.stores.workflows.loadWorkflowSnapshot(params);
-  }
-  async listWorkflowRuns(args = {}) {
-    return this.stores.workflows.listWorkflowRuns(args);
-  }
-  async getWorkflowRunById({
-    runId,
-    workflowName
-  }) {
-    return this.stores.workflows.getWorkflowRunById({ runId, workflowName });
-  }
-  /**
-   * Insert multiple records in a batch operation
-   * @param tableName The table to insert into
-   * @param records The records to insert
-   */
-  async batchInsert({ tableName, records }) {
-    return this.stores.operations.batchInsert({ tableName, records });
-  }
-  async updateMessages(_args) {
-    return this.stores.memory.updateMessages(_args);
-  }
-  async getResourceById({ resourceId }) {
-    return this.stores.memory.getResourceById({ resourceId });
-  }
-  async saveResource({ resource }) {
-    return this.stores.memory.saveResource({ resource });
-  }
-  async updateResource({
-    resourceId,
-    workingMemory,
-    metadata
-  }) {
-    return this.stores.memory.updateResource({ resourceId, workingMemory, metadata });
-  }
-  async getScoreById({ id: _id }) {
-    return this.stores.scores.getScoreById({ id: _id });
-  }
-  async saveScore(_score) {
-    return this.stores.scores.saveScore(_score);
-  }
-  async listScoresByRunId({
-    runId: _runId,
-    pagination: _pagination
-  }) {
-    return this.stores.scores.listScoresByRunId({ runId: _runId, pagination: _pagination });
-  }
-  async listScoresByEntityId({
-    entityId: _entityId,
-    entityType: _entityType,
-    pagination: _pagination
-  }) {
-    return this.stores.scores.listScoresByEntityId({
-      entityId: _entityId,
-      entityType: _entityType,
-      pagination: _pagination
-    });
-  }
-  async listScoresByScorerId({
-    scorerId,
-    pagination,
-    entityId,
-    entityType,
-    source
-  }) {
-    return this.stores.scores.listScoresByScorerId({ scorerId, pagination, entityId, entityType, source });
-  }
-  async listScoresBySpan({
-    traceId,
-    spanId,
-    pagination
-  }) {
-    return this.stores.scores.listScoresBySpan({ traceId, spanId, pagination });
-  }
   /**
    * Close the database connection
    * No explicit cleanup needed for D1 in either REST or Workers Binding mode
@@ -2157,5 +2178,8 @@ var D1Store = class extends storage.MastraStorage {
 };
 
 exports.D1Store = D1Store;
+exports.MemoryStorageD1 = MemoryStorageD1;
+exports.ScoresStorageD1 = ScoresStorageD1;
+exports.WorkflowsStorageD1 = WorkflowsStorageD1;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map