@mastra/libsql 1.12.0 → 1.12.1-alpha.0

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # @mastra/libsql
 
+## 1.12.1-alpha.0
+
+### Patch Changes
+
+- Added LibSQL support for the notifications storage domain so notification signals can persist thread-scoped inbox records. ([#17241](https://github.com/mastra-ai/mastra/pull/17241))
+
+  ```ts
+  import { LibSQLStore } from '@mastra/libsql';
+
+  const storage = new LibSQLStore({ url: 'file:./mastra.db' });
+  ```
+
+- Fixed LibSQL memory cleanup so in-memory stores initialize their tables before clearing data. This prevents reset flows from failing with missing table errors such as mastra_resources. ([#17532](https://github.com/mastra-ai/mastra/pull/17532))
+
+- Updated dependencies [[`c973db4`](https://github.com/mastra-ai/mastra/commit/c973db428df1b564ff0c35d4b2a90e8f4f1e13fd), [`552285e`](https://github.com/mastra-ai/mastra/commit/552285e5af43cfc680a0972032cab8de8776c6a0), [`77e686c`](https://github.com/mastra-ai/mastra/commit/77e686c264e493e99ae5024e4dfe3ea5d5a09718), [`ece8dba`](https://github.com/mastra-ai/mastra/commit/ece8dba7ec1a5089eee8c33167cd762bfa91e509), [`e751af2`](https://github.com/mastra-ai/mastra/commit/e751af219433fbf4c7035b2d771b4c9ec8813b05), [`e2a8380`](https://github.com/mastra-ai/mastra/commit/e2a838017a7657850404c1e94c70d79ffdc6f14a), [`be3f1cd`](https://github.com/mastra-ai/mastra/commit/be3f1cd81f0e2a649e8eac15a024d542d814aef8), [`a34d9db`](https://github.com/mastra-ai/mastra/commit/a34d9dbc39fedb722f271318e9355ecee70489ab)]:
+  - @mastra/core@1.39.0-alpha.0
+
 ## 1.12.0
 
 ### Minor Changes

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.12.0"
+  version: "1.12.1-alpha.0"
 ---
 
 ## When to use

package/dist/docs/assets/SOURCE_MAP.json

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

package/dist/docs/references/docs-memory-multi-user-threads.md

@@ -135,7 +135,7 @@ const memory = new Memory({
 
 The model reads identity from the `<turn>` tag on the current message and from prior tagged messages brought back through `lastMessages`.
 
-### With observational memory (recommended)
+### With Observational Memory (recommended)
 
 [Observational Memory](https://mastra.ai/docs/memory/observational-memory) (OM) extracts per-user facts into a background log without burning the agent's tool budget. The default Observer model reads `<turn>` tags natively and produces named attribution like `Alice stated her favorite color is teal.` and `Bob asked for QA sign-off before publish.`
 

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

@@ -393,6 +393,33 @@ const response = await agent.generate('What do you know about me?', {
 })
 ```
 
+## Opt in to state signals (experimental)
+
+By default, working memory reaches the model as part of the system message. You can opt into delivering it as a [state signal](https://mastra.ai/docs/agents/signals) instead by setting `useStateSignals: true`:
+
+```typescript
+const memory = new Memory({
+  storage: new LibSQLStore({ url: 'file:./mastra.db' }),
+  options: {
+    workingMemory: {
+      enabled: true,
+      template: '# User\n- name:\n- location:',
+      useStateSignals: true, // experimental: deliver as state signal
+    },
+  },
+})
+```
+
+What changes:
+
+- **Storage is identical.** The same resource/thread `workingMemory` field is read and written.
+- **The tool is the same shape, exposed under a new name.** Writes still flow through the same underlying tool; on this path it is registered as `setWorkingMemory` (instead of `updateWorkingMemory`). The rename keeps legacy strip filters from removing tool-call parts so they persist as a normal audit trail and the next model step picks the new value up automatically.
+- **Delivery only.** Instead of folding into the system prompt, `Memory` auto-attaches a `WorkingMemoryStateProcessor` that emits the current working memory as a `state` signal with `stateId: 'working-memory'`.
+
+You inherit the standard state-signal benefits: thread-scoped tracking metadata, `cacheKey` dedup so identical snapshots are only emitted once, and `contextWindow.hasSnapshot` re-injection when an older snapshot rolls out of the window.
+
+The default (`useStateSignals: false`) keeps the existing system-message behavior unchanged. `useStateSignals` is not supported with template working memory `version: 'vnext'`.
+
 ## Examples
 
 - [Working memory with template](https://github.com/mastra-ai/mastra/tree/main/examples/memory-with-template)

package/dist/docs/references/reference-storage-libsql.md

@@ -93,6 +93,12 @@ storage: new LibSQLStore({
 
 **authToken** (`string`): Authentication token for remote libSQL databases.
 
+## Managed tables
+
+The storage implementation creates the core storage tables automatically, including `mastra_notifications` for notification inbox records and delivery metadata.
+
+`LibSQLStore` exposes notification storage through `getStore('notifications')`.
+
 ## Initialization
 
 When you pass storage to the Mastra class, `init()` is called automatically to create the [core schema](https://mastra.ai/reference/storage/overview):

package/dist/index.cjs

@@ -6350,6 +6350,7 @@ var MemoryLibSQL = class extends storage.MemoryStorage {
     }
   }
   async dangerouslyClearAll() {
+    await this.init();
     await this.#db.deleteData({ tableName: storage.TABLE_MESSAGES });
     await this.#db.deleteData({ tableName: storage.TABLE_THREADS });
     await this.#db.deleteData({ tableName: storage.TABLE_RESOURCES });
@@ -8355,6 +8356,294 @@ ${unreflectedContent}` : bufferedReflection;
     }
   }
 };
+var statusTimestamp = (status, now) => {
+  if (status === "delivered") return { deliveredAt: now };
+  if (status === "seen") return { seenAt: now };
+  if (status === "dismissed") return { dismissedAt: now };
+  if (status === "archived") return { archivedAt: now };
+  if (status === "discarded") return { discardedAt: now };
+  return {};
+};
+function parseJson2(value) {
+  if (value == null) return void 0;
+  if (typeof value === "string") {
+    try {
+      return JSON.parse(value);
+    } catch {
+      return value;
+    }
+  }
+  return value;
+}
+function parseDate(value) {
+  return value == null ? void 0 : new Date(String(value));
+}
+var cloneValue = (value) => value === void 0 ? void 0 : structuredClone(value);
+function rowToNotification(row) {
+  return {
+    id: String(row.id),
+    threadId: String(row.threadId),
+    source: String(row.source),
+    kind: String(row.kind),
+    priority: String(row.priority),
+    status: String(row.status),
+    summary: String(row.summary),
+    payload: parseJson2(row.payload),
+    resourceId: row.resourceId == null ? void 0 : String(row.resourceId),
+    agentId: row.agentId == null ? void 0 : String(row.agentId),
+    sourceId: row.sourceId == null ? void 0 : String(row.sourceId),
+    dedupeKey: row.dedupeKey == null ? void 0 : String(row.dedupeKey),
+    coalesceKey: row.coalesceKey == null ? void 0 : String(row.coalesceKey),
+    coalescedCount: Number(row.coalescedCount ?? 1),
+    attributes: parseJson2(row.attributes),
+    createdAt: new Date(String(row.createdAt)),
+    updatedAt: new Date(String(row.updatedAt)),
+    deliveredAt: parseDate(row.deliveredAt),
+    seenAt: parseDate(row.seenAt),
+    dismissedAt: parseDate(row.dismissedAt),
+    archivedAt: parseDate(row.archivedAt),
+    discardedAt: parseDate(row.discardedAt),
+    deliverAt: parseDate(row.deliverAt),
+    summaryAt: parseDate(row.summaryAt),
+    deliveryReason: row.deliveryReason == null ? void 0 : String(row.deliveryReason),
+    deliveryAttempts: Number(row.deliveryAttempts ?? 0),
+    lastDeliveryAttemptAt: parseDate(row.lastDeliveryAttemptAt),
+    lastDeliveryError: row.lastDeliveryError == null ? void 0 : String(row.lastDeliveryError),
+    deliveredSignalId: row.deliveredSignalId == null ? void 0 : String(row.deliveredSignalId),
+    summarySignalId: row.summarySignalId == null ? void 0 : String(row.summarySignalId),
+    metadata: parseJson2(row.metadata)
+  };
+}
+function addArrayFilter(conditions, args, column, value) {
+  if (!value) return;
+  const values = Array.isArray(value) ? value : [value];
+  conditions.push(`"${column}" IN (${values.map(() => "?").join(", ")})`);
+  args.push(...values);
+}
+var NotificationsLibSQL = class extends storage.NotificationsStorage {
+  #db;
+  #client;
+  constructor(config) {
+    super();
+    const client = resolveClient(config);
+    this.#client = client;
+    this.#db = new LibSQLDB({ client, maxRetries: config.maxRetries, initialBackoffMs: config.initialBackoffMs });
+  }
+  async init() {
+    await this.#db.createTable({
+      tableName: storage.TABLE_NOTIFICATIONS,
+      schema: storage.TABLE_SCHEMAS[storage.TABLE_NOTIFICATIONS]
+    });
+    await this.#client.batch(
+      [
+        {
+          sql: `CREATE INDEX IF NOT EXISTS idx_notifications_thread_status_updated ON "${storage.TABLE_NOTIFICATIONS}" ("threadId", "status", "updatedAt")`,
+          args: []
+        },
+        {
+          sql: `CREATE INDEX IF NOT EXISTS idx_notifications_coalescing ON "${storage.TABLE_NOTIFICATIONS}" ("threadId", "source", "kind", "status", "agentId", "resourceId", "dedupeKey", "coalesceKey")`,
+          args: []
+        },
+        {
+          sql: `CREATE INDEX IF NOT EXISTS idx_notifications_due ON "${storage.TABLE_NOTIFICATIONS}" ("status", "deliverAt", "summaryAt")`,
+          args: []
+        }
+      ],
+      "write"
+    );
+  }
+  async dangerouslyClearAll() {
+    await this.#db.deleteData({ tableName: storage.TABLE_NOTIFICATIONS });
+  }
+  async createNotification(input) {
+    const existing = await this.findCoalescable(input);
+    if (existing) {
+      const now2 = /* @__PURE__ */ new Date();
+      const attributes = input.attributes ? { ...cloneValue(existing.attributes), ...cloneValue(input.attributes) } : cloneValue(existing.attributes);
+      const metadata = input.metadata ? { ...cloneValue(existing.metadata), ...cloneValue(input.metadata) } : cloneValue(existing.metadata);
+      await this.#db.update({
+        tableName: storage.TABLE_NOTIFICATIONS,
+        keys: { threadId: existing.threadId, id: existing.id },
+        data: {
+          summary: input.summary,
+          payload: cloneValue(input.payload ?? existing.payload) ?? null,
+          priority: input.priority ?? existing.priority,
+          attributes: attributes ?? null,
+          updatedAt: now2,
+          deliverAt: input.deliverAt ?? existing.deliverAt ?? null,
+          summaryAt: input.summaryAt ?? existing.summaryAt ?? null,
+          deliveryReason: input.deliveryReason ?? existing.deliveryReason ?? null,
+          coalescedCount: (existing.coalescedCount ?? 1) + 1,
+          metadata: metadata ?? null
+        }
+      });
+      const updated = await this.getNotification({ threadId: existing.threadId, id: existing.id });
+      if (!updated) throw new Error(`Notification ${existing.id} was not found for thread ${existing.threadId}`);
+      return updated;
+    }
+    const now = input.createdAt ?? /* @__PURE__ */ new Date();
+    const record = {
+      id: input.id ?? crypto$1.randomUUID(),
+      threadId: input.threadId,
+      source: input.source,
+      kind: input.kind,
+      priority: input.priority ?? "medium",
+      status: "pending",
+      summary: input.summary,
+      payload: cloneValue(input.payload),
+      resourceId: input.resourceId,
+      agentId: input.agentId,
+      sourceId: input.sourceId,
+      dedupeKey: input.dedupeKey,
+      coalesceKey: input.coalesceKey,
+      coalescedCount: 1,
+      attributes: cloneValue(input.attributes),
+      createdAt: now,
+      updatedAt: now,
+      deliverAt: input.deliverAt,
+      summaryAt: input.summaryAt,
+      deliveryReason: input.deliveryReason,
+      deliveryAttempts: 0,
+      metadata: cloneValue(input.metadata)
+    };
+    await this.#db.insert({
+      tableName: storage.TABLE_NOTIFICATIONS,
+      record: {
+        ...record,
+        payload: record.payload ?? null,
+        attributes: record.attributes ?? null,
+        metadata: record.metadata ?? null,
+        resourceId: record.resourceId ?? null,
+        agentId: record.agentId ?? null,
+        sourceId: record.sourceId ?? null,
+        dedupeKey: record.dedupeKey ?? null,
+        coalesceKey: record.coalesceKey ?? null,
+        deliverAt: record.deliverAt ?? null,
+        summaryAt: record.summaryAt ?? null,
+        deliveryReason: record.deliveryReason ?? null,
+        deliveryAttempts: record.deliveryAttempts ?? 0
+      }
+    });
+    return record;
+  }
+  async listNotifications(input) {
+    const conditions = ['"threadId" = ?'];
+    const args = [input.threadId];
+    addArrayFilter(conditions, args, "status", input.status);
+    addArrayFilter(conditions, args, "priority", input.priority);
+    if (input.source) {
+      conditions.push('"source" = ?');
+      args.push(input.source);
+    }
+    if (input.resourceId) {
+      conditions.push('"resourceId" = ?');
+      args.push(input.resourceId);
+    }
+    if (input.agentId) {
+      conditions.push('"agentId" = ?');
+      args.push(input.agentId);
+    }
+    if (input.search) {
+      conditions.push('(LOWER("summary") LIKE ? OR LOWER("kind") LIKE ?)');
+      const search = `%${input.search.toLowerCase()}%`;
+      args.push(search, search);
+    }
+    const limit = input.limit ? " LIMIT ?" : "";
+    if (input.limit) args.push(input.limit);
+    const result = await this.#client.execute({
+      sql: `SELECT ${buildSelectColumns(storage.TABLE_NOTIFICATIONS)} FROM "${storage.TABLE_NOTIFICATIONS}" WHERE ${conditions.join(" AND ")} ORDER BY "updatedAt" DESC${limit}`,
+      args
+    });
+    return (result.rows ?? []).map((row) => rowToNotification(row));
+  }
+  async listDueNotifications(input) {
+    const now = input.now.toISOString();
+    const conditions = [
+      '"status" = ?',
+      '(("deliverAt" IS NOT NULL AND "deliverAt" <= ?) OR ("summaryAt" IS NOT NULL AND "summaryAt" <= ?))'
+    ];
+    const args = ["pending", now, now];
+    if (input.agentId) {
+      conditions.push('"agentId" = ?');
+      args.push(input.agentId);
+    }
+    if (input.resourceId) {
+      conditions.push('"resourceId" = ?');
+      args.push(input.resourceId);
+    }
+    const limit = input.limit ? " LIMIT ?" : "";
+    if (input.limit) args.push(input.limit);
+    const result = await this.#client.execute({
+      sql: `SELECT ${buildSelectColumns(storage.TABLE_NOTIFICATIONS)} FROM "${storage.TABLE_NOTIFICATIONS}" WHERE ${conditions.join(" AND ")} ORDER BY CASE WHEN "deliverAt" IS NULL THEN "summaryAt" WHEN "summaryAt" IS NULL THEN "deliverAt" WHEN "deliverAt" <= "summaryAt" THEN "deliverAt" ELSE "summaryAt" END ASC, "updatedAt" ASC${limit}`,
+      args
+    });
+    return (result.rows ?? []).map((row) => rowToNotification(row));
+  }
+  async getNotification(input) {
+    const result = await this.#client.execute({
+      sql: `SELECT ${buildSelectColumns(storage.TABLE_NOTIFICATIONS)} FROM "${storage.TABLE_NOTIFICATIONS}" WHERE "threadId" = ? AND "id" = ? LIMIT 1`,
+      args: [input.threadId, input.id]
+    });
+    const row = result.rows?.[0];
+    return row ? rowToNotification(row) : null;
+  }
+  async updateNotification(input) {
+    const existing = await this.getNotification({ threadId: input.threadId, id: input.id });
+    if (!existing) {
+      throw new Error(`Notification ${input.id} was not found for thread ${input.threadId}`);
+    }
+    const now = /* @__PURE__ */ new Date();
+    await this.#db.update({
+      tableName: storage.TABLE_NOTIFICATIONS,
+      keys: { threadId: input.threadId, id: input.id },
+      data: {
+        ...input.status ? { status: input.status, ...statusTimestamp(input.status, now) } : {},
+        ...input.summary !== void 0 ? { summary: input.summary } : {},
+        ...input.payload !== void 0 ? { payload: cloneValue(input.payload) } : {},
+        ...input.attributes !== void 0 ? { attributes: cloneValue(input.attributes) } : {},
+        ...input.metadata !== void 0 ? { metadata: cloneValue(input.metadata) } : {},
+        ...input.deliverAt !== void 0 ? { deliverAt: input.deliverAt } : {},
+        ...input.summaryAt !== void 0 ? { summaryAt: input.summaryAt } : {},
+        ...input.deliveryReason !== void 0 ? { deliveryReason: input.deliveryReason } : {},
+        ...input.deliveryAttempts !== void 0 ? { deliveryAttempts: input.deliveryAttempts } : {},
+        ...input.lastDeliveryAttemptAt !== void 0 ? { lastDeliveryAttemptAt: input.lastDeliveryAttemptAt } : {},
+        ...input.lastDeliveryError !== void 0 ? { lastDeliveryError: input.lastDeliveryError } : {},
+        ...input.deliveredSignalId !== void 0 ? { deliveredSignalId: input.deliveredSignalId } : {},
+        ...input.summarySignalId !== void 0 ? { summarySignalId: input.summarySignalId } : {},
+        updatedAt: now
+      }
+    });
+    const updated = await this.getNotification({ threadId: input.threadId, id: input.id });
+    if (!updated) throw new Error(`Notification ${input.id} was not found for thread ${input.threadId}`);
+    return updated;
+  }
+  async findCoalescable(input) {
+    if (!input.dedupeKey && !input.coalesceKey) return void 0;
+    const agentId = input.agentId ?? null;
+    const resourceId = input.resourceId ?? null;
+    const dedupeKey = input.dedupeKey ?? null;
+    const coalesceKey = input.coalesceKey ?? null;
+    const result = await this.#client.execute({
+      sql: `SELECT ${buildSelectColumns(storage.TABLE_NOTIFICATIONS)} FROM "${storage.TABLE_NOTIFICATIONS}" WHERE "threadId" = ? AND "source" = ? AND "kind" = ? AND "status" = ? AND (("agentId" = ?) OR ("agentId" IS NULL AND ? IS NULL)) AND (("resourceId" = ?) OR ("resourceId" IS NULL AND ? IS NULL)) AND ((? IS NOT NULL AND "dedupeKey" = ?) OR (? IS NOT NULL AND "coalesceKey" = ?)) ORDER BY "updatedAt" DESC LIMIT 1`,
+      args: [
+        input.threadId,
+        input.source,
+        input.kind,
+        "pending",
+        agentId,
+        agentId,
+        resourceId,
+        resourceId,
+        dedupeKey,
+        dedupeKey,
+        coalesceKey,
+        coalesceKey
+      ]
+    });
+    const row = result.rows?.[0];
+    return row ? rowToNotification(row) : void 0;
+  }
+};
 var ObservabilityLibSQL = class extends storage.ObservabilityStorage {
   #db;
   constructor(config) {
@@ -9327,7 +9616,7 @@ var PromptBlocksLibSQL = class extends storage.PromptBlocksStorage {
     };
   }
 };
-function parseJson2(val) {
+function parseJson3(val) {
   if (val == null) return void 0;
   if (typeof val === "string") {
     try {
@@ -9343,7 +9632,7 @@ function toNumber(val) {
   return Number(val);
 }
 function rowToSchedule(row) {
-  const target = parseJson2(row.target);
+  const target = parseJson3(row.target);
   if (!target) {
     throw new Error(`Schedule row ${row.id} has invalid target`);
   }
@@ -9359,7 +9648,7 @@ function rowToSchedule(row) {
   if (row.timezone != null) schedule.timezone = String(row.timezone);
   if (row.last_fire_at != null) schedule.lastFireAt = toNumber(row.last_fire_at);
   if (row.last_run_id != null) schedule.lastRunId = String(row.last_run_id);
-  const metadata = parseJson2(row.metadata);
+  const metadata = parseJson3(row.metadata);
   if (metadata !== void 0) schedule.metadata = metadata;
   if (row.owner_type != null) schedule.ownerType = String(row.owner_type);
   if (row.owner_id != null) schedule.ownerId = String(row.owner_id);
@@ -9377,7 +9666,7 @@ function rowToTrigger(row) {
   };
   if (row.error != null) trigger.error = String(row.error);
   if (row.parent_trigger_id != null) trigger.parentTriggerId = String(row.parent_trigger_id);
-  const metadata = parseJson2(row.metadata);
+  const metadata = parseJson3(row.metadata);
   if (metadata !== void 0) trigger.metadata = metadata;
   return trigger;
 }
@@ -12119,6 +12408,7 @@ var LibSQLStore = class extends storage.MastraCompositeStore {
     const backgroundTasks = new BackgroundTasksLibSQL(domainConfig);
     const schedules = new SchedulesLibSQL(domainConfig);
     const toolProviderConnections = new ToolProviderConnectionsLibSQL(domainConfig);
+    const notifications = new NotificationsLibSQL(domainConfig);
     this.stores = {
       scores,
       workflows,
@@ -12138,7 +12428,8 @@ var LibSQLStore = class extends storage.MastraCompositeStore {
       blobs,
       backgroundTasks,
       schedules,
-      toolProviderConnections
+      toolProviderConnections,
+      notifications
     };
   }
   async applyLocalPragmas() {
@@ -12341,6 +12632,7 @@ exports.LibSQLVector = LibSQLVector;
 exports.MCPClientsLibSQL = MCPClientsLibSQL;
 exports.MCPServersLibSQL = MCPServersLibSQL;
 exports.MemoryLibSQL = MemoryLibSQL;
+exports.NotificationsLibSQL = NotificationsLibSQL;
 exports.ObservabilityLibSQL = ObservabilityLibSQL;
 exports.PromptBlocksLibSQL = PromptBlocksLibSQL;
 exports.SchedulesLibSQL = SchedulesLibSQL;