@mastra/pg 1.0.0-beta.4 → 1.0.0-beta.6

package/CHANGELOG.md

@@ -1,5 +1,73 @@
 # @mastra/pg
 
+## 1.0.0-beta.6
+
+### Minor Changes
+
+- Add stored agents support ([#10953](https://github.com/mastra-ai/mastra/pull/10953))
+
+  Agents can now be stored in the database and loaded at runtime. This lets you persist agent configurations and dynamically create executable Agent instances from storage.
+
+  ```typescript
+  import { Mastra } from '@mastra/core';
+  import { LibSQLStore } from '@mastra/libsql';
+
+  const mastra = new Mastra({
+    storage: new LibSQLStore({ url: ':memory:' }),
+    tools: { myTool },
+    scorers: { myScorer },
+  });
+
+  // Create agent in storage via API or directly
+  await mastra.getStorage().createAgent({
+    agent: {
+      id: 'my-agent',
+      name: 'My Agent',
+      instructions: 'You are helpful',
+      model: { provider: 'openai', name: 'gpt-4' },
+      tools: { myTool: {} },
+      scorers: { myScorer: { sampling: { type: 'ratio', rate: 0.5 } } },
+    },
+  });
+
+  // Load and use the agent
+  const agent = await mastra.getStoredAgentById('my-agent');
+  const response = await agent.generate({ messages: 'Hello!' });
+
+  // List all stored agents with pagination
+  const { agents, total, hasMore } = await mastra.listStoredAgents({
+    page: 0,
+    perPage: 10,
+  });
+  ```
+
+  Also adds a memory registry to Mastra so stored agents can reference memory instances by key.
+
+### Patch Changes
+
+- Updated dependencies [[`72df8ae`](https://github.com/mastra-ai/mastra/commit/72df8ae595584cdd7747d5c39ffaca45e4507227), [`9198899`](https://github.com/mastra-ai/mastra/commit/91988995c427b185c33714b7f3be955367911324), [`653e65a`](https://github.com/mastra-ai/mastra/commit/653e65ae1f9502c2958a32f47a5a2df11e612a92), [`c6fd6fe`](https://github.com/mastra-ai/mastra/commit/c6fd6fedd09e9cf8004b03a80925f5e94826ad7e), [`0bed332`](https://github.com/mastra-ai/mastra/commit/0bed332843f627202c6520eaf671771313cd20f3)]:
+  - @mastra/core@1.0.0-beta.9
+
+## 1.0.0-beta.5
+
+### Patch Changes
+
+- Fix saveScore not persisting ID correctly, breaking getScoreById retrieval ([#10915](https://github.com/mastra-ai/mastra/pull/10915))
+
+  **What Changed**
+  - saveScore now correctly returns scores that can be retrieved with getScoreById
+  - Validation errors now include contextual information (scorer, entity, trace details) for easier debugging
+
+  **Impact**
+  Previously, calling getScoreById after saveScore would return null because the generated ID wasn't persisted to the database. This is now fixed across all store implementations, ensuring consistent behavior and data integrity.
+
+- PostgresStore was setting `this.stores = {}` in the constructor and only populating it in the async `init()` method. This broke Memory because it checks `storage.stores.memory` synchronously in `getInputProcessors()` before `init()` is called. ([#10943](https://github.com/mastra-ai/mastra/pull/10943))
+
+  The fix moves domain instance creation to the constructor. This is safe because pg-promise creates database connections lazily when queries are executed.
+
+- Updated dependencies [[`0d41fe2`](https://github.com/mastra-ai/mastra/commit/0d41fe245355dfc66d61a0d9c85d9400aac351ff), [`6b3ba91`](https://github.com/mastra-ai/mastra/commit/6b3ba91494cc10394df96782f349a4f7b1e152cc), [`7907fd1`](https://github.com/mastra-ai/mastra/commit/7907fd1c5059813b7b870b81ca71041dc807331b)]:
+  - @mastra/core@1.0.0-beta.8
+
 ## 1.0.0-beta.4
 
 ### Minor Changes

package/dist/index.cjs

@@ -1663,7 +1663,302 @@ function transformFromSqlRow({
   return result;
 }
 
-// src/storage/domains/memory/index.ts
+// src/storage/domains/agents/index.ts
+var AgentsPG = class extends storage.AgentsStorage {
+  client;
+  schema;
+  constructor({ client, schema }) {
+    super();
+    this.client = client;
+    this.schema = schema;
+  }
+  parseJson(value, fieldName) {
+    if (!value) return void 0;
+    if (typeof value !== "string") return value;
+    try {
+      return JSON.parse(value);
+    } catch (error$1) {
+      const details = {
+        value: value.length > 100 ? value.substring(0, 100) + "..." : value
+      };
+      if (fieldName) {
+        details.field = fieldName;
+      }
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("PG", "PARSE_JSON", "INVALID_JSON"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.SYSTEM,
+          text: `Failed to parse JSON${fieldName ? ` for field "${fieldName}"` : ""}: ${error$1 instanceof Error ? error$1.message : "Unknown error"}`,
+          details
+        },
+        error$1
+      );
+    }
+  }
+  parseRow(row) {
+    return {
+      id: row.id,
+      name: row.name,
+      description: row.description,
+      instructions: row.instructions,
+      model: this.parseJson(row.model, "model"),
+      tools: this.parseJson(row.tools, "tools"),
+      defaultOptions: this.parseJson(row.defaultOptions, "defaultOptions"),
+      workflows: this.parseJson(row.workflows, "workflows"),
+      agents: this.parseJson(row.agents, "agents"),
+      inputProcessors: this.parseJson(row.inputProcessors, "inputProcessors"),
+      outputProcessors: this.parseJson(row.outputProcessors, "outputProcessors"),
+      memory: this.parseJson(row.memory, "memory"),
+      scorers: this.parseJson(row.scorers, "scorers"),
+      metadata: this.parseJson(row.metadata, "metadata"),
+      createdAt: row.createdAtZ || row.createdAt,
+      updatedAt: row.updatedAtZ || row.updatedAt
+    };
+  }
+  async getAgentById({ id }) {
+    try {
+      const tableName = getTableName({ indexName: storage.TABLE_AGENTS, schemaName: getSchemaName(this.schema) });
+      const result = await this.client.oneOrNone(`SELECT * FROM ${tableName} WHERE id = $1`, [id]);
+      if (!result) {
+        return null;
+      }
+      return this.parseRow(result);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("PG", "GET_AGENT_BY_ID", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { agentId: id }
+        },
+        error$1
+      );
+    }
+  }
+  async createAgent({ agent }) {
+    try {
+      const tableName = getTableName({ indexName: storage.TABLE_AGENTS, schemaName: getSchemaName(this.schema) });
+      const now = /* @__PURE__ */ new Date();
+      const nowIso = now.toISOString();
+      await this.client.none(
+        `INSERT INTO ${tableName} (
+          id, name, description, instructions, model, tools, 
+          "defaultOptions", workflows, agents, "inputProcessors", "outputProcessors", memory, scorers, metadata, 
+          "createdAt", "createdAtZ", "updatedAt", "updatedAtZ"
+        ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17, $18)`,
+        [
+          agent.id,
+          agent.name,
+          agent.description ?? null,
+          agent.instructions,
+          JSON.stringify(agent.model),
+          agent.tools ? JSON.stringify(agent.tools) : null,
+          agent.defaultOptions ? JSON.stringify(agent.defaultOptions) : null,
+          agent.workflows ? JSON.stringify(agent.workflows) : null,
+          agent.agents ? JSON.stringify(agent.agents) : null,
+          agent.inputProcessors ? JSON.stringify(agent.inputProcessors) : null,
+          agent.outputProcessors ? JSON.stringify(agent.outputProcessors) : null,
+          agent.memory ? JSON.stringify(agent.memory) : null,
+          agent.scorers ? JSON.stringify(agent.scorers) : null,
+          agent.metadata ? JSON.stringify(agent.metadata) : null,
+          nowIso,
+          nowIso,
+          nowIso,
+          nowIso
+        ]
+      );
+      return {
+        ...agent,
+        createdAt: now,
+        updatedAt: now
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("PG", "CREATE_AGENT", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { agentId: agent.id }
+        },
+        error$1
+      );
+    }
+  }
+  async updateAgent({ id, ...updates }) {
+    try {
+      const tableName = getTableName({ indexName: storage.TABLE_AGENTS, schemaName: getSchemaName(this.schema) });
+      const existingAgent = await this.getAgentById({ id });
+      if (!existingAgent) {
+        throw new error.MastraError({
+          id: storage.createStorageErrorId("PG", "UPDATE_AGENT", "NOT_FOUND"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          text: `Agent ${id} not found`,
+          details: { agentId: id }
+        });
+      }
+      const setClauses = [];
+      const values = [];
+      let paramIndex = 1;
+      if (updates.name !== void 0) {
+        setClauses.push(`name = $${paramIndex++}`);
+        values.push(updates.name);
+      }
+      if (updates.description !== void 0) {
+        setClauses.push(`description = $${paramIndex++}`);
+        values.push(updates.description);
+      }
+      if (updates.instructions !== void 0) {
+        setClauses.push(`instructions = $${paramIndex++}`);
+        values.push(updates.instructions);
+      }
+      if (updates.model !== void 0) {
+        setClauses.push(`model = $${paramIndex++}`);
+        values.push(JSON.stringify(updates.model));
+      }
+      if (updates.tools !== void 0) {
+        setClauses.push(`tools = $${paramIndex++}`);
+        values.push(JSON.stringify(updates.tools));
+      }
+      if (updates.defaultOptions !== void 0) {
+        setClauses.push(`"defaultOptions" = $${paramIndex++}`);
+        values.push(JSON.stringify(updates.defaultOptions));
+      }
+      if (updates.workflows !== void 0) {
+        setClauses.push(`workflows = $${paramIndex++}`);
+        values.push(JSON.stringify(updates.workflows));
+      }
+      if (updates.agents !== void 0) {
+        setClauses.push(`agents = $${paramIndex++}`);
+        values.push(JSON.stringify(updates.agents));
+      }
+      if (updates.inputProcessors !== void 0) {
+        setClauses.push(`"inputProcessors" = $${paramIndex++}`);
+        values.push(JSON.stringify(updates.inputProcessors));
+      }
+      if (updates.outputProcessors !== void 0) {
+        setClauses.push(`"outputProcessors" = $${paramIndex++}`);
+        values.push(JSON.stringify(updates.outputProcessors));
+      }
+      if (updates.memory !== void 0) {
+        setClauses.push(`memory = $${paramIndex++}`);
+        values.push(JSON.stringify(updates.memory));
+      }
+      if (updates.scorers !== void 0) {
+        setClauses.push(`scorers = $${paramIndex++}`);
+        values.push(JSON.stringify(updates.scorers));
+      }
+      if (updates.metadata !== void 0) {
+        const mergedMetadata = { ...existingAgent.metadata, ...updates.metadata };
+        setClauses.push(`metadata = $${paramIndex++}`);
+        values.push(JSON.stringify(mergedMetadata));
+      }
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      setClauses.push(`"updatedAt" = $${paramIndex++}`);
+      values.push(now);
+      setClauses.push(`"updatedAtZ" = $${paramIndex++}`);
+      values.push(now);
+      values.push(id);
+      if (setClauses.length > 2) {
+        await this.client.none(`UPDATE ${tableName} SET ${setClauses.join(", ")} WHERE id = $${paramIndex}`, values);
+      }
+      const updatedAgent = await this.getAgentById({ id });
+      if (!updatedAgent) {
+        throw new error.MastraError({
+          id: storage.createStorageErrorId("PG", "UPDATE_AGENT", "NOT_FOUND_AFTER_UPDATE"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.SYSTEM,
+          text: `Agent ${id} not found after update`,
+          details: { agentId: id }
+        });
+      }
+      return updatedAgent;
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) {
+        throw error$1;
+      }
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("PG", "UPDATE_AGENT", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { agentId: id }
+        },
+        error$1
+      );
+    }
+  }
+  async deleteAgent({ id }) {
+    try {
+      const tableName = getTableName({ indexName: storage.TABLE_AGENTS, schemaName: getSchemaName(this.schema) });
+      await this.client.none(`DELETE FROM ${tableName} WHERE id = $1`, [id]);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("PG", "DELETE_AGENT", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { agentId: id }
+        },
+        error$1
+      );
+    }
+  }
+  async listAgents(args) {
+    const { page = 0, perPage: perPageInput, orderBy } = args || {};
+    const { field, direction } = this.parseOrderBy(orderBy);
+    if (page < 0) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("PG", "LIST_AGENTS", "INVALID_PAGE"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: { page }
+        },
+        new Error("page must be >= 0")
+      );
+    }
+    const perPage = storage.normalizePerPage(perPageInput, 100);
+    const { offset, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
+    try {
+      const tableName = getTableName({ indexName: storage.TABLE_AGENTS, schemaName: getSchemaName(this.schema) });
+      const countResult = await this.client.one(`SELECT COUNT(*) as count FROM ${tableName}`);
+      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 dataResult = await this.client.manyOrNone(
+        `SELECT * FROM ${tableName} ORDER BY "${field}" ${direction} LIMIT $1 OFFSET $2`,
+        [limitValue, offset]
+      );
+      const agents = (dataResult || []).map((row) => this.parseRow(row));
+      return {
+        agents,
+        total,
+        page,
+        perPage: perPageForResponse,
+        hasMore: perPageInput === false ? false : offset + perPage < total
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("PG", "LIST_AGENTS", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+};
 var MemoryPG = class extends storage.MemoryStorage {
   client;
   schema;
@@ -3737,15 +4032,15 @@ var ScoresPG = class extends storage.ScoresStorage {
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: storage.createStorageErrorId("PG", "SAVE_SCORE", "INVALID_PAYLOAD"),
+          id: storage.createStorageErrorId("PG", "SAVE_SCORE", "VALIDATION_FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.USER,
           details: {
-            scorer: score.scorer.id,
-            entityId: score.entityId,
-            entityType: score.entityType,
-            traceId: score.traceId || "",
-            spanId: score.spanId || ""
+            scorer: score.scorer?.id ?? "unknown",
+            entityId: score.entityId ?? "unknown",
+            entityType: score.entityType ?? "unknown",
+            traceId: score.traceId ?? "",
+            spanId: score.spanId ?? ""
           }
         },
         error$1
@@ -3753,6 +4048,7 @@ var ScoresPG = class extends storage.ScoresStorage {
     }
     try {
       const id = crypto.randomUUID();
+      const now = /* @__PURE__ */ new Date();
       const {
         scorer,
         preprocessStepResult,
@@ -3775,14 +4071,15 @@ var ScoresPG = class extends storage.ScoresStorage {
           scorer: scorer ? JSON.stringify(scorer) : null,
           preprocessStepResult: preprocessStepResult ? JSON.stringify(preprocessStepResult) : null,
           analyzeStepResult: analyzeStepResult ? JSON.stringify(analyzeStepResult) : null,
+          metadata: metadata ? JSON.stringify(metadata) : null,
+          additionalContext: additionalContext ? JSON.stringify(additionalContext) : null,
           requestContext: requestContext ? JSON.stringify(requestContext) : null,
           entity: entity ? JSON.stringify(entity) : null,
-          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+          createdAt: now.toISOString(),
+          updatedAt: now.toISOString()
         }
       });
-      const scoreFromDb = await this.getScoreById({ id });
-      return { score: scoreFromDb };
+      return { score: { ...parsedScore, id, createdAt: now, updatedAt: now } };
     } catch (error$1) {
       throw new error.MastraError(
         {
@@ -4164,17 +4461,17 @@ var WorkflowsPG = class extends storage.WorkflowsStorage {
 var PostgresStore = class extends storage.MastraStorage {
   #db;
   #pgp;
-  #config;
   schema;
-  isConnected = false;
+  isInitialized = false;
   stores;
   constructor(config) {
     try {
       validateConfig("PostgresStore", config);
       super({ id: config.id, name: "PostgresStore", disableInit: config.disableInit });
       this.schema = config.schemaName || "public";
+      let pgConfig;
       if (isConnectionStringConfig(config)) {
-        this.#config = {
+        pgConfig = {
           id: config.id,
           connectionString: config.connectionString,
           max: config.max,
@@ -4182,14 +4479,14 @@ var PostgresStore = class extends storage.MastraStorage {
           ssl: config.ssl
         };
       } else if (isCloudSqlConfig(config)) {
-        this.#config = {
+        pgConfig = {
           ...config,
           id: config.id,
           max: config.max,
           idleTimeoutMillis: config.idleTimeoutMillis
         };
       } else if (isHostConfig(config)) {
-        this.#config = {
+        pgConfig = {
           id: config.id,
           host: config.host,
           port: config.port,
@@ -4205,7 +4502,22 @@ var PostgresStore = class extends storage.MastraStorage {
           "PostgresStore: invalid config. Provide either {connectionString}, {host,port,database,user,password}, or a pg ClientConfig (e.g., Cloud SQL connector with `stream`)."
         );
       }
-      this.stores = {};
+      this.#pgp = pgPromise__default.default();
+      this.#db = this.#pgp(pgConfig);
+      const operations = new StoreOperationsPG({ client: this.#db, schemaName: this.schema });
+      const scores = new ScoresPG({ client: this.#db, operations, schema: this.schema });
+      const workflows = new WorkflowsPG({ client: this.#db, operations, schema: this.schema });
+      const memory = new MemoryPG({ client: this.#db, schema: this.schema, operations });
+      const observability = new ObservabilityPG({ client: this.#db, operations, schema: this.schema });
+      const agents = new AgentsPG({ client: this.#db, schema: this.schema });
+      this.stores = {
+        operations,
+        scores,
+        workflows,
+        memory,
+        observability,
+        agents
+      };
     } catch (e) {
       throw new error.MastraError(
         {
@@ -4218,33 +4530,19 @@ var PostgresStore = class extends storage.MastraStorage {
     }
   }
   async init() {
-    if (this.isConnected) {
+    if (this.isInitialized) {
       return;
     }
     try {
-      this.isConnected = true;
-      this.#pgp = pgPromise__default.default();
-      this.#db = this.#pgp(this.#config);
-      const operations = new StoreOperationsPG({ client: this.#db, schemaName: this.schema });
-      const scores = new ScoresPG({ client: this.#db, operations, schema: this.schema });
-      const workflows = new WorkflowsPG({ client: this.#db, operations, schema: this.schema });
-      const memory = new MemoryPG({ client: this.#db, schema: this.schema, operations });
-      const observability = new ObservabilityPG({ client: this.#db, operations, schema: this.schema });
-      this.stores = {
-        operations,
-        scores,
-        workflows,
-        memory,
-        observability
-      };
+      this.isInitialized = true;
       await super.init();
       try {
-        await operations.createAutomaticIndexes();
+        await this.stores.operations.createAutomaticIndexes();
       } catch (indexError) {
         console.warn("Failed to create indexes:", indexError);
       }
     } catch (error$1) {
-      this.isConnected = false;
+      this.isInitialized = false;
       throw new error.MastraError(
         {
           id: storage.createStorageErrorId("PG", "INIT", "FAILED"),
@@ -4256,15 +4554,9 @@ var PostgresStore = class extends storage.MastraStorage {
     }
   }
   get db() {
-    if (!this.#db) {
-      throw new Error(`PostgresStore: Store is not initialized, please call "init()" first.`);
-    }
     return this.#db;
   }
   get pgp() {
-    if (!this.#pgp) {
-      throw new Error(`PostgresStore: Store is not initialized, please call "init()" first.`);
-    }
     return this.#pgp;
   }
   get supports() {
@@ -4276,7 +4568,8 @@ var PostgresStore = class extends storage.MastraStorage {
       deleteMessages: true,
       observabilityInstance: true,
       indexManagement: true,
-      listScoresBySpan: true
+      listScoresBySpan: true,
+      agents: true
     };
   }
   async createTable({