@mastra/libsql 1.3.0 → 1.4.0-alpha.0

package/dist/index.cjs

@@ -1692,17 +1692,30 @@ var LibSQLDB = class extends base.MastraBase {
    */
   async createTable({
     tableName,
-    schema
+    schema,
+    compositePrimaryKey
   }) {
     try {
       const parsedTableName = utils.parseSqlIdentifier(tableName, "table name");
+      if (compositePrimaryKey) {
+        for (const col of compositePrimaryKey) {
+          if (!(col in schema)) {
+            throw new Error(`compositePrimaryKey column "${col}" does not exist in schema for table "${tableName}"`);
+          }
+        }
+      }
+      const compositePKSet = compositePrimaryKey ? new Set(compositePrimaryKey) : null;
       const columnDefinitions = Object.entries(schema).map(([colName, colDef]) => {
         const type = this.getSqlType(colDef.type);
         const nullable = colDef.nullable === false ? "NOT NULL" : "";
-        const primaryKey = colDef.primaryKey ? "PRIMARY KEY" : "";
+        const primaryKey = colDef.primaryKey && !compositePKSet?.has(colName) ? "PRIMARY KEY" : "";
         return `"${colName}" ${type} ${nullable} ${primaryKey}`.trim();
       });
       const tableConstraints = [];
+      if (compositePrimaryKey) {
+        const pkCols = compositePrimaryKey.map((c) => `"${c}"`).join(", ");
+        tableConstraints.push(`PRIMARY KEY (${pkCols})`);
+      }
       if (tableName === storage.TABLE_WORKFLOW_SNAPSHOT) {
         tableConstraints.push("UNIQUE (workflow_name, run_id)");
       }
@@ -2055,7 +2068,9 @@ var SNAPSHOT_FIELDS = [
   "inputProcessors",
   "outputProcessors",
   "memory",
-  "scorers"
+  "scorers",
+  "mcpClients",
+  "requestContextSchema"
 ];
 var AgentsLibSQL = class extends storage.AgentsStorage {
   #db;
@@ -2485,33 +2500,1858 @@ var AgentsLibSQL = class extends storage.AgentsStorage {
       const total = await this.#db.selectTotalCount({ tableName: storage.TABLE_AGENTS });
       if (total === 0) {
         return {
-          agents: [],
+          agents: [],
+          total: 0,
+          page,
+          perPage: perPageForResponse,
+          hasMore: false
+        };
+      }
+      const limitValue = perPageInput === false ? total : perPage;
+      const rows = await this.#db.selectMany({
+        tableName: storage.TABLE_AGENTS,
+        orderBy: `"${field}" ${direction}`,
+        limit: limitValue,
+        offset
+      });
+      const agents = rows.map((row) => this.parseRow(row));
+      return {
+        agents,
+        total,
+        page,
+        perPage: perPageForResponse,
+        hasMore: perPageInput === false ? false : offset + perPage < total
+      };
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) throw error$1;
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("LIBSQL", "LIST_AGENTS", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  // ==========================================================================
+  // Agent Version Methods
+  // ==========================================================================
+  async createVersion(input) {
+    try {
+      const now = /* @__PURE__ */ new Date();
+      await this.#db.insert({
+        tableName: storage.TABLE_AGENT_VERSIONS,
+        record: {
+          id: input.id,
+          agentId: input.agentId,
+          versionNumber: input.versionNumber,
+          name: input.name ?? null,
+          description: input.description ?? null,
+          instructions: this.serializeInstructions(input.instructions),
+          model: input.model,
+          tools: input.tools ?? null,
+          defaultOptions: input.defaultOptions ?? null,
+          workflows: input.workflows ?? null,
+          agents: input.agents ?? null,
+          integrationTools: input.integrationTools ?? null,
+          inputProcessors: input.inputProcessors ?? null,
+          outputProcessors: input.outputProcessors ?? null,
+          memory: input.memory ?? null,
+          scorers: input.scorers ?? null,
+          mcpClients: input.mcpClients ?? null,
+          requestContextSchema: input.requestContextSchema ?? null,
+          changedFields: input.changedFields ?? null,
+          changeMessage: input.changeMessage ?? null,
+          createdAt: now
+        }
+      });
+      return {
+        ...input,
+        createdAt: now
+      };
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) throw error$1;
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("LIBSQL", "CREATE_VERSION", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { versionId: input.id, agentId: input.agentId }
+        },
+        error$1
+      );
+    }
+  }
+  async getVersion(id) {
+    try {
+      const result = await this.#db.select({
+        tableName: storage.TABLE_AGENT_VERSIONS,
+        keys: { id }
+      });
+      if (!result) {
+        return null;
+      }
+      return this.parseVersionRow(result);
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) throw error$1;
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("LIBSQL", "GET_VERSION", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { versionId: id }
+        },
+        error$1
+      );
+    }
+  }
+  async getVersionByNumber(agentId, versionNumber) {
+    try {
+      const rows = await this.#db.selectMany({
+        tableName: storage.TABLE_AGENT_VERSIONS,
+        whereClause: {
+          sql: "WHERE agentId = ? AND versionNumber = ?",
+          args: [agentId, versionNumber]
+        },
+        limit: 1
+      });
+      if (!rows || rows.length === 0) {
+        return null;
+      }
+      return this.parseVersionRow(rows[0]);
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) throw error$1;
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("LIBSQL", "GET_VERSION_BY_NUMBER", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { agentId, versionNumber }
+        },
+        error$1
+      );
+    }
+  }
+  async getLatestVersion(agentId) {
+    try {
+      const rows = await this.#db.selectMany({
+        tableName: storage.TABLE_AGENT_VERSIONS,
+        whereClause: {
+          sql: "WHERE agentId = ?",
+          args: [agentId]
+        },
+        orderBy: "versionNumber DESC",
+        limit: 1
+      });
+      if (!rows || rows.length === 0) {
+        return null;
+      }
+      return this.parseVersionRow(rows[0]);
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) throw error$1;
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("LIBSQL", "GET_LATEST_VERSION", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { agentId }
+        },
+        error$1
+      );
+    }
+  }
+  async listVersions(input) {
+    const { agentId, page = 0, perPage: perPageInput, orderBy } = input;
+    if (page < 0) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("LIBSQL", "LIST_VERSIONS", "INVALID_PAGE"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: { page }
+        },
+        new Error("page must be >= 0")
+      );
+    }
+    const perPage = storage.normalizePerPage(perPageInput, 20);
+    const { offset, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
+    try {
+      const { field, direction } = this.parseVersionOrderBy(orderBy);
+      const total = await this.#db.selectTotalCount({
+        tableName: storage.TABLE_AGENT_VERSIONS,
+        whereClause: {
+          sql: "WHERE agentId = ?",
+          args: [agentId]
+        }
+      });
+      if (total === 0) {
+        return {
+          versions: [],
+          total: 0,
+          page,
+          perPage: perPageForResponse,
+          hasMore: false
+        };
+      }
+      const limitValue = perPageInput === false ? total : perPage;
+      const rows = await this.#db.selectMany({
+        tableName: storage.TABLE_AGENT_VERSIONS,
+        whereClause: {
+          sql: "WHERE agentId = ?",
+          args: [agentId]
+        },
+        orderBy: `"${field}" ${direction}`,
+        limit: limitValue,
+        offset
+      });
+      const versions = rows.map((row) => this.parseVersionRow(row));
+      return {
+        versions,
+        total,
+        page,
+        perPage: perPageForResponse,
+        hasMore: perPageInput === false ? false : offset + perPage < total
+      };
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) throw error$1;
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("LIBSQL", "LIST_VERSIONS", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { agentId }
+        },
+        error$1
+      );
+    }
+  }
+  async deleteVersion(id) {
+    try {
+      await this.#db.delete({
+        tableName: storage.TABLE_AGENT_VERSIONS,
+        keys: { id }
+      });
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) throw error$1;
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("LIBSQL", "DELETE_VERSION", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { versionId: id }
+        },
+        error$1
+      );
+    }
+  }
+  async deleteVersionsByParentId(entityId) {
+    try {
+      const versions = await this.#db.selectMany({
+        tableName: storage.TABLE_AGENT_VERSIONS,
+        whereClause: {
+          sql: "WHERE agentId = ?",
+          args: [entityId]
+        }
+      });
+      for (const version of versions) {
+        await this.#db.delete({
+          tableName: storage.TABLE_AGENT_VERSIONS,
+          keys: { id: version.id }
+        });
+      }
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) throw error$1;
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("LIBSQL", "DELETE_VERSIONS_BY_AGENT_ID", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { agentId: entityId }
+        },
+        error$1
+      );
+    }
+  }
+  async countVersions(agentId) {
+    try {
+      const count = await this.#db.selectTotalCount({
+        tableName: storage.TABLE_AGENT_VERSIONS,
+        whereClause: {
+          sql: "WHERE agentId = ?",
+          args: [agentId]
+        }
+      });
+      return count;
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) throw error$1;
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("LIBSQL", "COUNT_VERSIONS", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { agentId }
+        },
+        error$1
+      );
+    }
+  }
+  // ==========================================================================
+  // Private Helper Methods
+  // ==========================================================================
+  serializeInstructions(instructions) {
+    return Array.isArray(instructions) ? JSON.stringify(instructions) : instructions;
+  }
+  deserializeInstructions(raw) {
+    if (!raw) return raw;
+    try {
+      const parsed = JSON.parse(raw);
+      if (Array.isArray(parsed)) return parsed;
+    } catch {
+    }
+    return raw;
+  }
+  parseVersionRow(row) {
+    return {
+      id: row.id,
+      agentId: row.agentId,
+      versionNumber: row.versionNumber,
+      name: row.name,
+      description: row.description,
+      instructions: this.deserializeInstructions(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"),
+      integrationTools: this.parseJson(row.integrationTools, "integrationTools"),
+      inputProcessors: this.parseJson(row.inputProcessors, "inputProcessors"),
+      outputProcessors: this.parseJson(row.outputProcessors, "outputProcessors"),
+      memory: this.parseJson(row.memory, "memory"),
+      scorers: this.parseJson(row.scorers, "scorers"),
+      mcpClients: this.parseJson(row.mcpClients, "mcpClients"),
+      requestContextSchema: this.parseJson(row.requestContextSchema, "requestContextSchema"),
+      changedFields: this.parseJson(row.changedFields, "changedFields"),
+      changeMessage: row.changeMessage,
+      createdAt: new Date(row.createdAt)
+    };
+  }
+};
+function jsonbArg(value) {
+  return value === void 0 || value === null ? null : JSON.stringify(value);
+}
+var DatasetsLibSQL = class extends storage.DatasetsStorage {
+  #db;
+  #client;
+  constructor(config) {
+    super();
+    const client = resolveClient(config);
+    this.#client = client;
+    this.#db = new LibSQLDB({ client, maxRetries: config.maxRetries, initialBackoffMs: config.initialBackoffMs });
+  }
+  async init() {
+    await this.#db.createTable({ tableName: storage.TABLE_DATASETS, schema: storage.DATASETS_SCHEMA });
+    await this.#db.createTable({ tableName: storage.TABLE_DATASET_ITEMS, schema: storage.DATASET_ITEMS_SCHEMA });
+    await this.#db.createTable({ tableName: storage.TABLE_DATASET_VERSIONS, schema: storage.DATASET_VERSIONS_SCHEMA });
+    await this.#client.execute({
+      sql: `CREATE INDEX IF NOT EXISTS idx_dataset_items_dataset_validto ON "${storage.TABLE_DATASET_ITEMS}" ("datasetId", "validTo")`,
+      args: []
+    });
+    await this.#client.execute({
+      sql: `CREATE INDEX IF NOT EXISTS idx_dataset_items_dataset_version ON "${storage.TABLE_DATASET_ITEMS}" ("datasetId", "datasetVersion")`,
+      args: []
+    });
+    await this.#client.execute({
+      sql: `CREATE INDEX IF NOT EXISTS idx_dataset_items_dataset_validto_deleted ON "${storage.TABLE_DATASET_ITEMS}" ("datasetId", "validTo", "isDeleted")`,
+      args: []
+    });
+    await this.#client.execute({
+      sql: `CREATE INDEX IF NOT EXISTS idx_dataset_versions_dataset_version ON "${storage.TABLE_DATASET_VERSIONS}" ("datasetId", "version")`,
+      args: []
+    });
+    await this.#client.execute({
+      sql: `CREATE UNIQUE INDEX IF NOT EXISTS idx_dataset_versions_dataset_version_unique ON "${storage.TABLE_DATASET_VERSIONS}" ("datasetId", "version")`,
+      args: []
+    });
+  }
+  async dangerouslyClearAll() {
+    await this.#db.deleteData({ tableName: storage.TABLE_DATASET_VERSIONS });
+    await this.#db.deleteData({ tableName: storage.TABLE_DATASET_ITEMS });
+    await this.#db.deleteData({ tableName: storage.TABLE_DATASETS });
+  }
+  // --- Row transformers ---
+  transformDatasetRow(row) {
+    return {
+      id: row.id,
+      name: row.name,
+      description: row.description,
+      metadata: row.metadata ? storage.safelyParseJSON(row.metadata) : void 0,
+      inputSchema: row.inputSchema ? storage.safelyParseJSON(row.inputSchema) : void 0,
+      groundTruthSchema: row.groundTruthSchema ? storage.safelyParseJSON(row.groundTruthSchema) : void 0,
+      version: row.version,
+      createdAt: storage.ensureDate(row.createdAt),
+      updatedAt: storage.ensureDate(row.updatedAt)
+    };
+  }
+  transformItemRow(row) {
+    return {
+      id: row.id,
+      datasetId: row.datasetId,
+      datasetVersion: row.datasetVersion,
+      input: storage.safelyParseJSON(row.input),
+      groundTruth: row.groundTruth ? storage.safelyParseJSON(row.groundTruth) : void 0,
+      metadata: row.metadata ? storage.safelyParseJSON(row.metadata) : void 0,
+      createdAt: storage.ensureDate(row.createdAt),
+      updatedAt: storage.ensureDate(row.updatedAt)
+    };
+  }
+  transformItemRowFull(row) {
+    return {
+      id: row.id,
+      datasetId: row.datasetId,
+      datasetVersion: row.datasetVersion,
+      validTo: row.validTo,
+      isDeleted: Boolean(row.isDeleted),
+      input: storage.safelyParseJSON(row.input),
+      groundTruth: row.groundTruth ? storage.safelyParseJSON(row.groundTruth) : void 0,
+      metadata: row.metadata ? storage.safelyParseJSON(row.metadata) : void 0,
+      createdAt: storage.ensureDate(row.createdAt),
+      updatedAt: storage.ensureDate(row.updatedAt)
+    };
+  }
+  transformDatasetVersionRow(row) {
+    return {
+      id: row.id,
+      datasetId: row.datasetId,
+      version: row.version,
+      createdAt: storage.ensureDate(row.createdAt)
+    };
+  }
+  // --- Dataset CRUD ---
+  async createDataset(input) {
+    try {
+      const id = crypto.randomUUID();
+      const now = /* @__PURE__ */ new Date();
+      const nowIso = now.toISOString();
+      await this.#db.insert({
+        tableName: storage.TABLE_DATASETS,
+        record: {
+          id,
+          name: input.name,
+          description: input.description ?? null,
+          metadata: input.metadata,
+          inputSchema: input.inputSchema ?? null,
+          groundTruthSchema: input.groundTruthSchema ?? null,
+          version: 0,
+          createdAt: nowIso,
+          updatedAt: nowIso
+        }
+      });
+      return {
+        id,
+        name: input.name,
+        description: input.description,
+        metadata: input.metadata,
+        inputSchema: input.inputSchema,
+        groundTruthSchema: input.groundTruthSchema,
+        version: 0,
+        createdAt: now,
+        updatedAt: now
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("LIBSQL", "CREATE_DATASET", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  async getDatasetById({ id }) {
+    try {
+      const result = await this.#client.execute({
+        sql: `SELECT ${buildSelectColumns(storage.TABLE_DATASETS)} FROM ${storage.TABLE_DATASETS} WHERE id = ?`,
+        args: [id]
+      });
+      return result.rows?.[0] ? this.transformDatasetRow(result.rows[0]) : null;
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("LIBSQL", "GET_DATASET", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  async _doUpdateDataset(args) {
+    try {
+      const existing = await this.getDatasetById({ id: args.id });
+      if (!existing) {
+        throw new error.MastraError({
+          id: storage.createStorageErrorId("LIBSQL", "UPDATE_DATASET", "NOT_FOUND"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: { datasetId: args.id }
+        });
+      }
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const updates = ["updatedAt = ?"];
+      const values = [now];
+      if (args.name !== void 0) {
+        updates.push("name = ?");
+        values.push(args.name);
+      }
+      if (args.description !== void 0) {
+        updates.push("description = ?");
+        values.push(args.description);
+      }
+      if (args.metadata !== void 0) {
+        updates.push("metadata = ?");
+        values.push(JSON.stringify(args.metadata));
+      }
+      if (args.inputSchema !== void 0) {
+        updates.push("inputSchema = ?");
+        values.push(args.inputSchema === null ? null : JSON.stringify(args.inputSchema));
+      }
+      if (args.groundTruthSchema !== void 0) {
+        updates.push("groundTruthSchema = ?");
+        values.push(args.groundTruthSchema === null ? null : JSON.stringify(args.groundTruthSchema));
+      }
+      values.push(args.id);
+      await this.#client.execute({
+        sql: `UPDATE ${storage.TABLE_DATASETS} SET ${updates.join(", ")} WHERE id = ?`,
+        args: values
+      });
+      return {
+        ...existing,
+        name: args.name ?? existing.name,
+        description: args.description ?? existing.description,
+        metadata: args.metadata ?? existing.metadata,
+        inputSchema: args.inputSchema !== void 0 ? args.inputSchema : existing.inputSchema,
+        groundTruthSchema: args.groundTruthSchema !== void 0 ? args.groundTruthSchema : existing.groundTruthSchema,
+        updatedAt: new Date(now)
+      };
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) throw error$1;
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("LIBSQL", "UPDATE_DATASET", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  async deleteDataset({ id }) {
+    try {
+      try {
+        await this.#client.execute({
+          sql: `DELETE FROM ${storage.TABLE_EXPERIMENT_RESULTS} WHERE experimentId IN (SELECT id FROM ${storage.TABLE_EXPERIMENTS} WHERE datasetId = ?)`,
+          args: [id]
+        });
+      } catch {
+      }
+      try {
+        await this.#client.execute({
+          sql: `UPDATE ${storage.TABLE_EXPERIMENTS} SET datasetId = NULL, datasetVersion = NULL WHERE datasetId = ?`,
+          args: [id]
+        });
+      } catch {
+      }
+      await this.#client.batch(
+        [
+          { sql: `DELETE FROM ${storage.TABLE_DATASET_VERSIONS} WHERE datasetId = ?`, args: [id] },
+          { sql: `DELETE FROM ${storage.TABLE_DATASET_ITEMS} WHERE datasetId = ?`, args: [id] },
+          { sql: `DELETE FROM ${storage.TABLE_DATASETS} WHERE id = ?`, args: [id] }
+        ],
+        "write"
+      );
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("LIBSQL", "DELETE_DATASET", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  async listDatasets(args) {
+    try {
+      const { page, perPage: perPageInput } = args.pagination;
+      const countResult = await this.#client.execute({
+        sql: `SELECT COUNT(*) as count FROM ${storage.TABLE_DATASETS}`,
+        args: []
+      });
+      const total = Number(countResult.rows?.[0]?.count ?? 0);
+      if (total === 0) {
+        return {
+          datasets: [],
+          pagination: { total: 0, page, perPage: perPageInput, hasMore: false }
+        };
+      }
+      const perPage = storage.normalizePerPage(perPageInput, 100);
+      const { offset: start, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
+      const limitValue = perPageInput === false ? total : perPage;
+      const end = perPageInput === false ? total : start + perPage;
+      const result = await this.#client.execute({
+        sql: `SELECT ${buildSelectColumns(storage.TABLE_DATASETS)} FROM ${storage.TABLE_DATASETS} ORDER BY createdAt DESC LIMIT ? OFFSET ?`,
+        args: [limitValue, start]
+      });
+      return {
+        datasets: result.rows?.map((row) => this.transformDatasetRow(row)) ?? [],
+        pagination: {
+          total,
+          page,
+          perPage: perPageForResponse,
+          hasMore: end < total
+        }
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("LIBSQL", "LIST_DATASETS", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  // --- SCD-2 item mutations ---
+  async _doAddItem(args) {
+    try {
+      const id = crypto.randomUUID();
+      const versionId = crypto.randomUUID();
+      const now = /* @__PURE__ */ new Date();
+      const nowIso = now.toISOString();
+      const results = await this.#client.batch(
+        [
+          {
+            sql: `UPDATE ${storage.TABLE_DATASETS} SET version = version + 1 WHERE id = ? RETURNING version`,
+            args: [args.datasetId]
+          },
+          {
+            sql: `INSERT INTO ${storage.TABLE_DATASET_ITEMS} (id, datasetId, datasetVersion, validTo, isDeleted, input, groundTruth, metadata, createdAt, updatedAt) VALUES (?, ?, (SELECT version FROM ${storage.TABLE_DATASETS} WHERE id = ?), NULL, 0, jsonb(?), jsonb(?), jsonb(?), ?, ?)`,
+            args: [
+              id,
+              args.datasetId,
+              args.datasetId,
+              jsonbArg(args.input),
+              jsonbArg(args.groundTruth),
+              jsonbArg(args.metadata),
+              nowIso,
+              nowIso
+            ]
+          },
+          {
+            sql: `INSERT INTO ${storage.TABLE_DATASET_VERSIONS} (id, datasetId, version, createdAt) VALUES (?, ?, (SELECT version FROM ${storage.TABLE_DATASETS} WHERE id = ?), ?)`,
+            args: [versionId, args.datasetId, args.datasetId, nowIso]
+          }
+        ],
+        "write"
+      );
+      const newVersion = Number(results[0].rows[0].version);
+      return {
+        id,
+        datasetId: args.datasetId,
+        datasetVersion: newVersion,
+        input: args.input,
+        groundTruth: args.groundTruth,
+        metadata: args.metadata,
+        createdAt: now,
+        updatedAt: now
+      };
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) throw error$1;
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("LIBSQL", "ADD_ITEM", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  async _doUpdateItem(args) {
+    try {
+      const existing = await this.getItemById({ id: args.id });
+      if (!existing) {
+        throw new error.MastraError({
+          id: storage.createStorageErrorId("LIBSQL", "UPDATE_ITEM", "NOT_FOUND"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: { itemId: args.id }
+        });
+      }
+      if (existing.datasetId !== args.datasetId) {
+        throw new error.MastraError({
+          id: storage.createStorageErrorId("LIBSQL", "UPDATE_ITEM", "DATASET_MISMATCH"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: { itemId: args.id, expectedDatasetId: args.datasetId, actualDatasetId: existing.datasetId }
+        });
+      }
+      const versionId = crypto.randomUUID();
+      const now = /* @__PURE__ */ new Date();
+      const nowIso = now.toISOString();
+      const mergedInput = args.input ?? existing.input;
+      const mergedGroundTruth = args.groundTruth ?? existing.groundTruth;
+      const mergedMetadata = args.metadata ?? existing.metadata;
+      const results = await this.#client.batch(
+        [
+          {
+            sql: `UPDATE ${storage.TABLE_DATASETS} SET version = version + 1 WHERE id = ? RETURNING version`,
+            args: [args.datasetId]
+          },
+          {
+            sql: `UPDATE ${storage.TABLE_DATASET_ITEMS} SET validTo = (SELECT version FROM ${storage.TABLE_DATASETS} WHERE id = ?) WHERE id = ? AND validTo IS NULL AND isDeleted = 0`,
+            args: [args.datasetId, args.id]
+          },
+          {
+            sql: `INSERT INTO ${storage.TABLE_DATASET_ITEMS} (id, datasetId, datasetVersion, validTo, isDeleted, input, groundTruth, metadata, createdAt, updatedAt) VALUES (?, ?, (SELECT version FROM ${storage.TABLE_DATASETS} WHERE id = ?), NULL, 0, jsonb(?), jsonb(?), jsonb(?), ?, ?)`,
+            args: [
+              args.id,
+              args.datasetId,
+              args.datasetId,
+              jsonbArg(mergedInput),
+              jsonbArg(mergedGroundTruth),
+              jsonbArg(mergedMetadata),
+              existing.createdAt.toISOString(),
+              nowIso
+            ]
+          },
+          {
+            sql: `INSERT INTO ${storage.TABLE_DATASET_VERSIONS} (id, datasetId, version, createdAt) VALUES (?, ?, (SELECT version FROM ${storage.TABLE_DATASETS} WHERE id = ?), ?)`,
+            args: [versionId, args.datasetId, args.datasetId, nowIso]
+          }
+        ],
+        "write"
+      );
+      const newVersion = Number(results[0].rows[0].version);
+      return {
+        ...existing,
+        datasetVersion: newVersion,
+        input: mergedInput,
+        groundTruth: mergedGroundTruth,
+        metadata: mergedMetadata,
+        updatedAt: now
+      };
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) throw error$1;
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("LIBSQL", "UPDATE_ITEM", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  async _doDeleteItem({ id, datasetId }) {
+    try {
+      const existing = await this.getItemById({ id });
+      if (!existing) return;
+      if (existing.datasetId !== datasetId) {
+        throw new error.MastraError({
+          id: storage.createStorageErrorId("LIBSQL", "DELETE_ITEM", "DATASET_MISMATCH"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: { itemId: id, expectedDatasetId: datasetId, actualDatasetId: existing.datasetId }
+        });
+      }
+      const versionId = crypto.randomUUID();
+      const nowIso = (/* @__PURE__ */ new Date()).toISOString();
+      await this.#client.batch(
+        [
+          {
+            sql: `UPDATE ${storage.TABLE_DATASETS} SET version = version + 1 WHERE id = ? RETURNING version`,
+            args: [datasetId]
+          },
+          {
+            sql: `UPDATE ${storage.TABLE_DATASET_ITEMS} SET validTo = (SELECT version FROM ${storage.TABLE_DATASETS} WHERE id = ?) WHERE id = ? AND validTo IS NULL AND isDeleted = 0`,
+            args: [datasetId, id]
+          },
+          {
+            sql: `INSERT INTO ${storage.TABLE_DATASET_ITEMS} (id, datasetId, datasetVersion, validTo, isDeleted, input, groundTruth, metadata, createdAt, updatedAt) VALUES (?, ?, (SELECT version FROM ${storage.TABLE_DATASETS} WHERE id = ?), NULL, 1, jsonb(?), jsonb(?), jsonb(?), ?, ?)`,
+            args: [
+              id,
+              datasetId,
+              datasetId,
+              jsonbArg(existing.input),
+              jsonbArg(existing.groundTruth),
+              jsonbArg(existing.metadata),
+              existing.createdAt.toISOString(),
+              nowIso
+            ]
+          },
+          {
+            sql: `INSERT INTO ${storage.TABLE_DATASET_VERSIONS} (id, datasetId, version, createdAt) VALUES (?, ?, (SELECT version FROM ${storage.TABLE_DATASETS} WHERE id = ?), ?)`,
+            args: [versionId, datasetId, datasetId, nowIso]
+          }
+        ],
+        "write"
+      );
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) throw error$1;
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("LIBSQL", "DELETE_ITEM", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  // --- SCD-2 queries ---
+  async getItemById(args) {
+    try {
+      let result;
+      if (args.datasetVersion !== void 0) {
+        result = await this.#client.execute({
+          sql: `SELECT ${buildSelectColumns(storage.TABLE_DATASET_ITEMS)} FROM ${storage.TABLE_DATASET_ITEMS} WHERE id = ? AND datasetVersion = ? AND isDeleted = 0`,
+          args: [args.id, args.datasetVersion]
+        });
+      } else {
+        result = await this.#client.execute({
+          sql: `SELECT ${buildSelectColumns(storage.TABLE_DATASET_ITEMS)} FROM ${storage.TABLE_DATASET_ITEMS} WHERE id = ? AND validTo IS NULL AND isDeleted = 0`,
+          args: [args.id]
+        });
+      }
+      return result.rows?.[0] ? this.transformItemRow(result.rows[0]) : null;
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("LIBSQL", "GET_ITEM", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  async getItemsByVersion({ datasetId, version }) {
+    try {
+      const result = await this.#client.execute({
+        sql: `SELECT ${buildSelectColumns(storage.TABLE_DATASET_ITEMS)} FROM ${storage.TABLE_DATASET_ITEMS} WHERE datasetId = ? AND datasetVersion <= ? AND (validTo IS NULL OR validTo > ?) AND isDeleted = 0 ORDER BY createdAt DESC`,
+        args: [datasetId, version, version]
+      });
+      return result.rows?.map((row) => this.transformItemRow(row)) ?? [];
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("LIBSQL", "GET_ITEMS_BY_VERSION", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  async getItemHistory(itemId) {
+    try {
+      const result = await this.#client.execute({
+        sql: `SELECT ${buildSelectColumns(storage.TABLE_DATASET_ITEMS)} FROM ${storage.TABLE_DATASET_ITEMS} WHERE id = ? ORDER BY datasetVersion DESC`,
+        args: [itemId]
+      });
+      return result.rows?.map((row) => this.transformItemRowFull(row)) ?? [];
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("LIBSQL", "GET_ITEM_HISTORY", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  async listItems(args) {
+    try {
+      const { page, perPage: perPageInput } = args.pagination;
+      if (args.version !== void 0) {
+        const conditions2 = [
+          "datasetId = ?",
+          "datasetVersion <= ?",
+          "(validTo IS NULL OR validTo > ?)",
+          "isDeleted = 0"
+        ];
+        const queryParams2 = [args.datasetId, args.version, args.version];
+        if (args.search) {
+          conditions2.push(`(LOWER(json(input)) LIKE ? OR LOWER(COALESCE(json(groundTruth), '')) LIKE ?)`);
+          const searchPattern = `%${args.search.toLowerCase()}%`;
+          queryParams2.push(searchPattern, searchPattern);
+        }
+        const whereClause2 = `WHERE ${conditions2.join(" AND ")}`;
+        const countResult2 = await this.#client.execute({
+          sql: `SELECT COUNT(*) as count FROM ${storage.TABLE_DATASET_ITEMS} ${whereClause2}`,
+          args: queryParams2
+        });
+        const total2 = Number(countResult2.rows?.[0]?.count ?? 0);
+        if (total2 === 0) {
+          return {
+            items: [],
+            pagination: { total: 0, page, perPage: perPageInput, hasMore: false }
+          };
+        }
+        const perPage2 = storage.normalizePerPage(perPageInput, 100);
+        const { offset: start2, perPage: perPageForResponse2 } = storage.calculatePagination(page, perPageInput, perPage2);
+        const limitValue2 = perPageInput === false ? total2 : perPage2;
+        const end2 = perPageInput === false ? total2 : start2 + perPage2;
+        const result2 = await this.#client.execute({
+          sql: `SELECT ${buildSelectColumns(storage.TABLE_DATASET_ITEMS)} FROM ${storage.TABLE_DATASET_ITEMS} ${whereClause2} ORDER BY createdAt DESC LIMIT ? OFFSET ?`,
+          args: [...queryParams2, limitValue2, start2]
+        });
+        return {
+          items: result2.rows?.map((row) => this.transformItemRow(row)) ?? [],
+          pagination: {
+            total: total2,
+            page,
+            perPage: perPageForResponse2,
+            hasMore: end2 < total2
+          }
+        };
+      }
+      const conditions = ["datasetId = ?", "validTo IS NULL", "isDeleted = 0"];
+      const queryParams = [args.datasetId];
+      if (args.search) {
+        conditions.push(`(LOWER(json(input)) LIKE ? OR LOWER(COALESCE(json(groundTruth), '')) LIKE ?)`);
+        const searchPattern = `%${args.search.toLowerCase()}%`;
+        queryParams.push(searchPattern, searchPattern);
+      }
+      const whereClause = `WHERE ${conditions.join(" AND ")}`;
+      const countResult = await this.#client.execute({
+        sql: `SELECT COUNT(*) as count FROM ${storage.TABLE_DATASET_ITEMS} ${whereClause}`,
+        args: queryParams
+      });
+      const total = Number(countResult.rows?.[0]?.count ?? 0);
+      if (total === 0) {
+        return {
+          items: [],
+          pagination: { total: 0, page, perPage: perPageInput, hasMore: false }
+        };
+      }
+      const perPage = storage.normalizePerPage(perPageInput, 100);
+      const { offset: start, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
+      const limitValue = perPageInput === false ? total : perPage;
+      const end = perPageInput === false ? total : start + perPage;
+      const result = await this.#client.execute({
+        sql: `SELECT ${buildSelectColumns(storage.TABLE_DATASET_ITEMS)} FROM ${storage.TABLE_DATASET_ITEMS} ${whereClause} ORDER BY createdAt DESC LIMIT ? OFFSET ?`,
+        args: [...queryParams, limitValue, start]
+      });
+      return {
+        items: result.rows?.map((row) => this.transformItemRow(row)) ?? [],
+        pagination: {
+          total,
+          page,
+          perPage: perPageForResponse,
+          hasMore: end < total
+        }
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("LIBSQL", "LIST_ITEMS", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  // --- Dataset version methods ---
+  async createDatasetVersion(datasetId, version) {
+    try {
+      const id = crypto.randomUUID();
+      const now = /* @__PURE__ */ new Date();
+      const nowIso = now.toISOString();
+      await this.#db.insert({
+        tableName: storage.TABLE_DATASET_VERSIONS,
+        record: {
+          id,
+          datasetId,
+          version,
+          createdAt: nowIso
+        }
+      });
+      return {
+        id,
+        datasetId,
+        version,
+        createdAt: now
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("LIBSQL", "CREATE_DATASET_VERSION", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  async listDatasetVersions(input) {
+    try {
+      const { page, perPage: perPageInput } = input.pagination;
+      const countResult = await this.#client.execute({
+        sql: `SELECT COUNT(*) as count FROM ${storage.TABLE_DATASET_VERSIONS} WHERE datasetId = ?`,
+        args: [input.datasetId]
+      });
+      const total = Number(countResult.rows?.[0]?.count ?? 0);
+      if (total === 0) {
+        return {
+          versions: [],
+          pagination: { total: 0, page, perPage: perPageInput, hasMore: false }
+        };
+      }
+      const perPage = storage.normalizePerPage(perPageInput, 100);
+      const { offset: start, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
+      const limitValue = perPageInput === false ? total : perPage;
+      const end = perPageInput === false ? total : start + perPage;
+      const result = await this.#client.execute({
+        sql: `SELECT ${buildSelectColumns(storage.TABLE_DATASET_VERSIONS)} FROM ${storage.TABLE_DATASET_VERSIONS} WHERE datasetId = ? ORDER BY version DESC LIMIT ? OFFSET ?`,
+        args: [input.datasetId, limitValue, start]
+      });
+      return {
+        versions: result.rows?.map((row) => this.transformDatasetVersionRow(row)) ?? [],
+        pagination: {
+          total,
+          page,
+          perPage: perPageForResponse,
+          hasMore: end < total
+        }
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("LIBSQL", "LIST_DATASET_VERSIONS", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  // --- Bulk operations (SCD-2 internally) ---
+  async _doBatchInsertItems(input) {
+    try {
+      const dataset = await this.getDatasetById({ id: input.datasetId });
+      if (!dataset) {
+        throw new error.MastraError({
+          id: storage.createStorageErrorId("LIBSQL", "BULK_ADD_ITEMS", "DATASET_NOT_FOUND"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: { datasetId: input.datasetId }
+        });
+      }
+      const now = /* @__PURE__ */ new Date();
+      const nowIso = now.toISOString();
+      const versionId = crypto.randomUUID();
+      const statements = [
+        {
+          sql: `UPDATE ${storage.TABLE_DATASETS} SET version = version + 1 WHERE id = ? RETURNING version`,
+          args: [input.datasetId]
+        }
+      ];
+      const items = [];
+      for (const itemInput of input.items) {
+        const id = crypto.randomUUID();
+        items.push({ id, input: itemInput });
+        statements.push({
+          sql: `INSERT INTO ${storage.TABLE_DATASET_ITEMS} (id, datasetId, datasetVersion, validTo, isDeleted, input, groundTruth, metadata, createdAt, updatedAt) VALUES (?, ?, (SELECT version FROM ${storage.TABLE_DATASETS} WHERE id = ?), NULL, 0, jsonb(?), jsonb(?), jsonb(?), ?, ?)`,
+          args: [
+            id,
+            input.datasetId,
+            input.datasetId,
+            jsonbArg(itemInput.input),
+            jsonbArg(itemInput.groundTruth),
+            jsonbArg(itemInput.metadata),
+            nowIso,
+            nowIso
+          ]
+        });
+      }
+      statements.push({
+        sql: `INSERT INTO ${storage.TABLE_DATASET_VERSIONS} (id, datasetId, version, createdAt) VALUES (?, ?, (SELECT version FROM ${storage.TABLE_DATASETS} WHERE id = ?), ?)`,
+        args: [versionId, input.datasetId, input.datasetId, nowIso]
+      });
+      const results = await this.#client.batch(statements, "write");
+      const newVersion = Number(results[0].rows[0].version);
+      return items.map(({ id, input: itemInput }) => ({
+        id,
+        datasetId: input.datasetId,
+        datasetVersion: newVersion,
+        input: itemInput.input,
+        groundTruth: itemInput.groundTruth,
+        metadata: itemInput.metadata,
+        createdAt: now,
+        updatedAt: now
+      }));
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) throw error$1;
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("LIBSQL", "BULK_ADD_ITEMS", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  async _doBatchDeleteItems(input) {
+    try {
+      const dataset = await this.getDatasetById({ id: input.datasetId });
+      if (!dataset) {
+        throw new error.MastraError({
+          id: storage.createStorageErrorId("LIBSQL", "BULK_DELETE_ITEMS", "DATASET_NOT_FOUND"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: { datasetId: input.datasetId }
+        });
+      }
+      const currentItems = [];
+      for (const itemId of input.itemIds) {
+        const item = await this.getItemById({ id: itemId });
+        if (item && item.datasetId === input.datasetId) {
+          currentItems.push(item);
+        }
+      }
+      if (currentItems.length === 0) return;
+      const nowIso = (/* @__PURE__ */ new Date()).toISOString();
+      const versionId = crypto.randomUUID();
+      const statements = [
+        {
+          sql: `UPDATE ${storage.TABLE_DATASETS} SET version = version + 1 WHERE id = ? RETURNING version`,
+          args: [input.datasetId]
+        }
+      ];
+      for (const item of currentItems) {
+        statements.push({
+          sql: `UPDATE ${storage.TABLE_DATASET_ITEMS} SET validTo = (SELECT version FROM ${storage.TABLE_DATASETS} WHERE id = ?) WHERE id = ? AND validTo IS NULL AND isDeleted = 0`,
+          args: [input.datasetId, item.id]
+        });
+        statements.push({
+          sql: `INSERT INTO ${storage.TABLE_DATASET_ITEMS} (id, datasetId, datasetVersion, validTo, isDeleted, input, groundTruth, metadata, createdAt, updatedAt) VALUES (?, ?, (SELECT version FROM ${storage.TABLE_DATASETS} WHERE id = ?), NULL, 1, jsonb(?), jsonb(?), jsonb(?), ?, ?)`,
+          args: [
+            item.id,
+            input.datasetId,
+            input.datasetId,
+            jsonbArg(item.input),
+            jsonbArg(item.groundTruth),
+            jsonbArg(item.metadata),
+            item.createdAt.toISOString(),
+            nowIso
+          ]
+        });
+      }
+      statements.push({
+        sql: `INSERT INTO ${storage.TABLE_DATASET_VERSIONS} (id, datasetId, version, createdAt) VALUES (?, ?, (SELECT version FROM ${storage.TABLE_DATASETS} WHERE id = ?), ?)`,
+        args: [versionId, input.datasetId, input.datasetId, nowIso]
+      });
+      await this.#client.batch(statements, "write");
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) throw error$1;
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("LIBSQL", "BULK_DELETE_ITEMS", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+};
+var ExperimentsLibSQL = class extends storage.ExperimentsStorage {
+  #db;
+  #client;
+  constructor(config) {
+    super();
+    const client = resolveClient(config);
+    this.#client = client;
+    this.#db = new LibSQLDB({ client, maxRetries: config.maxRetries, initialBackoffMs: config.initialBackoffMs });
+  }
+  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.#client.execute({
+      sql: `CREATE INDEX IF NOT EXISTS idx_experiments_datasetid ON "${storage.TABLE_EXPERIMENTS}" ("datasetId")`,
+      args: []
+    });
+    await this.#client.execute({
+      sql: `CREATE INDEX IF NOT EXISTS idx_experiment_results_experimentid ON "${storage.TABLE_EXPERIMENT_RESULTS}" ("experimentId")`,
+      args: []
+    });
+    await this.#client.execute({
+      sql: `CREATE UNIQUE INDEX IF NOT EXISTS idx_experiment_results_exp_item ON "${storage.TABLE_EXPERIMENT_RESULTS}" ("experimentId", "itemId")`,
+      args: []
+    });
+  }
+  async dangerouslyClearAll() {
+    await this.#db.deleteData({ tableName: storage.TABLE_EXPERIMENT_RESULTS });
+    await this.#db.deleteData({ tableName: storage.TABLE_EXPERIMENTS });
+  }
+  // Helper to transform row to Experiment
+  transformExperimentRow(row) {
+    return {
+      id: row.id,
+      datasetId: row.datasetId ?? null,
+      datasetVersion: row.datasetVersion != null ? row.datasetVersion : null,
+      targetType: row.targetType,
+      targetId: row.targetId,
+      name: row.name ?? void 0,
+      description: row.description ?? void 0,
+      metadata: row.metadata ? storage.safelyParseJSON(row.metadata) : void 0,
+      status: row.status,
+      totalItems: row.totalItems,
+      succeededCount: row.succeededCount,
+      failedCount: row.failedCount,
+      skippedCount: row.skippedCount ?? 0,
+      startedAt: row.startedAt ? storage.ensureDate(row.startedAt) : null,
+      completedAt: row.completedAt ? storage.ensureDate(row.completedAt) : null,
+      createdAt: storage.ensureDate(row.createdAt),
+      updatedAt: storage.ensureDate(row.updatedAt)
+    };
+  }
+  // Helper to transform row to ExperimentResult
+  transformExperimentResultRow(row) {
+    return {
+      id: row.id,
+      experimentId: row.experimentId,
+      itemId: row.itemId,
+      itemDatasetVersion: row.itemDatasetVersion != null ? row.itemDatasetVersion : null,
+      input: storage.safelyParseJSON(row.input),
+      output: row.output ? storage.safelyParseJSON(row.output) : null,
+      groundTruth: row.groundTruth ? storage.safelyParseJSON(row.groundTruth) : null,
+      error: row.error ? storage.safelyParseJSON(row.error) : null,
+      startedAt: storage.ensureDate(row.startedAt),
+      completedAt: storage.ensureDate(row.completedAt),
+      retryCount: row.retryCount,
+      traceId: row.traceId ?? null,
+      createdAt: storage.ensureDate(row.createdAt)
+    };
+  }
+  // Experiment lifecycle
+  async createExperiment(input) {
+    try {
+      const id = input.id ?? crypto.randomUUID();
+      const now = /* @__PURE__ */ new Date();
+      const nowIso = now.toISOString();
+      await this.#db.insert({
+        tableName: storage.TABLE_EXPERIMENTS,
+        record: {
+          id,
+          datasetId: input.datasetId ?? null,
+          datasetVersion: input.datasetVersion ?? null,
+          targetType: input.targetType,
+          targetId: input.targetId,
+          name: input.name ?? null,
+          description: input.description ?? null,
+          metadata: input.metadata ?? null,
+          status: "pending",
+          totalItems: input.totalItems,
+          succeededCount: 0,
+          failedCount: 0,
+          skippedCount: 0,
+          startedAt: null,
+          completedAt: null,
+          createdAt: nowIso,
+          updatedAt: nowIso
+        }
+      });
+      return {
+        id,
+        datasetId: input.datasetId,
+        datasetVersion: input.datasetVersion,
+        targetType: input.targetType,
+        targetId: input.targetId,
+        name: input.name,
+        description: input.description,
+        metadata: input.metadata,
+        status: "pending",
+        totalItems: input.totalItems,
+        succeededCount: 0,
+        failedCount: 0,
+        skippedCount: 0,
+        startedAt: null,
+        completedAt: null,
+        createdAt: now,
+        updatedAt: now
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("LIBSQL", "CREATE_EXPERIMENT", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  async updateExperiment(input) {
+    try {
+      const existing = await this.getExperimentById({ id: input.id });
+      if (!existing) {
+        throw new error.MastraError({
+          id: storage.createStorageErrorId("LIBSQL", "UPDATE_EXPERIMENT", "NOT_FOUND"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: { experimentId: input.id }
+        });
+      }
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const updates = ["updatedAt = ?"];
+      const values = [now];
+      if (input.status !== void 0) {
+        updates.push("status = ?");
+        values.push(input.status);
+      }
+      if (input.succeededCount !== void 0) {
+        updates.push("succeededCount = ?");
+        values.push(input.succeededCount);
+      }
+      if (input.failedCount !== void 0) {
+        updates.push("failedCount = ?");
+        values.push(input.failedCount);
+      }
+      if (input.startedAt !== void 0) {
+        updates.push("startedAt = ?");
+        values.push(input.startedAt?.toISOString() ?? null);
+      }
+      if (input.completedAt !== void 0) {
+        updates.push("completedAt = ?");
+        values.push(input.completedAt?.toISOString() ?? null);
+      }
+      if (input.skippedCount !== void 0) {
+        updates.push("skippedCount = ?");
+        values.push(input.skippedCount);
+      }
+      if (input.name !== void 0) {
+        updates.push("name = ?");
+        values.push(input.name);
+      }
+      if (input.description !== void 0) {
+        updates.push("description = ?");
+        values.push(input.description);
+      }
+      if (input.metadata !== void 0) {
+        updates.push("metadata = ?");
+        values.push(JSON.stringify(input.metadata));
+      }
+      values.push(input.id);
+      await this.#client.execute({
+        sql: `UPDATE ${storage.TABLE_EXPERIMENTS} SET ${updates.join(", ")} WHERE id = ?`,
+        args: values
+      });
+      const updated = await this.getExperimentById({ id: input.id });
+      return updated;
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) throw error$1;
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("LIBSQL", "UPDATE_EXPERIMENT", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  async getExperimentById(args) {
+    try {
+      const result = await this.#client.execute({
+        sql: `SELECT ${buildSelectColumns(storage.TABLE_EXPERIMENTS)} FROM ${storage.TABLE_EXPERIMENTS} WHERE id = ?`,
+        args: [args.id]
+      });
+      return result.rows?.[0] ? this.transformExperimentRow(result.rows[0]) : null;
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("LIBSQL", "GET_EXPERIMENT", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  async listExperiments(args) {
+    try {
+      const { page, perPage: perPageInput } = args.pagination;
+      const conditions = [];
+      const queryParams = [];
+      if (args.datasetId) {
+        conditions.push("datasetId = ?");
+        queryParams.push(args.datasetId);
+      }
+      const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+      const countResult = await this.#client.execute({
+        sql: `SELECT COUNT(*) as count FROM ${storage.TABLE_EXPERIMENTS} ${whereClause}`,
+        args: queryParams
+      });
+      const total = Number(countResult.rows?.[0]?.count ?? 0);
+      if (total === 0) {
+        return {
+          experiments: [],
+          pagination: { total: 0, page, perPage: perPageInput, hasMore: false }
+        };
+      }
+      const perPage = storage.normalizePerPage(perPageInput, 100);
+      const { offset: start, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
+      const limitValue = perPageInput === false ? total : perPage;
+      const end = perPageInput === false ? total : start + perPage;
+      const result = await this.#client.execute({
+        sql: `SELECT ${buildSelectColumns(storage.TABLE_EXPERIMENTS)} FROM ${storage.TABLE_EXPERIMENTS} ${whereClause} ORDER BY createdAt DESC LIMIT ? OFFSET ?`,
+        args: [...queryParams, limitValue, start]
+      });
+      return {
+        experiments: result.rows?.map((row) => this.transformExperimentRow(row)) ?? [],
+        pagination: {
+          total,
+          page,
+          perPage: perPageForResponse,
+          hasMore: end < total
+        }
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("LIBSQL", "LIST_EXPERIMENTS", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  async deleteExperiment(args) {
+    try {
+      await this.#client.execute({
+        sql: `DELETE FROM ${storage.TABLE_EXPERIMENT_RESULTS} WHERE experimentId = ?`,
+        args: [args.id]
+      });
+      await this.#client.execute({
+        sql: `DELETE FROM ${storage.TABLE_EXPERIMENTS} WHERE id = ?`,
+        args: [args.id]
+      });
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("LIBSQL", "DELETE_EXPERIMENT", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  // Results (per-item)
+  async addExperimentResult(input) {
+    try {
+      const id = input.id ?? crypto.randomUUID();
+      const now = /* @__PURE__ */ new Date();
+      const nowIso = now.toISOString();
+      await this.#db.insert({
+        tableName: storage.TABLE_EXPERIMENT_RESULTS,
+        record: {
+          id,
+          experimentId: input.experimentId,
+          itemId: input.itemId,
+          itemDatasetVersion: input.itemDatasetVersion ?? null,
+          input: input.input,
+          output: input.output,
+          groundTruth: input.groundTruth,
+          error: input.error ?? null,
+          startedAt: input.startedAt.toISOString(),
+          completedAt: input.completedAt.toISOString(),
+          retryCount: input.retryCount,
+          traceId: input.traceId ?? null,
+          createdAt: nowIso
+        }
+      });
+      return {
+        id,
+        experimentId: input.experimentId,
+        itemId: input.itemId,
+        itemDatasetVersion: input.itemDatasetVersion,
+        input: input.input,
+        output: input.output,
+        groundTruth: input.groundTruth,
+        error: input.error,
+        startedAt: input.startedAt,
+        completedAt: input.completedAt,
+        retryCount: input.retryCount,
+        traceId: input.traceId ?? null,
+        createdAt: now
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("LIBSQL", "ADD_EXPERIMENT_RESULT", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  async getExperimentResultById(args) {
+    try {
+      const result = await this.#client.execute({
+        sql: `SELECT ${buildSelectColumns(storage.TABLE_EXPERIMENT_RESULTS)} FROM ${storage.TABLE_EXPERIMENT_RESULTS} WHERE id = ?`,
+        args: [args.id]
+      });
+      return result.rows?.[0] ? this.transformExperimentResultRow(result.rows[0]) : null;
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("LIBSQL", "GET_EXPERIMENT_RESULT", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  async listExperimentResults(args) {
+    try {
+      const { page, perPage: perPageInput } = args.pagination;
+      const conditions = ["experimentId = ?"];
+      const queryParams = [args.experimentId];
+      const whereClause = `WHERE ${conditions.join(" AND ")}`;
+      const countResult = await this.#client.execute({
+        sql: `SELECT COUNT(*) as count FROM ${storage.TABLE_EXPERIMENT_RESULTS} ${whereClause}`,
+        args: queryParams
+      });
+      const total = Number(countResult.rows?.[0]?.count ?? 0);
+      if (total === 0) {
+        return {
+          results: [],
+          pagination: { total: 0, page, perPage: perPageInput, hasMore: false }
+        };
+      }
+      const perPage = storage.normalizePerPage(perPageInput, 100);
+      const { offset: start, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
+      const limitValue = perPageInput === false ? total : perPage;
+      const end = perPageInput === false ? total : start + perPage;
+      const result = await this.#client.execute({
+        sql: `SELECT ${buildSelectColumns(storage.TABLE_EXPERIMENT_RESULTS)} FROM ${storage.TABLE_EXPERIMENT_RESULTS} ${whereClause} ORDER BY startedAt ASC LIMIT ? OFFSET ?`,
+        args: [...queryParams, limitValue, start]
+      });
+      return {
+        results: result.rows?.map((row) => this.transformExperimentResultRow(row)) ?? [],
+        pagination: {
+          total,
+          page,
+          perPage: perPageForResponse,
+          hasMore: end < total
+        }
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("LIBSQL", "LIST_EXPERIMENT_RESULTS", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  async deleteExperimentResults(args) {
+    try {
+      await this.#client.execute({
+        sql: `DELETE FROM ${storage.TABLE_EXPERIMENT_RESULTS} WHERE experimentId = ?`,
+        args: [args.experimentId]
+      });
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("LIBSQL", "DELETE_EXPERIMENT_RESULTS", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+};
+var SNAPSHOT_FIELDS2 = ["name", "description", "servers"];
+var MCPClientsLibSQL = class extends storage.MCPClientsStorage {
+  #db;
+  #client;
+  constructor(config) {
+    super();
+    const client = resolveClient(config);
+    this.#client = client;
+    this.#db = new LibSQLDB({ client, maxRetries: config.maxRetries, initialBackoffMs: config.initialBackoffMs });
+  }
+  async init() {
+    await this.#db.createTable({ tableName: storage.TABLE_MCP_CLIENTS, schema: storage.MCP_CLIENTS_SCHEMA });
+    await this.#db.createTable({
+      tableName: storage.TABLE_MCP_CLIENT_VERSIONS,
+      schema: storage.MCP_CLIENT_VERSIONS_SCHEMA
+    });
+    await this.#client.execute(
+      `CREATE UNIQUE INDEX IF NOT EXISTS idx_mcp_client_versions_client_version ON "${storage.TABLE_MCP_CLIENT_VERSIONS}" ("mcpClientId", "versionNumber")`
+    );
+  }
+  async dangerouslyClearAll() {
+    await this.#db.deleteData({ tableName: storage.TABLE_MCP_CLIENTS });
+    await this.#db.deleteData({ tableName: storage.TABLE_MCP_CLIENT_VERSIONS });
+  }
+  // ==========================================================================
+  // MCP Client CRUD
+  // ==========================================================================
+  async getById(id) {
+    try {
+      const result = await this.#client.execute({
+        sql: `SELECT ${buildSelectColumns(storage.TABLE_MCP_CLIENTS)} FROM "${storage.TABLE_MCP_CLIENTS}" WHERE id = ?`,
+        args: [id]
+      });
+      const row = result.rows?.[0];
+      return row ? this.#parseMCPClientRow(row) : null;
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) throw error$1;
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("LIBSQL", "GET_MCP_CLIENT", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  async create(input) {
+    const { mcpClient } = input;
+    try {
+      const now = /* @__PURE__ */ new Date();
+      await this.#db.insert({
+        tableName: storage.TABLE_MCP_CLIENTS,
+        record: {
+          id: mcpClient.id,
+          status: "draft",
+          activeVersionId: null,
+          authorId: mcpClient.authorId ?? null,
+          metadata: mcpClient.metadata ?? null,
+          createdAt: now.toISOString(),
+          updatedAt: now.toISOString()
+        }
+      });
+      const { id: _id, authorId: _authorId, metadata: _metadata, ...snapshotConfig } = mcpClient;
+      const versionId = crypto.randomUUID();
+      try {
+        await this.createVersion({
+          id: versionId,
+          mcpClientId: mcpClient.id,
+          versionNumber: 1,
+          ...snapshotConfig,
+          changedFields: Object.keys(snapshotConfig),
+          changeMessage: "Initial version"
+        });
+      } catch (versionError) {
+        await this.#db.delete({ tableName: storage.TABLE_MCP_CLIENTS, keys: { id: mcpClient.id } });
+        throw versionError;
+      }
+      return {
+        id: mcpClient.id,
+        status: "draft",
+        activeVersionId: void 0,
+        authorId: mcpClient.authorId,
+        metadata: mcpClient.metadata,
+        createdAt: now,
+        updatedAt: now
+      };
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) throw error$1;
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("LIBSQL", "CREATE_MCP_CLIENT", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  async update(input) {
+    const { id, ...updates } = input;
+    try {
+      const existing = await this.getById(id);
+      if (!existing) {
+        throw new Error(`MCP client with id ${id} not found`);
+      }
+      const { authorId, activeVersionId, metadata, status, ...configFields } = updates;
+      const configFieldNames = SNAPSHOT_FIELDS2;
+      const hasConfigUpdate = configFieldNames.some((field) => field in configFields);
+      const updateData = {
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      if (authorId !== void 0) updateData.authorId = authorId;
+      if (activeVersionId !== void 0) {
+        updateData.activeVersionId = activeVersionId;
+        if (status === void 0) {
+          updateData.status = "published";
+        }
+      }
+      if (status !== void 0) updateData.status = status;
+      if (metadata !== void 0) {
+        updateData.metadata = { ...existing.metadata, ...metadata };
+      }
+      await this.#db.update({
+        tableName: storage.TABLE_MCP_CLIENTS,
+        keys: { id },
+        data: updateData
+      });
+      if (hasConfigUpdate) {
+        const latestVersion = await this.getLatestVersion(id);
+        if (!latestVersion) {
+          throw new Error(`No versions found for MCP client ${id}`);
+        }
+        const {
+          id: _versionId,
+          mcpClientId: _mcpClientId,
+          versionNumber: _versionNumber,
+          changedFields: _changedFields,
+          changeMessage: _changeMessage,
+          createdAt: _createdAt,
+          ...latestConfig
+        } = latestVersion;
+        const newConfig = { ...latestConfig, ...configFields };
+        const changedFields = configFieldNames.filter(
+          (field) => field in configFields && JSON.stringify(configFields[field]) !== JSON.stringify(latestConfig[field])
+        );
+        if (changedFields.length > 0) {
+          const newVersionId = crypto.randomUUID();
+          await this.createVersion({
+            id: newVersionId,
+            mcpClientId: id,
+            versionNumber: latestVersion.versionNumber + 1,
+            ...newConfig,
+            changedFields,
+            changeMessage: `Updated ${changedFields.join(", ")}`
+          });
+        }
+      }
+      const updated = await this.getById(id);
+      if (!updated) {
+        throw new error.MastraError({
+          id: storage.createStorageErrorId("LIBSQL", "UPDATE_MCP_CLIENT", "NOT_FOUND_AFTER_UPDATE"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.SYSTEM,
+          text: `MCP client ${id} not found after update`,
+          details: { id }
+        });
+      }
+      return updated;
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) throw error$1;
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("LIBSQL", "UPDATE_MCP_CLIENT", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  async delete(id) {
+    try {
+      await this.deleteVersionsByParentId(id);
+      await this.#client.execute({
+        sql: `DELETE FROM "${storage.TABLE_MCP_CLIENTS}" WHERE "id" = ?`,
+        args: [id]
+      });
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) throw error$1;
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("LIBSQL", "DELETE_MCP_CLIENT", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  async list(args) {
+    try {
+      const { page = 0, perPage: perPageInput, orderBy, authorId, metadata } = args || {};
+      const { field, direction } = this.parseOrderBy(orderBy);
+      const conditions = [];
+      const queryParams = [];
+      if (authorId !== void 0) {
+        conditions.push("authorId = ?");
+        queryParams.push(authorId);
+      }
+      if (metadata && Object.keys(metadata).length > 0) {
+        for (const [key, value] of Object.entries(metadata)) {
+          if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(key)) {
+            throw new error.MastraError({
+              id: storage.createStorageErrorId("LIBSQL", "LIST_MCP_CLIENTS", "INVALID_METADATA_KEY"),
+              domain: error.ErrorDomain.STORAGE,
+              category: error.ErrorCategory.USER,
+              text: `Invalid metadata key: ${key}. Keys must be alphanumeric with underscores.`,
+              details: { key }
+            });
+          }
+          conditions.push(`json_extract(metadata, '$.${key}') = ?`);
+          queryParams.push(typeof value === "string" ? value : JSON.stringify(value));
+        }
+      }
+      const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+      const countResult = await this.#client.execute({
+        sql: `SELECT COUNT(*) as count FROM "${storage.TABLE_MCP_CLIENTS}" ${whereClause}`,
+        args: queryParams
+      });
+      const total = Number(countResult.rows?.[0]?.count ?? 0);
+      if (total === 0) {
+        return {
+          mcpClients: [],
           total: 0,
           page,
-          perPage: perPageForResponse,
+          perPage: perPageInput ?? 100,
           hasMore: false
         };
       }
+      const perPage = storage.normalizePerPage(perPageInput, 100);
+      const { offset: start, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
       const limitValue = perPageInput === false ? total : perPage;
-      const rows = await this.#db.selectMany({
-        tableName: storage.TABLE_AGENTS,
-        orderBy: `"${field}" ${direction}`,
-        limit: limitValue,
-        offset
+      const end = perPageInput === false ? total : start + perPage;
+      const result = await this.#client.execute({
+        sql: `SELECT ${buildSelectColumns(storage.TABLE_MCP_CLIENTS)} FROM "${storage.TABLE_MCP_CLIENTS}" ${whereClause} ORDER BY ${field} ${direction} LIMIT ? OFFSET ?`,
+        args: [...queryParams, limitValue, start]
       });
-      const agents = rows.map((row) => this.parseRow(row));
+      const mcpClients = result.rows?.map((row) => this.#parseMCPClientRow(row)) ?? [];
       return {
-        agents,
+        mcpClients,
         total,
         page,
         perPage: perPageForResponse,
-        hasMore: perPageInput === false ? false : offset + perPage < total
+        hasMore: end < total
       };
     } catch (error$1) {
       if (error$1 instanceof error.MastraError) throw error$1;
       throw new error.MastraError(
         {
-          id: storage.createStorageErrorId("LIBSQL", "LIST_AGENTS", "FAILED"),
+          id: storage.createStorageErrorId("LIBSQL", "LIST_MCP_CLIENTS", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY
         },
@@ -2520,33 +4360,23 @@ var AgentsLibSQL = class extends storage.AgentsStorage {
     }
   }
   // ==========================================================================
-  // Agent Version Methods
+  // MCP Client Version Methods
   // ==========================================================================
   async createVersion(input) {
     try {
       const now = /* @__PURE__ */ new Date();
       await this.#db.insert({
-        tableName: storage.TABLE_AGENT_VERSIONS,
+        tableName: storage.TABLE_MCP_CLIENT_VERSIONS,
         record: {
           id: input.id,
-          agentId: input.agentId,
+          mcpClientId: input.mcpClientId,
           versionNumber: input.versionNumber,
-          name: input.name ?? null,
+          name: input.name,
           description: input.description ?? null,
-          instructions: this.serializeInstructions(input.instructions),
-          model: input.model,
-          tools: input.tools ?? null,
-          defaultOptions: input.defaultOptions ?? null,
-          workflows: input.workflows ?? null,
-          agents: input.agents ?? null,
-          integrationTools: input.integrationTools ?? null,
-          inputProcessors: input.inputProcessors ?? null,
-          outputProcessors: input.outputProcessors ?? null,
-          memory: input.memory ?? null,
-          scorers: input.scorers ?? null,
+          servers: input.servers ?? null,
           changedFields: input.changedFields ?? null,
           changeMessage: input.changeMessage ?? null,
-          createdAt: now
+          createdAt: now.toISOString()
         }
       });
       return {
@@ -2557,10 +4387,9 @@ var AgentsLibSQL = class extends storage.AgentsStorage {
       if (error$1 instanceof error.MastraError) throw error$1;
       throw new error.MastraError(
         {
-          id: storage.createStorageErrorId("LIBSQL", "CREATE_VERSION", "FAILED"),
+          id: storage.createStorageErrorId("LIBSQL", "CREATE_MCP_CLIENT_VERSION", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: { versionId: input.id, agentId: input.agentId }
+          category: error.ErrorCategory.THIRD_PARTY
         },
         error$1
       );
@@ -2568,142 +4397,105 @@ var AgentsLibSQL = class extends storage.AgentsStorage {
   }
   async getVersion(id) {
     try {
-      const result = await this.#db.select({
-        tableName: storage.TABLE_AGENT_VERSIONS,
-        keys: { id }
+      const result = await this.#client.execute({
+        sql: `SELECT ${buildSelectColumns(storage.TABLE_MCP_CLIENT_VERSIONS)} FROM "${storage.TABLE_MCP_CLIENT_VERSIONS}" WHERE id = ?`,
+        args: [id]
       });
-      if (!result) {
-        return null;
-      }
-      return this.parseVersionRow(result);
+      const row = result.rows?.[0];
+      return row ? this.#parseVersionRow(row) : null;
     } catch (error$1) {
       if (error$1 instanceof error.MastraError) throw error$1;
       throw new error.MastraError(
         {
-          id: storage.createStorageErrorId("LIBSQL", "GET_VERSION", "FAILED"),
+          id: storage.createStorageErrorId("LIBSQL", "GET_MCP_CLIENT_VERSION", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: { versionId: id }
+          category: error.ErrorCategory.THIRD_PARTY
         },
         error$1
       );
     }
   }
-  async getVersionByNumber(agentId, versionNumber) {
+  async getVersionByNumber(mcpClientId, versionNumber) {
     try {
-      const rows = await this.#db.selectMany({
-        tableName: storage.TABLE_AGENT_VERSIONS,
-        whereClause: {
-          sql: "WHERE agentId = ? AND versionNumber = ?",
-          args: [agentId, versionNumber]
-        },
-        limit: 1
+      const result = await this.#client.execute({
+        sql: `SELECT ${buildSelectColumns(storage.TABLE_MCP_CLIENT_VERSIONS)} FROM "${storage.TABLE_MCP_CLIENT_VERSIONS}" WHERE mcpClientId = ? AND versionNumber = ?`,
+        args: [mcpClientId, versionNumber]
       });
-      if (!rows || rows.length === 0) {
-        return null;
-      }
-      return this.parseVersionRow(rows[0]);
+      const row = result.rows?.[0];
+      return row ? this.#parseVersionRow(row) : null;
     } catch (error$1) {
       if (error$1 instanceof error.MastraError) throw error$1;
       throw new error.MastraError(
         {
-          id: storage.createStorageErrorId("LIBSQL", "GET_VERSION_BY_NUMBER", "FAILED"),
+          id: storage.createStorageErrorId("LIBSQL", "GET_MCP_CLIENT_VERSION_BY_NUMBER", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: { agentId, versionNumber }
+          category: error.ErrorCategory.THIRD_PARTY
         },
         error$1
       );
     }
   }
-  async getLatestVersion(agentId) {
+  async getLatestVersion(mcpClientId) {
     try {
-      const rows = await this.#db.selectMany({
-        tableName: storage.TABLE_AGENT_VERSIONS,
-        whereClause: {
-          sql: "WHERE agentId = ?",
-          args: [agentId]
-        },
-        orderBy: "versionNumber DESC",
-        limit: 1
+      const result = await this.#client.execute({
+        sql: `SELECT ${buildSelectColumns(storage.TABLE_MCP_CLIENT_VERSIONS)} FROM "${storage.TABLE_MCP_CLIENT_VERSIONS}" WHERE mcpClientId = ? ORDER BY versionNumber DESC LIMIT 1`,
+        args: [mcpClientId]
       });
-      if (!rows || rows.length === 0) {
-        return null;
-      }
-      return this.parseVersionRow(rows[0]);
+      const row = result.rows?.[0];
+      return row ? this.#parseVersionRow(row) : null;
     } catch (error$1) {
       if (error$1 instanceof error.MastraError) throw error$1;
       throw new error.MastraError(
         {
-          id: storage.createStorageErrorId("LIBSQL", "GET_LATEST_VERSION", "FAILED"),
+          id: storage.createStorageErrorId("LIBSQL", "GET_LATEST_MCP_CLIENT_VERSION", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: { agentId }
+          category: error.ErrorCategory.THIRD_PARTY
         },
         error$1
       );
     }
   }
   async listVersions(input) {
-    const { agentId, page = 0, perPage: perPageInput, orderBy } = input;
-    if (page < 0) {
-      throw new error.MastraError(
-        {
-          id: storage.createStorageErrorId("LIBSQL", "LIST_VERSIONS", "INVALID_PAGE"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.USER,
-          details: { page }
-        },
-        new Error("page must be >= 0")
-      );
-    }
-    const perPage = storage.normalizePerPage(perPageInput, 20);
-    const { offset, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
     try {
+      const { mcpClientId, page = 0, perPage: perPageInput, orderBy } = input;
       const { field, direction } = this.parseVersionOrderBy(orderBy);
-      const total = await this.#db.selectTotalCount({
-        tableName: storage.TABLE_AGENT_VERSIONS,
-        whereClause: {
-          sql: "WHERE agentId = ?",
-          args: [agentId]
-        }
+      const countResult = await this.#client.execute({
+        sql: `SELECT COUNT(*) as count FROM "${storage.TABLE_MCP_CLIENT_VERSIONS}" WHERE mcpClientId = ?`,
+        args: [mcpClientId]
       });
+      const total = Number(countResult.rows?.[0]?.count ?? 0);
       if (total === 0) {
         return {
           versions: [],
           total: 0,
           page,
-          perPage: perPageForResponse,
+          perPage: perPageInput ?? 20,
           hasMore: false
         };
       }
+      const perPage = storage.normalizePerPage(perPageInput, 20);
+      const { offset: start, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
       const limitValue = perPageInput === false ? total : perPage;
-      const rows = await this.#db.selectMany({
-        tableName: storage.TABLE_AGENT_VERSIONS,
-        whereClause: {
-          sql: "WHERE agentId = ?",
-          args: [agentId]
-        },
-        orderBy: `"${field}" ${direction}`,
-        limit: limitValue,
-        offset
+      const end = perPageInput === false ? total : start + perPage;
+      const result = await this.#client.execute({
+        sql: `SELECT ${buildSelectColumns(storage.TABLE_MCP_CLIENT_VERSIONS)} FROM "${storage.TABLE_MCP_CLIENT_VERSIONS}" WHERE mcpClientId = ? ORDER BY ${field} ${direction} LIMIT ? OFFSET ?`,
+        args: [mcpClientId, limitValue, start]
       });
-      const versions = rows.map((row) => this.parseVersionRow(row));
+      const versions = result.rows?.map((row) => this.#parseVersionRow(row)) ?? [];
       return {
         versions,
         total,
         page,
         perPage: perPageForResponse,
-        hasMore: perPageInput === false ? false : offset + perPage < total
+        hasMore: end < total
       };
     } catch (error$1) {
       if (error$1 instanceof error.MastraError) throw error$1;
       throw new error.MastraError(
         {
-          id: storage.createStorageErrorId("LIBSQL", "LIST_VERSIONS", "FAILED"),
+          id: storage.createStorageErrorId("LIBSQL", "LIST_MCP_CLIENT_VERSIONS", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: { agentId }
+          category: error.ErrorCategory.THIRD_PARTY
         },
         error$1
       );
@@ -2711,18 +4503,17 @@ var AgentsLibSQL = class extends storage.AgentsStorage {
   }
   async deleteVersion(id) {
     try {
-      await this.#db.delete({
-        tableName: storage.TABLE_AGENT_VERSIONS,
-        keys: { id }
+      await this.#client.execute({
+        sql: `DELETE FROM "${storage.TABLE_MCP_CLIENT_VERSIONS}" WHERE "id" = ?`,
+        args: [id]
       });
     } catch (error$1) {
       if (error$1 instanceof error.MastraError) throw error$1;
       throw new error.MastraError(
         {
-          id: storage.createStorageErrorId("LIBSQL", "DELETE_VERSION", "FAILED"),
+          id: storage.createStorageErrorId("LIBSQL", "DELETE_MCP_CLIENT_VERSION", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: { versionId: id }
+          category: error.ErrorCategory.THIRD_PARTY
         },
         error$1
       );
@@ -2730,90 +4521,87 @@ var AgentsLibSQL = class extends storage.AgentsStorage {
   }
   async deleteVersionsByParentId(entityId) {
     try {
-      const versions = await this.#db.selectMany({
-        tableName: storage.TABLE_AGENT_VERSIONS,
-        whereClause: {
-          sql: "WHERE agentId = ?",
-          args: [entityId]
-        }
+      await this.#client.execute({
+        sql: `DELETE FROM "${storage.TABLE_MCP_CLIENT_VERSIONS}" WHERE "mcpClientId" = ?`,
+        args: [entityId]
       });
-      for (const version of versions) {
-        await this.#db.delete({
-          tableName: storage.TABLE_AGENT_VERSIONS,
-          keys: { id: version.id }
-        });
-      }
     } catch (error$1) {
       if (error$1 instanceof error.MastraError) throw error$1;
       throw new error.MastraError(
         {
-          id: storage.createStorageErrorId("LIBSQL", "DELETE_VERSIONS_BY_AGENT_ID", "FAILED"),
+          id: storage.createStorageErrorId("LIBSQL", "DELETE_MCP_CLIENT_VERSIONS_BY_CLIENT", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: { agentId: entityId }
+          category: error.ErrorCategory.THIRD_PARTY
         },
         error$1
       );
     }
   }
-  async countVersions(agentId) {
+  async countVersions(mcpClientId) {
     try {
-      const count = await this.#db.selectTotalCount({
-        tableName: storage.TABLE_AGENT_VERSIONS,
-        whereClause: {
-          sql: "WHERE agentId = ?",
-          args: [agentId]
-        }
+      const result = await this.#client.execute({
+        sql: `SELECT COUNT(*) as count FROM "${storage.TABLE_MCP_CLIENT_VERSIONS}" WHERE mcpClientId = ?`,
+        args: [mcpClientId]
       });
-      return count;
+      return Number(result.rows?.[0]?.count ?? 0);
     } catch (error$1) {
       if (error$1 instanceof error.MastraError) throw error$1;
       throw new error.MastraError(
         {
-          id: storage.createStorageErrorId("LIBSQL", "COUNT_VERSIONS", "FAILED"),
+          id: storage.createStorageErrorId("LIBSQL", "COUNT_MCP_CLIENT_VERSIONS", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: { agentId }
+          category: error.ErrorCategory.THIRD_PARTY
         },
         error$1
       );
     }
   }
   // ==========================================================================
-  // Private Helper Methods
+  // Private Helpers
   // ==========================================================================
-  serializeInstructions(instructions) {
-    return Array.isArray(instructions) ? JSON.stringify(instructions) : instructions;
-  }
-  deserializeInstructions(raw) {
-    if (!raw) return raw;
-    try {
-      const parsed = JSON.parse(raw);
-      if (Array.isArray(parsed)) return parsed;
-    } catch {
-    }
-    return raw;
+  #parseMCPClientRow(row) {
+    const safeParseJSON = (val) => {
+      if (val === null || val === void 0) return void 0;
+      if (typeof val === "string") {
+        try {
+          return JSON.parse(val);
+        } catch {
+          return val;
+        }
+      }
+      return val;
+    };
+    return {
+      id: row.id,
+      status: row.status ?? "draft",
+      activeVersionId: row.activeVersionId ?? void 0,
+      authorId: row.authorId ?? void 0,
+      metadata: safeParseJSON(row.metadata),
+      createdAt: new Date(row.createdAt),
+      updatedAt: new Date(row.updatedAt)
+    };
   }
-  parseVersionRow(row) {
+  #parseVersionRow(row) {
+    const safeParseJSON = (val) => {
+      if (val === null || val === void 0) return void 0;
+      if (typeof val === "string") {
+        try {
+          return JSON.parse(val);
+        } catch {
+          return val;
+        }
+      }
+      return val;
+    };
     return {
       id: row.id,
-      agentId: row.agentId,
-      versionNumber: row.versionNumber,
+      mcpClientId: row.mcpClientId,
+      versionNumber: Number(row.versionNumber),
       name: row.name,
-      description: row.description,
-      instructions: this.deserializeInstructions(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"),
-      integrationTools: this.parseJson(row.integrationTools, "integrationTools"),
-      inputProcessors: this.parseJson(row.inputProcessors, "inputProcessors"),
-      outputProcessors: this.parseJson(row.outputProcessors, "outputProcessors"),
-      memory: this.parseJson(row.memory, "memory"),
-      scorers: this.parseJson(row.scorers, "scorers"),
-      changedFields: this.parseJson(row.changedFields, "changedFields"),
-      changeMessage: row.changeMessage,
+      description: row.description ?? void 0,
+      servers: safeParseJSON(row.servers),
+      changedFields: safeParseJSON(row.changedFields),
+      changeMessage: row.changeMessage ?? void 0,
       createdAt: new Date(row.createdAt)
     };
   }
@@ -5144,7 +6932,7 @@ var ObservabilityLibSQL = class extends storage.ObservabilityStorage {
     }
   }
 };
-var SNAPSHOT_FIELDS2 = ["name", "description", "content", "rules"];
+var SNAPSHOT_FIELDS3 = ["name", "description", "content", "rules"];
 var PromptBlocksLibSQL = class extends storage.PromptBlocksStorage {
   #db;
   #client;
@@ -5243,7 +7031,7 @@ var PromptBlocksLibSQL = class extends storage.PromptBlocksStorage {
         throw new Error(`Prompt block with id ${id} not found`);
       }
       const { authorId, activeVersionId, metadata, status, ...configFields } = updates;
-      const configFieldNames = SNAPSHOT_FIELDS2;
+      const configFieldNames = SNAPSHOT_FIELDS3;
       const hasConfigUpdate = configFieldNames.some((field) => field in configFields);
       const updateData = {
         updatedAt: (/* @__PURE__ */ new Date()).toISOString()
@@ -5651,7 +7439,7 @@ var PromptBlocksLibSQL = class extends storage.PromptBlocksStorage {
     };
   }
 };
-var SNAPSHOT_FIELDS3 = [
+var SNAPSHOT_FIELDS4 = [
   "name",
   "description",
   "type",
@@ -5762,7 +7550,7 @@ var ScorerDefinitionsLibSQL = class extends storage.ScorerDefinitionsStorage {
         throw new Error(`Scorer definition with id ${id} not found`);
       }
       const { authorId, activeVersionId, metadata, status, ...configFields } = updates;
-      const configFieldNames = SNAPSHOT_FIELDS3;
+      const configFieldNames = SNAPSHOT_FIELDS4;
       const hasConfigUpdate = configFieldNames.some((field) => field in configFields);
       const updateData = {
         updatedAt: (/* @__PURE__ */ new Date()).toISOString()
@@ -6830,16 +8618,22 @@ var LibSQLStore = class extends storage.MastraCompositeStore {
     const memory = new MemoryLibSQL(domainConfig);
     const observability = new ObservabilityLibSQL(domainConfig);
     const agents = new AgentsLibSQL(domainConfig);
+    const datasets = new DatasetsLibSQL(domainConfig);
+    const experiments = new ExperimentsLibSQL(domainConfig);
     const promptBlocks = new PromptBlocksLibSQL(domainConfig);
     const scorerDefinitions = new ScorerDefinitionsLibSQL(domainConfig);
+    const mcpClients = new MCPClientsLibSQL(domainConfig);
     this.stores = {
       scores,
       workflows,
       memory,
       observability,
       agents,
+      datasets,
+      experiments,
       promptBlocks,
-      scorerDefinitions
+      scorerDefinitions,
+      mcpClients
     };
   }
 };
@@ -6944,10 +8738,13 @@ Example Complex Query:
 }`;
 
 exports.AgentsLibSQL = AgentsLibSQL;
+exports.DatasetsLibSQL = DatasetsLibSQL;
 exports.DefaultStorage = LibSQLStore;
+exports.ExperimentsLibSQL = ExperimentsLibSQL;
 exports.LIBSQL_PROMPT = LIBSQL_PROMPT;
 exports.LibSQLStore = LibSQLStore;
 exports.LibSQLVector = LibSQLVector;
+exports.MCPClientsLibSQL = MCPClientsLibSQL;
 exports.MemoryLibSQL = MemoryLibSQL;
 exports.ObservabilityLibSQL = ObservabilityLibSQL;
 exports.PromptBlocksLibSQL = PromptBlocksLibSQL;