@mastra/cloudflare-d1 0.0.0-vnextWorkflows-20250422081019 → 0.0.0-workflow-deno-20250616115451

package/dist/index.js

@@ -1,9 +1,9 @@
+import { MessageList } from '@mastra/core/agent';
 import { MastraStorage, TABLE_THREADS, TABLE_MESSAGES, TABLE_WORKFLOW_SNAPSHOT, TABLE_TRACES, TABLE_EVALS } from '@mastra/core/storage';
 import Cloudflare from 'cloudflare';
+import { parseSqlIdentifier } from '@mastra/core/utils';
 
 // src/storage/index.ts
-
-// src/storage/sql-builder.ts
 var SqlBuilder = class {
   sql = "";
   params = [];
@@ -13,12 +13,15 @@ var SqlBuilder = class {
     if (!columns || Array.isArray(columns) && columns.length === 0) {
       this.sql = "SELECT *";
     } else {
-      this.sql = `SELECT ${Array.isArray(columns) ? columns.join(", ") : columns}`;
+      const cols = Array.isArray(columns) ? columns : [columns];
+      const parsedCols = cols.map((col) => parseSelectIdentifier(col));
+      this.sql = `SELECT ${parsedCols.join(", ")}`;
     }
     return this;
   }
   from(table) {
-    this.sql += ` FROM ${table}`;
+    const parsedTableName = parseSqlIdentifier(table, "table name");
+    this.sql += ` FROM ${parsedTableName}`;
     return this;
   }
   /**
@@ -55,7 +58,11 @@ var SqlBuilder = class {
     return this;
   }
   orderBy(column, direction = "ASC") {
-    this.sql += ` ORDER BY ${column} ${direction}`;
+    const parsedColumn = parseSqlIdentifier(column, "column name");
+    if (!["ASC", "DESC"].includes(direction)) {
+      throw new Error(`Invalid sort direction: ${direction}`);
+    }
+    this.sql += ` ORDER BY ${parsedColumn} ${direction}`;
     return this;
   }
   limit(count) {
@@ -68,6 +75,10 @@ var SqlBuilder = class {
     this.params.push(count);
     return this;
   }
+  count() {
+    this.sql += "SELECT COUNT(*) AS count";
+    return this;
+  }
   /**
    * Insert a row, or update specific columns on conflict (upsert).
    * @param table Table name
@@ -77,27 +88,33 @@ var SqlBuilder = class {
    * @param updateMap Object mapping columns to update to their new value (e.g. { name: 'excluded.name' })
    */
   insert(table, columns, values, conflictColumns, updateMap) {
-    const placeholders = columns.map(() => "?").join(", ");
+    const parsedTableName = parseSqlIdentifier(table, "table name");
+    const parsedColumns = columns.map((col) => parseSqlIdentifier(col, "column name"));
+    const placeholders = parsedColumns.map(() => "?").join(", ");
     if (conflictColumns && updateMap) {
+      const parsedConflictColumns = conflictColumns.map((col) => parseSqlIdentifier(col, "column name"));
       const updateClause = Object.entries(updateMap).map(([col, expr]) => `${col} = ${expr}`).join(", ");
-      this.sql = `INSERT INTO ${table} (${columns.join(", ")}) VALUES (${placeholders}) ON CONFLICT(${conflictColumns.join(", ")}) DO UPDATE SET ${updateClause}`;
+      this.sql = `INSERT INTO ${parsedTableName} (${parsedColumns.join(", ")}) VALUES (${placeholders}) ON CONFLICT(${parsedConflictColumns.join(", ")}) DO UPDATE SET ${updateClause}`;
       this.params.push(...values);
       return this;
     }
-    this.sql = `INSERT INTO ${table} (${columns.join(", ")}) VALUES (${placeholders})`;
+    this.sql = `INSERT INTO ${parsedTableName} (${parsedColumns.join(", ")}) VALUES (${placeholders})`;
     this.params.push(...values);
     return this;
   }
   // Update operations
   update(table, columns, values) {
-    const setClause = columns.map((col) => `${col} = ?`).join(", ");
-    this.sql = `UPDATE ${table} SET ${setClause}`;
+    const parsedTableName = parseSqlIdentifier(table, "table name");
+    const parsedColumns = columns.map((col) => parseSqlIdentifier(col, "column name"));
+    const setClause = parsedColumns.map((col) => `${col} = ?`).join(", ");
+    this.sql = `UPDATE ${parsedTableName} SET ${setClause}`;
     this.params.push(...values);
     return this;
   }
   // Delete operations
   delete(table) {
-    this.sql = `DELETE FROM ${table}`;
+    const parsedTableName = parseSqlIdentifier(table, "table name");
+    this.sql = `DELETE FROM ${parsedTableName}`;
     return this;
   }
   /**
@@ -108,9 +125,16 @@ var SqlBuilder = class {
    * @returns The builder instance
    */
   createTable(table, columnDefinitions, tableConstraints) {
-    const columns = columnDefinitions.join(", ");
+    const parsedTableName = parseSqlIdentifier(table, "table name");
+    const parsedColumnDefinitions = columnDefinitions.map((def) => {
+      const colName = def.split(/\s+/)[0];
+      if (!colName) throw new Error("Empty column name in definition");
+      parseSqlIdentifier(colName, "column name");
+      return def;
+    });
+    const columns = parsedColumnDefinitions.join(", ");
     const constraints = tableConstraints && tableConstraints.length > 0 ? ", " + tableConstraints.join(", ") : "";
-    this.sql = `CREATE TABLE IF NOT EXISTS ${table} (${columns}${constraints})`;
+    this.sql = `CREATE TABLE IF NOT EXISTS ${parsedTableName} (${columns}${constraints})`;
     return this;
   }
   /**
@@ -133,13 +157,10 @@ var SqlBuilder = class {
    * @returns The builder instance
    */
   createIndex(indexName, tableName, columnName, indexType = "") {
-    this.sql = `CREATE ${indexType ? indexType + " " : ""}INDEX IF NOT EXISTS ${indexName} ON ${tableName}(${columnName})`;
-    return this;
-  }
-  // Raw SQL with params
-  raw(sql, ...params) {
-    this.sql = sql;
-    this.params.push(...params);
+    const parsedIndexName = parseSqlIdentifier(indexName, "index name");
+    const parsedTableName = parseSqlIdentifier(tableName, "table name");
+    const parsedColumnName = parseSqlIdentifier(columnName, "column name");
+    this.sql = `CREATE ${indexType ? indexType + " " : ""}INDEX IF NOT EXISTS ${parsedIndexName} ON ${parsedTableName}(${parsedColumnName})`;
     return this;
   }
   /**
@@ -149,11 +170,12 @@ var SqlBuilder = class {
    * @param exact If true, will not add % wildcards
    */
   like(column, value, exact = false) {
+    const parsedColumnName = parseSqlIdentifier(column, "column name");
     const likeValue = exact ? value : `%${value}%`;
     if (this.whereAdded) {
-      this.sql += ` AND ${column} LIKE ?`;
+      this.sql += ` AND ${parsedColumnName} LIKE ?`;
     } else {
-      this.sql += ` WHERE ${column} LIKE ?`;
+      this.sql += ` WHERE ${parsedColumnName} LIKE ?`;
       this.whereAdded = true;
     }
     this.params.push(likeValue);
@@ -166,11 +188,13 @@ var SqlBuilder = class {
    * @param value The value to match
    */
   jsonLike(column, key, value) {
-    const jsonPattern = `%"${key}":"${value}"%`;
+    const parsedColumnName = parseSqlIdentifier(column, "column name");
+    const parsedKey = parseSqlIdentifier(key, "key name");
+    const jsonPattern = `%"${parsedKey}":"${value}"%`;
     if (this.whereAdded) {
-      this.sql += ` AND ${column} LIKE ?`;
+      this.sql += ` AND ${parsedColumnName} LIKE ?`;
     } else {
-      this.sql += ` WHERE ${column} LIKE ?`;
+      this.sql += ` WHERE ${parsedColumnName} LIKE ?`;
       this.whereAdded = true;
     }
     this.params.push(jsonPattern);
@@ -200,6 +224,15 @@ var SqlBuilder = class {
 function createSqlBuilder() {
   return new SqlBuilder();
 }
+var SQL_IDENTIFIER_PATTERN = /^[a-zA-Z0-9_]+(\s+AS\s+[a-zA-Z0-9_]+)?$/;
+function parseSelectIdentifier(column) {
+  if (column !== "*" && !SQL_IDENTIFIER_PATTERN.test(column)) {
+    throw new Error(
+      `Invalid column name: "${column}". Must be "*" or a valid identifier (letters, numbers, underscores), optionally with "AS alias".`
+    );
+  }
+  return column;
+}
 
 // src/storage/index.ts
 function isArrayOfRecords(value) {
@@ -218,6 +251,9 @@ var D1Store = class extends MastraStorage {
    */
   constructor(config) {
     super({ name: "D1" });
+    if (config.tablePrefix && !/^[a-zA-Z0-9_]*$/.test(config.tablePrefix)) {
+      throw new Error("Invalid tablePrefix: only letters, numbers, and underscores are allowed.");
+    }
     this.tablePrefix = config.tablePrefix || "";
     if ("binding" in config) {
       if (!config.binding) {
@@ -244,30 +280,6 @@ var D1Store = class extends MastraStorage {
   formatSqlParams(params) {
     return params.map((p) => p === void 0 || p === null ? null : p);
   }
-  // Helper method to create SQL indexes for better query performance
-  async createIndexIfNotExists(tableName, columnName, indexType = "") {
-    const fullTableName = this.getTableName(tableName);
-    const indexName = `idx_${tableName}_${columnName}`;
-    try {
-      const checkQuery = createSqlBuilder().checkIndexExists(indexName, fullTableName);
-      const { sql: checkSql, params: checkParams } = checkQuery.build();
-      const indexExists = await this.executeQuery({
-        sql: checkSql,
-        params: checkParams,
-        first: true
-      });
-      if (!indexExists) {
-        const createQuery = createSqlBuilder().createIndex(indexName, fullTableName, columnName, indexType);
-        const { sql: createSql, params: createParams } = createQuery.build();
-        await this.executeQuery({ sql: createSql, params: createParams });
-        this.logger.debug(`Created index ${indexName} on ${fullTableName}(${columnName})`);
-      }
-    } catch (error) {
-      this.logger.error(`Error creating index on ${fullTableName}(${columnName}):`, {
-        message: error instanceof Error ? error.message : String(error)
-      });
-    }
-  }
   async executeWorkersBindingQuery({
     sql,
     params = [],
@@ -371,34 +383,25 @@ var D1Store = class extends MastraStorage {
       throw new Error(`D1 query error: ${error.message}`);
     }
   }
-  // Helper to convert storage type to SQL type
-  getSqlType(type) {
-    switch (type) {
-      case "text":
-        return "TEXT";
-      case "timestamp":
-        return "TIMESTAMP";
-      case "integer":
-        return "INTEGER";
-      case "bigint":
-        return "INTEGER";
-      // SQLite doesn't have a separate BIGINT type
-      case "jsonb":
-        return "TEXT";
-      // Store JSON as TEXT in SQLite
-      default:
-        return "TEXT";
+  // Helper to get existing table columns
+  async getTableColumns(tableName) {
+    try {
+      const sql = `PRAGMA table_info(${tableName})`;
+      const result = await this.executeQuery({ sql, params: [] });
+      if (!result || !Array.isArray(result)) {
+        return [];
+      }
+      return result.map((row) => ({
+        name: row.name,
+        type: row.type
+      }));
+    } catch (error) {
+      this.logger.error(`Error getting table columns for ${tableName}:`, {
+        message: error instanceof Error ? error.message : String(error)
+      });
+      return [];
     }
   }
-  ensureDate(date) {
-    if (!date) return void 0;
-    return date instanceof Date ? date : new Date(date);
-  }
-  serializeDate(date) {
-    if (!date) return void 0;
-    const dateObj = this.ensureDate(date);
-    return dateObj?.toISOString();
-  }
   // Helper to serialize objects to JSON strings
   serializeValue(value) {
     if (value === null || value === void 0) return null;
@@ -432,6 +435,18 @@ var D1Store = class extends MastraStorage {
     }
     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
@@ -459,6 +474,39 @@ var D1Store = class extends MastraStorage {
       throw new Error(`Failed to create table ${fullTableName}: ${error}`);
     }
   }
+  /**
+   * 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
+  }) {
+    const fullTableName = this.getTableName(tableName);
+    try {
+      const existingColumns = await this.getTableColumns(fullTableName);
+      const existingColumnNames = new Set(existingColumns.map((col) => col.name.toLowerCase()));
+      for (const columnName of ifNotExists) {
+        if (!existingColumnNames.has(columnName.toLowerCase()) && schema[columnName]) {
+          const columnDef = schema[columnName];
+          const sqlType = this.getSqlType(columnDef.type);
+          const nullable = columnDef.nullable === false ? "NOT NULL" : "";
+          const defaultValue = columnDef.nullable === false ? this.getDefaultValue(columnDef.type) : "";
+          const alterSql = `ALTER TABLE ${fullTableName} ADD COLUMN ${columnName} ${sqlType} ${nullable} ${defaultValue}`.trim();
+          await this.executeQuery({ sql: alterSql, params: [] });
+          this.logger.debug(`Added column ${columnName} to table ${fullTableName}`);
+        }
+      }
+    } catch (error) {
+      this.logger.error(`Error altering table ${fullTableName}:`, {
+        message: error instanceof Error ? error.message : String(error)
+      });
+      throw new Error(`Failed to alter table ${fullTableName}: ${error}`);
+    }
+  }
   async clearTable({ tableName }) {
     const fullTableName = this.getTableName(tableName);
     try {
@@ -490,7 +538,8 @@ var D1Store = class extends MastraStorage {
     try {
       await this.executeQuery({ sql, params });
     } catch (error) {
-      this.logger.error(`Error inserting into ${fullTableName}:`, { error });
+      const message = error instanceof Error ? error.message : String(error);
+      this.logger.error(`Error inserting into ${fullTableName}:`, { message });
       throw new Error(`Failed to insert into ${fullTableName}: ${error}`);
     }
   }
@@ -543,6 +592,9 @@ var D1Store = class extends MastraStorage {
       return null;
     }
   }
+  /**
+   * @deprecated use getThreadsByResourceIdPaginated instead
+   */
   async getThreadsByResourceId({ resourceId }) {
     const fullTableName = this.getTableName(TABLE_THREADS);
     try {
@@ -562,6 +614,29 @@ var D1Store = class extends MastraStorage {
       return [];
     }
   }
+  async getThreadsByResourceIdPaginated(args) {
+    const { resourceId, page, perPage } = args;
+    const fullTableName = this.getTableName(TABLE_THREADS);
+    const mapRowToStorageThreadType = (row) => ({
+      ...row,
+      createdAt: this.ensureDate(row.createdAt),
+      updatedAt: this.ensureDate(row.updatedAt),
+      metadata: typeof row.metadata === "string" ? JSON.parse(row.metadata || "{}") : row.metadata || {}
+    });
+    const countQuery = createSqlBuilder().count().from(fullTableName).where("resourceId = ?", resourceId);
+    const countResult = await this.executeQuery(countQuery.build());
+    const total = Number(countResult?.[0]?.count ?? 0);
+    const selectQuery = createSqlBuilder().select("*").from(fullTableName).where("resourceId = ?", resourceId).orderBy("createdAt", "DESC").limit(perPage).offset(page * perPage);
+    const results = await this.executeQuery(selectQuery.build());
+    const threads = results.map(mapRowToStorageThreadType);
+    return {
+      threads,
+      total,
+      page,
+      perPage,
+      hasMore: page * perPage + threads.length < total
+    };
+  }
   async saveThread({ thread }) {
     const fullTableName = this.getTableName(TABLE_THREADS);
     const threadToSave = {
@@ -588,7 +663,8 @@ var D1Store = class extends MastraStorage {
       await this.executeQuery({ sql, params });
       return thread;
     } catch (error) {
-      this.logger.error(`Error saving thread to ${fullTableName}:`, { error });
+      const message = error instanceof Error ? error.message : String(error);
+      this.logger.error(`Error saving thread to ${fullTableName}:`, { message });
       throw error;
     }
   }
@@ -622,7 +698,8 @@ var D1Store = class extends MastraStorage {
         updatedAt: /* @__PURE__ */ new Date()
       };
     } catch (error) {
-      this.logger.error("Error updating thread:", { error });
+      const message = error instanceof Error ? error.message : String(error);
+      this.logger.error("Error updating thread:", { message });
       throw error;
     }
   }
@@ -643,11 +720,12 @@ var D1Store = class extends MastraStorage {
       throw new Error(`Failed to delete thread ${threadId}: ${error}`);
     }
   }
-  // Thread and message management methods
-  async saveMessages({ messages }) {
+  async saveMessages(args) {
+    const { messages, format = "v1" } = args;
     if (messages.length === 0) return [];
     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`);
@@ -666,36 +744,42 @@ var D1Store = class extends MastraStorage {
           content: typeof message.content === "string" ? message.content : JSON.stringify(message.content),
           createdAt: createdAt.toISOString(),
           role: message.role,
-          type: message.type
+          type: message.type || "v2",
+          resourceId: message.resourceId
         };
       });
-      await this.batchInsert({
-        tableName: TABLE_MESSAGES,
-        records: messagesToInsert
-      });
+      await Promise.all([
+        this.batchInsert({
+          tableName: TABLE_MESSAGES,
+          records: messagesToInsert
+        }),
+        // Update thread's updatedAt timestamp
+        this.executeQuery({
+          sql: `UPDATE ${this.getTableName(TABLE_THREADS)} SET updatedAt = ? WHERE id = ?`,
+          params: [now.toISOString(), threadId]
+        })
+      ]);
       this.logger.debug(`Saved ${messages.length} messages`);
-      return messages;
+      const list = new MessageList().add(messages, "memory");
+      if (format === `v2`) return list.get.all.v2();
+      return list.get.all.v1();
     } catch (error) {
       this.logger.error("Error saving messages:", { message: error instanceof Error ? error.message : String(error) });
       throw error;
     }
   }
-  async getMessages({ threadId, selectBy }) {
-    const fullTableName = this.getTableName(TABLE_MESSAGES);
-    const limit = typeof selectBy?.last === "number" ? selectBy.last : 40;
-    const include = selectBy?.include || [];
-    const messages = [];
-    try {
-      if (include.length) {
-        const prevMax = Math.max(...include.map((i) => i.withPreviousMessages || 0));
-        const nextMax = Math.max(...include.map((i) => i.withNextMessages || 0));
-        const includeIds = include.map((i) => i.id);
-        const sql2 = `
+  async _getIncludedMessages(threadId, selectBy) {
+    const include = selectBy?.include;
+    if (!include) return null;
+    const prevMax = Math.max(...include.map((i) => i.withPreviousMessages || 0));
+    const nextMax = Math.max(...include.map((i) => i.withNextMessages || 0));
+    const includeIds = include.map((i) => i.id);
+    const sql = `
         WITH ordered_messages AS (
           SELECT
             *,
             ROW_NUMBER() OVER (ORDER BY createdAt DESC) AS row_num
-          FROM ${fullTableName}
+          FROM ${this.getTableName(TABLE_MESSAGES)}
           WHERE thread_id = ?
         )
         SELECT
@@ -704,7 +788,7 @@ var D1Store = class extends MastraStorage {
           m.role,
           m.type,
           m.createdAt,
-          m.thread_id AS "threadId"
+          m.thread_id AS threadId
         FROM ordered_messages m
         WHERE m.id IN (${includeIds.map(() => "?").join(",")})
         OR EXISTS (
@@ -718,20 +802,38 @@ var D1Store = class extends MastraStorage {
         )
         ORDER BY m.createdAt DESC
       `;
-        const params2 = [
-          threadId,
-          ...includeIds,
-          // for m.id IN (...)
-          ...includeIds,
-          // for target.id IN (...)
-          prevMax,
-          nextMax
-        ];
-        const includeResult = await this.executeQuery({ sql: sql2, params: params2 });
+    const params = [
+      threadId,
+      ...includeIds,
+      // for m.id IN (...)
+      ...includeIds,
+      // for target.id IN (...)
+      prevMax,
+      nextMax
+    ];
+    const messages = await this.executeQuery({ sql, params });
+    return messages;
+  }
+  async getMessages({
+    threadId,
+    selectBy,
+    format
+  }) {
+    const fullTableName = this.getTableName(TABLE_MESSAGES);
+    const limit = typeof selectBy?.last === "number" ? selectBy.last : 40;
+    const include = selectBy?.include || [];
+    const messages = [];
+    try {
+      if (include.length) {
+        const includeResult = await this._getIncludedMessages(threadId, selectBy);
         if (Array.isArray(includeResult)) messages.push(...includeResult);
       }
       const excludeIds = messages.map((m) => m.id);
-      let query = createSqlBuilder().select(["id", "content", "role", "type", '"createdAt"', 'thread_id AS "threadId"']).from(fullTableName).where("thread_id = ?", threadId).andWhere(`id NOT IN (${excludeIds.map(() => "?").join(",")})`, ...excludeIds).orderBy("createdAt", "DESC").limit(limit);
+      const query = createSqlBuilder().select(["id", "content", "role", "type", "createdAt", "thread_id AS threadId"]).from(fullTableName).where("thread_id = ?", threadId);
+      if (excludeIds.length > 0) {
+        query.andWhere(`id NOT IN (${excludeIds.map(() => "?").join(",")})`, ...excludeIds);
+      }
+      query.orderBy("createdAt", "DESC").limit(limit);
       const { sql, params } = query.build();
       const result = await this.executeQuery({ sql, params });
       if (Array.isArray(result)) messages.push(...result);
@@ -745,12 +847,15 @@ var D1Store = class extends MastraStorage {
       const processedMessages = messages.map((message) => {
         const processedMsg = {};
         for (const [key, value] of Object.entries(message)) {
+          if (key === `type` && value === `v2`) continue;
           processedMsg[key] = this.deserializeValue(value);
         }
         return processedMsg;
       });
       this.logger.debug(`Retrieved ${messages.length} messages for thread ${threadId}`);
-      return processedMessages;
+      const list = new MessageList().add(processedMessages, "memory");
+      if (format === `v2`) return list.get.all.v2();
+      return list.get.all.v1();
     } catch (error) {
       this.logger.error("Error retrieving messages for thread", {
         threadId,
@@ -759,6 +864,47 @@ var D1Store = class extends MastraStorage {
       return [];
     }
   }
+  async getMessagesPaginated({
+    threadId,
+    selectBy,
+    format
+  }) {
+    const { dateRange, page = 0, perPage = 40 } = selectBy?.pagination || {};
+    const { start: fromDate, end: toDate } = dateRange || {};
+    const fullTableName = this.getTableName(TABLE_MESSAGES);
+    const messages = [];
+    if (selectBy?.include?.length) {
+      const includeResult = await this._getIncludedMessages(threadId, selectBy);
+      if (Array.isArray(includeResult)) messages.push(...includeResult);
+    }
+    const countQuery = createSqlBuilder().count().from(fullTableName).where("thread_id = ?", threadId);
+    if (fromDate) {
+      countQuery.andWhere("createdAt >= ?", this.serializeDate(fromDate));
+    }
+    if (toDate) {
+      countQuery.andWhere("createdAt <= ?", this.serializeDate(toDate));
+    }
+    const countResult = await this.executeQuery(countQuery.build());
+    const total = Number(countResult[0]?.count ?? 0);
+    const query = createSqlBuilder().select(["id", "content", "role", "type", "createdAt", "thread_id AS threadId"]).from(fullTableName).where("thread_id = ?", threadId);
+    if (fromDate) {
+      query.andWhere("createdAt >= ?", this.serializeDate(fromDate));
+    }
+    if (toDate) {
+      query.andWhere("createdAt <= ?", this.serializeDate(toDate));
+    }
+    query.orderBy("createdAt", "DESC").limit(perPage).offset(page * perPage);
+    const results = await this.executeQuery(query.build());
+    const list = new MessageList().add(results, "memory");
+    messages.push(...format === `v2` ? list.get.all.v2() : list.get.all.v1());
+    return {
+      messages,
+      total,
+      page,
+      perPage,
+      hasMore: page * perPage + messages.length < total
+    };
+  }
   async persistWorkflowSnapshot({
     workflowName,
     runId,
@@ -851,12 +997,17 @@ var D1Store = class extends MastraStorage {
       throw new Error(`Failed to batch insert into ${tableName}: ${error}`);
     }
   }
+  /**
+   * @deprecated use getTracesPaginated instead
+   */
   async getTraces({
     name,
     scope,
     page,
     perPage,
-    attributes
+    attributes,
+    fromDate,
+    toDate
   }) {
     const fullTableName = this.getTableName(TABLE_TRACES);
     try {
@@ -872,22 +1023,89 @@ var D1Store = class extends MastraStorage {
           query.jsonLike("attributes", key, value);
         }
       }
-      query.orderBy("startTime", "DESC").limit(perPage).offset((page - 1) * perPage);
+      if (fromDate) {
+        query.andWhere("createdAt >= ?", fromDate instanceof Date ? fromDate.toISOString() : fromDate);
+      }
+      if (toDate) {
+        query.andWhere("createdAt <= ?", toDate instanceof Date ? toDate.toISOString() : toDate);
+      }
+      query.orderBy("startTime", "DESC").limit(perPage).offset(page * perPage);
       const { sql, params } = query.build();
       const results = await this.executeQuery({ sql, params });
-      return isArrayOfRecords(results) ? results.map((trace) => ({
-        ...trace,
-        attributes: this.deserializeValue(trace.attributes, "jsonb"),
-        status: this.deserializeValue(trace.status, "jsonb"),
-        events: this.deserializeValue(trace.events, "jsonb"),
-        links: this.deserializeValue(trace.links, "jsonb"),
-        other: this.deserializeValue(trace.other, "jsonb")
-      })) : [];
+      return isArrayOfRecords(results) ? results.map(
+        (trace) => ({
+          ...trace,
+          attributes: this.deserializeValue(trace.attributes, "jsonb"),
+          status: this.deserializeValue(trace.status, "jsonb"),
+          events: this.deserializeValue(trace.events, "jsonb"),
+          links: this.deserializeValue(trace.links, "jsonb"),
+          other: this.deserializeValue(trace.other, "jsonb")
+        })
+      ) : [];
     } catch (error) {
       this.logger.error("Error getting traces:", { message: error instanceof Error ? error.message : String(error) });
       return [];
     }
   }
+  async getTracesPaginated(args) {
+    const { name, scope, page, perPage, attributes, fromDate, toDate } = args;
+    const fullTableName = this.getTableName(TABLE_TRACES);
+    try {
+      const dataQuery = createSqlBuilder().select("*").from(fullTableName).where("1=1");
+      const countQuery = createSqlBuilder().count().from(fullTableName).where("1=1");
+      if (name) {
+        dataQuery.andWhere("name LIKE ?", `%${name}%`);
+        countQuery.andWhere("name LIKE ?", `%${name}%`);
+      }
+      if (scope) {
+        dataQuery.andWhere("scope = ?", scope);
+        countQuery.andWhere("scope = ?", scope);
+      }
+      if (attributes && Object.keys(attributes).length > 0) {
+        for (const [key, value] of Object.entries(attributes)) {
+          dataQuery.jsonLike("attributes", key, value);
+          countQuery.jsonLike("attributes", key, value);
+        }
+      }
+      if (fromDate) {
+        const fromDateStr = fromDate instanceof Date ? fromDate.toISOString() : fromDate;
+        dataQuery.andWhere("createdAt >= ?", fromDateStr);
+        countQuery.andWhere("createdAt >= ?", fromDateStr);
+      }
+      if (toDate) {
+        const toDateStr = toDate instanceof Date ? toDate.toISOString() : toDate;
+        dataQuery.andWhere("createdAt <= ?", toDateStr);
+        countQuery.andWhere("createdAt <= ?", toDateStr);
+      }
+      const countResult = await this.executeQuery(countQuery.build());
+      const total = Number(countResult?.[0]?.count ?? 0);
+      dataQuery.orderBy("startTime", "DESC").limit(perPage).offset(page * perPage);
+      const results = await this.executeQuery(dataQuery.build());
+      const traces = isArrayOfRecords(results) ? results.map(
+        (trace) => ({
+          ...trace,
+          attributes: this.deserializeValue(trace.attributes, "jsonb"),
+          status: this.deserializeValue(trace.status, "jsonb"),
+          events: this.deserializeValue(trace.events, "jsonb"),
+          links: this.deserializeValue(trace.links, "jsonb"),
+          other: this.deserializeValue(trace.other, "jsonb")
+        })
+      ) : [];
+      return {
+        traces,
+        total,
+        page,
+        perPage,
+        hasMore: page * perPage + traces.length < total
+      };
+    } catch (error) {
+      this.logger.error("Error getting traces:", { message: error instanceof Error ? error.message : String(error) });
+      return { traces: [], total: 0, page, perPage, hasMore: false };
+    }
+  }
+  /**
+   * @deprecated use getEvals instead
+   */
   async getEvalsByAgentName(agentName, type) {
     const fullTableName = this.getTableName(TABLE_EVALS);
     try {
@@ -923,8 +1141,181 @@ var D1Store = class extends MastraStorage {
       return [];
     }
   }
-  getWorkflowRuns(_args) {
-    throw new Error("Method not implemented.");
+  async getEvals(options) {
+    const { agentName, type, page = 0, perPage = 40, fromDate, toDate } = options || {};
+    const fullTableName = this.getTableName(TABLE_EVALS);
+    const conditions = [];
+    const queryParams = [];
+    if (agentName) {
+      conditions.push(`agent_name = ?`);
+      queryParams.push(agentName);
+    }
+    if (type === "test") {
+      conditions.push(`(test_info IS NOT NULL AND json_extract(test_info, '$.testPath') IS NOT NULL)`);
+    } else if (type === "live") {
+      conditions.push(`(test_info IS NULL OR json_extract(test_info, '$.testPath') IS NULL)`);
+    }
+    if (fromDate) {
+      conditions.push(`createdAt >= ?`);
+      queryParams.push(this.serializeDate(fromDate));
+    }
+    if (toDate) {
+      conditions.push(`createdAt <= ?`);
+      queryParams.push(this.serializeDate(toDate));
+    }
+    const countQueryBuilder = createSqlBuilder().count().from(fullTableName);
+    if (conditions.length > 0) {
+      countQueryBuilder.where(conditions.join(" AND "), ...queryParams);
+    }
+    const { sql: countSql, params: countParams } = countQueryBuilder.build();
+    const countResult = await this.executeQuery({ sql: countSql, params: countParams, first: true });
+    const total = Number(countResult?.count || 0);
+    const currentOffset = page * perPage;
+    if (total === 0) {
+      return {
+        evals: [],
+        total: 0,
+        page,
+        perPage,
+        hasMore: false
+      };
+    }
+    const dataQueryBuilder = createSqlBuilder().select("*").from(fullTableName);
+    if (conditions.length > 0) {
+      dataQueryBuilder.where(conditions.join(" AND "), ...queryParams);
+    }
+    dataQueryBuilder.orderBy("createdAt", "DESC").limit(perPage).offset(currentOffset);
+    const { sql: dataSql, params: dataParams } = dataQueryBuilder.build();
+    const rows = await this.executeQuery({ sql: dataSql, params: dataParams });
+    const evals = (isArrayOfRecords(rows) ? rows : []).map((row) => {
+      const result = this.deserializeValue(row.result);
+      const testInfo = row.test_info ? this.deserializeValue(row.test_info) : void 0;
+      if (!result || typeof result !== "object" || !("score" in result)) {
+        throw new Error(`Invalid MetricResult format: ${JSON.stringify(result)}`);
+      }
+      return {
+        input: row.input,
+        output: row.output,
+        result,
+        agentName: row.agent_name,
+        metricName: row.metric_name,
+        instructions: row.instructions,
+        testInfo,
+        globalRunId: row.global_run_id,
+        runId: row.run_id,
+        createdAt: row.createdAt
+      };
+    });
+    const hasMore = currentOffset + evals.length < total;
+    return {
+      evals,
+      total,
+      page,
+      perPage,
+      hasMore
+    };
+  }
+  parseWorkflowRun(row) {
+    let parsedSnapshot = row.snapshot;
+    if (typeof parsedSnapshot === "string") {
+      try {
+        parsedSnapshot = JSON.parse(row.snapshot);
+      } catch (e) {
+        console.warn(`Failed to parse snapshot for workflow ${row.workflow_name}: ${e}`);
+      }
+    }
+    return {
+      workflowName: row.workflow_name,
+      runId: row.run_id,
+      snapshot: parsedSnapshot,
+      createdAt: this.ensureDate(row.createdAt),
+      updatedAt: this.ensureDate(row.updatedAt),
+      resourceId: row.resourceId
+    };
+  }
+  async hasColumn(table, column) {
+    const sql = `PRAGMA table_info(${table});`;
+    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());
+  }
+  async getWorkflowRuns({
+    workflowName,
+    fromDate,
+    toDate,
+    limit,
+    offset,
+    resourceId
+  } = {}) {
+    const fullTableName = this.getTableName(TABLE_WORKFLOW_SNAPSHOT);
+    try {
+      const builder = createSqlBuilder().select().from(fullTableName);
+      const countBuilder = createSqlBuilder().count().from(fullTableName);
+      if (workflowName) builder.whereAnd("workflow_name = ?", workflowName);
+      if (resourceId) {
+        const hasResourceId = await this.hasColumn(fullTableName, "resourceId");
+        if (hasResourceId) {
+          builder.whereAnd("resourceId = ?", resourceId);
+          countBuilder.whereAnd("resourceId = ?", resourceId);
+        } else {
+          console.warn(`[${fullTableName}] resourceId column not found. Skipping resourceId filter.`);
+        }
+      }
+      if (fromDate) {
+        builder.whereAnd("createdAt >= ?", fromDate instanceof Date ? fromDate.toISOString() : fromDate);
+        countBuilder.whereAnd("createdAt >= ?", fromDate instanceof Date ? fromDate.toISOString() : fromDate);
+      }
+      if (toDate) {
+        builder.whereAnd("createdAt <= ?", toDate instanceof Date ? toDate.toISOString() : toDate);
+        countBuilder.whereAnd("createdAt <= ?", toDate instanceof Date ? toDate.toISOString() : toDate);
+      }
+      builder.orderBy("createdAt", "DESC");
+      if (typeof limit === "number") builder.limit(limit);
+      if (typeof offset === "number") builder.offset(offset);
+      const { sql, params } = builder.build();
+      let total = 0;
+      if (limit !== void 0 && offset !== void 0) {
+        const { sql: countSql, params: countParams } = countBuilder.build();
+        const countResult = await this.executeQuery({ sql: countSql, params: countParams, first: true });
+        total = Number(countResult?.count ?? 0);
+      }
+      const results = await this.executeQuery({ sql, params });
+      const runs = (isArrayOfRecords(results) ? results : []).map((row) => this.parseWorkflowRun(row));
+      return { runs, total: total || runs.length };
+    } catch (error) {
+      this.logger.error("Error getting workflow runs:", {
+        message: error instanceof Error ? error.message : String(error)
+      });
+      throw error;
+    }
+  }
+  async getWorkflowRunById({
+    runId,
+    workflowName
+  }) {
+    const fullTableName = this.getTableName(TABLE_WORKFLOW_SNAPSHOT);
+    try {
+      const conditions = [];
+      const params = [];
+      if (runId) {
+        conditions.push("run_id = ?");
+        params.push(runId);
+      }
+      if (workflowName) {
+        conditions.push("workflow_name = ?");
+        params.push(workflowName);
+      }
+      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.executeQuery({ sql, params, first: true });
+      if (!result) return null;
+      return this.parseWorkflowRun(result);
+    } catch (error) {
+      this.logger.error("Error getting workflow run by ID:", {
+        message: error instanceof Error ? error.message : String(error)
+      });
+      throw error;
+    }
   }
   /**
    * Close the database connection