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

package/dist/index.js

@@ -1,6 +1,6 @@
 import { createClient } from '@libsql/client';
 import { MastraError, ErrorCategory, ErrorDomain } from '@mastra/core/error';
-import { createVectorErrorId, MastraStorage, StoreOperations, TABLE_WORKFLOW_SNAPSHOT, TABLE_SPANS, createStorageErrorId, ScoresStorage, TABLE_SCORERS, normalizePerPage, calculatePagination, transformScoreRow, WorkflowsStorage, MemoryStorage, TABLE_MESSAGES, TABLE_THREADS, TABLE_RESOURCES, ObservabilityStorage, TABLE_SCHEMAS, safelyParseJSON, SPAN_SCHEMA } from '@mastra/core/storage';
+import { createVectorErrorId, MastraStorage, StoreOperations, TABLE_WORKFLOW_SNAPSHOT, TABLE_SPANS, createStorageErrorId, ScoresStorage, TABLE_SCORERS, normalizePerPage, calculatePagination, transformScoreRow, WorkflowsStorage, MemoryStorage, TABLE_MESSAGES, TABLE_THREADS, TABLE_RESOURCES, ObservabilityStorage, AgentsStorage, TABLE_AGENTS, TABLE_SCHEMAS, safelyParseJSON, SPAN_SCHEMA } from '@mastra/core/storage';
 import { parseSqlIdentifier, parseFieldKey } from '@mastra/core/utils';
 import { MastraVector } from '@mastra/core/vector';
 import { BaseFilterTranslator } from '@mastra/core/vector/filter';
@@ -1092,6 +1092,298 @@ var LibSQLVector = class extends MastraVector {
     });
   }
 };
+var AgentsLibSQL = class extends AgentsStorage {
+  client;
+  constructor({ client, operations: _ }) {
+    super();
+    this.client = client;
+  }
+  parseJson(value, fieldName) {
+    if (!value) return void 0;
+    if (typeof value !== "string") return value;
+    try {
+      return JSON.parse(value);
+    } catch (error) {
+      const details = {
+        value: value.length > 100 ? value.substring(0, 100) + "..." : value
+      };
+      if (fieldName) {
+        details.field = fieldName;
+      }
+      throw new MastraError(
+        {
+          id: createStorageErrorId("LIBSQL", "PARSE_JSON", "INVALID_JSON"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.SYSTEM,
+          text: `Failed to parse JSON${fieldName ? ` for field "${fieldName}"` : ""}: ${error instanceof Error ? error.message : "Unknown error"}`,
+          details
+        },
+        error
+      );
+    }
+  }
+  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: new Date(row.createdAt),
+      updatedAt: new Date(row.updatedAt)
+    };
+  }
+  async getAgentById({ id }) {
+    try {
+      const result = await this.client.execute({
+        sql: `SELECT * FROM "${TABLE_AGENTS}" WHERE id = ?`,
+        args: [id]
+      });
+      if (!result.rows || result.rows.length === 0) {
+        return null;
+      }
+      return this.parseRow(result.rows[0]);
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("LIBSQL", "GET_AGENT_BY_ID", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { agentId: id }
+        },
+        error
+      );
+    }
+  }
+  async createAgent({ agent }) {
+    try {
+      const now = /* @__PURE__ */ new Date();
+      const nowIso = now.toISOString();
+      await this.client.execute({
+        sql: `INSERT INTO "${TABLE_AGENTS}" (id, name, description, instructions, model, tools, "defaultOptions", workflows, agents, "inputProcessors", "outputProcessors", memory, scorers, metadata, "createdAt", "updatedAt")
+              VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+        args: [
+          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
+        ]
+      });
+      return {
+        ...agent,
+        createdAt: now,
+        updatedAt: now
+      };
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("LIBSQL", "CREATE_AGENT", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { agentId: agent.id }
+        },
+        error
+      );
+    }
+  }
+  async updateAgent({ id, ...updates }) {
+    try {
+      const existingAgent = await this.getAgentById({ id });
+      if (!existingAgent) {
+        throw new MastraError({
+          id: createStorageErrorId("LIBSQL", "UPDATE_AGENT", "NOT_FOUND"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.USER,
+          text: `Agent ${id} not found`,
+          details: { agentId: id }
+        });
+      }
+      const setClauses = [];
+      const args = [];
+      if (updates.name !== void 0) {
+        setClauses.push("name = ?");
+        args.push(updates.name);
+      }
+      if (updates.description !== void 0) {
+        setClauses.push("description = ?");
+        args.push(updates.description);
+      }
+      if (updates.instructions !== void 0) {
+        setClauses.push("instructions = ?");
+        args.push(updates.instructions);
+      }
+      if (updates.model !== void 0) {
+        setClauses.push("model = ?");
+        args.push(JSON.stringify(updates.model));
+      }
+      if (updates.tools !== void 0) {
+        setClauses.push("tools = ?");
+        args.push(JSON.stringify(updates.tools));
+      }
+      if (updates.defaultOptions !== void 0) {
+        setClauses.push('"defaultOptions" = ?');
+        args.push(JSON.stringify(updates.defaultOptions));
+      }
+      if (updates.workflows !== void 0) {
+        setClauses.push("workflows = ?");
+        args.push(JSON.stringify(updates.workflows));
+      }
+      if (updates.agents !== void 0) {
+        setClauses.push("agents = ?");
+        args.push(JSON.stringify(updates.agents));
+      }
+      if (updates.inputProcessors !== void 0) {
+        setClauses.push('"inputProcessors" = ?');
+        args.push(JSON.stringify(updates.inputProcessors));
+      }
+      if (updates.outputProcessors !== void 0) {
+        setClauses.push('"outputProcessors" = ?');
+        args.push(JSON.stringify(updates.outputProcessors));
+      }
+      if (updates.memory !== void 0) {
+        setClauses.push("memory = ?");
+        args.push(JSON.stringify(updates.memory));
+      }
+      if (updates.scorers !== void 0) {
+        setClauses.push("scorers = ?");
+        args.push(JSON.stringify(updates.scorers));
+      }
+      if (updates.metadata !== void 0) {
+        const mergedMetadata = { ...existingAgent.metadata, ...updates.metadata };
+        setClauses.push("metadata = ?");
+        args.push(JSON.stringify(mergedMetadata));
+      }
+      const now = /* @__PURE__ */ new Date();
+      setClauses.push('"updatedAt" = ?');
+      args.push(now.toISOString());
+      args.push(id);
+      if (setClauses.length > 1) {
+        await this.client.execute({
+          sql: `UPDATE "${TABLE_AGENTS}" SET ${setClauses.join(", ")} WHERE id = ?`,
+          args
+        });
+      }
+      const updatedAgent = await this.getAgentById({ id });
+      if (!updatedAgent) {
+        throw new MastraError({
+          id: createStorageErrorId("LIBSQL", "UPDATE_AGENT", "NOT_FOUND_AFTER_UPDATE"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.SYSTEM,
+          text: `Agent ${id} not found after update`,
+          details: { agentId: id }
+        });
+      }
+      return updatedAgent;
+    } catch (error) {
+      if (error instanceof MastraError) {
+        throw error;
+      }
+      throw new MastraError(
+        {
+          id: createStorageErrorId("LIBSQL", "UPDATE_AGENT", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { agentId: id }
+        },
+        error
+      );
+    }
+  }
+  async deleteAgent({ id }) {
+    try {
+      await this.client.execute({
+        sql: `DELETE FROM "${TABLE_AGENTS}" WHERE id = ?`,
+        args: [id]
+      });
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("LIBSQL", "DELETE_AGENT", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { agentId: id }
+        },
+        error
+      );
+    }
+  }
+  async listAgents(args) {
+    const { page = 0, perPage: perPageInput, orderBy } = args || {};
+    const { field, direction } = this.parseOrderBy(orderBy);
+    if (page < 0) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("LIBSQL", "LIST_AGENTS", "INVALID_PAGE"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.USER,
+          details: { page }
+        },
+        new Error("page must be >= 0")
+      );
+    }
+    const perPage = normalizePerPage(perPageInput, 100);
+    const { offset, perPage: perPageForResponse } = calculatePagination(page, perPageInput, perPage);
+    try {
+      const countResult = await this.client.execute({
+        sql: `SELECT COUNT(*) as count FROM "${TABLE_AGENTS}"`,
+        args: []
+      });
+      const total = Number(countResult.rows?.[0]?.count ?? 0);
+      if (total === 0) {
+        return {
+          agents: [],
+          total: 0,
+          page,
+          perPage: perPageForResponse,
+          hasMore: false
+        };
+      }
+      const limitValue = perPageInput === false ? total : perPage;
+      const dataResult = await this.client.execute({
+        sql: `SELECT * FROM "${TABLE_AGENTS}" ORDER BY "${field}" ${direction} LIMIT ? OFFSET ?`,
+        args: [limitValue, offset]
+      });
+      const agents = (dataResult.rows || []).map((row) => this.parseRow(row));
+      return {
+        agents,
+        total,
+        page,
+        perPage: perPageForResponse,
+        hasMore: perPageInput === false ? false : offset + perPage < total
+      };
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("LIBSQL", "LIST_AGENTS", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY
+        },
+        error
+      );
+    }
+  }
+};
 var MemoryLibSQL = class extends MemoryStorage {
   client;
   operations;
@@ -2753,11 +3045,11 @@ var ScoresLibSQL = class extends ScoresStorage {
           domain: ErrorDomain.STORAGE,
           category: 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
@@ -2765,17 +3057,17 @@ var ScoresLibSQL = class extends ScoresStorage {
     }
     try {
       const id = crypto.randomUUID();
+      const now = /* @__PURE__ */ new Date();
       await this.operations.insert({
         tableName: TABLE_SCORERS,
         record: {
+          ...parsedScore,
           id,
-          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-          updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-          ...parsedScore
+          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) {
       throw new MastraError(
         {
@@ -3235,12 +3527,14 @@ var LibSQLStore = class extends MastraStorage {
     const workflows = new WorkflowsLibSQL({ client: this.client, operations });
     const memory = new MemoryLibSQL({ client: this.client, operations });
     const observability = new ObservabilityLibSQL({ operations });
+    const agents = new AgentsLibSQL({ client: this.client, operations });
     this.stores = {
       operations,
       scores,
       workflows,
       memory,
-      observability
+      observability,
+      agents
     };
   }
   get supports() {
@@ -3251,7 +3545,8 @@ var LibSQLStore = class extends MastraStorage {
       createTable: true,
       deleteMessages: true,
       observabilityInstance: true,
-      listScoresBySpan: true
+      listScoresBySpan: true,
+      agents: true
     };
   }
   async createTable({