@mastra/libsql 0.10.2-alpha.0 → 0.10.2-alpha.2

package/.turbo/turbo-build.log

@@ -1,23 +1,23 @@
 
-> @mastra/libsql@0.10.2-alpha.0 build /home/runner/work/mastra/mastra/stores/libsql
+> @mastra/libsql@0.10.2-alpha.2 build /home/runner/work/mastra/mastra/stores/libsql
 > tsup src/index.ts --format esm,cjs --experimental-dts --clean --treeshake=smallest --splitting
 
 CLI Building entry: src/index.ts
 CLI Using tsconfig: tsconfig.json
 CLI tsup v8.5.0
 TSC Build start
-TSC ⚡️ Build success in 9535ms
+TSC ⚡️ Build success in 9592ms
 DTS Build start
 CLI Target: es2022
 Analysis will use the bundled TypeScript version 5.8.3
 Writing package typings: /home/runner/work/mastra/mastra/stores/libsql/dist/_tsup-dts-rollup.d.ts
 Analysis will use the bundled TypeScript version 5.8.3
 Writing package typings: /home/runner/work/mastra/mastra/stores/libsql/dist/_tsup-dts-rollup.d.cts
-DTS ⚡️ Build success in 9079ms
+DTS ⚡️ Build success in 10548ms
 CLI Cleaning output folder
 ESM Build start
 CJS Build start
-ESM dist/index.js 55.48 KB
-ESM ⚡️ Build success in 980ms
-CJS dist/index.cjs 55.76 KB
-CJS ⚡️ Build success in 980ms
+ESM dist/index.js 58.54 KB
+ESM ⚡️ Build success in 1646ms
+CJS dist/index.cjs 58.83 KB
+CJS ⚡️ Build success in 1647ms

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # @mastra/libsql
 
+## 0.10.2-alpha.2
+
+### Patch Changes
+
+- 48eddb9: update filter logic in Memory class to support semantic recall search scope
+- Updated dependencies [48eddb9]
+  - @mastra/core@0.10.4-alpha.2
+
+## 0.10.2-alpha.1
+
+### Patch Changes
+
+- dffb67b: updated stores to add alter table and change tests
+- Updated dependencies [f6fd25f]
+- Updated dependencies [dffb67b]
+- Updated dependencies [f1309d3]
+- Updated dependencies [f7f8293]
+  - @mastra/core@0.10.4-alpha.1
+
 ## 0.10.2-alpha.0
 
 ### Patch Changes

package/dist/_tsup-dts-rollup.d.cts

@@ -84,11 +84,26 @@ declare class LibSQLStore extends MastraStorage {
     private readonly maxRetries;
     private readonly initialBackoffMs;
     constructor(config: LibSQLConfig);
+    get supports(): {
+        selectByIncludeResourceScope: boolean;
+    };
     private getCreateTableSQL;
     createTable({ tableName, schema, }: {
         tableName: TABLE_NAMES;
         schema: Record<string, StorageColumn>;
     }): Promise<void>;
+    protected getSqlType(type: StorageColumn['type']): string;
+    /**
+     * 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
+     */
+    alterTable({ tableName, schema, ifNotExists, }: {
+        tableName: TABLE_NAMES;
+        schema: Record<string, StorageColumn>;
+        ifNotExists: string[];
+    }): Promise<void>;
     clearTable({ tableName }: {
         tableName: TABLE_NAMES;
     }): Promise<void>;

package/dist/_tsup-dts-rollup.d.ts

@@ -84,11 +84,26 @@ declare class LibSQLStore extends MastraStorage {
     private readonly maxRetries;
     private readonly initialBackoffMs;
     constructor(config: LibSQLConfig);
+    get supports(): {
+        selectByIncludeResourceScope: boolean;
+    };
     private getCreateTableSQL;
     createTable({ tableName, schema, }: {
         tableName: TABLE_NAMES;
         schema: Record<string, StorageColumn>;
     }): Promise<void>;
+    protected getSqlType(type: StorageColumn['type']): string;
+    /**
+     * 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
+     */
+    alterTable({ tableName, schema, ifNotExists, }: {
+        tableName: TABLE_NAMES;
+        schema: Record<string, StorageColumn>;
+        ifNotExists: string[];
+    }): Promise<void>;
     clearTable({ tableName }: {
         tableName: TABLE_NAMES;
     }): Promise<void>;

package/dist/index.cjs

@@ -818,6 +818,11 @@ var LibSQLStore = class extends storage.MastraStorage {
       this.client.execute("PRAGMA busy_timeout = 5000;").then(() => this.logger.debug("LibSQLStore: PRAGMA busy_timeout=5000 set.")).catch((err) => this.logger.warn("LibSQLStore: Failed to set PRAGMA busy_timeout.", err));
     }
   }
+  get supports() {
+    return {
+      selectByIncludeResourceScope: true
+    };
+  }
   getCreateTableSQL(tableName, schema) {
     const parsedTableName = utils.parseSqlIdentifier(tableName, "table name");
     const columns = Object.entries(schema).map(([name, col]) => {
@@ -851,6 +856,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 {
@@ -1076,6 +1127,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]
@@ -1092,40 +1147,61 @@ 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) {
+  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));
+    const unionQueries = [];
+    const params = [];
+    for (const inc of include) {
+      const { id, withPreviousMessages = 0, withNextMessages = 0 } = inc;
+      const searchId = inc.threadId || threadId;
+      unionQueries.push(
+        `
+            SELECT * FROM (
+              WITH numbered_messages AS (
+                SELECT
+                  id, content, role, type, "createdAt", thread_id, "resourceId",
+                  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 = ?
+              )
+              SELECT DISTINCT m.*
+              FROM numbered_messages m
+              CROSS JOIN target_positions t
+              WHERE m.row_num BETWEEN (t.target_pos - ?) AND (t.target_pos + ?)
+            ) 
+            `
+        // Keep ASC for final sorting after fetching context
+      );
+      params.push(searchId, id, withPreviousMessages, withNextMessages);
+    }
+    const finalQuery = unionQueries.join(" UNION ALL ") + ' ORDER BY "createdAt" ASC';
+    const includedResult = await this.client.execute({ sql: finalQuery, args: params });
+    const includedRows = includedResult.rows?.map((row) => this.parseRow(row));
+    const dedupedRows = Object.values(
+      includedRows.reduce(
+        (acc, row) => {
+          acc[row.id] = row;
+          return acc;
+        },
+        {}
+      )
+    );
+    return dedupedRows;
   }
   async getMessages({
     threadId,
@@ -1136,19 +1212,27 @@ var LibSQLStore = class extends storage.MastraStorage {
       const messages = [];
       const limit = typeof selectBy?.last === `number` ? selectBy.last : 40;
       if (selectBy?.include?.length) {
-        const includeMessages = await this._getIncludedMessages(threadId, selectBy);
+        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,
+          "resourceId"
+        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 });
       if (remainingResult.rows) {
@@ -1170,7 +1254,7 @@ var LibSQLStore = class extends storage.MastraStorage {
     const toDate = dateRange?.end;
     const messages = [];
     if (selectBy?.include?.length) {
-      const includeMessages = await this._getIncludedMessages(threadId, selectBy);
+      const includeMessages = await this._getIncludedMessages({ threadId, selectBy });
       if (includeMessages) {
         messages.push(...includeMessages);
       }
@@ -1232,16 +1316,27 @@ var LibSQLStore = class extends storage.MastraStorage {
       }
       const batchStatements = messages.map((message) => {
         const time = message.createdAt || /* @__PURE__ */ new Date();
+        if (!message.threadId) {
+          throw new Error(
+            `Expected to find a threadId for message, but couldn't find one. An unexpected error has occurred.`
+          );
+        }
+        if (!message.resourceId) {
+          throw new Error(
+            `Expected to find a resourceId for message, but couldn't find one. An unexpected error has occurred.`
+          );
+        }
         return {
-          sql: `INSERT INTO ${storage.TABLE_MESSAGES} (id, thread_id, content, role, type, createdAt) 
-                VALUES (?, ?, ?, ?, ?, ?)`,
+          sql: `INSERT INTO ${storage.TABLE_MESSAGES} (id, thread_id, content, role, type, createdAt, resourceId) 
+                VALUES (?, ?, ?, ?, ?, ?, ?)`,
           args: [
             message.id,
-            threadId,
+            message.threadId,
             typeof message.content === "object" ? JSON.stringify(message.content) : message.content,
             message.role,
             message.type || "v2",
-            time instanceof Date ? time.toISOString() : time
+            time instanceof Date ? time.toISOString() : time,
+            message.resourceId
           ]
         };
       });

package/dist/index.js

@@ -816,6 +816,11 @@ var LibSQLStore = class extends MastraStorage {
       this.client.execute("PRAGMA busy_timeout = 5000;").then(() => this.logger.debug("LibSQLStore: PRAGMA busy_timeout=5000 set.")).catch((err) => this.logger.warn("LibSQLStore: Failed to set PRAGMA busy_timeout.", err));
     }
   }
+  get supports() {
+    return {
+      selectByIncludeResourceScope: true
+    };
+  }
   getCreateTableSQL(tableName, schema) {
     const parsedTableName = parseSqlIdentifier(tableName, "table name");
     const columns = Object.entries(schema).map(([name, col]) => {
@@ -849,6 +854,52 @@ var LibSQLStore = class extends 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 = 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 = parseSqlIdentifier(tableName, "table name");
     try {
@@ -1074,6 +1125,10 @@ var LibSQLStore = class extends MastraStorage {
     return updatedThread;
   }
   async deleteThread({ threadId }) {
+    await this.client.execute({
+      sql: `DELETE FROM ${TABLE_MESSAGES} WHERE thread_id = ?`,
+      args: [threadId]
+    });
     await this.client.execute({
       sql: `DELETE FROM ${TABLE_THREADS} WHERE id = ?`,
       args: [threadId]
@@ -1090,40 +1145,61 @@ var LibSQLStore = class extends 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) {
+  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 "${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));
+    const unionQueries = [];
+    const params = [];
+    for (const inc of include) {
+      const { id, withPreviousMessages = 0, withNextMessages = 0 } = inc;
+      const searchId = inc.threadId || threadId;
+      unionQueries.push(
+        `
+            SELECT * FROM (
+              WITH numbered_messages AS (
+                SELECT
+                  id, content, role, type, "createdAt", thread_id, "resourceId",
+                  ROW_NUMBER() OVER (ORDER BY "createdAt" ASC) as row_num
+                FROM "${TABLE_MESSAGES}"
+                WHERE thread_id = ?
+              ),
+              target_positions AS (
+                SELECT row_num as target_pos
+                FROM numbered_messages
+                WHERE id = ?
+              )
+              SELECT DISTINCT m.*
+              FROM numbered_messages m
+              CROSS JOIN target_positions t
+              WHERE m.row_num BETWEEN (t.target_pos - ?) AND (t.target_pos + ?)
+            ) 
+            `
+        // Keep ASC for final sorting after fetching context
+      );
+      params.push(searchId, id, withPreviousMessages, withNextMessages);
+    }
+    const finalQuery = unionQueries.join(" UNION ALL ") + ' ORDER BY "createdAt" ASC';
+    const includedResult = await this.client.execute({ sql: finalQuery, args: params });
+    const includedRows = includedResult.rows?.map((row) => this.parseRow(row));
+    const dedupedRows = Object.values(
+      includedRows.reduce(
+        (acc, row) => {
+          acc[row.id] = row;
+          return acc;
+        },
+        {}
+      )
+    );
+    return dedupedRows;
   }
   async getMessages({
     threadId,
@@ -1134,19 +1210,27 @@ var LibSQLStore = class extends MastraStorage {
       const messages = [];
       const limit = typeof selectBy?.last === `number` ? selectBy.last : 40;
       if (selectBy?.include?.length) {
-        const includeMessages = await this._getIncludedMessages(threadId, selectBy);
+        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 "${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,
+          "resourceId"
+        FROM "${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 });
       if (remainingResult.rows) {
@@ -1168,7 +1252,7 @@ var LibSQLStore = class extends MastraStorage {
     const toDate = dateRange?.end;
     const messages = [];
     if (selectBy?.include?.length) {
-      const includeMessages = await this._getIncludedMessages(threadId, selectBy);
+      const includeMessages = await this._getIncludedMessages({ threadId, selectBy });
       if (includeMessages) {
         messages.push(...includeMessages);
       }
@@ -1230,16 +1314,27 @@ var LibSQLStore = class extends MastraStorage {
       }
       const batchStatements = messages.map((message) => {
         const time = message.createdAt || /* @__PURE__ */ new Date();
+        if (!message.threadId) {
+          throw new Error(
+            `Expected to find a threadId for message, but couldn't find one. An unexpected error has occurred.`
+          );
+        }
+        if (!message.resourceId) {
+          throw new Error(
+            `Expected to find a resourceId for message, but couldn't find one. An unexpected error has occurred.`
+          );
+        }
         return {
-          sql: `INSERT INTO ${TABLE_MESSAGES} (id, thread_id, content, role, type, createdAt) 
-                VALUES (?, ?, ?, ?, ?, ?)`,
+          sql: `INSERT INTO ${TABLE_MESSAGES} (id, thread_id, content, role, type, createdAt, resourceId) 
+                VALUES (?, ?, ?, ?, ?, ?, ?)`,
           args: [
             message.id,
-            threadId,
+            message.threadId,
             typeof message.content === "object" ? JSON.stringify(message.content) : message.content,
             message.role,
             message.type || "v2",
-            time instanceof Date ? time.toISOString() : time
+            time instanceof Date ? time.toISOString() : time,
+            message.resourceId
           ]
         };
       });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/libsql",
-  "version": "0.10.2-alpha.0",
+  "version": "0.10.2-alpha.2",
   "description": "Libsql provider for Mastra - includes both vector and db storage capabilities",
   "type": "module",
   "main": "dist/index.js",
@@ -28,9 +28,9 @@
     "eslint": "^9.28.0",
     "tsup": "^8.5.0",
     "typescript": "^5.8.3",
-    "vitest": "^3.1.2",
+    "vitest": "^3.2.2",
     "@internal/lint": "0.0.10",
-    "@mastra/core": "0.10.4-alpha.0",
+    "@mastra/core": "0.10.4-alpha.2",
     "@internal/storage-test-utils": "0.0.6"
   },
   "peerDependencies": {

package/src/storage/index.test.ts

@@ -3,8 +3,9 @@ import {
   createSampleEval,
   createSampleTraceForDB,
   createSampleThread,
-  createSampleMessage,
   createTestSuite,
+  createSampleMessageV1,
+  resetRole,
 } from '@internal/storage-test-utils';
 import type { MastraMessageV1, StorageThreadType } from '@mastra/core';
 import { Mastra } from '@mastra/core/mastra';
@@ -243,16 +244,14 @@ describe('LibSQLStore Pagination Features', () => {
 
   describe('getMessages with pagination', () => {
     it('should return paginated messages with total count', async () => {
+      resetRole();
       const threadData = createSampleThread();
       threadData.resourceId = 'resource-msg-pagination';
       const thread = await store.saveThread({ thread: threadData as StorageThreadType });
 
       const messageRecords: MastraMessageV1[] = [];
       for (let i = 0; i < 15; i++) {
-        messageRecords.push({
-          ...createSampleMessage(thread.id),
-          content: [{ type: 'text', text: `Message ${i + 1}` }],
-        } as MastraMessageV1);
+        messageRecords.push(createSampleMessageV1({ threadId: thread.id, content: `Message ${i + 1}` }));
       }
       await store.saveMessages({ messages: messageRecords });
 
@@ -300,17 +299,21 @@ describe('LibSQLStore Pagination Features', () => {
 
       // Ensure timestamps are distinct for reliable sorting by creating them with a slight delay for testing clarity
       const messagesToSave: MastraMessageV1[] = [];
-      messagesToSave.push(createSampleMessage(thread.id, dayBeforeYesterday));
+      messagesToSave.push(
+        createSampleMessageV1({ threadId: thread.id, content: 'Message 1', createdAt: dayBeforeYesterday }),
+      );
       await new Promise(r => setTimeout(r, 5));
-      messagesToSave.push(createSampleMessage(thread.id, dayBeforeYesterday));
+      messagesToSave.push(
+        createSampleMessageV1({ threadId: thread.id, content: 'Message 2', createdAt: dayBeforeYesterday }),
+      );
       await new Promise(r => setTimeout(r, 5));
-      messagesToSave.push(createSampleMessage(thread.id, yesterday));
+      messagesToSave.push(createSampleMessageV1({ threadId: thread.id, content: 'Message 3', createdAt: yesterday }));
       await new Promise(r => setTimeout(r, 5));
-      messagesToSave.push(createSampleMessage(thread.id, yesterday));
+      messagesToSave.push(createSampleMessageV1({ threadId: thread.id, content: 'Message 4', createdAt: yesterday }));
       await new Promise(r => setTimeout(r, 5));
-      messagesToSave.push(createSampleMessage(thread.id, now));
+      messagesToSave.push(createSampleMessageV1({ threadId: thread.id, content: 'Message 5', createdAt: now }));
       await new Promise(r => setTimeout(r, 5));
-      messagesToSave.push(createSampleMessage(thread.id, now));
+      messagesToSave.push(createSampleMessageV1({ threadId: thread.id, content: 'Message 6', createdAt: now }));
 
       await store.saveMessages({ messages: messagesToSave, format: 'v1' });
       // Total 6 messages: 2 now, 2 yesterday, 2 dayBeforeYesterday (oldest to newest)

package/src/storage/index.ts

@@ -81,6 +81,14 @@ export class LibSQLStore extends MastraStorage {
     }
   }
 
+  public get supports(): {
+    selectByIncludeResourceScope: boolean;
+  } {
+    return {
+      selectByIncludeResourceScope: true,
+    };
+  }
+
   private getCreateTableSQL(tableName: TABLE_NAMES, schema: Record<string, StorageColumn>): string {
     const parsedTableName = parseSqlIdentifier(tableName, 'table name');
     const columns = Object.entries(schema).map(([name, col]) => {
@@ -125,6 +133,63 @@ export class LibSQLStore extends MastraStorage {
     }
   }
 
+  protected getSqlType(type: StorageColumn['type']): string {
+    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,
+  }: {
+    tableName: TABLE_NAMES;
+    schema: Record<string, StorageColumn>;
+    ifNotExists: string[];
+  }): Promise<void> {
+    const parsedTableName = parseSqlIdentifier(tableName, 'table name');
+
+    try {
+      // 1. Get existing columns using PRAGMA
+      const pragmaQuery = `PRAGMA table_info(${parsedTableName})`;
+      const result = await this.client.execute(pragmaQuery);
+      const existingColumnNames = new Set(result.rows.map((row: any) => row.name.toLowerCase()));
+
+      // 2. Add missing columns
+      for (const columnName of ifNotExists) {
+        if (!existingColumnNames.has(columnName.toLowerCase()) && schema[columnName]) {
+          const columnDef = schema[columnName];
+          const sqlType = this.getSqlType(columnDef.type); // ensure this exists or implement
+          const nullable = columnDef.nullable === false ? 'NOT NULL' : '';
+          // In SQLite, you must provide a DEFAULT if adding a NOT NULL column to a non-empty table
+          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 }: { tableName: TABLE_NAMES }): Promise<void> {
     const parsedTableName = parseSqlIdentifier(tableName, 'table name');
     try {
@@ -414,11 +479,16 @@ export class LibSQLStore extends MastraStorage {
   }
 
   async deleteThread({ threadId }: { threadId: string }): Promise<void> {
+    // Delete messages for this thread (manual step)
+    await this.client.execute({
+      sql: `DELETE FROM ${TABLE_MESSAGES} WHERE thread_id = ?`,
+      args: [threadId],
+    });
     await this.client.execute({
       sql: `DELETE FROM ${TABLE_THREADS} WHERE id = ?`,
       args: [threadId],
     });
-    // Messages will be automatically deleted due to CASCADE constraint
+    // TODO: Need to check if CASCADE is enabled so that messages will be automatically deleted due to CASCADE constraint
   }
 
   private parseRow(row: any): MastraMessageV2 {
@@ -434,42 +504,66 @@ export class LibSQLStore extends MastraStorage {
       role: row.role,
       createdAt: new Date(row.createdAt as string),
       threadId: row.thread_id,
+      resourceId: row.resourceId,
     } as MastraMessageV2;
     if (row.type && row.type !== `v2`) result.type = row.type;
     return result;
   }
 
-  private async _getIncludedMessages(threadId: string, selectBy: StorageGetMessagesArg['selectBy']) {
+  private async _getIncludedMessages({
+    threadId,
+    selectBy,
+  }: {
+    threadId: string;
+    selectBy: StorageGetMessagesArg['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 "${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: any) => this.parseRow(row));
+    const unionQueries: string[] = [];
+    const params: any[] = [];
+
+    for (const inc of include) {
+      const { id, withPreviousMessages = 0, withNextMessages = 0 } = inc;
+      // if threadId is provided, use it, otherwise use threadId from args
+      const searchId = inc.threadId || threadId;
+      unionQueries.push(
+        `
+            SELECT * FROM (
+              WITH numbered_messages AS (
+                SELECT
+                  id, content, role, type, "createdAt", thread_id, "resourceId",
+                  ROW_NUMBER() OVER (ORDER BY "createdAt" ASC) as row_num
+                FROM "${TABLE_MESSAGES}"
+                WHERE thread_id = ?
+              ),
+              target_positions AS (
+                SELECT row_num as target_pos
+                FROM numbered_messages
+                WHERE id = ?
+              )
+              SELECT DISTINCT m.*
+              FROM numbered_messages m
+              CROSS JOIN target_positions t
+              WHERE m.row_num BETWEEN (t.target_pos - ?) AND (t.target_pos + ?)
+            ) 
+            `, // Keep ASC for final sorting after fetching context
+      );
+      params.push(searchId, id, withPreviousMessages, withNextMessages);
+    }
+    const finalQuery = unionQueries.join(' UNION ALL ') + ' ORDER BY "createdAt" ASC';
+    const includedResult = await this.client.execute({ sql: finalQuery, args: params });
+    const includedRows = includedResult.rows?.map(row => this.parseRow(row));
+    const dedupedRows = Object.values(
+      includedRows.reduce(
+        (acc, row) => {
+          acc[row.id] = row;
+          return acc;
+        },
+        {} as Record<string, MastraMessageV2>,
+      ),
+    );
+    return dedupedRows;
   }
 
   /**
@@ -489,7 +583,7 @@ export class LibSQLStore extends MastraStorage {
       const limit = typeof selectBy?.last === `number` ? selectBy.last : 40;
 
       if (selectBy?.include?.length) {
-        const includeMessages = await this._getIncludedMessages(threadId, selectBy);
+        const includeMessages = await this._getIncludedMessages({ threadId, selectBy });
         if (includeMessages) {
           messages.push(...includeMessages);
         }
@@ -497,12 +591,20 @@ export class LibSQLStore extends MastraStorage {
 
       const excludeIds = messages.map(m => m.id);
       const remainingSql = `
-          SELECT id, content, role, type, "createdAt", thread_id
-          FROM "${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,
+          "resourceId"
+        FROM "${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 });
       if (remainingResult.rows) {
@@ -531,7 +633,7 @@ export class LibSQLStore extends MastraStorage {
     const messages: MastraMessageV2[] = [];
 
     if (selectBy?.include?.length) {
-      const includeMessages = await this._getIncludedMessages(threadId, selectBy);
+      const includeMessages = await this._getIncludedMessages({ threadId, selectBy });
       if (includeMessages) {
         messages.push(...includeMessages);
       }
@@ -613,16 +715,27 @@ export class LibSQLStore extends MastraStorage {
       // Prepare batch statements for all messages
       const batchStatements = messages.map(message => {
         const time = message.createdAt || new Date();
+        if (!message.threadId) {
+          throw new Error(
+            `Expected to find a threadId for message, but couldn't find one. An unexpected error has occurred.`,
+          );
+        }
+        if (!message.resourceId) {
+          throw new Error(
+            `Expected to find a resourceId for message, but couldn't find one. An unexpected error has occurred.`,
+          );
+        }
         return {
-          sql: `INSERT INTO ${TABLE_MESSAGES} (id, thread_id, content, role, type, createdAt) 
-                VALUES (?, ?, ?, ?, ?, ?)`,
+          sql: `INSERT INTO ${TABLE_MESSAGES} (id, thread_id, content, role, type, createdAt, resourceId) 
+                VALUES (?, ?, ?, ?, ?, ?, ?)`,
           args: [
             message.id,
-            threadId,
+            message.threadId!,
             typeof message.content === 'object' ? JSON.stringify(message.content) : message.content,
             message.role,
             message.type || 'v2',
             time instanceof Date ? time.toISOString() : time,
+            message.resourceId,
           ],
         };
       });