@mastra/pg 0.0.0-studio-deploy-20260404182525 → 0.0.0-studio-cli-20260504022012

package/dist/index.cjs

@@ -734,6 +734,25 @@ var PgVector = class extends vector.MastraVector {
       return null;
     }
   }
+  /**
+   * Sets search_path on the client connection so that vector operators (e.g. <=>, vector_cosine_ops)
+   * are resolvable when the pgvector extension is installed in a non-default schema.
+   *
+   * PostgreSQL's default search_path is ("$user", public). If the extension lives in a custom schema
+   * (e.g. "myapp"), operator classes and distance operators won't resolve without this.
+   */
+  async ensureSearchPath(client) {
+    if (!this.vectorExtensionSchema) {
+      await this.detectVectorExtensionSchema(client);
+    }
+    if (this.vectorExtensionSchema && this.vectorExtensionSchema !== "public" && this.vectorExtensionSchema !== "pg_catalog") {
+      const schemas = /* @__PURE__ */ new Set();
+      schemas.add(this.vectorExtensionSchema);
+      if (this.schema) schemas.add(this.schema);
+      schemas.add("public");
+      await client.query(`SET search_path TO ${[...schemas].map((s) => `"${s}"`).join(", ")}`);
+    }
+  }
   /**
    * Checks if the installed pgvector version supports halfvec type.
    * halfvec was introduced in pgvector 0.7.0.
@@ -947,6 +966,7 @@ var PgVector = class extends vector.MastraVector {
     }
     const client = await this.pool.connect();
     try {
+      await this.ensureSearchPath(client);
       await client.query("BEGIN");
       const translatedFilter = this.transformFilter(filter);
       const { sql: filterQuery, values: filterValues } = buildFilterQuery(translatedFilter, minScore, topK);
@@ -966,7 +986,23 @@ var PgVector = class extends vector.MastraVector {
       const qualifiedVectorType = this.getVectorTypeName(indexInfo.vectorType, indexInfo.dimension);
       const distanceExpr = `embedding ${ops.distanceOperator} '${vectorStr}'::${qualifiedVectorType}`;
       const scoreExpr = ops.scoreExpr(distanceExpr);
-      const query = `
+      const hasFilter = filterQuery.trim().length > 0;
+      const useIndexedOrder = indexInfo.type === "hnsw" && !hasFilter && minScore <= 0;
+      const query = useIndexedOrder ? `
+        WITH vector_scores AS (
+          SELECT
+            vector_id as id,
+            ${scoreExpr} as score,
+            metadata
+            ${includeVector ? ", embedding" : ""}
+          FROM ${tableName}
+          ORDER BY ${distanceExpr}
+          LIMIT $2
+        )
+        SELECT *
+        FROM vector_scores
+        WHERE score > $1
+        ORDER BY score DESC` : `
         WITH vector_scores AS (
           SELECT
             vector_id as id,
@@ -1019,6 +1055,7 @@ var PgVector = class extends vector.MastraVector {
     const { tableName } = this.getTableName(indexName);
     const client = await this.pool.connect();
     try {
+      await this.ensureSearchPath(client);
       await client.query("BEGIN");
       if (deleteFilter) {
         this.logger?.debug(`Deleting vectors matching filter before upsert`, { indexName, deleteFilter });
@@ -1269,9 +1306,6 @@ var PgVector = class extends vector.MastraVector {
             }
           });
         }
-        if (this.schema && this.vectorExtensionSchema && this.schema !== this.vectorExtensionSchema && this.vectorExtensionSchema !== "pg_catalog") {
-          await client.query(`SET search_path TO ${this.getSchemaName()}, "${this.vectorExtensionSchema}"`);
-        }
         const qualifiedVectorType = this.getVectorTypeName(vectorType);
         await client.query(`
           CREATE TABLE IF NOT EXISTS ${tableName} (
@@ -1414,6 +1448,7 @@ var PgVector = class extends vector.MastraVector {
         this.describeIndexCache.delete(indexName);
         return;
       }
+      await this.ensureSearchPath(client);
       const effectiveVectorType = existingIndexInfo?.vectorType ?? vectorType;
       const metricOp = this.getVectorOps(effectiveVectorType, metric).operatorClass;
       let indexSQL;
@@ -1764,6 +1799,7 @@ var PgVector = class extends vector.MastraVector {
         });
       }
       client = await this.pool.connect();
+      await this.ensureSearchPath(client);
       const { tableName } = this.getTableName(indexName);
       const indexInfo = await this.getIndexInfo({ indexName });
       const qualifiedVectorType = this.getVectorTypeName(indexInfo.vectorType, indexInfo.dimension);
@@ -2002,6 +2038,7 @@ var PoolAdapter = class {
   constructor($pool) {
     this.$pool = $pool;
   }
+  $pool;
   connect() {
     return this.$pool.connect();
   }
@@ -2070,6 +2107,7 @@ var TransactionClient = class {
   constructor(client) {
     this.client = client;
   }
+  client;
   async none(query, values) {
     await this.client.query(query, values);
     return null;
@@ -2499,36 +2537,39 @@ var PgDB = class extends base.MastraBase {
         return storage.getDefaultValue(type);
     }
   }
-  async insert({ tableName, record }) {
-    try {
-      this.addTimestampZColumns(record);
-      const filteredRecord = await this.filterRecordToKnownColumns(tableName, record);
-      const schemaName = getSchemaName(this.schemaName);
-      const columns = Object.keys(filteredRecord).map((col) => utils.parseSqlIdentifier(col, "column name"));
-      if (columns.length === 0) return;
-      const values = this.prepareValuesForInsert(filteredRecord, tableName);
-      const placeholders = values.map((_, i) => `$${i + 1}`).join(", ");
-      const fullTableName = getTableName({ indexName: tableName, schemaName });
-      const columnList = columns.map((c) => `"${c}"`).join(", ");
-      if (tableName === storage.TABLE_SPANS) {
-        const updateColumns = columns.filter((c) => c !== "traceId" && c !== "spanId");
-        if (updateColumns.length > 0) {
-          const updateClause = updateColumns.map((c) => `"${c}" = EXCLUDED."${c}"`).join(", ");
-          await this.client.none(
-            `INSERT INTO ${fullTableName} (${columnList}) VALUES (${placeholders})
+  async executeInsert(client, { tableName, record }) {
+    this.addTimestampZColumns(record);
+    const filteredRecord = await this.filterRecordToKnownColumns(tableName, record);
+    const schemaName = getSchemaName(this.schemaName);
+    const columns = Object.keys(filteredRecord).map((col) => utils.parseSqlIdentifier(col, "column name"));
+    if (columns.length === 0) return;
+    const values = this.prepareValuesForInsert(filteredRecord, tableName);
+    const placeholders = values.map((_, i) => `$${i + 1}`).join(", ");
+    const fullTableName = getTableName({ indexName: tableName, schemaName });
+    const columnList = columns.map((c) => `"${c}"`).join(", ");
+    if (tableName === storage.TABLE_SPANS) {
+      const updateColumns = columns.filter((c) => c !== "traceId" && c !== "spanId");
+      if (updateColumns.length > 0) {
+        const updateClause = updateColumns.map((c) => `"${c}" = EXCLUDED."${c}"`).join(", ");
+        await client.none(
+          `INSERT INTO ${fullTableName} (${columnList}) VALUES (${placeholders})
              ON CONFLICT ("traceId", "spanId") DO UPDATE SET ${updateClause}`,
-            values
-          );
-        } else {
-          await this.client.none(
-            `INSERT INTO ${fullTableName} (${columnList}) VALUES (${placeholders})
-             ON CONFLICT ("traceId", "spanId") DO NOTHING`,
-            values
-          );
-        }
+          values
+        );
       } else {
-        await this.client.none(`INSERT INTO ${fullTableName} (${columnList}) VALUES (${placeholders})`, values);
+        await client.none(
+          `INSERT INTO ${fullTableName} (${columnList}) VALUES (${placeholders})
+             ON CONFLICT ("traceId", "spanId") DO NOTHING`,
+          values
+        );
       }
+    } else {
+      await client.none(`INSERT INTO ${fullTableName} (${columnList}) VALUES (${placeholders})`, values);
+    }
+  }
+  async insert({ tableName, record }) {
+    try {
+      await this.executeInsert(this.client, { tableName, record });
     } catch (error$1) {
       throw new error.MastraError(
         {
@@ -3003,13 +3044,12 @@ Note: This migration may take some time for large tables.
   }
   async batchInsert({ tableName, records }) {
     try {
-      await this.client.query("BEGIN");
-      for (const record of records) {
-        await this.insert({ tableName, record });
-      }
-      await this.client.query("COMMIT");
+      await this.client.tx(async (tx) => {
+        for (const record of records) {
+          await this.executeInsert(tx, { tableName, record });
+        }
+      });
     } catch (error$1) {
-      await this.client.query("ROLLBACK");
       throw new error.MastraError(
         {
           id: storage.createStorageErrorId("PG", "BATCH_INSERT", "FAILED"),
@@ -3287,30 +3327,7 @@ Note: This migration may take some time for large tables.
     data
   }) {
     try {
-      const filteredData = await this.filterRecordToKnownColumns(tableName, data);
-      if (Object.keys(filteredData).length === 0) return;
-      const setColumns = [];
-      const setValues = [];
-      let paramIndex = 1;
-      Object.entries(filteredData).forEach(([key, value]) => {
-        const parsedKey = utils.parseSqlIdentifier(key, "column name");
-        setColumns.push(`"${parsedKey}" = $${paramIndex++}`);
-        setValues.push(this.prepareValue(value, key, tableName));
-      });
-      const whereConditions = [];
-      const whereValues = [];
-      Object.entries(keys).forEach(([key, value]) => {
-        const parsedKey = utils.parseSqlIdentifier(key, "column name");
-        whereConditions.push(`"${parsedKey}" = $${paramIndex++}`);
-        whereValues.push(this.prepareValue(value, key, tableName));
-      });
-      const tableName_ = getTableName({
-        indexName: tableName,
-        schemaName: getSchemaName(this.schemaName)
-      });
-      const sql = `UPDATE ${tableName_} SET ${setColumns.join(", ")} WHERE ${whereConditions.join(" AND ")}`;
-      const values = [...setValues, ...whereValues];
-      await this.client.none(sql, values);
+      await this.executeUpdate(this.client, { tableName, keys, data });
     } catch (error$1) {
       throw new error.MastraError(
         {
@@ -3330,13 +3347,12 @@ Note: This migration may take some time for large tables.
     updates
   }) {
     try {
-      await this.client.query("BEGIN");
-      for (const { keys, data } of updates) {
-        await this.update({ tableName, keys, data });
-      }
-      await this.client.query("COMMIT");
+      await this.client.tx(async (tx) => {
+        for (const { keys, data } of updates) {
+          await this.executeUpdate(tx, { tableName, keys, data });
+        }
+      });
     } catch (error$1) {
-      await this.client.query("ROLLBACK");
       throw new error.MastraError(
         {
           id: storage.createStorageErrorId("PG", "BATCH_UPDATE", "FAILED"),
@@ -3395,6 +3411,36 @@ Note: This migration may take some time for large tables.
   async deleteData({ tableName }) {
     return this.clearTable({ tableName });
   }
+  async executeUpdate(client, {
+    tableName,
+    keys,
+    data
+  }) {
+    const filteredData = await this.filterRecordToKnownColumns(tableName, data);
+    if (Object.keys(filteredData).length === 0) return;
+    const setColumns = [];
+    const setValues = [];
+    let paramIndex = 1;
+    Object.entries(filteredData).forEach(([key, value]) => {
+      const parsedKey = utils.parseSqlIdentifier(key, "column name");
+      setColumns.push(`"${parsedKey}" = $${paramIndex++}`);
+      setValues.push(this.prepareValue(value, key, tableName));
+    });
+    const whereConditions = [];
+    const whereValues = [];
+    Object.entries(keys).forEach(([key, value]) => {
+      const parsedKey = utils.parseSqlIdentifier(key, "column name");
+      whereConditions.push(`"${parsedKey}" = $${paramIndex++}`);
+      whereValues.push(this.prepareValue(value, key, tableName));
+    });
+    const tableName_ = getTableName({
+      indexName: tableName,
+      schemaName: getSchemaName(this.schemaName)
+    });
+    const sql = `UPDATE ${tableName_} SET ${setColumns.join(", ")} WHERE ${whereConditions.join(" AND ")}`;
+    const values = [...setValues, ...whereValues];
+    await client.none(sql, values);
+  }
 };
 function getSchemaName2(schema) {
   return schema ? `"${utils.parseSqlIdentifier(schema, "schema name")}"` : void 0;
@@ -4234,6 +4280,307 @@ var AgentsPG = class _AgentsPG extends storage.AgentsStorage {
     };
   }
 };
+function getSchemaName3(schema) {
+  return schema ? `"${schema}"` : '"public"';
+}
+function getTableName3(schemaName) {
+  const quoted = `"${storage.TABLE_BACKGROUND_TASKS}"`;
+  return schemaName ? `${schemaName}.${quoted}` : quoted;
+}
+function serializeJson(v) {
+  if (typeof v === "object" && v != null) return JSON.stringify(v);
+  return v ?? null;
+}
+function parseJson(v) {
+  if (typeof v === "string") {
+    try {
+      return JSON.parse(v);
+    } catch {
+      return v;
+    }
+  }
+  return v ?? void 0;
+}
+function rowToTask(row) {
+  return {
+    id: row.id,
+    status: row.status,
+    toolName: row.tool_name,
+    toolCallId: row.tool_call_id,
+    args: parseJson(row.args),
+    agentId: row.agent_id,
+    threadId: row.thread_id ?? void 0,
+    resourceId: row.resource_id ?? void 0,
+    runId: row.run_id,
+    result: parseJson(row.result),
+    error: parseJson(row.error),
+    retryCount: Number(row.retry_count),
+    maxRetries: Number(row.max_retries),
+    timeoutMs: Number(row.timeout_ms),
+    createdAt: row.createdAt instanceof Date ? row.createdAt : new Date(row.createdAt),
+    startedAt: row.startedAt ? row.startedAt instanceof Date ? row.startedAt : new Date(row.startedAt) : void 0,
+    completedAt: row.completedAt ? row.completedAt instanceof Date ? row.completedAt : new Date(row.completedAt) : void 0
+  };
+}
+var BackgroundTasksPG = class _BackgroundTasksPG extends storage.BackgroundTasksStorage {
+  #db;
+  #schema;
+  #skipDefaultIndexes;
+  #indexes;
+  static MANAGED_TABLES = [storage.TABLE_BACKGROUND_TASKS];
+  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) => _BackgroundTasksPG.MANAGED_TABLES.includes(idx.table));
+  }
+  async init() {
+    await this.#db.createTable({
+      tableName: storage.TABLE_BACKGROUND_TASKS,
+      schema: storage.TABLE_SCHEMAS[storage.TABLE_BACKGROUND_TASKS]
+    });
+    await this.createDefaultIndexes();
+    await this.createCustomIndexes();
+  }
+  static getDefaultIndexDefs(schemaPrefix) {
+    return [
+      {
+        name: `${schemaPrefix}mastra_bg_tasks_status_created_at_idx`,
+        table: storage.TABLE_BACKGROUND_TASKS,
+        columns: ["status", "createdAt"]
+      },
+      {
+        name: `${schemaPrefix}mastra_bg_tasks_agent_status_idx`,
+        table: storage.TABLE_BACKGROUND_TASKS,
+        columns: ["agent_id", "status"]
+      },
+      {
+        name: `${schemaPrefix}mastra_bg_tasks_thread_idx`,
+        table: storage.TABLE_BACKGROUND_TASKS,
+        columns: ["thread_id", "createdAt"]
+      },
+      {
+        name: `${schemaPrefix}mastra_bg_tasks_tool_call_idx`,
+        table: storage.TABLE_BACKGROUND_TASKS,
+        columns: ["tool_call_id"]
+      }
+    ];
+  }
+  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_BACKGROUND_TASKS,
+        schema: storage.TABLE_SCHEMAS[storage.TABLE_BACKGROUND_TASKS],
+        schemaName,
+        includeAllConstraints: true
+      })
+    );
+    for (const idx of _BackgroundTasksPG.getDefaultIndexDefs(schemaPrefix)) {
+      statements.push(generateIndexSQL(idx, schemaName));
+    }
+    return statements;
+  }
+  getDefaultIndexDefinitions() {
+    const schemaPrefix = this.#schema !== "public" ? `${this.#schema}_` : "";
+    return _BackgroundTasksPG.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_BACKGROUND_TASKS });
+  }
+  async createTask(task) {
+    await this.#db.insert({
+      tableName: storage.TABLE_BACKGROUND_TASKS,
+      record: {
+        id: task.id,
+        tool_call_id: task.toolCallId,
+        tool_name: task.toolName,
+        agent_id: task.agentId,
+        thread_id: task.threadId ?? null,
+        resource_id: task.resourceId ?? null,
+        run_id: task.runId,
+        status: task.status,
+        args: serializeJson(task.args),
+        result: serializeJson(task.result),
+        error: serializeJson(task.error),
+        retry_count: task.retryCount,
+        max_retries: task.maxRetries,
+        timeout_ms: task.timeoutMs,
+        createdAt: task.createdAt.toISOString(),
+        startedAt: task.startedAt?.toISOString() ?? null,
+        completedAt: task.completedAt?.toISOString() ?? null
+      }
+    });
+  }
+  async updateTask(taskId, update) {
+    const setClauses = [];
+    const params = [];
+    let paramIdx = 1;
+    if ("status" in update) {
+      setClauses.push(`"status" = $${paramIdx++}`);
+      params.push(update.status);
+    }
+    if ("result" in update) {
+      setClauses.push(`"result" = $${paramIdx++}`);
+      params.push(serializeJson(update.result));
+    }
+    if ("error" in update) {
+      setClauses.push(`"error" = $${paramIdx++}`);
+      params.push(serializeJson(update.error));
+    }
+    if ("retryCount" in update) {
+      setClauses.push(`"retry_count" = $${paramIdx++}`);
+      params.push(update.retryCount);
+    }
+    if ("startedAt" in update) {
+      setClauses.push(`"startedAt" = $${paramIdx++}`);
+      params.push(update.startedAt?.toISOString() ?? null);
+    }
+    if ("completedAt" in update) {
+      setClauses.push(`"completedAt" = $${paramIdx++}`);
+      params.push(update.completedAt?.toISOString() ?? null);
+    }
+    if (setClauses.length === 0) return;
+    const table = getTableName3(getSchemaName3(this.#schema));
+    params.push(taskId);
+    await this.#db.client.none(`UPDATE ${table} SET ${setClauses.join(", ")} WHERE "id" = $${paramIdx}`, params);
+  }
+  async getTask(taskId) {
+    const table = getTableName3(getSchemaName3(this.#schema));
+    const row = await this.#db.client.oneOrNone(`SELECT * FROM ${table} WHERE "id" = $1`, [taskId]);
+    return row ? rowToTask(row) : null;
+  }
+  async listTasks(filter) {
+    const table = getTableName3(getSchemaName3(this.#schema));
+    const conditions = [];
+    const params = [];
+    let paramIdx = 1;
+    if (filter.status) {
+      const statuses = Array.isArray(filter.status) ? filter.status : [filter.status];
+      const placeholders = statuses.map(() => `$${paramIdx++}`);
+      conditions.push(`"status" IN (${placeholders.join(", ")})`);
+      params.push(...statuses);
+    }
+    if (filter.agentId) {
+      conditions.push(`"agent_id" = $${paramIdx++}`);
+      params.push(filter.agentId);
+    }
+    if (filter.threadId) {
+      conditions.push(`"thread_id" = $${paramIdx++}`);
+      params.push(filter.threadId);
+    }
+    if (filter.resourceId) {
+      conditions.push(`"resource_id" = $${paramIdx++}`);
+      params.push(filter.resourceId);
+    }
+    if (filter.runId) {
+      conditions.push(`"run_id" = $${paramIdx++}`);
+      params.push(filter.runId);
+    }
+    if (filter.toolName) {
+      conditions.push(`"tool_name" = $${paramIdx++}`);
+      params.push(filter.toolName);
+    }
+    const dateCol = filter.dateFilterBy === "startedAt" ? '"startedAt"' : filter.dateFilterBy === "completedAt" ? '"completedAt"' : '"createdAt"';
+    if (filter.fromDate) {
+      conditions.push(`${dateCol} >= $${paramIdx++}`);
+      params.push(filter.fromDate.toISOString());
+    }
+    if (filter.toDate) {
+      conditions.push(`${dateCol} < $${paramIdx++}`);
+      params.push(filter.toDate.toISOString());
+    }
+    const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    const countResult = await this.#db.client.oneOrNone(
+      `SELECT COUNT(*) as count FROM ${table} ${where}`,
+      params.slice(0, paramIdx - 1)
+    );
+    const total = Number(countResult?.count ?? 0);
+    const orderCol = filter.orderBy === "startedAt" ? '"startedAt"' : filter.orderBy === "completedAt" ? '"completedAt"' : '"createdAt"';
+    const direction = filter.orderDirection === "desc" ? "DESC" : "ASC";
+    let sql = `SELECT * FROM ${table} ${where} ORDER BY ${orderCol} ${direction}`;
+    if (filter.perPage != null) {
+      sql += ` LIMIT $${paramIdx++}`;
+      params.push(filter.perPage);
+      if (filter.page != null) {
+        sql += ` OFFSET $${paramIdx++}`;
+        params.push(filter.page * filter.perPage);
+      }
+    }
+    const rows = await this.#db.client.manyOrNone(sql, params);
+    return { tasks: rows.map(rowToTask), total };
+  }
+  async deleteTask(taskId) {
+    const table = getTableName3(getSchemaName3(this.#schema));
+    await this.#db.client.none(`DELETE FROM ${table} WHERE "id" = $1`, [taskId]);
+  }
+  async deleteTasks(filter) {
+    const table = getTableName3(getSchemaName3(this.#schema));
+    const conditions = [];
+    const params = [];
+    let paramIdx = 1;
+    if (filter.status) {
+      const statuses = Array.isArray(filter.status) ? filter.status : [filter.status];
+      const placeholders = statuses.map(() => `$${paramIdx++}`);
+      conditions.push(`"status" IN (${placeholders.join(", ")})`);
+      params.push(...statuses);
+    }
+    const dateCol = filter.dateFilterBy === "startedAt" ? '"startedAt"' : filter.dateFilterBy === "completedAt" ? '"completedAt"' : '"createdAt"';
+    if (filter.fromDate) {
+      conditions.push(`${dateCol} >= $${paramIdx++}`);
+      params.push(filter.fromDate.toISOString());
+    }
+    if (filter.toDate) {
+      conditions.push(`${dateCol} < $${paramIdx++}`);
+      params.push(filter.toDate.toISOString());
+    }
+    if (filter.agentId) {
+      conditions.push(`"agent_id" = $${paramIdx++}`);
+      params.push(filter.agentId);
+    }
+    if (conditions.length === 0) return;
+    await this.#db.client.none(`DELETE FROM ${table} WHERE ${conditions.join(" AND ")}`, params);
+  }
+  async getRunningCount() {
+    const table = getTableName3(getSchemaName3(this.#schema));
+    const result = await this.#db.client.oneOrNone(
+      `SELECT COUNT(*) FROM ${table} WHERE "status" = 'running'`
+    );
+    return Number(result?.count ?? 0);
+  }
+  async getRunningCountByAgent(agentId) {
+    const table = getTableName3(getSchemaName3(this.#schema));
+    const result = await this.#db.client.oneOrNone(
+      `SELECT COUNT(*) FROM ${table} WHERE "status" = 'running' AND "agent_id" = $1`,
+      [agentId]
+    );
+    return Number(result?.count ?? 0);
+  }
+};
 var BlobsPG = class extends storage.BlobStore {
   #db;
   #schema;
@@ -4311,6 +4658,202 @@ var BlobsPG = class extends storage.BlobStore {
     };
   }
 };
+var ChannelsPG = class _ChannelsPG extends storage.ChannelsStorage {
+  #db;
+  #schema;
+  #skipDefaultIndexes;
+  #indexes;
+  static MANAGED_TABLES = [storage.TABLE_CHANNEL_INSTALLATIONS, storage.TABLE_CHANNEL_CONFIG];
+  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) => _ChannelsPG.MANAGED_TABLES.includes(idx.table));
+  }
+  async init() {
+    await this.#db.createTable({
+      tableName: storage.TABLE_CHANNEL_INSTALLATIONS,
+      schema: storage.TABLE_SCHEMAS[storage.TABLE_CHANNEL_INSTALLATIONS]
+    });
+    await this.#db.createTable({
+      tableName: storage.TABLE_CHANNEL_CONFIG,
+      schema: storage.TABLE_SCHEMAS[storage.TABLE_CHANNEL_CONFIG]
+    });
+    await this.createDefaultIndexes();
+    await this.createCustomIndexes();
+  }
+  static getDefaultIndexDefs(schemaPrefix) {
+    return [
+      {
+        name: `${schemaPrefix}idx_channel_installations_webhook`,
+        table: storage.TABLE_CHANNEL_INSTALLATIONS,
+        columns: ["webhookId"],
+        unique: true
+      },
+      {
+        name: `${schemaPrefix}idx_channel_installations_platform_agent`,
+        table: storage.TABLE_CHANNEL_INSTALLATIONS,
+        columns: ["platform", "agentId"]
+      }
+    ];
+  }
+  static getExportDDL(schemaName) {
+    const statements = [];
+    const parsedSchema = schemaName ? utils.parseSqlIdentifier(schemaName, "schema name") : "";
+    const schemaPrefix = parsedSchema && parsedSchema !== "public" ? `${parsedSchema}_` : "";
+    for (const tableName of _ChannelsPG.MANAGED_TABLES) {
+      statements.push(
+        generateTableSQL({
+          tableName,
+          schema: storage.TABLE_SCHEMAS[tableName],
+          schemaName,
+          includeAllConstraints: true
+        })
+      );
+    }
+    for (const idx of _ChannelsPG.getDefaultIndexDefs(schemaPrefix)) {
+      statements.push(generateIndexSQL(idx, schemaName));
+    }
+    return statements;
+  }
+  getDefaultIndexDefinitions() {
+    const schemaPrefix = this.#schema !== "public" ? `${this.#schema}_` : "";
+    return _ChannelsPG.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_CHANNEL_INSTALLATIONS });
+    await this.#db.clearTable({ tableName: storage.TABLE_CHANNEL_CONFIG });
+  }
+  async saveInstallation(installation) {
+    const schemaName = getSchemaName2(this.#schema);
+    const tableName = getTableName2({ indexName: storage.TABLE_CHANNEL_INSTALLATIONS, schemaName });
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    await this.#db.client.none(
+      `INSERT INTO ${tableName} ("id", "platform", "agentId", "status", "webhookId", "data", "configHash", "error", "createdAt", "updatedAt")
+       VALUES ($1, $2, $3, $4, $5, $6::jsonb, $7, $8, $9, $10)
+       ON CONFLICT ("id") DO UPDATE SET
+         "platform" = EXCLUDED."platform",
+         "agentId" = EXCLUDED."agentId",
+         "status" = EXCLUDED."status",
+         "webhookId" = EXCLUDED."webhookId",
+         "data" = EXCLUDED."data",
+         "configHash" = EXCLUDED."configHash",
+         "error" = EXCLUDED."error",
+         "updatedAt" = EXCLUDED."updatedAt"`,
+      [
+        installation.id,
+        installation.platform,
+        installation.agentId,
+        installation.status,
+        installation.webhookId ?? null,
+        JSON.stringify(installation.data),
+        installation.configHash ?? null,
+        installation.error ?? null,
+        installation.createdAt?.toISOString() ?? now,
+        now
+      ]
+    );
+  }
+  async getInstallation(id) {
+    const schemaName = getSchemaName2(this.#schema);
+    const tableName = getTableName2({ indexName: storage.TABLE_CHANNEL_INSTALLATIONS, schemaName });
+    const row = await this.#db.client.oneOrNone(`SELECT * FROM ${tableName} WHERE "id" = $1`, [id]);
+    return row ? this.#parseInstallationRow(row) : null;
+  }
+  async getInstallationByAgent(platform, agentId) {
+    const schemaName = getSchemaName2(this.#schema);
+    const tableName = getTableName2({ indexName: storage.TABLE_CHANNEL_INSTALLATIONS, schemaName });
+    const row = await this.#db.client.oneOrNone(
+      `SELECT * FROM ${tableName} WHERE "platform" = $1 AND "agentId" = $2 ORDER BY CASE "status" WHEN 'active' THEN 0 WHEN 'pending' THEN 1 ELSE 2 END, "updatedAt" DESC LIMIT 1`,
+      [platform, agentId]
+    );
+    return row ? this.#parseInstallationRow(row) : null;
+  }
+  async getInstallationByWebhookId(webhookId) {
+    const schemaName = getSchemaName2(this.#schema);
+    const tableName = getTableName2({ indexName: storage.TABLE_CHANNEL_INSTALLATIONS, schemaName });
+    const row = await this.#db.client.oneOrNone(`SELECT * FROM ${tableName} WHERE "webhookId" = $1`, [webhookId]);
+    return row ? this.#parseInstallationRow(row) : null;
+  }
+  async listInstallations(platform) {
+    const schemaName = getSchemaName2(this.#schema);
+    const tableName = getTableName2({ indexName: storage.TABLE_CHANNEL_INSTALLATIONS, schemaName });
+    const rows = await this.#db.client.manyOrNone(
+      `SELECT * FROM ${tableName} WHERE "platform" = $1 ORDER BY "createdAt" DESC`,
+      [platform]
+    );
+    return rows.map((row) => this.#parseInstallationRow(row));
+  }
+  async deleteInstallation(id) {
+    const schemaName = getSchemaName2(this.#schema);
+    const tableName = getTableName2({ indexName: storage.TABLE_CHANNEL_INSTALLATIONS, schemaName });
+    await this.#db.client.none(`DELETE FROM ${tableName} WHERE "id" = $1`, [id]);
+  }
+  async saveConfig(config) {
+    const schemaName = getSchemaName2(this.#schema);
+    const tableName = getTableName2({ indexName: storage.TABLE_CHANNEL_CONFIG, schemaName });
+    await this.#db.client.none(
+      `INSERT INTO ${tableName} ("platform", "data", "updatedAt")
+       VALUES ($1, $2::jsonb, $3)
+       ON CONFLICT ("platform") DO UPDATE SET
+         "data" = EXCLUDED."data",
+         "updatedAt" = EXCLUDED."updatedAt"`,
+      [config.platform, JSON.stringify(config.data), config.updatedAt.toISOString()]
+    );
+  }
+  async getConfig(platform) {
+    const schemaName = getSchemaName2(this.#schema);
+    const tableName = getTableName2({ indexName: storage.TABLE_CHANNEL_CONFIG, schemaName });
+    const row = await this.#db.client.oneOrNone(`SELECT * FROM ${tableName} WHERE "platform" = $1`, [platform]);
+    if (!row) return null;
+    return {
+      platform: row.platform,
+      data: typeof row.data === "string" ? JSON.parse(row.data) : row.data,
+      updatedAt: new Date(row.updatedAt)
+    };
+  }
+  async deleteConfig(platform) {
+    const schemaName = getSchemaName2(this.#schema);
+    const tableName = getTableName2({ indexName: storage.TABLE_CHANNEL_CONFIG, schemaName });
+    await this.#db.client.none(`DELETE FROM ${tableName} WHERE "platform" = $1`, [platform]);
+  }
+  #parseInstallationRow(row) {
+    return {
+      id: row.id,
+      platform: row.platform,
+      agentId: row.agentId,
+      status: row.status,
+      webhookId: row.webhookId || void 0,
+      data: typeof row.data === "string" ? JSON.parse(row.data) : row.data,
+      configHash: row.configHash || void 0,
+      error: row.error || void 0,
+      createdAt: row.createdAt instanceof Date ? row.createdAt : new Date(row.createdAt),
+      updatedAt: row.updatedAt instanceof Date ? row.updatedAt : new Date(row.updatedAt)
+    };
+  }
+};
 function jsonbArg(value) {
   return value === void 0 || value === null ? null : JSON.stringify(value);
 }
@@ -5308,6 +5851,16 @@ var ExperimentsPG = class _ExperimentsPG extends storage.ExperimentsStorage {
   async init() {
     await this.#db.createTable({ tableName: storage.TABLE_EXPERIMENTS, schema: storage.EXPERIMENTS_SCHEMA });
     await this.#db.createTable({ tableName: storage.TABLE_EXPERIMENT_RESULTS, schema: storage.EXPERIMENT_RESULTS_SCHEMA });
+    await this.#db.alterTable({
+      tableName: storage.TABLE_EXPERIMENTS,
+      schema: storage.EXPERIMENTS_SCHEMA,
+      ifNotExists: ["agentVersion"]
+    });
+    await this.#db.alterTable({
+      tableName: storage.TABLE_EXPERIMENT_RESULTS,
+      schema: storage.EXPERIMENT_RESULTS_SCHEMA,
+      ifNotExists: ["status", "tags"]
+    });
     await this.createDefaultIndexes();
     await this.createCustomIndexes();
   }
@@ -5547,6 +6100,22 @@ var ExperimentsPG = class _ExperimentsPG extends storage.ExperimentsStorage {
         conditions.push(`"datasetId" = $${paramIndex++}`);
         queryParams.push(args.datasetId);
       }
+      if (args.targetType) {
+        conditions.push(`"targetType" = $${paramIndex++}`);
+        queryParams.push(args.targetType);
+      }
+      if (args.targetId) {
+        conditions.push(`"targetId" = $${paramIndex++}`);
+        queryParams.push(args.targetId);
+      }
+      if (args.agentVersion) {
+        conditions.push(`"agentVersion" = $${paramIndex++}`);
+        queryParams.push(args.agentVersion);
+      }
+      if (args.status) {
+        conditions.push(`"status" = $${paramIndex++}`);
+        queryParams.push(args.status);
+      }
       const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
       const countResult = await this.#db.client.one(
         `SELECT COUNT(*) as count FROM ${tableName} ${whereClause}`,
@@ -5735,9 +6304,21 @@ var ExperimentsPG = class _ExperimentsPG extends storage.ExperimentsStorage {
     try {
       const { page, perPage: perPageInput } = args.pagination;
       const tableName = getTableName2({ indexName: storage.TABLE_EXPERIMENT_RESULTS, schemaName: getSchemaName2(this.#schema) });
+      const conditions = ['"experimentId" = $1'];
+      const queryParams = [args.experimentId];
+      let paramIndex = 2;
+      if (args.traceId) {
+        conditions.push(`"traceId" = $${paramIndex++}`);
+        queryParams.push(args.traceId);
+      }
+      if (args.status) {
+        conditions.push(`"status" = $${paramIndex++}`);
+        queryParams.push(args.status);
+      }
+      const whereClause = `WHERE ${conditions.join(" AND ")}`;
       const countResult = await this.#db.client.one(
-        `SELECT COUNT(*) as count FROM ${tableName} WHERE "experimentId" = $1`,
-        [args.experimentId]
+        `SELECT COUNT(*) as count FROM ${tableName} ${whereClause}`,
+        queryParams
       );
       const total = parseInt(countResult.count, 10);
       if (total === 0) {
@@ -5747,8 +6328,8 @@ var ExperimentsPG = class _ExperimentsPG extends storage.ExperimentsStorage {
       const { offset, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
       const limitValue = perPageInput === false ? total : perPage;
       const rows = await this.#db.client.manyOrNone(
-        `SELECT * FROM ${tableName} WHERE "experimentId" = $1 ORDER BY "startedAt" ASC LIMIT $2 OFFSET $3`,
-        [args.experimentId, limitValue, offset]
+        `SELECT * FROM ${tableName} ${whereClause} ORDER BY "startedAt" ASC LIMIT $${paramIndex} OFFSET $${paramIndex + 1}`,
+        [...queryParams, limitValue, offset]
       );
       return {
         results: (rows || []).map((row) => this.transformExperimentResultRow(row)),
@@ -7078,6 +7659,23 @@ var MCPServersPG = class _MCPServersPG extends storage.MCPServersStorage {
   }
 };
 var OM_TABLE = "mastra_observational_memory";
+var OM_MIGRATION_COLUMNS = [
+  "observedMessageIds",
+  "observedTimezone",
+  "bufferedObservations",
+  "bufferedObservationTokens",
+  "bufferedMessageIds",
+  "bufferedReflection",
+  "bufferedReflectionTokens",
+  "bufferedReflectionInputTokens",
+  "reflectedObservationLineCount",
+  "bufferedObservationChunks",
+  "isBufferingObservation",
+  "isBufferingReflection",
+  "lastBufferedAtTokens",
+  "lastBufferedAtTime",
+  "metadata"
+];
 var _omTableSchema;
 try {
   const __require2 = typeof __require === "function" ? __require : module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)));
@@ -7085,10 +7683,10 @@ try {
   _omTableSchema = storage.OBSERVATIONAL_MEMORY_TABLE_SCHEMA;
 } catch {
 }
-function getSchemaName3(schema) {
+function getSchemaName4(schema) {
   return schema ? `"${schema}"` : '"public"';
 }
-function getTableName3({ indexName, schemaName }) {
+function getTableName4({ indexName, schemaName }) {
   const quotedIndexName = `"${indexName}"`;
   return schemaName ? `${schemaName}.${quotedIndexName}` : quotedIndexName;
 }
@@ -7129,22 +7727,7 @@ var MemoryPG = class _MemoryPG extends storage.MemoryStorage {
       await this.#db.alterTable({
         tableName: OM_TABLE,
         schema: omSchema,
-        ifNotExists: [
-          "observedMessageIds",
-          "observedTimezone",
-          "bufferedObservations",
-          "bufferedObservationTokens",
-          "bufferedMessageIds",
-          "bufferedReflection",
-          "bufferedReflectionTokens",
-          "bufferedReflectionInputTokens",
-          "bufferedObservationChunks",
-          "isBufferingObservation",
-          "isBufferingReflection",
-          "lastBufferedAtTokens",
-          "lastBufferedAtTime",
-          "metadata"
-        ]
+        ifNotExists: OM_MIGRATION_COLUMNS
       });
     }
     await this.#db.alterTable({
@@ -7153,9 +7736,9 @@ var MemoryPG = class _MemoryPG extends storage.MemoryStorage {
       ifNotExists: ["resourceId"]
     });
     if (omSchema) {
-      const omTableName = getTableName3({
+      const omTableName = getTableName4({
         indexName: OM_TABLE,
-        schemaName: getSchemaName3(this.#schema)
+        schemaName: getSchemaName4(this.#schema)
       });
       await this.#db.client.none(`CREATE INDEX IF NOT EXISTS idx_om_lookup_key ON ${omTableName} ("lookupKey")`);
     }
@@ -7278,7 +7861,7 @@ var MemoryPG = class _MemoryPG extends storage.MemoryStorage {
   }
   async getThreadById({ threadId }) {
     try {
-      const tableName = getTableName3({ indexName: storage.TABLE_THREADS, schemaName: getSchemaName3(this.#schema) });
+      const tableName = getTableName4({ indexName: storage.TABLE_THREADS, schemaName: getSchemaName4(this.#schema) });
       const thread = await this.#db.client.oneOrNone(
         `SELECT * FROM ${tableName} WHERE id = $1`,
         [threadId]
@@ -7336,7 +7919,7 @@ var MemoryPG = class _MemoryPG extends storage.MemoryStorage {
     const { field, direction } = this.parseOrderBy(orderBy);
     const { offset, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
     try {
-      const tableName = getTableName3({ indexName: storage.TABLE_THREADS, schemaName: getSchemaName3(this.#schema) });
+      const tableName = getTableName4({ indexName: storage.TABLE_THREADS, schemaName: getSchemaName4(this.#schema) });
       const whereClauses = [];
       const queryParams = [];
       let paramIndex = 1;
@@ -7415,7 +7998,7 @@ var MemoryPG = class _MemoryPG extends storage.MemoryStorage {
   }
   async saveThread({ thread }) {
     try {
-      const tableName = getTableName3({ indexName: storage.TABLE_THREADS, schemaName: getSchemaName3(this.#schema) });
+      const tableName = getTableName4({ indexName: storage.TABLE_THREADS, schemaName: getSchemaName4(this.#schema) });
       await this.#db.client.none(
         `INSERT INTO ${tableName} (
           id,
@@ -7466,7 +8049,7 @@ var MemoryPG = class _MemoryPG extends storage.MemoryStorage {
     title,
     metadata
   }) {
-    const threadTableName = getTableName3({ indexName: storage.TABLE_THREADS, schemaName: getSchemaName3(this.#schema) });
+    const threadTableName = getTableName4({ indexName: storage.TABLE_THREADS, schemaName: getSchemaName4(this.#schema) });
     const existingThread = await this.getThreadById({ threadId: id });
     if (!existingThread) {
       throw new error.MastraError({
@@ -7523,8 +8106,8 @@ var MemoryPG = class _MemoryPG extends storage.MemoryStorage {
   }
   async deleteThread({ threadId }) {
     try {
-      const tableName = getTableName3({ indexName: storage.TABLE_MESSAGES, schemaName: getSchemaName3(this.#schema) });
-      const threadTableName = getTableName3({ indexName: storage.TABLE_THREADS, schemaName: getSchemaName3(this.#schema) });
+      const tableName = getTableName4({ indexName: storage.TABLE_MESSAGES, schemaName: getSchemaName4(this.#schema) });
+      const threadTableName = getTableName4({ indexName: storage.TABLE_THREADS, schemaName: getSchemaName4(this.#schema) });
       await this.#db.client.tx(async (t) => {
         await t.none(`DELETE FROM ${tableName} WHERE thread_id = $1`, [threadId]);
         const schemaName = this.#schema || "public";
@@ -7538,7 +8121,7 @@ var MemoryPG = class _MemoryPG extends storage.MemoryStorage {
           [schemaName]
         );
         for (const { tablename } of vectorTables) {
-          const vectorTableName = getTableName3({ indexName: tablename, schemaName: getSchemaName3(this.#schema) });
+          const vectorTableName = getTableName4({ indexName: tablename, schemaName: getSchemaName4(this.#schema) });
           await t.none(`DELETE FROM ${vectorTableName} WHERE metadata->>'thread_id' = $1`, [threadId]);
         }
         await t.none(`DELETE FROM ${threadTableName} WHERE id = $1`, [threadId]);
@@ -7589,7 +8172,7 @@ var MemoryPG = class _MemoryPG extends storage.MemoryStorage {
   }
   async _getIncludedMessages({ include }) {
     if (!include || include.length === 0) return null;
-    const tableName = getTableName3({ indexName: storage.TABLE_MESSAGES, schemaName: getSchemaName3(this.#schema) });
+    const tableName = getTableName4({ indexName: storage.TABLE_MESSAGES, schemaName: getSchemaName4(this.#schema) });
     const selectColumns = `id, content, role, type, "createdAt", "createdAtZ", thread_id AS "threadId", "resourceId"`;
     const targetIds = include.map((inc) => inc.id).filter(Boolean);
     if (targetIds.length === 0) return null;
@@ -7670,7 +8253,7 @@ var MemoryPG = class _MemoryPG extends storage.MemoryStorage {
     if (messageIds.length === 0) return { messages: [] };
     const selectStatement = `SELECT id, content, role, type, "createdAt", "createdAtZ", thread_id AS "threadId", "resourceId"`;
     try {
-      const tableName = getTableName3({ indexName: storage.TABLE_MESSAGES, schemaName: getSchemaName3(this.#schema) });
+      const tableName = getTableName4({ indexName: storage.TABLE_MESSAGES, schemaName: getSchemaName4(this.#schema) });
       const query = `
         ${selectStatement} FROM ${tableName}
         WHERE id IN (${inPlaceholders(messageIds.length)})
@@ -7733,7 +8316,7 @@ var MemoryPG = class _MemoryPG extends storage.MemoryStorage {
       const { field, direction } = this.parseOrderBy(orderBy, "ASC");
       const orderByStatement = `ORDER BY COALESCE("${field}Z", "${field}") ${direction}`;
       const selectStatement = `SELECT id, content, role, type, "createdAt", "createdAtZ", thread_id AS "threadId", "resourceId"`;
-      const tableName = getTableName3({ indexName: storage.TABLE_MESSAGES, schemaName: getSchemaName3(this.#schema) });
+      const tableName = getTableName4({ indexName: storage.TABLE_MESSAGES, schemaName: getSchemaName4(this.#schema) });
       const conditions = [`thread_id IN (${inPlaceholders(threadIds.length)})`];
       const queryParams = [...threadIds];
       let paramIndex = threadIds.length + 1;
@@ -7872,7 +8455,7 @@ var MemoryPG = class _MemoryPG extends storage.MemoryStorage {
       const { field, direction } = this.parseOrderBy(orderBy, "ASC");
       const orderByStatement = `ORDER BY COALESCE("${field}Z", "${field}") ${direction}`;
       const selectStatement = `SELECT id, content, role, type, "createdAt", "createdAtZ", thread_id AS "threadId", "resourceId"`;
-      const tableName = getTableName3({ indexName: storage.TABLE_MESSAGES, schemaName: getSchemaName3(this.#schema) });
+      const tableName = getTableName4({ indexName: storage.TABLE_MESSAGES, schemaName: getSchemaName4(this.#schema) });
       const conditions = [];
       const queryParams = [];
       let paramIndex = 1;
@@ -7999,7 +8582,7 @@ var MemoryPG = class _MemoryPG extends storage.MemoryStorage {
       });
     }
     try {
-      const tableName = getTableName3({ indexName: storage.TABLE_MESSAGES, schemaName: getSchemaName3(this.#schema) });
+      const tableName = getTableName4({ indexName: storage.TABLE_MESSAGES, schemaName: getSchemaName4(this.#schema) });
       await this.#db.client.tx(async (t) => {
         for (const message of messages) {
           if (!message.threadId) {
@@ -8033,7 +8616,7 @@ var MemoryPG = class _MemoryPG extends storage.MemoryStorage {
             ]
           );
         }
-        const threadTableName = getTableName3({ indexName: storage.TABLE_THREADS, schemaName: getSchemaName3(this.#schema) });
+        const threadTableName = getTableName4({ indexName: storage.TABLE_THREADS, schemaName: getSchemaName4(this.#schema) });
         const now = /* @__PURE__ */ new Date();
         await t.none(
           `UPDATE ${threadTableName}
@@ -8077,7 +8660,7 @@ var MemoryPG = class _MemoryPG extends storage.MemoryStorage {
       return [];
     }
     const messageIds = messages.map((m) => m.id);
-    const selectQuery = `SELECT id, content, role, type, "createdAt", "createdAtZ", thread_id AS "threadId", "resourceId" FROM ${getTableName3({ indexName: storage.TABLE_MESSAGES, schemaName: getSchemaName3(this.#schema) })} WHERE id IN (${inPlaceholders(messageIds.length)})`;
+    const selectQuery = `SELECT id, content, role, type, "createdAt", "createdAtZ", thread_id AS "threadId", "resourceId" FROM ${getTableName4({ indexName: storage.TABLE_MESSAGES, schemaName: getSchemaName4(this.#schema) })} WHERE id IN (${inPlaceholders(messageIds.length)})`;
     const existingMessagesDb = await this.#db.client.manyOrNone(selectQuery, messageIds);
     if (existingMessagesDb.length === 0) {
       return [];
@@ -8134,7 +8717,7 @@ var MemoryPG = class _MemoryPG extends storage.MemoryStorage {
         }
         if (setClauses.length > 0) {
           values.push(id);
-          const sql = `UPDATE ${getTableName3({ indexName: storage.TABLE_MESSAGES, schemaName: getSchemaName3(this.#schema) })} SET ${setClauses.join(", ")} WHERE id = $${paramIndex}`;
+          const sql = `UPDATE ${getTableName4({ indexName: storage.TABLE_MESSAGES, schemaName: getSchemaName4(this.#schema) })} SET ${setClauses.join(", ")} WHERE id = $${paramIndex}`;
           queries.push(t.none(sql, values));
         }
       }
@@ -8142,7 +8725,7 @@ var MemoryPG = class _MemoryPG extends storage.MemoryStorage {
         const threadIds = Array.from(threadIdsToUpdate);
         queries.push(
           t.none(
-            `UPDATE ${getTableName3({ indexName: storage.TABLE_THREADS, schemaName: getSchemaName3(this.#schema) })} SET "updatedAt" = NOW(), "updatedAtZ" = NOW() WHERE id IN (${inPlaceholders(threadIds.length)})`,
+            `UPDATE ${getTableName4({ indexName: storage.TABLE_THREADS, schemaName: getSchemaName4(this.#schema) })} SET "updatedAt" = NOW(), "updatedAtZ" = NOW() WHERE id IN (${inPlaceholders(threadIds.length)})`,
             threadIds
           )
         );
@@ -8168,8 +8751,8 @@ var MemoryPG = class _MemoryPG extends storage.MemoryStorage {
       return;
     }
     try {
-      const messageTableName = getTableName3({ indexName: storage.TABLE_MESSAGES, schemaName: getSchemaName3(this.#schema) });
-      const threadTableName = getTableName3({ indexName: storage.TABLE_THREADS, schemaName: getSchemaName3(this.#schema) });
+      const messageTableName = getTableName4({ indexName: storage.TABLE_MESSAGES, schemaName: getSchemaName4(this.#schema) });
+      const threadTableName = getTableName4({ indexName: storage.TABLE_THREADS, schemaName: getSchemaName4(this.#schema) });
       await this.#db.client.tx(async (t) => {
         const placeholders = messageIds.map((_, idx) => `$${idx + 1}`).join(",");
         const messages = await t.manyOrNone(
@@ -8198,7 +8781,7 @@ var MemoryPG = class _MemoryPG extends storage.MemoryStorage {
     }
   }
   async getResourceById({ resourceId }) {
-    const tableName = getTableName3({ indexName: storage.TABLE_RESOURCES, schemaName: getSchemaName3(this.#schema) });
+    const tableName = getTableName4({ indexName: storage.TABLE_RESOURCES, schemaName: getSchemaName4(this.#schema) });
     const result = await this.#db.client.oneOrNone(
       `SELECT * FROM ${tableName} WHERE id = $1`,
       [resourceId]
@@ -8249,7 +8832,7 @@ var MemoryPG = class _MemoryPG extends storage.MemoryStorage {
       },
       updatedAt: /* @__PURE__ */ new Date()
     };
-    const tableName = getTableName3({ indexName: storage.TABLE_RESOURCES, schemaName: getSchemaName3(this.#schema) });
+    const tableName = getTableName4({ indexName: storage.TABLE_RESOURCES, schemaName: getSchemaName4(this.#schema) });
     const updates = [];
     const values = [];
     let paramIndex = 1;
@@ -8295,8 +8878,8 @@ var MemoryPG = class _MemoryPG extends storage.MemoryStorage {
         details: { newThreadId }
       });
     }
-    const threadTableName = getTableName3({ indexName: storage.TABLE_THREADS, schemaName: getSchemaName3(this.#schema) });
-    const messageTableName = getTableName3({ indexName: storage.TABLE_MESSAGES, schemaName: getSchemaName3(this.#schema) });
+    const threadTableName = getTableName4({ indexName: storage.TABLE_THREADS, schemaName: getSchemaName4(this.#schema) });
+    const messageTableName = getTableName4({ indexName: storage.TABLE_MESSAGES, schemaName: getSchemaName4(this.#schema) });
     try {
       return await this.#db.client.tx(async (t) => {
         let messageQuery = `SELECT id, content, role, type, "createdAt", "createdAtZ", thread_id AS "threadId", "resourceId"
@@ -8466,9 +9049,9 @@ var MemoryPG = class _MemoryPG extends storage.MemoryStorage {
   async getObservationalMemory(threadId, resourceId) {
     try {
       const lookupKey = this.getOMKey(threadId, resourceId);
-      const tableName = getTableName3({
+      const tableName = getTableName4({
         indexName: OM_TABLE,
-        schemaName: getSchemaName3(this.#schema)
+        schemaName: getSchemaName4(this.#schema)
       });
       const result = await this.#db.client.oneOrNone(
         `SELECT * FROM ${tableName} WHERE "lookupKey" = $1 ORDER BY "generationCount" DESC LIMIT 1`,
@@ -8488,17 +9071,34 @@ var MemoryPG = class _MemoryPG extends storage.MemoryStorage {
       );
     }
   }
-  async getObservationalMemoryHistory(threadId, resourceId, limit = 10) {
+  async getObservationalMemoryHistory(threadId, resourceId, limit = 10, options) {
     try {
       const lookupKey = this.getOMKey(threadId, resourceId);
-      const tableName = getTableName3({
+      const tableName = getTableName4({
         indexName: OM_TABLE,
-        schemaName: getSchemaName3(this.#schema)
+        schemaName: getSchemaName4(this.#schema)
       });
-      const result = await this.#db.client.manyOrNone(
-        `SELECT * FROM ${tableName} WHERE "lookupKey" = $1 ORDER BY "generationCount" DESC LIMIT $2`,
-        [lookupKey, limit]
-      );
+      const conditions = [`"lookupKey" = $1`];
+      const params = [lookupKey];
+      let paramIndex = 2;
+      if (options?.from) {
+        conditions.push(`"createdAtZ" >= $${paramIndex}`);
+        params.push(options.from.toISOString());
+        paramIndex++;
+      }
+      if (options?.to) {
+        conditions.push(`"createdAtZ" <= $${paramIndex}`);
+        params.push(options.to.toISOString());
+        paramIndex++;
+      }
+      params.push(limit);
+      let sql = `SELECT * FROM ${tableName} WHERE ${conditions.join(" AND ")} ORDER BY "generationCount" DESC LIMIT $${paramIndex}`;
+      paramIndex++;
+      if (options?.offset != null) {
+        params.push(options.offset);
+        sql += ` OFFSET $${paramIndex}`;
+      }
+      const result = await this.#db.client.manyOrNone(sql, params);
       if (!result) return [];
       return result.map((row) => this.parseOMRow(row));
     } catch (error$1) {
@@ -8541,9 +9141,9 @@ var MemoryPG = class _MemoryPG extends storage.MemoryStorage {
         config: input.config,
         observedTimezone: input.observedTimezone
       };
-      const tableName = getTableName3({
+      const tableName = getTableName4({
         indexName: OM_TABLE,
-        schemaName: getSchemaName3(this.#schema)
+        schemaName: getSchemaName4(this.#schema)
       });
       const nowStr = now.toISOString();
       await this.#db.client.none(
@@ -8614,9 +9214,9 @@ var MemoryPG = class _MemoryPG extends storage.MemoryStorage {
   async insertObservationalMemoryRecord(record) {
     try {
       const lookupKey = this.getOMKey(record.threadId, record.resourceId);
-      const tableName = getTableName3({
+      const tableName = getTableName4({
         indexName: OM_TABLE,
-        schemaName: getSchemaName3(this.#schema)
+        schemaName: getSchemaName4(this.#schema)
       });
       const lastObservedAtStr = record.lastObservedAt ? record.lastObservedAt.toISOString() : null;
       const lastBufferedAtTimeStr = record.lastBufferedAtTime ? record.lastBufferedAtTime.toISOString() : null;
@@ -8688,9 +9288,9 @@ var MemoryPG = class _MemoryPG extends storage.MemoryStorage {
   async updateActiveObservations(input) {
     try {
       const now = /* @__PURE__ */ new Date();
-      const tableName = getTableName3({
+      const tableName = getTableName4({
         indexName: OM_TABLE,
-        schemaName: getSchemaName3(this.#schema)
+        schemaName: getSchemaName4(this.#schema)
       });
       const lastObservedAtStr = input.lastObservedAt.toISOString();
       const nowStr = now.toISOString();
@@ -8772,9 +9372,9 @@ var MemoryPG = class _MemoryPG extends storage.MemoryStorage {
         metadata: input.currentRecord.metadata,
         observedTimezone: input.currentRecord.observedTimezone
       };
-      const tableName = getTableName3({
+      const tableName = getTableName4({
         indexName: OM_TABLE,
-        schemaName: getSchemaName3(this.#schema)
+        schemaName: getSchemaName4(this.#schema)
       });
       const nowStr = now.toISOString();
       const lastObservedAtStr = record.lastObservedAt?.toISOString() || null;
@@ -8848,9 +9448,9 @@ var MemoryPG = class _MemoryPG extends storage.MemoryStorage {
   }
   async setReflectingFlag(id, isReflecting) {
     try {
-      const tableName = getTableName3({
+      const tableName = getTableName4({
         indexName: OM_TABLE,
-        schemaName: getSchemaName3(this.#schema)
+        schemaName: getSchemaName4(this.#schema)
       });
       const nowStr = (/* @__PURE__ */ new Date()).toISOString();
       const result = await this.#db.client.query(
@@ -8883,9 +9483,9 @@ var MemoryPG = class _MemoryPG extends storage.MemoryStorage {
   }
   async setObservingFlag(id, isObserving) {
     try {
-      const tableName = getTableName3({
+      const tableName = getTableName4({
         indexName: OM_TABLE,
-        schemaName: getSchemaName3(this.#schema)
+        schemaName: getSchemaName4(this.#schema)
       });
       const nowStr = (/* @__PURE__ */ new Date()).toISOString();
       const result = await this.#db.client.query(
@@ -8918,9 +9518,9 @@ var MemoryPG = class _MemoryPG extends storage.MemoryStorage {
   }
   async setBufferingObservationFlag(id, isBuffering, lastBufferedAtTokens) {
     try {
-      const tableName = getTableName3({
+      const tableName = getTableName4({
         indexName: OM_TABLE,
-        schemaName: getSchemaName3(this.#schema)
+        schemaName: getSchemaName4(this.#schema)
       });
       const nowStr = (/* @__PURE__ */ new Date()).toISOString();
       let query;
@@ -8959,9 +9559,9 @@ var MemoryPG = class _MemoryPG extends storage.MemoryStorage {
   }
   async setBufferingReflectionFlag(id, isBuffering) {
     try {
-      const tableName = getTableName3({
+      const tableName = getTableName4({
         indexName: OM_TABLE,
-        schemaName: getSchemaName3(this.#schema)
+        schemaName: getSchemaName4(this.#schema)
       });
       const nowStr = (/* @__PURE__ */ new Date()).toISOString();
       const result = await this.#db.client.query(
@@ -8995,9 +9595,9 @@ var MemoryPG = class _MemoryPG extends storage.MemoryStorage {
   async clearObservationalMemory(threadId, resourceId) {
     try {
       const lookupKey = this.getOMKey(threadId, resourceId);
-      const tableName = getTableName3({
+      const tableName = getTableName4({
         indexName: OM_TABLE,
-        schemaName: getSchemaName3(this.#schema)
+        schemaName: getSchemaName4(this.#schema)
       });
       await this.#db.client.none(`DELETE FROM ${tableName} WHERE "lookupKey" = $1`, [lookupKey]);
     } catch (error$1) {
@@ -9014,9 +9614,9 @@ var MemoryPG = class _MemoryPG extends storage.MemoryStorage {
   }
   async setPendingMessageTokens(id, tokenCount) {
     try {
-      const tableName = getTableName3({
+      const tableName = getTableName4({
         indexName: OM_TABLE,
-        schemaName: getSchemaName3(this.#schema)
+        schemaName: getSchemaName4(this.#schema)
       });
       const nowStr = (/* @__PURE__ */ new Date()).toISOString();
       const result = await this.#db.client.query(
@@ -9051,14 +9651,53 @@ var MemoryPG = class _MemoryPG extends storage.MemoryStorage {
       );
     }
   }
+  async updateObservationalMemoryConfig(input) {
+    try {
+      const tableName = getTableName4({
+        indexName: OM_TABLE,
+        schemaName: getSchemaName4(this.#schema)
+      });
+      const selectResult = await this.#db.client.query(`SELECT config FROM ${tableName} WHERE id = $1`, [input.id]);
+      if (selectResult.rowCount === 0) {
+        throw new error.MastraError({
+          id: storage.createStorageErrorId("PG", "UPDATE_OM_CONFIG", "NOT_FOUND"),
+          text: `Observational memory record not found: ${input.id}`,
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { id: input.id }
+        });
+      }
+      const row = selectResult.rows[0];
+      const existing = row.config ? typeof row.config === "string" ? JSON.parse(row.config) : row.config : {};
+      const merged = this.deepMergeConfig(existing, input.config);
+      const nowStr = (/* @__PURE__ */ new Date()).toISOString();
+      await this.#db.client.query(
+        `UPDATE ${tableName} SET config = $1, "updatedAt" = $2, "updatedAtZ" = $3 WHERE id = $4`,
+        [JSON.stringify(merged), nowStr, nowStr, input.id]
+      );
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) {
+        throw error$1;
+      }
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("PG", "UPDATE_OM_CONFIG", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { id: input.id }
+        },
+        error$1
+      );
+    }
+  }
   // ============================================
   // Async Buffering Methods
   // ============================================
   async updateBufferedObservations(input) {
     try {
-      const tableName = getTableName3({
+      const tableName = getTableName4({
         indexName: OM_TABLE,
-        schemaName: getSchemaName3(this.#schema)
+        schemaName: getSchemaName4(this.#schema)
       });
       const nowStr = (/* @__PURE__ */ new Date()).toISOString();
       const newChunk = {
@@ -9110,9 +9749,9 @@ var MemoryPG = class _MemoryPG extends storage.MemoryStorage {
   }
   async swapBufferedToActive(input) {
     try {
-      const tableName = getTableName3({
+      const tableName = getTableName4({
         indexName: OM_TABLE,
-        schemaName: getSchemaName3(this.#schema)
+        schemaName: getSchemaName4(this.#schema)
       });
       const nowStr = (/* @__PURE__ */ new Date()).toISOString();
       const record = await this.#db.client.oneOrNone(`SELECT * FROM ${tableName} WHERE id = $1`, [input.id]);
@@ -9275,9 +9914,9 @@ var MemoryPG = class _MemoryPG extends storage.MemoryStorage {
   }
   async updateBufferedReflection(input) {
     try {
-      const tableName = getTableName3({
+      const tableName = getTableName4({
         indexName: OM_TABLE,
-        schemaName: getSchemaName3(this.#schema)
+        schemaName: getSchemaName4(this.#schema)
       });
       const nowStr = (/* @__PURE__ */ new Date()).toISOString();
       const result = await this.#db.client.query(
@@ -9329,9 +9968,9 @@ var MemoryPG = class _MemoryPG extends storage.MemoryStorage {
   }
   async swapBufferedReflectionToActive(input) {
     try {
-      const tableName = getTableName3({
+      const tableName = getTableName4({
         indexName: OM_TABLE,
-        schemaName: getSchemaName3(this.#schema)
+        schemaName: getSchemaName4(this.#schema)
       });
       const record = await this.#db.client.oneOrNone(`SELECT * FROM ${tableName} WHERE id = $1`, [
         input.currentRecord.id
@@ -9737,6 +10376,51 @@ var ObservabilityPG = class _ObservabilityPG extends storage.ObservabilityStorag
       );
     }
   }
+  async getTraceLight(args) {
+    const { traceId } = args;
+    try {
+      const tableName = getTableName2({
+        indexName: storage.TABLE_SPANS,
+        schemaName: getSchemaName2(this.#schema)
+      });
+      const spans = await this.#db.client.manyOrNone(
+        `SELECT
+          "traceId", "spanId", "parentSpanId", "name",
+          "entityType", "entityId", "entityName",
+          "spanType", "error", "isEvent",
+          "startedAtZ" as "startedAt", "endedAtZ" as "endedAt",
+          "createdAtZ" as "createdAt", "updatedAtZ" as "updatedAt"
+        FROM ${tableName}
+        WHERE "traceId" = $1
+        ORDER BY "startedAtZ" ASC`,
+        [traceId]
+      );
+      if (!spans || spans.length === 0) {
+        return null;
+      }
+      return {
+        traceId,
+        spans: spans.map(
+          (span) => transformFromSqlRow({
+            tableName: storage.TABLE_SPANS,
+            sqlRow: span
+          })
+        )
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("PG", "GET_TRACE_LIGHT", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: {
+            traceId
+          }
+        },
+        error$1
+      );
+    }
+  }
   async updateSpan(args) {
     const { traceId, spanId, updates } = args;
     try {
@@ -10693,6 +11377,252 @@ var PromptBlocksPG = class _PromptBlocksPG extends storage.PromptBlocksStorage {
     };
   }
 };
+function getSchemaName5(schema) {
+  return schema ? `"${schema}"` : '"public"';
+}
+function getTableName5(table, schema) {
+  const quoted = `"${table}"`;
+  return schema ? `${schema}.${quoted}` : quoted;
+}
+function parseJson2(val) {
+  if (val == null) return void 0;
+  if (typeof val === "string") {
+    try {
+      return JSON.parse(val);
+    } catch {
+      return val;
+    }
+  }
+  return val;
+}
+function toNumber(val) {
+  if (typeof val === "bigint") return Number(val);
+  return Number(val);
+}
+function rowToSchedule(row) {
+  const target = parseJson2(row.target);
+  if (!target) {
+    throw new Error(`Schedule row ${row.id} has invalid target`);
+  }
+  const schedule = {
+    id: String(row.id),
+    target,
+    cron: String(row.cron),
+    status: String(row.status),
+    nextFireAt: toNumber(row.next_fire_at),
+    createdAt: toNumber(row.created_at),
+    updatedAt: toNumber(row.updated_at)
+  };
+  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);
+  if (metadata !== void 0) schedule.metadata = metadata;
+  return schedule;
+}
+function rowToTrigger(row) {
+  const trigger = {
+    scheduleId: String(row.schedule_id),
+    runId: String(row.run_id),
+    scheduledFireAt: toNumber(row.scheduled_fire_at),
+    actualFireAt: toNumber(row.actual_fire_at),
+    status: String(row.status)
+  };
+  if (row.error != null) trigger.error = String(row.error);
+  return trigger;
+}
+var SchedulesPG = class extends storage.SchedulesStorage {
+  #db;
+  #client;
+  #schema;
+  /** Tables managed by this domain */
+  static MANAGED_TABLES = [storage.TABLE_SCHEDULES, storage.TABLE_SCHEDULE_TRIGGERS];
+  constructor(config) {
+    super();
+    const { client, schemaName, skipDefaultIndexes } = resolvePgConfig(config);
+    this.#client = client;
+    this.#db = new PgDB({ client, schemaName, skipDefaultIndexes });
+    this.#schema = schemaName || "public";
+  }
+  async init() {
+    await this.#db.createTable({
+      tableName: storage.TABLE_SCHEDULES,
+      schema: storage.TABLE_SCHEMAS[storage.TABLE_SCHEDULES]
+    });
+    await this.#db.createTable({
+      tableName: storage.TABLE_SCHEDULE_TRIGGERS,
+      schema: storage.TABLE_SCHEMAS[storage.TABLE_SCHEDULE_TRIGGERS]
+    });
+  }
+  static getExportDDL(schemaName) {
+    return [
+      generateTableSQL({
+        tableName: storage.TABLE_SCHEDULES,
+        schema: storage.TABLE_SCHEMAS[storage.TABLE_SCHEDULES],
+        schemaName,
+        includeAllConstraints: true
+      }),
+      generateTableSQL({
+        tableName: storage.TABLE_SCHEDULE_TRIGGERS,
+        schema: storage.TABLE_SCHEMAS[storage.TABLE_SCHEDULE_TRIGGERS],
+        schemaName,
+        includeAllConstraints: true
+      })
+    ];
+  }
+  async dangerouslyClearAll() {
+    await this.#db.clearTable({ tableName: storage.TABLE_SCHEDULE_TRIGGERS });
+    await this.#db.clearTable({ tableName: storage.TABLE_SCHEDULES });
+  }
+  #table(tableName) {
+    const schema = utils.parseSqlIdentifier(this.#schema, "schema name");
+    return getTableName5(tableName, getSchemaName5(schema));
+  }
+  async createSchedule(schedule) {
+    const existing = await this.getSchedule(schedule.id);
+    if (existing) {
+      throw new Error(`Schedule with id "${schedule.id}" already exists`);
+    }
+    await this.#db.insert({
+      tableName: storage.TABLE_SCHEDULES,
+      record: {
+        id: schedule.id,
+        target: schedule.target,
+        cron: schedule.cron,
+        timezone: schedule.timezone ?? null,
+        status: schedule.status,
+        next_fire_at: schedule.nextFireAt,
+        last_fire_at: schedule.lastFireAt ?? null,
+        last_run_id: schedule.lastRunId ?? null,
+        created_at: schedule.createdAt,
+        updated_at: schedule.updatedAt,
+        metadata: schedule.metadata ?? null
+      }
+    });
+    return schedule;
+  }
+  async getSchedule(id) {
+    const row = await this.#client.oneOrNone(
+      `SELECT * FROM ${this.#table(storage.TABLE_SCHEDULES)} WHERE id = $1`,
+      [id]
+    );
+    return row ? rowToSchedule(row) : null;
+  }
+  async listSchedules(filter) {
+    const conditions = [];
+    const params = [];
+    if (filter?.status) {
+      params.push(filter.status);
+      conditions.push(`status = $${params.length}`);
+    }
+    if (filter?.workflowId) {
+      params.push(filter.workflowId);
+      conditions.push(`target->>'workflowId' = $${params.length}`);
+    }
+    const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    const rows = await this.#client.manyOrNone(
+      `SELECT * FROM ${this.#table(storage.TABLE_SCHEDULES)} ${where} ORDER BY created_at ASC`,
+      params
+    );
+    return rows.map(rowToSchedule);
+  }
+  async listDueSchedules(now, limit) {
+    const cap = limit ?? 100;
+    const rows = await this.#client.manyOrNone(
+      `SELECT * FROM ${this.#table(storage.TABLE_SCHEDULES)}
+       WHERE status = $1 AND next_fire_at <= $2
+       ORDER BY next_fire_at ASC
+       LIMIT $3`,
+      ["active", now, cap]
+    );
+    return rows.map(rowToSchedule);
+  }
+  async updateSchedule(id, patch) {
+    const setClauses = [];
+    const params = [];
+    const push = (frag, value) => {
+      params.push(value);
+      setClauses.push(frag.replace("?", `$${params.length}`));
+    };
+    if ("cron" in patch && patch.cron !== void 0) push("cron = ?", patch.cron);
+    if ("timezone" in patch) push("timezone = ?", patch.timezone ?? null);
+    if ("status" in patch && patch.status !== void 0) push("status = ?", patch.status);
+    if ("nextFireAt" in patch && patch.nextFireAt !== void 0) push("next_fire_at = ?", patch.nextFireAt);
+    if ("target" in patch && patch.target !== void 0) {
+      push("target = ?::jsonb", JSON.stringify(patch.target));
+    }
+    if ("metadata" in patch) {
+      push("metadata = ?::jsonb", patch.metadata != null ? JSON.stringify(patch.metadata) : null);
+    }
+    push("updated_at = ?", Date.now());
+    if (setClauses.length === 1) {
+      const existing = await this.getSchedule(id);
+      if (!existing) throw new Error(`Schedule ${id} not found`);
+      return existing;
+    }
+    params.push(id);
+    await this.#client.none(
+      `UPDATE ${this.#table(storage.TABLE_SCHEDULES)} SET ${setClauses.join(", ")} WHERE id = $${params.length}`,
+      params
+    );
+    const updated = await this.getSchedule(id);
+    if (!updated) throw new Error(`Schedule ${id} not found`);
+    return updated;
+  }
+  async updateScheduleNextFire(id, expectedNextFireAt, newNextFireAt, lastFireAt, lastRunId) {
+    const result = await this.#client.query(
+      `UPDATE ${this.#table(storage.TABLE_SCHEDULES)}
+       SET next_fire_at = $1, last_fire_at = $2, last_run_id = $3, updated_at = $4
+       WHERE id = $5 AND next_fire_at = $6 AND status = $7`,
+      [newNextFireAt, lastFireAt, lastRunId, Date.now(), id, expectedNextFireAt, "active"]
+    );
+    return (result.rowCount ?? 0) > 0;
+  }
+  async deleteSchedule(id) {
+    await this.#client.none(`DELETE FROM ${this.#table(storage.TABLE_SCHEDULE_TRIGGERS)} WHERE schedule_id = $1`, [id]);
+    await this.#client.none(`DELETE FROM ${this.#table(storage.TABLE_SCHEDULES)} WHERE id = $1`, [id]);
+  }
+  async recordTrigger(trigger) {
+    await this.#db.insert({
+      tableName: storage.TABLE_SCHEDULE_TRIGGERS,
+      record: {
+        schedule_id: trigger.scheduleId,
+        run_id: trigger.runId,
+        scheduled_fire_at: trigger.scheduledFireAt,
+        actual_fire_at: trigger.actualFireAt,
+        status: trigger.status,
+        error: trigger.error ?? null
+      }
+    });
+  }
+  async listTriggers(scheduleId, opts) {
+    const conditions = [];
+    const params = [];
+    params.push(scheduleId);
+    conditions.push(`schedule_id = $${params.length}`);
+    if (opts?.fromActualFireAt != null) {
+      params.push(opts.fromActualFireAt);
+      conditions.push(`actual_fire_at >= $${params.length}`);
+    }
+    if (opts?.toActualFireAt != null) {
+      params.push(opts.toActualFireAt);
+      conditions.push(`actual_fire_at < $${params.length}`);
+    }
+    let limitClause = "";
+    if (opts?.limit != null) {
+      params.push(Math.floor(opts.limit));
+      limitClause = `LIMIT $${params.length}`;
+    }
+    const rows = await this.#client.manyOrNone(
+      `SELECT * FROM ${this.#table(storage.TABLE_SCHEDULE_TRIGGERS)}
+       WHERE ${conditions.join(" AND ")}
+       ORDER BY actual_fire_at DESC
+       ${limitClause}`,
+      params
+    );
+    return rows.map(rowToTrigger);
+  }
+};
 var SNAPSHOT_FIELDS4 = [
   "name",
   "description",
@@ -11360,10 +12290,10 @@ var ScorerDefinitionsPG = class _ScorerDefinitionsPG extends storage.ScorerDefin
     };
   }
 };
-function getSchemaName4(schema) {
+function getSchemaName6(schema) {
   return schema ? `"${schema}"` : '"public"';
 }
-function getTableName4({ indexName, schemaName }) {
+function getTableName6({ indexName, schemaName }) {
   const quotedIndexName = `"${indexName}"`;
   return schemaName ? `${schemaName}.${quotedIndexName}` : quotedIndexName;
 }
@@ -11477,7 +12407,7 @@ var ScoresPG = class _ScoresPG extends storage.ScoresStorage {
   async getScoreById({ id }) {
     try {
       const result = await this.#db.client.oneOrNone(
-        `SELECT * FROM ${getTableName4({ indexName: storage.TABLE_SCORERS, schemaName: getSchemaName4(this.#schema) })} WHERE id = $1`,
+        `SELECT * FROM ${getTableName6({ indexName: storage.TABLE_SCORERS, schemaName: getSchemaName6(this.#schema) })} WHERE id = $1`,
         [id]
       );
       return result ? transformScoreRow(result) : null;
@@ -11517,7 +12447,7 @@ var ScoresPG = class _ScoresPG extends storage.ScoresStorage {
       }
       const whereClause = conditions.join(" AND ");
       const total = await this.#db.client.oneOrNone(
-        `SELECT COUNT(*) FROM ${getTableName4({ indexName: storage.TABLE_SCORERS, schemaName: getSchemaName4(this.#schema) })} WHERE ${whereClause}`,
+        `SELECT COUNT(*) FROM ${getTableName6({ indexName: storage.TABLE_SCORERS, schemaName: getSchemaName6(this.#schema) })} WHERE ${whereClause}`,
         queryParams
       );
       const { page, perPage: perPageInput } = pagination;
@@ -11537,7 +12467,7 @@ var ScoresPG = class _ScoresPG extends storage.ScoresStorage {
       const limitValue = perPageInput === false ? Number(total?.count) : perPage;
       const end = perPageInput === false ? Number(total?.count) : start + perPage;
       const result = await this.#db.client.manyOrNone(
-        `SELECT * FROM ${getTableName4({ indexName: storage.TABLE_SCORERS, schemaName: getSchemaName4(this.#schema) })} WHERE ${whereClause} ORDER BY "createdAt" DESC LIMIT $${paramIndex++} OFFSET $${paramIndex++}`,
+        `SELECT * FROM ${getTableName6({ indexName: storage.TABLE_SCORERS, schemaName: getSchemaName6(this.#schema) })} WHERE ${whereClause} ORDER BY "createdAt" DESC LIMIT $${paramIndex++} OFFSET $${paramIndex++}`,
         [...queryParams, limitValue, start]
       );
       return {
@@ -11632,7 +12562,7 @@ var ScoresPG = class _ScoresPG extends storage.ScoresStorage {
   }) {
     try {
       const total = await this.#db.client.oneOrNone(
-        `SELECT COUNT(*) FROM ${getTableName4({ indexName: storage.TABLE_SCORERS, schemaName: getSchemaName4(this.#schema) })} WHERE "runId" = $1`,
+        `SELECT COUNT(*) FROM ${getTableName6({ indexName: storage.TABLE_SCORERS, schemaName: getSchemaName6(this.#schema) })} WHERE "runId" = $1`,
         [runId]
       );
       const { page, perPage: perPageInput } = pagination;
@@ -11652,7 +12582,7 @@ var ScoresPG = class _ScoresPG extends storage.ScoresStorage {
       const limitValue = perPageInput === false ? Number(total?.count) : perPage;
       const end = perPageInput === false ? Number(total?.count) : start + perPage;
       const result = await this.#db.client.manyOrNone(
-        `SELECT * FROM ${getTableName4({ indexName: storage.TABLE_SCORERS, schemaName: getSchemaName4(this.#schema) })} WHERE "runId" = $1 LIMIT $2 OFFSET $3`,
+        `SELECT * FROM ${getTableName6({ indexName: storage.TABLE_SCORERS, schemaName: getSchemaName6(this.#schema) })} WHERE "runId" = $1 LIMIT $2 OFFSET $3`,
         [runId, limitValue, start]
       );
       return {
@@ -11682,7 +12612,7 @@ var ScoresPG = class _ScoresPG extends storage.ScoresStorage {
   }) {
     try {
       const total = await this.#db.client.oneOrNone(
-        `SELECT COUNT(*) FROM ${getTableName4({ indexName: storage.TABLE_SCORERS, schemaName: getSchemaName4(this.#schema) })} WHERE "entityId" = $1 AND "entityType" = $2`,
+        `SELECT COUNT(*) FROM ${getTableName6({ indexName: storage.TABLE_SCORERS, schemaName: getSchemaName6(this.#schema) })} WHERE "entityId" = $1 AND "entityType" = $2`,
         [entityId, entityType]
       );
       const { page, perPage: perPageInput } = pagination;
@@ -11702,7 +12632,7 @@ var ScoresPG = class _ScoresPG extends storage.ScoresStorage {
       const limitValue = perPageInput === false ? Number(total?.count) : perPage;
       const end = perPageInput === false ? Number(total?.count) : start + perPage;
       const result = await this.#db.client.manyOrNone(
-        `SELECT * FROM ${getTableName4({ indexName: storage.TABLE_SCORERS, schemaName: getSchemaName4(this.#schema) })} WHERE "entityId" = $1 AND "entityType" = $2 LIMIT $3 OFFSET $4`,
+        `SELECT * FROM ${getTableName6({ indexName: storage.TABLE_SCORERS, schemaName: getSchemaName6(this.#schema) })} WHERE "entityId" = $1 AND "entityType" = $2 LIMIT $3 OFFSET $4`,
         [entityId, entityType, limitValue, start]
       );
       return {
@@ -11731,7 +12661,7 @@ var ScoresPG = class _ScoresPG extends storage.ScoresStorage {
     pagination
   }) {
     try {
-      const tableName = getTableName4({ indexName: storage.TABLE_SCORERS, schemaName: getSchemaName4(this.#schema) });
+      const tableName = getTableName6({ indexName: storage.TABLE_SCORERS, schemaName: getSchemaName6(this.#schema) });
       const countSQLResult = await this.#db.client.oneOrNone(
         `SELECT COUNT(*) as count FROM ${tableName} WHERE "traceId" = $1 AND "spanId" = $2`,
         [traceId, spanId]
@@ -12434,15 +13364,15 @@ var SkillsPG = class _SkillsPG extends storage.SkillsStorage {
     };
   }
 };
-function getSchemaName5(schema) {
+function getSchemaName7(schema) {
   return schema ? `"${schema}"` : '"public"';
 }
-function getTableName5({ indexName, schemaName }) {
+function getTableName7({ indexName, schemaName }) {
   const quotedIndexName = `"${indexName}"`;
   return schemaName ? `${schemaName}.${quotedIndexName}` : quotedIndexName;
 }
 function sanitizeJsonForPg(jsonString) {
-  return jsonString.replace(/(^|[^\\])(\\(?!["\\/bfnrtu]))/g, "$1\\\\").replace(/\\u(0000|[Dd][89A-Fa-f][0-9A-Fa-f]{2})/g, "");
+  return jsonString.replace(/\\\\?u(0000|[Dd][89A-Fa-f][0-9A-Fa-f]{2})/g, "").replace(/(^|[^\\])(\\(?!["\\/bfnrtu]))/g, "$1\\\\");
 }
 var WorkflowsPG = class _WorkflowsPG extends storage.WorkflowsStorage {
   #db;
@@ -12549,7 +13479,7 @@ var WorkflowsPG = class _WorkflowsPG extends storage.WorkflowsStorage {
   }) {
     try {
       return await this.#db.client.tx(async (t) => {
-        const tableName = getTableName5({ indexName: storage.TABLE_WORKFLOW_SNAPSHOT, schemaName: getSchemaName5(this.#schema) });
+        const tableName = getTableName7({ indexName: storage.TABLE_WORKFLOW_SNAPSHOT, schemaName: getSchemaName7(this.#schema) });
         const existingSnapshotResult = await t.oneOrNone(
           `SELECT snapshot FROM ${tableName} WHERE workflow_name = $1 AND run_id = $2 FOR UPDATE`,
           [workflowName, runId]
@@ -12610,7 +13540,7 @@ var WorkflowsPG = class _WorkflowsPG extends storage.WorkflowsStorage {
   }) {
     try {
       return await this.#db.client.tx(async (t) => {
-        const tableName = getTableName5({ indexName: storage.TABLE_WORKFLOW_SNAPSHOT, schemaName: getSchemaName5(this.#schema) });
+        const tableName = getTableName7({ indexName: storage.TABLE_WORKFLOW_SNAPSHOT, schemaName: getSchemaName7(this.#schema) });
         const existingSnapshotResult = await t.oneOrNone(
           `SELECT snapshot FROM ${tableName} WHERE workflow_name = $1 AND run_id = $2 FOR UPDATE`,
           [workflowName, runId]
@@ -12660,7 +13590,7 @@ var WorkflowsPG = class _WorkflowsPG extends storage.WorkflowsStorage {
       const updatedAtValue = updatedAt ? updatedAt : now;
       const sanitizedSnapshot = sanitizeJsonForPg(JSON.stringify(snapshot));
       await this.#db.client.none(
-        `INSERT INTO ${getTableName5({ indexName: storage.TABLE_WORKFLOW_SNAPSHOT, schemaName: getSchemaName5(this.#schema) })} (workflow_name, run_id, "resourceId", snapshot, "createdAt", "updatedAt")
+        `INSERT INTO ${getTableName7({ indexName: storage.TABLE_WORKFLOW_SNAPSHOT, schemaName: getSchemaName7(this.#schema) })} (workflow_name, run_id, "resourceId", snapshot, "createdAt", "updatedAt")
                  VALUES ($1, $2, $3, $4, $5, $6)
                  ON CONFLICT (workflow_name, run_id) DO UPDATE
                  SET "resourceId" = $3, snapshot = $4, "updatedAt" = $6`,
@@ -12718,7 +13648,7 @@ var WorkflowsPG = class _WorkflowsPG extends storage.WorkflowsStorage {
       }
       const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
       const query = `
-          SELECT * FROM ${getTableName5({ indexName: storage.TABLE_WORKFLOW_SNAPSHOT, schemaName: getSchemaName5(this.#schema) })}
+          SELECT * FROM ${getTableName7({ indexName: storage.TABLE_WORKFLOW_SNAPSHOT, schemaName: getSchemaName7(this.#schema) })}
           ${whereClause}
           ORDER BY "createdAt" DESC LIMIT 1
         `;
@@ -12746,7 +13676,7 @@ var WorkflowsPG = class _WorkflowsPG extends storage.WorkflowsStorage {
   async deleteWorkflowRunById({ runId, workflowName }) {
     try {
       await this.#db.client.none(
-        `DELETE FROM ${getTableName5({ indexName: storage.TABLE_WORKFLOW_SNAPSHOT, schemaName: getSchemaName5(this.#schema) })} WHERE run_id = $1 AND workflow_name = $2`,
+        `DELETE FROM ${getTableName7({ indexName: storage.TABLE_WORKFLOW_SNAPSHOT, schemaName: getSchemaName7(this.#schema) })} WHERE run_id = $1 AND workflow_name = $2`,
         [runId, workflowName]
       );
     } catch (error$1) {
@@ -12814,7 +13744,7 @@ var WorkflowsPG = class _WorkflowsPG extends storage.WorkflowsStorage {
       const usePagination = typeof perPage === "number" && typeof page === "number";
       if (usePagination) {
         const countResult = await this.#db.client.one(
-          `SELECT COUNT(*) as count FROM ${getTableName5({ indexName: storage.TABLE_WORKFLOW_SNAPSHOT, schemaName: getSchemaName5(this.#schema) })} ${whereClause}`,
+          `SELECT COUNT(*) as count FROM ${getTableName7({ indexName: storage.TABLE_WORKFLOW_SNAPSHOT, schemaName: getSchemaName7(this.#schema) })} ${whereClause}`,
           values
         );
         total = Number(countResult.count);
@@ -12822,7 +13752,7 @@ var WorkflowsPG = class _WorkflowsPG extends storage.WorkflowsStorage {
       const normalizedPerPage = usePagination ? storage.normalizePerPage(perPage, Number.MAX_SAFE_INTEGER) : 0;
       const offset = usePagination ? page * normalizedPerPage : void 0;
       const query = `
-          SELECT * FROM ${getTableName5({ indexName: storage.TABLE_WORKFLOW_SNAPSHOT, schemaName: getSchemaName5(this.#schema) })}
+          SELECT * FROM ${getTableName7({ indexName: storage.TABLE_WORKFLOW_SNAPSHOT, schemaName: getSchemaName7(this.#schema) })}
           ${whereClause}
           ORDER BY "createdAt" DESC
           ${usePagination ? ` LIMIT $${paramIndex} OFFSET $${paramIndex + 1}` : ""}
@@ -13545,7 +14475,10 @@ var ALL_DOMAINS = [
   AgentsPG,
   WorkflowsPG,
   DatasetsPG,
-  ExperimentsPG
+  ExperimentsPG,
+  BackgroundTasksPG,
+  ChannelsPG,
+  SchedulesPG
 ];
 function exportSchemas(schemaName) {
   const statements = [];
@@ -13599,7 +14532,10 @@ var PostgresStore = class extends storage.MastraCompositeStore {
         skills: new SkillsPG(domainConfig),
         blobs: new BlobsPG(domainConfig),
         datasets: new DatasetsPG(domainConfig),
-        experiments: new ExperimentsPG(domainConfig)
+        experiments: new ExperimentsPG(domainConfig),
+        backgroundTasks: new BackgroundTasksPG(domainConfig),
+        channels: new ChannelsPG(domainConfig),
+        schedules: new SchedulesPG(domainConfig)
       };
     } catch (e) {
       throw new error.MastraError(
@@ -13789,7 +14725,9 @@ Example Complex Query:
 }`;
 
 exports.AgentsPG = AgentsPG;
+exports.BackgroundTasksPG = BackgroundTasksPG;
 exports.BlobsPG = BlobsPG;
+exports.ChannelsPG = ChannelsPG;
 exports.DatasetsPG = DatasetsPG;
 exports.ExperimentsPG = ExperimentsPG;
 exports.MCPClientsPG = MCPClientsPG;
@@ -13801,6 +14739,7 @@ exports.PgVector = PgVector;
 exports.PoolAdapter = PoolAdapter;
 exports.PostgresStore = PostgresStore;
 exports.PromptBlocksPG = PromptBlocksPG;
+exports.SchedulesPG = SchedulesPG;
 exports.ScorerDefinitionsPG = ScorerDefinitionsPG;
 exports.ScoresPG = ScoresPG;
 exports.SkillsPG = SkillsPG;