@mastra/pg 1.12.0 → 1.12.1

package/CHANGELOG.md

@@ -1,5 +1,39 @@
 # @mastra/pg
 
+## 1.12.1
+
+### Patch Changes
+
+- Added notification inbox storage support for Postgres stores. ([#17241](https://github.com/mastra-ai/mastra/pull/17241))
+
+  ```ts
+  import { PostgresStore } from '@mastra/pg';
+
+  const storage = new PostgresStore({ connectionString: process.env.POSTGRES_URL! });
+  ```
+
+  Agents using this store can persist thread-scoped notification inbox records for notification signals.
+
+- 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
+
+## 1.12.1-alpha.0
+
+### Patch Changes
+
+- Added notification inbox storage support for Postgres stores. ([#17241](https://github.com/mastra-ai/mastra/pull/17241))
+
+  ```ts
+  import { PostgresStore } from '@mastra/pg';
+
+  const storage = new PostgresStore({ connectionString: process.env.POSTGRES_URL! });
+  ```
+
+  Agents using this store can persist thread-scoped notification inbox records for notification signals.
+
+- 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-pg
 description: Documentation for @mastra/pg. Use when working with @mastra/pg APIs, configuration, or implementation.
 metadata:
   package: "@mastra/pg"
-  version: "1.12.0"
+  version: "1.12.1"
 ---
 
 ## When to use

package/dist/docs/assets/SOURCE_MAP.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.12.0",
+  "version": "1.12.1",
   "package": "@mastra/pg",
   "exports": {},
   "modules": {}

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-postgresql.md

@@ -132,6 +132,9 @@ The storage implementation handles schema creation and updates automatically. It
 - `mastra_traces`: Stores telemetry and tracing data
 - `mastra_scorers`: Stores scoring and evaluation data
 - `mastra_resources`: Stores resource working memory data
+- `mastra_notifications`: Stores notification inbox records and delivery metadata
+
+`PostgresStore` exposes notification storage through `getStore('notifications')`.
 
 ### Observability
 

package/dist/index.cjs

@@ -10426,6 +10426,348 @@ ${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 {};
+};
+var parseDate = (value) => {
+  if (value == null) return void 0;
+  return value instanceof Date ? value : 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: parseJsonResilient(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: parseJsonResilient(row.attributes),
+    createdAt: parseDate(row.createdAt) ?? /* @__PURE__ */ new Date(),
+    updatedAt: parseDate(row.updatedAt) ?? /* @__PURE__ */ new Date(),
+    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: parseJsonResilient(row.metadata)
+  };
+}
+function addArrayFilter(conditions, args, column, value) {
+  if (!value) return;
+  const values = Array.isArray(value) ? value : [value];
+  const start = args.length + 1;
+  conditions.push(`"${column}" IN (${values.map((_, index) => `$${start + index}`).join(", ")})`);
+  args.push(...values);
+}
+function normalizeRecordForInsert(record) {
+  return {
+    ...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,
+    deliveredAt: record.deliveredAt ?? null,
+    seenAt: record.seenAt ?? null,
+    dismissedAt: record.dismissedAt ?? null,
+    archivedAt: record.archivedAt ?? null,
+    discardedAt: record.discardedAt ?? null,
+    deliverAt: record.deliverAt ?? null,
+    summaryAt: record.summaryAt ?? null,
+    deliveryReason: record.deliveryReason ?? null,
+    lastDeliveryAttemptAt: record.lastDeliveryAttemptAt ?? null,
+    lastDeliveryError: record.lastDeliveryError ?? null,
+    deliveredSignalId: record.deliveredSignalId ?? null,
+    summarySignalId: record.summarySignalId ?? null
+  };
+}
+var NotificationsPG = class _NotificationsPG extends storage.NotificationsStorage {
+  #db;
+  #schema;
+  #skipDefaultIndexes;
+  #indexes;
+  static MANAGED_TABLES = [storage.TABLE_NOTIFICATIONS];
+  constructor(config) {
+    super();
+    const { client, schemaName, skipDefaultIndexes, indexes } = resolvePgConfig(config);
+    this.#db = new PgDB({ client, schemaName, skipDefaultIndexes });
+    this.#schema = schemaName || "public";
+    this.#skipDefaultIndexes = skipDefaultIndexes;
+    this.#indexes = indexes?.filter((idx) => _NotificationsPG.MANAGED_TABLES.includes(idx.table));
+  }
+  async init() {
+    await this.#db.createTable({
+      tableName: storage.TABLE_NOTIFICATIONS,
+      schema: storage.TABLE_SCHEMAS[storage.TABLE_NOTIFICATIONS]
+    });
+    await this.createDefaultIndexes();
+    await this.createCustomIndexes();
+  }
+  static getDefaultIndexDefs(schemaPrefix) {
+    return [
+      {
+        name: `${schemaPrefix}idx_notifications_thread_status_updated`,
+        table: storage.TABLE_NOTIFICATIONS,
+        columns: ["threadId", "status", "updatedAt"]
+      },
+      {
+        name: `${schemaPrefix}idx_notifications_coalescing`,
+        table: storage.TABLE_NOTIFICATIONS,
+        columns: ["threadId", "source", "kind", "status", "agentId", "resourceId", "dedupeKey", "coalesceKey"]
+      },
+      {
+        name: `${schemaPrefix}idx_notifications_due`,
+        table: storage.TABLE_NOTIFICATIONS,
+        columns: ["status", "deliverAt", "summaryAt"]
+      }
+    ];
+  }
+  static getExportDDL(schemaName) {
+    const statements = [];
+    const parsedSchema = schemaName ? utils.parseSqlIdentifier(schemaName, "schema name") : "";
+    const schemaPrefix = parsedSchema && parsedSchema !== "public" ? `${parsedSchema}_` : "";
+    statements.push(
+      generateTableSQL({
+        tableName: storage.TABLE_NOTIFICATIONS,
+        schema: storage.TABLE_SCHEMAS[storage.TABLE_NOTIFICATIONS],
+        schemaName,
+        includeAllConstraints: true
+      })
+    );
+    for (const idx of _NotificationsPG.getDefaultIndexDefs(schemaPrefix)) {
+      statements.push(generateIndexSQL(idx, schemaName));
+    }
+    return statements;
+  }
+  getDefaultIndexDefinitions() {
+    const schemaPrefix = this.#schema !== "public" ? `${this.#schema}_` : "";
+    return _NotificationsPG.getDefaultIndexDefs(schemaPrefix);
+  }
+  async createDefaultIndexes() {
+    if (this.#skipDefaultIndexes) return;
+    for (const indexDef of this.getDefaultIndexDefinitions()) {
+      try {
+        await this.#db.createIndex(indexDef);
+      } catch (error) {
+        this.logger?.warn?.(`Failed to create index ${indexDef.name}:`, error);
+      }
+    }
+  }
+  async createCustomIndexes() {
+    if (!this.#indexes || this.#indexes.length === 0) return;
+    for (const indexDef of this.#indexes) {
+      try {
+        await this.#db.createIndex(indexDef);
+      } catch (error) {
+        this.logger?.warn?.(`Failed to create custom index ${indexDef.name}:`, error);
+      }
+    }
+  }
+  async dangerouslyClearAll() {
+    await this.#db.clearTable({ tableName: storage.TABLE_NOTIFICATIONS });
+  }
+  async updateNotificationRow(threadId, id, data) {
+    const entries = Object.entries(data).filter(([, value]) => value !== void 0);
+    if (entries.length === 0) return;
+    const schemaName = getSchemaName2(this.#schema);
+    const tableName = getTableName2({ indexName: storage.TABLE_NOTIFICATIONS, schemaName });
+    const setColumns = entries.map(([key], index) => `"${utils.parseSqlIdentifier(key, "column name")}" = $${index + 1}`);
+    const values = entries.map(([key, value]) => {
+      const columnSchema = storage.TABLE_SCHEMAS[storage.TABLE_NOTIFICATIONS][key];
+      if (columnSchema?.type === "jsonb" && value !== null) return JSON.stringify(value);
+      return value;
+    });
+    await this.#db.client.none(
+      `UPDATE ${tableName} SET ${setColumns.join(", ")} WHERE "threadId" = $${values.length + 1} AND "id" = $${values.length + 2}`,
+      [...values, threadId, id]
+    );
+  }
+  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.updateNotificationRow(existing.threadId, existing.id, {
+        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: normalizeRecordForInsert(record) });
+    return record;
+  }
+  async listNotifications(input) {
+    const conditions = ['"threadId" = $1'];
+    const args = [input.threadId];
+    addArrayFilter(conditions, args, "status", input.status);
+    addArrayFilter(conditions, args, "priority", input.priority);
+    if (input.source) {
+      args.push(input.source);
+      conditions.push(`"source" = $${args.length}`);
+    }
+    if (input.resourceId) {
+      args.push(input.resourceId);
+      conditions.push(`"resourceId" = $${args.length}`);
+    }
+    if (input.agentId) {
+      args.push(input.agentId);
+      conditions.push(`"agentId" = $${args.length}`);
+    }
+    if (input.search) {
+      const search = `%${input.search.toLowerCase()}%`;
+      args.push(search, search);
+      conditions.push(`(LOWER("summary") LIKE $${args.length - 1} OR LOWER("kind") LIKE $${args.length})`);
+    }
+    const limit = input.limit ? ` LIMIT $${args.length + 1}` : "";
+    if (input.limit) args.push(input.limit);
+    const schemaName = getSchemaName2(this.#schema);
+    const tableName = getTableName2({ indexName: storage.TABLE_NOTIFICATIONS, schemaName });
+    const rows = await this.#db.client.manyOrNone(
+      `SELECT * FROM ${tableName} WHERE ${conditions.join(" AND ")} ORDER BY "updatedAt" DESC${limit}`,
+      args
+    );
+    return rows.map((row) => rowToNotification(row));
+  }
+  async listDueNotifications(input) {
+    const conditions = [
+      '"status" = $1',
+      '(("deliverAt" IS NOT NULL AND "deliverAt" <= $2) OR ("summaryAt" IS NOT NULL AND "summaryAt" <= $3))'
+    ];
+    const args = ["pending", input.now, input.now];
+    if (input.agentId) {
+      args.push(input.agentId);
+      conditions.push(`"agentId" = $${args.length}`);
+    }
+    if (input.resourceId) {
+      args.push(input.resourceId);
+      conditions.push(`"resourceId" = $${args.length}`);
+    }
+    const limit = input.limit ? ` LIMIT $${args.length + 1}` : "";
+    if (input.limit) args.push(input.limit);
+    const schemaName = getSchemaName2(this.#schema);
+    const tableName = getTableName2({ indexName: storage.TABLE_NOTIFICATIONS, schemaName });
+    const rows = await this.#db.client.manyOrNone(
+      `SELECT * FROM ${tableName} 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 rows.map((row) => rowToNotification(row));
+  }
+  async getNotification(input) {
+    const schemaName = getSchemaName2(this.#schema);
+    const tableName = getTableName2({ indexName: storage.TABLE_NOTIFICATIONS, schemaName });
+    const row = await this.#db.client.oneOrNone(
+      `SELECT * FROM ${tableName} WHERE "threadId" = $1 AND "id" = $2 LIMIT 1`,
+      [input.threadId, input.id]
+    );
+    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.updateNotificationRow(input.threadId, input.id, {
+      ...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 schemaName = getSchemaName2(this.#schema);
+    const tableName = getTableName2({ indexName: storage.TABLE_NOTIFICATIONS, schemaName });
+    const row = await this.#db.client.oneOrNone(
+      `SELECT * FROM ${tableName} WHERE "threadId" = $1 AND "source" = $2 AND "kind" = $3 AND "status" = $4 AND (("agentId" = $5::text) OR ("agentId" IS NULL AND $5::text IS NULL)) AND (("resourceId" = $6::text) OR ("resourceId" IS NULL AND $6::text IS NULL)) AND (($7::text IS NOT NULL AND "dedupeKey" = $7::text) OR ($8::text IS NOT NULL AND "coalesceKey" = $8::text)) ORDER BY "updatedAt" DESC LIMIT 1`,
+      [
+        input.threadId,
+        input.source,
+        input.kind,
+        "pending",
+        input.agentId ?? null,
+        input.resourceId ?? null,
+        input.dedupeKey ?? null,
+        input.coalesceKey ?? null
+      ]
+    );
+    return row ? rowToNotification(row) : void 0;
+  }
+};
 var ObservabilityPG = class _ObservabilityPG extends storage.ObservabilityStorage {
   #db;
   #schema;
@@ -15005,6 +15347,7 @@ var DEFAULT_MAX_CONNECTIONS = 20;
 var DEFAULT_IDLE_TIMEOUT_MS = 3e4;
 var ALL_DOMAINS = [
   MemoryPG,
+  NotificationsPG,
   ObservabilityPG,
   ScoresPG,
   ScorerDefinitionsPG,
@@ -15060,6 +15403,7 @@ var PostgresStore = class extends storage.MastraCompositeStore {
         scores: new ScoresPG(domainConfig),
         workflows: new WorkflowsPG(domainConfig),
         memory: new MemoryPG(domainConfig),
+        notifications: new NotificationsPG(domainConfig),
         observability: new ObservabilityPG(domainConfig),
         agents: new AgentsPG(domainConfig),
         promptBlocks: new PromptBlocksPG(domainConfig),
@@ -15273,6 +15617,7 @@ exports.FavoritesPG = FavoritesPG;
 exports.MCPClientsPG = MCPClientsPG;
 exports.MCPServersPG = MCPServersPG;
 exports.MemoryPG = MemoryPG;
+exports.NotificationsPG = NotificationsPG;
 exports.ObservabilityPG = ObservabilityPG;
 exports.PGVECTOR_PROMPT = PGVECTOR_PROMPT;
 exports.PgVector = PgVector;