@mastra/libsql 1.26.1 → 1.26.2-alpha.0

package/dist/docs/SKILL.md

@@ -3,7 +3,7 @@ name: mastra-libsql
 description: Documentation for @mastra/libsql. Use when working with @mastra/libsql APIs, configuration, or implementation.
 metadata:
   package: "@mastra/libsql"
-  version: "1.26.1"
+  version: "1.26.2-alpha.0"
 ---
 
 ## When to use

package/dist/docs/assets/SOURCE_MAP.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.26.1",
+  "version": "1.26.2-alpha.0",
   "package": "@mastra/libsql",
   "exports": {},
   "modules": {}

package/dist/docs/references/docs-memory-overview.md

@@ -151,6 +151,37 @@ const response = await memoryAgent.generate("What's my favorite color?", {
 
 To list all threads for a resource, or retrieve a specific thread, [use the memory API directly](https://mastra.ai/docs/memory/message-history).
 
+### Identify memory with scopes
+
+Instead of a `memory` object, you can pass `scopes`: the addresses a run acts as, written as `<type>:<value>`. Memory reads the resource from a `resource:` scope and the thread from a `thread:` scope. Other scopes, such as `org:acme`, are passed to tools and processors.
+
+```typescript
+const response = await memoryAgent.generate('Remember my favorite color is blue.', {
+  scopes: ['org:acme', 'resource:user-123', 'thread:conversation-123'],
+})
+```
+
+Scopes can also come from the agent and from the request context. Mastra combines all three sources:
+
+```typescript
+export const memoryAgent = new Agent({
+  id: 'memory-agent',
+  name: 'Memory Agent',
+  scopes: ({ requestContext }) => {
+    // Set by your auth middleware. Request bodies can fill unreserved keys.
+    const orgId = requestContext.get('org-id')
+    return orgId ? [`org:${orgId}`] : []
+  },
+  memory: new Memory(),
+})
+```
+
+The resolver's inputs must come from the server, not the client: a request body can set any request context key that isn't reserved. Trusted server middleware can also set scopes directly with the `MASTRA_SCOPES_KEY` request context key. Visit [Request Context](https://mastra.ai/docs/server/request-context) for details. Clients can't send scopes in a request body.
+
+You can mix scopes with `memory.resource`, `memory.thread`, or the resource and thread request context keys, as long as they agree. If a `resource:` or `thread:` scope names a different value than another source, the call throws an error.
+
+Tools, processors, and subagents receive the run's other scopes, but not its `resource:` and `thread:` scopes. Each nested agent call picks its own resource and thread.
+
 ## Observational Memory
 
 Long conversations can fill the context window with raw message history and reduce agent performance. [Observational Memory](https://mastra.ai/docs/memory/observational-memory) uses background agents to compress older messages into observations. This reduces the context used by message history while retaining information for later turns.

package/dist/index.cjs

@@ -11823,8 +11823,10 @@ var NotificationsLibSQL = class NotificationsLibSQL extends _mastra_core_storage
 	async init() {
 		await this.#db.createTable({
 			tableName: _mastra_core_storage.TABLE_NOTIFICATIONS,
-			schema: _mastra_core_storage.TABLE_SCHEMAS[_mastra_core_storage.TABLE_NOTIFICATIONS]
+			schema: _mastra_core_storage.TABLE_SCHEMAS[_mastra_core_storage.TABLE_NOTIFICATIONS],
+			compositePrimaryKey: _mastra_core_storage.TABLE_CONFIGS[_mastra_core_storage.TABLE_NOTIFICATIONS]?.compositePrimaryKey
 		});
+		await this.ensureUniqueKey();
 		await this.#client.batch([
 			{
 				sql: `CREATE INDEX IF NOT EXISTS idx_notifications_thread_status_updated ON "${_mastra_core_storage.TABLE_NOTIFICATIONS}" ("threadId", "status", "updatedAt")`,
@@ -11840,6 +11842,21 @@ var NotificationsLibSQL = class NotificationsLibSQL extends _mastra_core_storage
 			}
 		], "write");
 	}
+	/**
+	* Tables created before the composite primary key was declared have no key.
+	* SQLite cannot add a primary key in place, so enforce the same uniqueness with
+	* a unique index. Tables that already have the key are skipped, since SQLite
+	* would otherwise maintain a redundant second index. If duplicate rows exist
+	* the index cannot be built; warn instead of blocking init.
+	*/
+	async ensureUniqueKey() {
+		if ((await this.#client.execute(`PRAGMA table_info("${_mastra_core_storage.TABLE_NOTIFICATIONS}")`)).rows.some((row) => Number(row.pk) > 0)) return;
+		try {
+			await this.#client.execute(`CREATE UNIQUE INDEX IF NOT EXISTS idx_notifications_thread_id_unique ON "${_mastra_core_storage.TABLE_NOTIFICATIONS}" ("threadId", "id")`);
+		} catch (error) {
+			this.logger?.warn?.(`Could not enforce unique ("threadId", "id") on ${_mastra_core_storage.TABLE_NOTIFICATIONS}; remove duplicate rows and restart to add it.`, error);
+		}
+	}
 	async dangerouslyClearAll() {
 		await this.#db.deleteData({ tableName: _mastra_core_storage.TABLE_NOTIFICATIONS });
 	}