@mastra/libsql 0.10.1 → 0.10.2-alpha.1

package/dist/index.cjs

@@ -851,6 +851,52 @@ var LibSQLStore = class extends storage.MastraStorage {
       throw error;
     }
   }
+  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);
+    }
+  }
+  /**
+   * 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 parsedTableName = utils.parseSqlIdentifier(tableName, "table name");
+    try {
+      const pragmaQuery = `PRAGMA table_info(${parsedTableName})`;
+      const result = await this.client.execute(pragmaQuery);
+      const existingColumnNames = new Set(result.rows.map((row) => row.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 ${parsedTableName} ADD COLUMN "${columnName}" ${sqlType} ${nullable} ${defaultValue}`.trim();
+          await this.client.execute(alterSql);
+          this.logger?.debug?.(`Added column ${columnName} to table ${parsedTableName}`);
+        }
+      }
+    } catch (error) {
+      this.logger?.error?.(
+        `Error altering table ${tableName}: ${error instanceof Error ? error.message : String(error)}`
+      );
+      throw new Error(`Failed to alter table ${tableName}: ${error}`);
+    }
+  }
   async clearTable({ tableName }) {
     const parsedTableName = utils.parseSqlIdentifier(tableName, "table name");
     try {
@@ -964,22 +1010,83 @@ var LibSQLStore = class extends storage.MastraStorage {
       metadata: typeof result.metadata === "string" ? JSON.parse(result.metadata) : result.metadata
     };
   }
-  async getThreadsByResourceId({ resourceId }) {
-    const result = await this.client.execute({
-      sql: `SELECT * FROM ${storage.TABLE_THREADS} WHERE resourceId = ?`,
-      args: [resourceId]
-    });
-    if (!result.rows) {
+  /**
+   * @deprecated use getThreadsByResourceIdPaginated instead for paginated results.
+   */
+  async getThreadsByResourceId(args) {
+    const { resourceId } = args;
+    try {
+      const baseQuery = `FROM ${storage.TABLE_THREADS} WHERE resourceId = ?`;
+      const queryParams = [resourceId];
+      const mapRowToStorageThreadType = (row) => ({
+        id: row.id,
+        resourceId: row.resourceId,
+        title: row.title,
+        createdAt: new Date(row.createdAt),
+        // Convert string to Date
+        updatedAt: new Date(row.updatedAt),
+        // Convert string to Date
+        metadata: typeof row.metadata === "string" ? JSON.parse(row.metadata) : row.metadata
+      });
+      const result = await this.client.execute({
+        sql: `SELECT * ${baseQuery} ORDER BY createdAt DESC`,
+        args: queryParams
+      });
+      if (!result.rows) {
+        return [];
+      }
+      return result.rows.map(mapRowToStorageThreadType);
+    } catch (error) {
+      this.logger.error(`Error getting threads for resource ${resourceId}:`, error);
       return [];
     }
-    return result.rows.map((thread) => ({
-      id: thread.id,
-      resourceId: thread.resourceId,
-      title: thread.title,
-      createdAt: thread.createdAt,
-      updatedAt: thread.updatedAt,
-      metadata: typeof thread.metadata === "string" ? JSON.parse(thread.metadata) : thread.metadata
-    }));
+  }
+  async getThreadsByResourceIdPaginated(args) {
+    const { resourceId, page = 0, perPage = 100 } = args;
+    try {
+      const baseQuery = `FROM ${storage.TABLE_THREADS} WHERE resourceId = ?`;
+      const queryParams = [resourceId];
+      const mapRowToStorageThreadType = (row) => ({
+        id: row.id,
+        resourceId: row.resourceId,
+        title: row.title,
+        createdAt: new Date(row.createdAt),
+        // Convert string to Date
+        updatedAt: new Date(row.updatedAt),
+        // Convert string to Date
+        metadata: typeof row.metadata === "string" ? JSON.parse(row.metadata) : row.metadata
+      });
+      const currentOffset = page * perPage;
+      const countResult = await this.client.execute({
+        sql: `SELECT COUNT(*) as count ${baseQuery}`,
+        args: queryParams
+      });
+      const total = Number(countResult.rows?.[0]?.count ?? 0);
+      if (total === 0) {
+        return {
+          threads: [],
+          total: 0,
+          page,
+          perPage,
+          hasMore: false
+        };
+      }
+      const dataResult = await this.client.execute({
+        sql: `SELECT * ${baseQuery} ORDER BY createdAt DESC LIMIT ? OFFSET ?`,
+        args: [...queryParams, perPage, currentOffset]
+      });
+      const threads = (dataResult.rows || []).map(mapRowToStorageThreadType);
+      return {
+        threads,
+        total,
+        page,
+        perPage,
+        hasMore: currentOffset + threads.length < total
+      };
+    } catch (error) {
+      this.logger.error(`Error getting threads for resource ${resourceId}:`, error);
+      return { threads: [], total: 0, page, perPage, hasMore: false };
+    }
   }
   async saveThread({ thread }) {
     await this.insert({
@@ -1015,6 +1122,10 @@ var LibSQLStore = class extends storage.MastraStorage {
     return updatedThread;
   }
   async deleteThread({ threadId }) {
+    await this.client.execute({
+      sql: `DELETE FROM ${storage.TABLE_MESSAGES} WHERE thread_id = ?`,
+      args: [threadId]
+    });
     await this.client.execute({
       sql: `DELETE FROM ${storage.TABLE_THREADS} WHERE id = ?`,
       args: [threadId]
@@ -1031,11 +1142,42 @@ var LibSQLStore = class extends storage.MastraStorage {
       content,
       role: row.role,
       createdAt: new Date(row.createdAt),
-      threadId: row.thread_id
+      threadId: row.thread_id,
+      resourceId: row.resourceId
     };
     if (row.type && row.type !== `v2`) result.type = row.type;
     return result;
   }
+  async _getIncludedMessages(threadId, selectBy) {
+    const include = selectBy?.include;
+    if (!include) return null;
+    const includeIds = include.map((i) => i.id);
+    const maxPrev = Math.max(...include.map((i) => i.withPreviousMessages || 0));
+    const maxNext = Math.max(...include.map((i) => i.withNextMessages || 0));
+    const includeResult = await this.client.execute({
+      sql: `
+          WITH numbered_messages AS (
+            SELECT 
+              id, content, role, type, "createdAt", thread_id,
+              ROW_NUMBER() OVER (ORDER BY "createdAt" ASC) as row_num
+            FROM "${storage.TABLE_MESSAGES}"
+            WHERE thread_id = ?
+          ),
+          target_positions AS (
+            SELECT row_num as target_pos
+            FROM numbered_messages
+            WHERE id IN (${includeIds.map(() => "?").join(", ")})
+          )
+          SELECT DISTINCT m.*
+          FROM numbered_messages m
+          CROSS JOIN target_positions t
+          WHERE m.row_num BETWEEN (t.target_pos - ?) AND (t.target_pos + ?)
+          ORDER BY m."createdAt" ASC
+        `,
+      args: [threadId, ...includeIds, maxPrev, maxNext]
+    });
+    return includeResult.rows?.map((row) => this.parseRow(row));
+  }
   async getMessages({
     threadId,
     selectBy,
@@ -1045,60 +1187,21 @@ var LibSQLStore = class extends storage.MastraStorage {
       const messages = [];
       const limit = typeof selectBy?.last === `number` ? selectBy.last : 40;
       if (selectBy?.include?.length) {
-        const includeIds = selectBy.include.map((i) => i.id);
-        const maxPrev = Math.max(...selectBy.include.map((i) => i.withPreviousMessages || 0));
-        const maxNext = Math.max(...selectBy.include.map((i) => i.withNextMessages || 0));
-        const includeResult = await this.client.execute({
-          sql: `
-            WITH numbered_messages AS (
-              SELECT 
-                id,
-                content,
-                role,
-                type,
-                "createdAt",
-                thread_id,
-                ROW_NUMBER() OVER (ORDER BY "createdAt" ASC) as row_num
-              FROM "${storage.TABLE_MESSAGES}"
-              WHERE thread_id = ?
-            ),
-            target_positions AS (
-              SELECT row_num as target_pos
-              FROM numbered_messages
-              WHERE id IN (${includeIds.map(() => "?").join(", ")})
-            )
-            SELECT DISTINCT m.*
-            FROM numbered_messages m
-            CROSS JOIN target_positions t
-            WHERE m.row_num BETWEEN (t.target_pos - ?) AND (t.target_pos + ?)
-            ORDER BY m."createdAt" ASC
-          `,
-          args: [threadId, ...includeIds, maxPrev, maxNext]
-        });
-        if (includeResult.rows) {
-          messages.push(...includeResult.rows.map((row) => this.parseRow(row)));
+        const includeMessages = await this._getIncludedMessages(threadId, selectBy);
+        if (includeMessages) {
+          messages.push(...includeMessages);
         }
       }
       const excludeIds = messages.map((m) => m.id);
       const remainingSql = `
-        SELECT 
-          id, 
-          content, 
-          role, 
-          type,
-          "createdAt", 
-          thread_id
-        FROM "${storage.TABLE_MESSAGES}"
-        WHERE thread_id = ?
-        ${excludeIds.length ? `AND id NOT IN (${excludeIds.map(() => "?").join(", ")})` : ""}
-        ORDER BY "createdAt" DESC
-        LIMIT ?
-      `;
+          SELECT id, content, role, type, "createdAt", thread_id
+          FROM "${storage.TABLE_MESSAGES}"
+          WHERE thread_id = ?
+          ${excludeIds.length ? `AND id NOT IN (${excludeIds.map(() => "?").join(", ")})` : ""}
+          ORDER BY "createdAt" DESC LIMIT ?
+        `;
       const remainingArgs = [threadId, ...excludeIds.length ? excludeIds : [], limit];
-      const remainingResult = await this.client.execute({
-        sql: remainingSql,
-        args: remainingArgs
-      });
+      const remainingResult = await this.client.execute({ sql: remainingSql, args: remainingArgs });
       if (remainingResult.rows) {
         messages.push(...remainingResult.rows.map((row) => this.parseRow(row)));
       }
@@ -1111,6 +1214,63 @@ var LibSQLStore = class extends storage.MastraStorage {
       throw error;
     }
   }
+  async getMessagesPaginated(args) {
+    const { threadId, format, selectBy } = args;
+    const { page = 0, perPage = 40, dateRange } = selectBy?.pagination || {};
+    const fromDate = dateRange?.start;
+    const toDate = dateRange?.end;
+    const messages = [];
+    if (selectBy?.include?.length) {
+      const includeMessages = await this._getIncludedMessages(threadId, selectBy);
+      if (includeMessages) {
+        messages.push(...includeMessages);
+      }
+    }
+    try {
+      const currentOffset = page * perPage;
+      const conditions = [`thread_id = ?`];
+      const queryParams = [threadId];
+      if (fromDate) {
+        conditions.push(`"createdAt" >= ?`);
+        queryParams.push(fromDate.toISOString());
+      }
+      if (toDate) {
+        conditions.push(`"createdAt" <= ?`);
+        queryParams.push(toDate.toISOString());
+      }
+      const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+      const countResult = await this.client.execute({
+        sql: `SELECT COUNT(*) as count FROM ${storage.TABLE_MESSAGES} ${whereClause}`,
+        args: queryParams
+      });
+      const total = Number(countResult.rows?.[0]?.count ?? 0);
+      if (total === 0) {
+        return {
+          messages: [],
+          total: 0,
+          page,
+          perPage,
+          hasMore: false
+        };
+      }
+      const dataResult = await this.client.execute({
+        sql: `SELECT id, content, role, type, "createdAt", thread_id FROM ${storage.TABLE_MESSAGES} ${whereClause} ORDER BY "createdAt" DESC LIMIT ? OFFSET ?`,
+        args: [...queryParams, perPage, currentOffset]
+      });
+      messages.push(...(dataResult.rows || []).map((row) => this.parseRow(row)));
+      const messagesToReturn = format === "v1" ? new agent.MessageList().add(messages, "memory").get.all.v1() : new agent.MessageList().add(messages, "memory").get.all.v2();
+      return {
+        messages: messagesToReturn,
+        total,
+        page,
+        perPage,
+        hasMore: currentOffset + messages.length < total
+      };
+    } catch (error) {
+      this.logger.error("Error getting paginated messages:", error);
+      return { messages: [], total: 0, page, perPage, hasMore: false };
+    }
+  }
   async saveMessages({
     messages,
     format
@@ -1169,6 +1329,7 @@ var LibSQLStore = class extends storage.MastraStorage {
       createdAt: row.created_at
     };
   }
+  /** @deprecated use getEvals instead */
   async getEvalsByAgentName(agentName, type) {
     try {
       const baseQuery = `SELECT * FROM ${storage.TABLE_EVALS} WHERE agent_name = ?`;
@@ -1186,93 +1347,150 @@ var LibSQLStore = class extends storage.MastraStorage {
       throw error;
     }
   }
-  // TODO: add types
-  async getTraces({
-    name,
-    scope,
-    page,
-    perPage,
-    attributes,
-    filters,
-    fromDate,
-    toDate
-  } = {
-    page: 0,
-    perPage: 100
-  }) {
-    const limit = perPage;
-    const offset = page * perPage;
-    const args = [];
+  async getEvals(options = {}) {
+    const { agentName, type, page = 0, perPage = 100, dateRange } = options;
+    const fromDate = dateRange?.start;
+    const toDate = dateRange?.end;
     const conditions = [];
-    if (name) {
-      conditions.push("name LIKE CONCAT(?, '%')");
+    const queryParams = [];
+    if (agentName) {
+      conditions.push(`agent_name = ?`);
+      queryParams.push(agentName);
     }
-    if (scope) {
-      conditions.push("scope = ?");
-    }
-    if (attributes) {
-      Object.keys(attributes).forEach((key) => {
-        conditions.push(`attributes->>'$.${key}' = ?`);
-      });
-    }
-    if (filters) {
-      Object.entries(filters).forEach(([key, _value]) => {
-        conditions.push(`${key} = ?`);
-      });
+    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 >= ?");
+      conditions.push(`created_at >= ?`);
+      queryParams.push(fromDate.toISOString());
     }
     if (toDate) {
-      conditions.push("createdAt <= ?");
+      conditions.push(`created_at <= ?`);
+      queryParams.push(toDate.toISOString());
     }
     const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    const countResult = await this.client.execute({
+      sql: `SELECT COUNT(*) as count FROM ${storage.TABLE_EVALS} ${whereClause}`,
+      args: queryParams
+    });
+    const total = Number(countResult.rows?.[0]?.count ?? 0);
+    const currentOffset = page * perPage;
+    const hasMore = currentOffset + perPage < total;
+    if (total === 0) {
+      return {
+        evals: [],
+        total: 0,
+        page,
+        perPage,
+        hasMore: false
+      };
+    }
+    const dataResult = await this.client.execute({
+      sql: `SELECT * FROM ${storage.TABLE_EVALS} ${whereClause} ORDER BY created_at DESC LIMIT ? OFFSET ?`,
+      args: [...queryParams, perPage, currentOffset]
+    });
+    return {
+      evals: dataResult.rows?.map((row) => this.transformEvalRow(row)) ?? [],
+      total,
+      page,
+      perPage,
+      hasMore
+    };
+  }
+  /**
+   * @deprecated use getTracesPaginated instead.
+   */
+  async getTraces(args) {
+    if (args.fromDate || args.toDate) {
+      args.dateRange = {
+        start: args.fromDate,
+        end: args.toDate
+      };
+    }
+    const result = await this.getTracesPaginated(args);
+    return result.traces;
+  }
+  async getTracesPaginated(args) {
+    const { name, scope, page = 0, perPage = 100, attributes, filters, dateRange } = args;
+    const fromDate = dateRange?.start;
+    const toDate = dateRange?.end;
+    const currentOffset = page * perPage;
+    const queryArgs = [];
+    const conditions = [];
     if (name) {
-      args.push(name);
+      conditions.push("name LIKE ?");
+      queryArgs.push(`${name}%`);
     }
     if (scope) {
-      args.push(scope);
+      conditions.push("scope = ?");
+      queryArgs.push(scope);
     }
     if (attributes) {
-      for (const [, value] of Object.entries(attributes)) {
-        args.push(value);
-      }
+      Object.entries(attributes).forEach(([key, value]) => {
+        conditions.push(`json_extract(attributes, '$.${key}') = ?`);
+        queryArgs.push(value);
+      });
     }
     if (filters) {
-      for (const [, value] of Object.entries(filters)) {
-        args.push(value);
-      }
+      Object.entries(filters).forEach(([key, value]) => {
+        conditions.push(`${utils.parseSqlIdentifier(key, "filter key")} = ?`);
+        queryArgs.push(value);
+      });
     }
     if (fromDate) {
-      args.push(fromDate.toISOString());
+      conditions.push("createdAt >= ?");
+      queryArgs.push(fromDate.toISOString());
     }
     if (toDate) {
-      args.push(toDate.toISOString());
+      conditions.push("createdAt <= ?");
+      queryArgs.push(toDate.toISOString());
     }
-    args.push(limit, offset);
-    const result = await this.client.execute({
-      sql: `SELECT * FROM ${storage.TABLE_TRACES} ${whereClause} ORDER BY "startTime" DESC LIMIT ? OFFSET ?`,
-      args
+    const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    const countResult = await this.client.execute({
+      sql: `SELECT COUNT(*) as count FROM ${storage.TABLE_TRACES} ${whereClause}`,
+      args: queryArgs
     });
-    if (!result.rows) {
-      return [];
+    const total = Number(countResult.rows?.[0]?.count ?? 0);
+    if (total === 0) {
+      return {
+        traces: [],
+        total: 0,
+        page,
+        perPage,
+        hasMore: false
+      };
     }
-    return result.rows.map((row) => ({
-      id: row.id,
-      parentSpanId: row.parentSpanId,
-      traceId: row.traceId,
-      name: row.name,
-      scope: row.scope,
-      kind: row.kind,
-      status: safelyParseJSON(row.status),
-      events: safelyParseJSON(row.events),
-      links: safelyParseJSON(row.links),
-      attributes: safelyParseJSON(row.attributes),
-      startTime: row.startTime,
-      endTime: row.endTime,
-      other: safelyParseJSON(row.other),
-      createdAt: row.createdAt
-    }));
+    const dataResult = await this.client.execute({
+      sql: `SELECT * FROM ${storage.TABLE_TRACES} ${whereClause} ORDER BY "startTime" DESC LIMIT ? OFFSET ?`,
+      args: [...queryArgs, perPage, currentOffset]
+    });
+    const traces = dataResult.rows?.map(
+      (row) => ({
+        id: row.id,
+        parentSpanId: row.parentSpanId,
+        traceId: row.traceId,
+        name: row.name,
+        scope: row.scope,
+        kind: row.kind,
+        status: safelyParseJSON(row.status),
+        events: safelyParseJSON(row.events),
+        links: safelyParseJSON(row.links),
+        attributes: safelyParseJSON(row.attributes),
+        startTime: row.startTime,
+        endTime: row.endTime,
+        other: safelyParseJSON(row.other),
+        createdAt: row.createdAt
+      })
+    ) ?? [];
+    return {
+      traces,
+      total,
+      page,
+      perPage,
+      hasMore: currentOffset + traces.length < total
+    };
   }
   async getWorkflowRuns({
     workflowName,