@mastra/pg 1.1.0 → 1.2.0

package/dist/index.js

@@ -3346,20 +3346,24 @@ var AgentsPG = class _AgentsPG extends AgentsStorage {
         changedFields: Object.keys(snapshotConfig),
         changeMessage: "Initial version"
       });
-      await this.#db.client.none(
-        `UPDATE ${agentsTable} SET "activeVersionId" = $1, status = $2, "updatedAt" = $3, "updatedAtZ" = $4 WHERE id = $5`,
-        [versionId, "published", nowIso, nowIso, agent.id]
-      );
       return {
         id: agent.id,
-        status: "published",
-        activeVersionId: versionId,
+        status: "draft",
+        activeVersionId: void 0,
         authorId: agent.authorId,
         metadata: agent.metadata,
         createdAt: now,
         updatedAt: now
       };
     } catch (error) {
+      try {
+        const agentsTable = getTableName2({ indexName: TABLE_AGENTS, schemaName: getSchemaName2(this.#schema) });
+        await this.#db.client.none(
+          `DELETE FROM ${agentsTable} WHERE id = $1 AND status = 'draft' AND "activeVersionId" IS NULL`,
+          [agent.id]
+        );
+      } catch {
+      }
       throw new MastraError(
         {
           id: createStorageErrorId("PG", "CREATE_AGENT", "FAILED"),
@@ -3384,23 +3388,77 @@ var AgentsPG = class _AgentsPG extends AgentsStorage {
           details: { agentId: id }
         });
       }
+      const { authorId, activeVersionId, metadata, ...configFields } = updates;
+      const configFieldNames = [
+        "name",
+        "description",
+        "instructions",
+        "model",
+        "tools",
+        "defaultOptions",
+        "workflows",
+        "agents",
+        "integrationTools",
+        "inputProcessors",
+        "outputProcessors",
+        "memory",
+        "scorers"
+      ];
+      const hasConfigUpdate = configFieldNames.some((field) => field in configFields);
+      if (hasConfigUpdate) {
+        const latestVersion = await this.getLatestVersion(id);
+        if (!latestVersion) {
+          throw new MastraError({
+            id: createStorageErrorId("PG", "UPDATE_AGENT", "NO_VERSIONS"),
+            domain: ErrorDomain.STORAGE,
+            category: ErrorCategory.SYSTEM,
+            text: `No versions found for agent ${id}`,
+            details: { agentId: id }
+          });
+        }
+        const {
+          id: _versionId,
+          agentId: _agentId,
+          versionNumber: _versionNumber,
+          changedFields: _changedFields,
+          changeMessage: _changeMessage,
+          createdAt: _createdAt,
+          ...latestConfig
+        } = latestVersion;
+        const newConfig = {
+          ...latestConfig,
+          ...configFields
+        };
+        const changedFields = configFieldNames.filter(
+          (field) => field in configFields && configFields[field] !== latestConfig[field]
+        );
+        if (changedFields.length > 0) {
+          const newVersionId = crypto.randomUUID();
+          const newVersionNumber = latestVersion.versionNumber + 1;
+          await this.createVersion({
+            id: newVersionId,
+            agentId: id,
+            versionNumber: newVersionNumber,
+            ...newConfig,
+            changedFields,
+            changeMessage: `Updated ${changedFields.join(", ")}`
+          });
+        }
+      }
       const setClauses = [];
       const values = [];
       let paramIndex = 1;
-      if (updates.authorId !== void 0) {
+      if (authorId !== void 0) {
         setClauses.push(`"authorId" = $${paramIndex++}`);
-        values.push(updates.authorId);
+        values.push(authorId);
       }
-      if (updates.activeVersionId !== void 0) {
+      if (activeVersionId !== void 0) {
         setClauses.push(`"activeVersionId" = $${paramIndex++}`);
-        values.push(updates.activeVersionId);
-        setClauses.push(`status = $${paramIndex++}`);
-        values.push("published");
+        values.push(activeVersionId);
       }
-      if (updates.metadata !== void 0) {
-        const mergedMetadata = { ...existingAgent.metadata, ...updates.metadata };
+      if (metadata !== void 0) {
         setClauses.push(`metadata = $${paramIndex++}`);
-        values.push(JSON.stringify(mergedMetadata));
+        values.push(JSON.stringify(metadata));
       }
       const now = (/* @__PURE__ */ new Date()).toISOString();
       setClauses.push(`"updatedAt" = $${paramIndex++}`);
@@ -3510,6 +3568,124 @@ var AgentsPG = class _AgentsPG extends AgentsStorage {
       );
     }
   }
+  async listAgentsResolved(args) {
+    const { page = 0, perPage: perPageInput, orderBy } = args || {};
+    const { field, direction } = this.parseOrderBy(orderBy);
+    if (page < 0) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("PG", "LIST_AGENTS_RESOLVED", "INVALID_PAGE"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.USER,
+          details: { page }
+        },
+        new Error("page must be >= 0")
+      );
+    }
+    const perPage = normalizePerPage(perPageInput, 100);
+    const { offset, perPage: perPageForResponse } = calculatePagination(page, perPageInput, perPage);
+    try {
+      const agentsTableName = getTableName2({ indexName: TABLE_AGENTS, schemaName: getSchemaName2(this.#schema) });
+      const versionsTableName = getTableName2({
+        indexName: TABLE_AGENT_VERSIONS,
+        schemaName: getSchemaName2(this.#schema)
+      });
+      const countResult = await this.#db.client.one(`SELECT COUNT(*) as count FROM ${agentsTableName}`);
+      const total = parseInt(countResult.count, 10);
+      if (total === 0) {
+        return {
+          agents: [],
+          total: 0,
+          page,
+          perPage: perPageForResponse,
+          hasMore: false
+        };
+      }
+      const limitValue = perPageInput === false ? total : perPage;
+      const query = `
+        WITH latest_versions AS (
+          SELECT v.*
+          FROM ${versionsTableName} v
+          INNER JOIN (
+            SELECT "agentId", MAX("versionNumber") as max_version
+            FROM ${versionsTableName}
+            GROUP BY "agentId"
+          ) lv ON v."agentId" = lv."agentId" AND v."versionNumber" = lv.max_version
+        )
+        SELECT 
+          a.*,
+          COALESCE(av.id, lv.id) as version_id,
+          COALESCE(av."versionNumber", lv."versionNumber") as version_number,
+          COALESCE(av.name, lv.name) as version_name,
+          COALESCE(av.description, lv.description) as version_description,
+          COALESCE(av.instructions, lv.instructions) as version_instructions,
+          COALESCE(av.model, lv.model) as version_model,
+          COALESCE(av.tools, lv.tools) as version_tools,
+          COALESCE(av."defaultOptions", lv."defaultOptions") as version_defaultOptions,
+          COALESCE(av.workflows, lv.workflows) as version_workflows,
+          COALESCE(av.agents, lv.agents) as version_agents,
+          COALESCE(av."integrationTools", lv."integrationTools") as version_integrationTools,
+          COALESCE(av."inputProcessors", lv."inputProcessors") as version_inputProcessors,
+          COALESCE(av."outputProcessors", lv."outputProcessors") as version_outputProcessors,
+          COALESCE(av.memory, lv.memory) as version_memory,
+          COALESCE(av.scorers, lv.scorers) as version_scorers
+        FROM ${agentsTableName} a
+        LEFT JOIN ${versionsTableName} av ON a."activeVersionId" = av.id
+        LEFT JOIN latest_versions lv ON a.id = lv."agentId"
+        ORDER BY a."${field}" ${direction}
+        LIMIT $1 OFFSET $2
+      `;
+      const dataResult = await this.#db.client.manyOrNone(query, [limitValue, offset]);
+      const resolvedAgents = (dataResult || []).map((row) => {
+        const agent = this.parseRow({
+          id: row.id,
+          status: row.status,
+          activeVersionId: row.activeVersionId,
+          authorId: row.authorId,
+          metadata: row.metadata,
+          createdAt: row.createdAt,
+          createdAtZ: row.createdAtZ,
+          updatedAt: row.updatedAt,
+          updatedAtZ: row.updatedAtZ
+        });
+        if (row.version_id) {
+          return {
+            ...agent,
+            name: row.version_name,
+            description: row.version_description,
+            instructions: row.version_instructions,
+            model: this.parseJson(row.version_model, "model"),
+            tools: this.parseJson(row.version_tools, "tools"),
+            defaultOptions: this.parseJson(row.version_defaultOptions, "defaultOptions"),
+            workflows: this.parseJson(row.version_workflows, "workflows"),
+            agents: this.parseJson(row.version_agents, "agents"),
+            integrationTools: this.parseJson(row.version_integrationTools, "integrationTools"),
+            inputProcessors: this.parseJson(row.version_inputProcessors, "inputProcessors"),
+            outputProcessors: this.parseJson(row.version_outputProcessors, "outputProcessors"),
+            memory: this.parseJson(row.version_memory, "memory"),
+            scorers: this.parseJson(row.version_scorers, "scorers")
+          };
+        }
+        return agent;
+      });
+      return {
+        agents: resolvedAgents,
+        total,
+        page,
+        perPage: perPageForResponse,
+        hasMore: perPageInput === false ? false : offset + perPage < total
+      };
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("PG", "LIST_AGENTS_RESOLVED", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY
+        },
+        error
+      );
+    }
+  }
   // ==========================================================================
   // Agent Version Methods
   // ==========================================================================
@@ -3766,6 +3942,7 @@ var AgentsPG = class _AgentsPG extends AgentsStorage {
     };
   }
 };
+var OM_TABLE = "mastra_observational_memory";
 function getSchemaName3(schema) {
   return schema ? `"${schema}"` : '"public"';
 }
@@ -3777,12 +3954,13 @@ function inPlaceholders(count, startIndex = 1) {
   return Array.from({ length: count }, (_, i) => `$${i + startIndex}`).join(", ");
 }
 var MemoryPG = class _MemoryPG extends MemoryStorage {
+  supportsObservationalMemory = true;
   #db;
   #schema;
   #skipDefaultIndexes;
   #indexes;
   /** Tables managed by this domain */
-  static MANAGED_TABLES = [TABLE_THREADS, TABLE_MESSAGES, TABLE_RESOURCES];
+  static MANAGED_TABLES = [TABLE_THREADS, TABLE_MESSAGES, TABLE_RESOURCES, OM_TABLE];
   constructor(config) {
     super();
     const { client, schemaName, skipDefaultIndexes, indexes } = resolvePgConfig(config);
@@ -3795,11 +3973,30 @@ var MemoryPG = class _MemoryPG extends MemoryStorage {
     await this.#db.createTable({ tableName: TABLE_THREADS, schema: TABLE_SCHEMAS[TABLE_THREADS] });
     await this.#db.createTable({ tableName: TABLE_MESSAGES, schema: TABLE_SCHEMAS[TABLE_MESSAGES] });
     await this.#db.createTable({ tableName: TABLE_RESOURCES, schema: TABLE_SCHEMAS[TABLE_RESOURCES] });
+    let omSchema;
+    try {
+      const { OBSERVATIONAL_MEMORY_TABLE_SCHEMA } = await import('@mastra/core/storage');
+      omSchema = OBSERVATIONAL_MEMORY_TABLE_SCHEMA?.[OM_TABLE];
+    } catch {
+    }
+    if (omSchema) {
+      await this.#db.createTable({
+        tableName: OM_TABLE,
+        schema: omSchema
+      });
+    }
     await this.#db.alterTable({
       tableName: TABLE_MESSAGES,
       schema: TABLE_SCHEMAS[TABLE_MESSAGES],
       ifNotExists: ["resourceId"]
     });
+    if (omSchema) {
+      const omTableName = getTableName3({
+        indexName: OM_TABLE,
+        schemaName: getSchemaName3(this.#schema)
+      });
+      await this.#db.client.none(`CREATE INDEX IF NOT EXISTS idx_om_lookup_key ON ${omTableName} ("lookupKey")`);
+    }
     await this.createDefaultIndexes();
     await this.createCustomIndexes();
   }
@@ -4174,8 +4371,8 @@ var MemoryPG = class _MemoryPG extends MemoryStorage {
         SELECT ${selectColumns}
         FROM ${tableName} m
         WHERE m.thread_id = (SELECT thread_id FROM ${tableName} WHERE id = $${paramIdx})
-          AND m."createdAt" <= (SELECT "createdAt" FROM ${tableName} WHERE id = $${paramIdx})
-        ORDER BY m."createdAt" DESC
+          AND COALESCE(m."createdAtZ", m."createdAt") <= (SELECT COALESCE("createdAtZ", "createdAt") FROM ${tableName} WHERE id = $${paramIdx})
+        ORDER BY COALESCE(m."createdAtZ", m."createdAt") DESC
         LIMIT $${paramIdx + 1}
       )`);
       params.push(id, withPreviousMessages + 1);
@@ -4185,8 +4382,8 @@ var MemoryPG = class _MemoryPG extends MemoryStorage {
           SELECT ${selectColumns}
           FROM ${tableName} m
           WHERE m.thread_id = (SELECT thread_id FROM ${tableName} WHERE id = $${paramIdx})
-            AND m."createdAt" > (SELECT "createdAt" FROM ${tableName} WHERE id = $${paramIdx})
-          ORDER BY m."createdAt" ASC
+            AND COALESCE(m."createdAtZ", m."createdAt") > (SELECT COALESCE("createdAtZ", "createdAt") FROM ${tableName} WHERE id = $${paramIdx})
+          ORDER BY COALESCE(m."createdAtZ", m."createdAt") ASC
           LIMIT $${paramIdx + 1}
         )`);
         params.push(id, withNextMessages);
@@ -4303,12 +4500,12 @@ var MemoryPG = class _MemoryPG extends MemoryStorage {
       }
       if (filter?.dateRange?.start) {
         const startOp = filter.dateRange.startExclusive ? ">" : ">=";
-        conditions.push(`"createdAt" ${startOp} $${paramIndex++}`);
+        conditions.push(`COALESCE("createdAtZ", "createdAt") ${startOp} $${paramIndex++}`);
         queryParams.push(filter.dateRange.start);
       }
       if (filter?.dateRange?.end) {
         const endOp = filter.dateRange.endExclusive ? "<" : "<=";
-        conditions.push(`"createdAt" ${endOp} $${paramIndex++}`);
+        conditions.push(`COALESCE("createdAtZ", "createdAt") ${endOp} $${paramIndex++}`);
         queryParams.push(filter.dateRange.end);
       }
       const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
@@ -4394,6 +4591,133 @@ var MemoryPG = class _MemoryPG extends MemoryStorage {
       };
     }
   }
+  async listMessagesByResourceId(args) {
+    const { resourceId, include, filter, perPage: perPageInput, page = 0, orderBy } = args;
+    const hasResourceId = resourceId !== void 0 && resourceId !== null && resourceId.trim() !== "";
+    if (!hasResourceId) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("PG", "LIST_MESSAGES_BY_RESOURCE_ID", "INVALID_QUERY"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.USER,
+          details: {
+            resourceId: resourceId ?? ""
+          }
+        },
+        new Error("resourceId is required")
+      );
+    }
+    if (page < 0) {
+      throw new MastraError({
+        id: createStorageErrorId("PG", "LIST_MESSAGES_BY_RESOURCE_ID", "INVALID_PAGE"),
+        domain: ErrorDomain.STORAGE,
+        category: ErrorCategory.USER,
+        text: "Page number must be non-negative",
+        details: {
+          resourceId,
+          page
+        }
+      });
+    }
+    const perPage = normalizePerPage(perPageInput, 40);
+    const { offset, perPage: perPageForResponse } = calculatePagination(page, perPageInput, perPage);
+    try {
+      const { field, direction } = this.parseOrderBy(orderBy, "ASC");
+      const orderByStatement = `ORDER BY "${field}" ${direction}`;
+      const selectStatement = `SELECT id, content, role, type, "createdAt", "createdAtZ", thread_id AS "threadId", "resourceId"`;
+      const tableName = getTableName3({ indexName: TABLE_MESSAGES, schemaName: getSchemaName3(this.#schema) });
+      const conditions = [];
+      const queryParams = [];
+      let paramIndex = 1;
+      conditions.push(`"resourceId" = $${paramIndex++}`);
+      queryParams.push(resourceId);
+      if (filter?.dateRange?.start) {
+        const startOp = filter.dateRange.startExclusive ? ">" : ">=";
+        conditions.push(`"createdAt" ${startOp} $${paramIndex++}`);
+        queryParams.push(filter.dateRange.start);
+      }
+      if (filter?.dateRange?.end) {
+        const endOp = filter.dateRange.endExclusive ? "<" : "<=";
+        conditions.push(`"createdAt" ${endOp} $${paramIndex++}`);
+        queryParams.push(filter.dateRange.end);
+      }
+      const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+      const countQuery = `SELECT COUNT(*) FROM ${tableName} ${whereClause}`;
+      const countResult = await this.#db.client.one(countQuery, queryParams);
+      const total = parseInt(countResult.count, 10);
+      const limitValue = perPageInput === false ? total : perPage;
+      const dataQuery = `${selectStatement} FROM ${tableName} ${whereClause} ${orderByStatement} LIMIT $${paramIndex++} OFFSET $${paramIndex++}`;
+      const rows = await this.#db.client.manyOrNone(dataQuery, [...queryParams, limitValue, offset]);
+      const messages = [...rows || []];
+      if (total === 0 && messages.length === 0 && (!include || include.length === 0)) {
+        return {
+          messages: [],
+          total: 0,
+          page,
+          perPage: perPageForResponse,
+          hasMore: false
+        };
+      }
+      const messageIds = new Set(messages.map((m) => m.id));
+      if (include && include.length > 0) {
+        const includeMessages = await this._getIncludedMessages({ include });
+        if (includeMessages) {
+          for (const includeMsg of includeMessages) {
+            if (!messageIds.has(includeMsg.id)) {
+              messages.push(includeMsg);
+              messageIds.add(includeMsg.id);
+            }
+          }
+        }
+      }
+      const messagesWithParsedContent = messages.map((row) => this.parseRow(row));
+      const list = new MessageList().add(messagesWithParsedContent, "memory");
+      let finalMessages = list.get.all.db();
+      finalMessages = finalMessages.sort((a, b) => {
+        const aValue = field === "createdAt" ? new Date(a.createdAt).getTime() : a[field];
+        const bValue = field === "createdAt" ? new Date(b.createdAt).getTime() : b[field];
+        if (aValue == null && bValue == null) return a.id.localeCompare(b.id);
+        if (aValue == null) return 1;
+        if (bValue == null) return -1;
+        if (aValue === bValue) {
+          return a.id.localeCompare(b.id);
+        }
+        if (typeof aValue === "number" && typeof bValue === "number") {
+          return direction === "ASC" ? aValue - bValue : bValue - aValue;
+        }
+        return direction === "ASC" ? String(aValue).localeCompare(String(bValue)) : String(bValue).localeCompare(String(aValue));
+      });
+      const hasMore = perPageInput !== false && offset + perPage < total;
+      return {
+        messages: finalMessages,
+        total,
+        page,
+        perPage: perPageForResponse,
+        hasMore
+      };
+    } catch (error) {
+      const mastraError = new MastraError(
+        {
+          id: createStorageErrorId("PG", "LIST_MESSAGES_BY_RESOURCE_ID", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: {
+            resourceId: resourceId ?? ""
+          }
+        },
+        error
+      );
+      this.logger?.error?.(mastraError.toString());
+      this.logger?.trackException(mastraError);
+      return {
+        messages: [],
+        total: 0,
+        page,
+        perPage: perPageForResponse,
+        hasMore: false
+      };
+    }
+  }
   async saveMessages({ messages }) {
     if (messages.length === 0) return { messages: [] };
     const threadId = messages[0]?.threadId;
@@ -4725,11 +5049,11 @@ var MemoryPG = class _MemoryPG extends MemoryStorage {
         const messageParams = [sourceThreadId];
         let paramIndex = 2;
         if (options?.messageFilter?.startDate) {
-          messageQuery += ` AND "createdAt" >= $${paramIndex++}`;
+          messageQuery += ` AND COALESCE("createdAtZ", "createdAt") >= $${paramIndex++}`;
           messageParams.push(options.messageFilter.startDate);
         }
         if (options?.messageFilter?.endDate) {
-          messageQuery += ` AND "createdAt" <= $${paramIndex++}`;
+          messageQuery += ` AND COALESCE("createdAtZ", "createdAt") <= $${paramIndex++}`;
           messageParams.push(options.messageFilter.endDate);
         }
         if (options?.messageFilter?.messageIds && options.messageFilter.messageIds.length > 0) {
@@ -4837,6 +5161,445 @@ var MemoryPG = class _MemoryPG extends MemoryStorage {
       );
     }
   }
+  // ============================================
+  // Observational Memory Methods
+  // ============================================
+  getOMKey(threadId, resourceId) {
+    return threadId ? `thread:${threadId}` : `resource:${resourceId}`;
+  }
+  parseOMRow(row) {
+    return {
+      id: row.id,
+      scope: row.scope,
+      threadId: row.threadId || null,
+      resourceId: row.resourceId,
+      createdAt: new Date(row.createdAtZ),
+      updatedAt: new Date(row.updatedAtZ),
+      lastObservedAt: row.lastObservedAtZ ? new Date(row.lastObservedAtZ) : void 0,
+      originType: row.originType || "initial",
+      generationCount: Number(row.generationCount || 0),
+      activeObservations: row.activeObservations || "",
+      bufferedObservations: row.activeObservationsPendingUpdate || void 0,
+      totalTokensObserved: Number(row.totalTokensObserved || 0),
+      observationTokenCount: Number(row.observationTokenCount || 0),
+      pendingMessageTokens: Number(row.pendingMessageTokens || 0),
+      isReflecting: Boolean(row.isReflecting),
+      isObserving: Boolean(row.isObserving),
+      config: row.config ? typeof row.config === "string" ? JSON.parse(row.config) : row.config : {},
+      metadata: row.metadata ? typeof row.metadata === "string" ? JSON.parse(row.metadata) : row.metadata : void 0,
+      observedMessageIds: row.observedMessageIds ? typeof row.observedMessageIds === "string" ? JSON.parse(row.observedMessageIds) : row.observedMessageIds : void 0,
+      observedTimezone: row.observedTimezone || void 0
+    };
+  }
+  async getObservationalMemory(threadId, resourceId) {
+    try {
+      const lookupKey = this.getOMKey(threadId, resourceId);
+      const tableName = getTableName3({
+        indexName: OM_TABLE,
+        schemaName: getSchemaName3(this.#schema)
+      });
+      const result = await this.#db.client.oneOrNone(
+        `SELECT * FROM ${tableName} WHERE "lookupKey" = $1 ORDER BY "generationCount" DESC LIMIT 1`,
+        [lookupKey]
+      );
+      if (!result) return null;
+      return this.parseOMRow(result);
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("PG", "GET_OBSERVATIONAL_MEMORY", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { threadId, resourceId }
+        },
+        error
+      );
+    }
+  }
+  async getObservationalMemoryHistory(threadId, resourceId, limit = 10) {
+    try {
+      const lookupKey = this.getOMKey(threadId, resourceId);
+      const tableName = getTableName3({
+        indexName: OM_TABLE,
+        schemaName: getSchemaName3(this.#schema)
+      });
+      const result = await this.#db.client.manyOrNone(
+        `SELECT * FROM ${tableName} WHERE "lookupKey" = $1 ORDER BY "generationCount" DESC LIMIT $2`,
+        [lookupKey, limit]
+      );
+      if (!result) return [];
+      return result.map((row) => this.parseOMRow(row));
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("PG", "GET_OBSERVATIONAL_MEMORY_HISTORY", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { threadId, resourceId, limit }
+        },
+        error
+      );
+    }
+  }
+  async initializeObservationalMemory(input) {
+    try {
+      const id = crypto.randomUUID();
+      const now = /* @__PURE__ */ new Date();
+      const lookupKey = this.getOMKey(input.threadId, input.resourceId);
+      const record = {
+        id,
+        scope: input.scope,
+        threadId: input.threadId,
+        resourceId: input.resourceId,
+        createdAt: now,
+        updatedAt: now,
+        lastObservedAt: void 0,
+        originType: "initial",
+        generationCount: 0,
+        activeObservations: "",
+        totalTokensObserved: 0,
+        observationTokenCount: 0,
+        pendingMessageTokens: 0,
+        isReflecting: false,
+        isObserving: false,
+        config: input.config,
+        observedTimezone: input.observedTimezone
+      };
+      const tableName = getTableName3({
+        indexName: OM_TABLE,
+        schemaName: getSchemaName3(this.#schema)
+      });
+      const nowStr = now.toISOString();
+      await this.#db.client.none(
+        `INSERT INTO ${tableName} (
+          id, "lookupKey", scope, "resourceId", "threadId",
+          "activeObservations", "activeObservationsPendingUpdate",
+          "originType", config, "generationCount", "lastObservedAt", "lastObservedAtZ", "lastReflectionAt", "lastReflectionAtZ",
+          "pendingMessageTokens", "totalTokensObserved", "observationTokenCount",
+          "isObserving", "isReflecting", "observedTimezone", "createdAt", "createdAtZ", "updatedAt", "updatedAtZ"
+        ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17, $18, $19, $20, $21, $22, $23, $24)`,
+        [
+          id,
+          lookupKey,
+          input.scope,
+          input.resourceId,
+          input.threadId || null,
+          "",
+          null,
+          "initial",
+          JSON.stringify(input.config),
+          0,
+          null,
+          // lastObservedAt
+          null,
+          // lastObservedAtZ
+          null,
+          // lastReflectionAt
+          null,
+          // lastReflectionAtZ
+          0,
+          0,
+          0,
+          false,
+          false,
+          input.observedTimezone || null,
+          nowStr,
+          // createdAt
+          nowStr,
+          // createdAtZ
+          nowStr,
+          // updatedAt
+          nowStr
+          // updatedAtZ
+        ]
+      );
+      return record;
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("PG", "INITIALIZE_OBSERVATIONAL_MEMORY", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { threadId: input.threadId, resourceId: input.resourceId }
+        },
+        error
+      );
+    }
+  }
+  async updateActiveObservations(input) {
+    try {
+      const now = /* @__PURE__ */ new Date();
+      const tableName = getTableName3({
+        indexName: OM_TABLE,
+        schemaName: getSchemaName3(this.#schema)
+      });
+      const lastObservedAtStr = input.lastObservedAt.toISOString();
+      const nowStr = now.toISOString();
+      const observedMessageIdsJson = input.observedMessageIds ? JSON.stringify(input.observedMessageIds) : null;
+      const result = await this.#db.client.query(
+        `UPDATE ${tableName} SET
+          "activeObservations" = $1,
+          "lastObservedAt" = $2,
+          "lastObservedAtZ" = $3,
+          "pendingMessageTokens" = 0,
+          "observationTokenCount" = $4,
+          "totalTokensObserved" = "totalTokensObserved" + $5,
+          "observedMessageIds" = $6,
+          "updatedAt" = $7,
+          "updatedAtZ" = $8
+        WHERE id = $9`,
+        [
+          input.observations,
+          lastObservedAtStr,
+          lastObservedAtStr,
+          input.tokenCount,
+          input.tokenCount,
+          observedMessageIdsJson,
+          nowStr,
+          nowStr,
+          input.id
+        ]
+      );
+      if (result.rowCount === 0) {
+        throw new MastraError({
+          id: createStorageErrorId("PG", "UPDATE_ACTIVE_OBSERVATIONS", "NOT_FOUND"),
+          text: `Observational memory record not found: ${input.id}`,
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { id: input.id }
+        });
+      }
+    } catch (error) {
+      if (error instanceof MastraError) {
+        throw error;
+      }
+      throw new MastraError(
+        {
+          id: createStorageErrorId("PG", "UPDATE_ACTIVE_OBSERVATIONS", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { id: input.id }
+        },
+        error
+      );
+    }
+  }
+  async createReflectionGeneration(input) {
+    try {
+      const id = crypto.randomUUID();
+      const now = /* @__PURE__ */ new Date();
+      const lookupKey = this.getOMKey(input.currentRecord.threadId, input.currentRecord.resourceId);
+      const record = {
+        id,
+        scope: input.currentRecord.scope,
+        threadId: input.currentRecord.threadId,
+        resourceId: input.currentRecord.resourceId,
+        createdAt: now,
+        updatedAt: now,
+        lastObservedAt: input.currentRecord.lastObservedAt,
+        originType: "reflection",
+        generationCount: input.currentRecord.generationCount + 1,
+        activeObservations: input.reflection,
+        totalTokensObserved: input.currentRecord.totalTokensObserved,
+        observationTokenCount: input.tokenCount,
+        pendingMessageTokens: 0,
+        isReflecting: false,
+        isObserving: false,
+        config: input.currentRecord.config,
+        metadata: input.currentRecord.metadata,
+        observedTimezone: input.currentRecord.observedTimezone
+      };
+      const tableName = getTableName3({
+        indexName: OM_TABLE,
+        schemaName: getSchemaName3(this.#schema)
+      });
+      const nowStr = now.toISOString();
+      const lastObservedAtStr = record.lastObservedAt?.toISOString() || null;
+      await this.#db.client.none(
+        `INSERT INTO ${tableName} (
+          id, "lookupKey", scope, "resourceId", "threadId",
+          "activeObservations", "activeObservationsPendingUpdate",
+          "originType", config, "generationCount", "lastObservedAt", "lastObservedAtZ", "lastReflectionAt", "lastReflectionAtZ",
+          "pendingMessageTokens", "totalTokensObserved", "observationTokenCount",
+          "isObserving", "isReflecting", "observedTimezone", "createdAt", "createdAtZ", "updatedAt", "updatedAtZ"
+        ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17, $18, $19, $20, $21, $22, $23, $24)`,
+        [
+          id,
+          lookupKey,
+          record.scope,
+          record.resourceId,
+          record.threadId || null,
+          input.reflection,
+          null,
+          "reflection",
+          JSON.stringify(record.config),
+          input.currentRecord.generationCount + 1,
+          lastObservedAtStr,
+          // lastObservedAt
+          lastObservedAtStr,
+          // lastObservedAtZ
+          nowStr,
+          // lastReflectionAt
+          nowStr,
+          // lastReflectionAtZ
+          record.pendingMessageTokens,
+          record.totalTokensObserved,
+          record.observationTokenCount,
+          false,
+          false,
+          record.observedTimezone || null,
+          nowStr,
+          // createdAt
+          nowStr,
+          // createdAtZ
+          nowStr,
+          // updatedAt
+          nowStr
+          // updatedAtZ
+        ]
+      );
+      return record;
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("PG", "CREATE_REFLECTION_GENERATION", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { currentRecordId: input.currentRecord.id }
+        },
+        error
+      );
+    }
+  }
+  async setReflectingFlag(id, isReflecting) {
+    try {
+      const tableName = getTableName3({
+        indexName: OM_TABLE,
+        schemaName: getSchemaName3(this.#schema)
+      });
+      const nowStr = (/* @__PURE__ */ new Date()).toISOString();
+      const result = await this.#db.client.query(
+        `UPDATE ${tableName} SET "isReflecting" = $1, "updatedAt" = $2, "updatedAtZ" = $3 WHERE id = $4`,
+        [isReflecting, nowStr, nowStr, id]
+      );
+      if (result.rowCount === 0) {
+        throw new MastraError({
+          id: createStorageErrorId("PG", "SET_REFLECTING_FLAG", "NOT_FOUND"),
+          text: `Observational memory record not found: ${id}`,
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { id, isReflecting }
+        });
+      }
+    } catch (error) {
+      if (error instanceof MastraError) {
+        throw error;
+      }
+      throw new MastraError(
+        {
+          id: createStorageErrorId("PG", "SET_REFLECTING_FLAG", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { id, isReflecting }
+        },
+        error
+      );
+    }
+  }
+  async setObservingFlag(id, isObserving) {
+    try {
+      const tableName = getTableName3({
+        indexName: OM_TABLE,
+        schemaName: getSchemaName3(this.#schema)
+      });
+      const nowStr = (/* @__PURE__ */ new Date()).toISOString();
+      const result = await this.#db.client.query(
+        `UPDATE ${tableName} SET "isObserving" = $1, "updatedAt" = $2, "updatedAtZ" = $3 WHERE id = $4`,
+        [isObserving, nowStr, nowStr, id]
+      );
+      if (result.rowCount === 0) {
+        throw new MastraError({
+          id: createStorageErrorId("PG", "SET_OBSERVING_FLAG", "NOT_FOUND"),
+          text: `Observational memory record not found: ${id}`,
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { id, isObserving }
+        });
+      }
+    } catch (error) {
+      if (error instanceof MastraError) {
+        throw error;
+      }
+      throw new MastraError(
+        {
+          id: createStorageErrorId("PG", "SET_OBSERVING_FLAG", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { id, isObserving }
+        },
+        error
+      );
+    }
+  }
+  async clearObservationalMemory(threadId, resourceId) {
+    try {
+      const lookupKey = this.getOMKey(threadId, resourceId);
+      const tableName = getTableName3({
+        indexName: OM_TABLE,
+        schemaName: getSchemaName3(this.#schema)
+      });
+      await this.#db.client.none(`DELETE FROM ${tableName} WHERE "lookupKey" = $1`, [lookupKey]);
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("PG", "CLEAR_OBSERVATIONAL_MEMORY", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { threadId, resourceId }
+        },
+        error
+      );
+    }
+  }
+  async addPendingMessageTokens(id, tokenCount) {
+    try {
+      const tableName = getTableName3({
+        indexName: OM_TABLE,
+        schemaName: getSchemaName3(this.#schema)
+      });
+      const nowStr = (/* @__PURE__ */ new Date()).toISOString();
+      const result = await this.#db.client.query(
+        `UPDATE ${tableName} SET 
+          "pendingMessageTokens" = "pendingMessageTokens" + $1, 
+          "updatedAt" = $2,
+          "updatedAtZ" = $3
+        WHERE id = $4`,
+        [tokenCount, nowStr, nowStr, id]
+      );
+      if (result.rowCount === 0) {
+        throw new MastraError({
+          id: createStorageErrorId("PG", "ADD_PENDING_MESSAGE_TOKENS", "NOT_FOUND"),
+          text: `Observational memory record not found: ${id}`,
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { id, tokenCount }
+        });
+      }
+    } catch (error) {
+      if (error instanceof MastraError) {
+        throw error;
+      }
+      throw new MastraError(
+        {
+          id: createStorageErrorId("PG", "ADD_PENDING_MESSAGE_TOKENS", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { id, tokenCount }
+        },
+        error
+      );
+    }
+  }
 };
 var ObservabilityPG = class _ObservabilityPG extends ObservabilityStorage {
   #db;