@mastra/core 1.3.0 → 1.4.0

package/dist/{chunk-TERSHTY5.cjs → chunk-BP7VYTOP.cjs}

@@ -1,10 +1,12 @@
 'use strict';
 
-var chunkUE2G2LRP_cjs = require('./chunk-UE2G2LRP.cjs');
-var chunkC3XU7ZDC_cjs = require('./chunk-C3XU7ZDC.cjs');
-var chunkOOCEAC6U_cjs = require('./chunk-OOCEAC6U.cjs');
+var chunkCZ4NQANZ_cjs = require('./chunk-CZ4NQANZ.cjs');
+var chunkSU5APAM6_cjs = require('./chunk-SU5APAM6.cjs');
+var chunk65PHUUMF_cjs = require('./chunk-65PHUUMF.cjs');
 var chunk4U7ZLI36_cjs = require('./chunk-4U7ZLI36.cjs');
 var chunkRO47SMI7_cjs = require('./chunk-RO47SMI7.cjs');
+var jsonToZod = require('@mastra/schema-compat/json-to-zod');
+var zod = require('zod');
 
 // src/storage/base.ts
 function normalizePerPage(perPageInput, defaultValue) {
@@ -61,8 +63,11 @@ var MastraCompositeStore = class extends chunkRO47SMI7_cjs.MastraBase {
         scores: domainOverrides.scores ?? defaultStores?.scores,
         observability: domainOverrides.observability ?? defaultStores?.observability,
         agents: domainOverrides.agents ?? defaultStores?.agents,
+        datasets: domainOverrides.datasets ?? defaultStores?.datasets,
+        experiments: domainOverrides.experiments ?? defaultStores?.experiments,
         promptBlocks: domainOverrides.promptBlocks ?? defaultStores?.promptBlocks,
-        scorerDefinitions: domainOverrides.scorerDefinitions ?? defaultStores?.scorerDefinitions
+        scorerDefinitions: domainOverrides.scorerDefinitions ?? defaultStores?.scorerDefinitions,
+        mcpClients: domainOverrides.mcpClients ?? defaultStores?.mcpClients
       };
     }
   }
@@ -107,12 +112,21 @@ var MastraCompositeStore = class extends chunkRO47SMI7_cjs.MastraBase {
     if (this.stores?.agents) {
       initTasks.push(this.stores.agents.init());
     }
+    if (this.stores?.datasets) {
+      initTasks.push(this.stores.datasets.init());
+    }
+    if (this.stores?.experiments) {
+      initTasks.push(this.stores.experiments.init());
+    }
     if (this.stores?.promptBlocks) {
       initTasks.push(this.stores.promptBlocks.init());
     }
     if (this.stores?.scorerDefinitions) {
       initTasks.push(this.stores.scorerDefinitions.init());
     }
+    if (this.stores?.mcpClients) {
+      initTasks.push(this.stores.mcpClients.init());
+    }
     this.hasInitialized = Promise.all(initTasks).then(() => true);
     await this.hasInitialized;
   }
@@ -313,7 +327,9 @@ var InMemoryAgentsStorage = class extends AgentsStorage {
       "inputProcessors",
       "outputProcessors",
       "memory",
-      "scorers"
+      "scorers",
+      "mcpClients",
+      "requestContextSchema"
     ];
     const hasConfigUpdate = configFieldNames.some((field) => field in configFields);
     const updatedAgent = {
@@ -392,7 +408,7 @@ var InMemoryAgentsStorage = class extends AgentsStorage {
     if (metadata && Object.keys(metadata).length > 0) {
       agents = agents.filter((agent) => {
         if (!agent.metadata) return false;
-        return Object.entries(metadata).every(([key, value]) => chunkOOCEAC6U_cjs.deepEqual(agent.metadata[key], value));
+        return Object.entries(metadata).every(([key, value]) => chunk65PHUUMF_cjs.deepEqual(agent.metadata[key], value));
       });
     }
     const sortedAgents = this.sortAgents(agents, field, direction);
@@ -559,8 +575,17 @@ var InMemoryDB = class {
   promptBlockVersions = /* @__PURE__ */ new Map();
   scorerDefinitions = /* @__PURE__ */ new Map();
   scorerDefinitionVersions = /* @__PURE__ */ new Map();
+  mcpClients = /* @__PURE__ */ new Map();
+  mcpClientVersions = /* @__PURE__ */ new Map();
   /** Observational memory records, keyed by resourceId, each holding array of records (generations) */
   observationalMemory = /* @__PURE__ */ new Map();
+  // Dataset domain maps
+  datasets = /* @__PURE__ */ new Map();
+  datasetItems = /* @__PURE__ */ new Map();
+  datasetVersions = /* @__PURE__ */ new Map();
+  // Experiment domain maps
+  experiments = /* @__PURE__ */ new Map();
+  experimentResults = /* @__PURE__ */ new Map();
   /**
    * Clears all data from all collections.
    * Useful for testing.
@@ -578,7 +603,318 @@ var InMemoryDB = class {
     this.promptBlockVersions.clear();
     this.scorerDefinitions.clear();
     this.scorerDefinitionVersions.clear();
+    this.mcpClients.clear();
+    this.mcpClientVersions.clear();
     this.observationalMemory.clear();
+    this.datasets.clear();
+    this.datasetItems.clear();
+    this.datasetVersions.clear();
+    this.experiments.clear();
+    this.experimentResults.clear();
+  }
+};
+
+// src/storage/domains/mcp-clients/base.ts
+var MCPClientsStorage = class extends VersionedStorageDomain {
+  listKey = "mcpClients";
+  versionMetadataFields = [
+    "id",
+    "mcpClientId",
+    "versionNumber",
+    "changedFields",
+    "changeMessage",
+    "createdAt"
+  ];
+  constructor() {
+    super({
+      component: "STORAGE",
+      name: "MCP_CLIENTS"
+    });
+  }
+};
+
+// src/storage/domains/mcp-clients/inmemory.ts
+var InMemoryMCPClientsStorage = class extends MCPClientsStorage {
+  db;
+  constructor({ db }) {
+    super();
+    this.db = db;
+  }
+  async dangerouslyClearAll() {
+    this.db.mcpClients.clear();
+    this.db.mcpClientVersions.clear();
+  }
+  // ==========================================================================
+  // MCP Client CRUD Methods
+  // ==========================================================================
+  async getById(id) {
+    this.logger.debug(`InMemoryMCPClientsStorage: getById called for ${id}`);
+    const config = this.db.mcpClients.get(id);
+    return config ? this.deepCopyConfig(config) : null;
+  }
+  async create(input) {
+    const { mcpClient } = input;
+    this.logger.debug(`InMemoryMCPClientsStorage: create called for ${mcpClient.id}`);
+    if (this.db.mcpClients.has(mcpClient.id)) {
+      throw new Error(`MCP client with id ${mcpClient.id} already exists`);
+    }
+    const now = /* @__PURE__ */ new Date();
+    const newConfig = {
+      id: mcpClient.id,
+      status: "draft",
+      activeVersionId: void 0,
+      authorId: mcpClient.authorId,
+      metadata: mcpClient.metadata,
+      createdAt: now,
+      updatedAt: now
+    };
+    this.db.mcpClients.set(mcpClient.id, newConfig);
+    const { id: _id, authorId: _authorId, metadata: _metadata, ...snapshotConfig } = mcpClient;
+    const versionId = crypto.randomUUID();
+    await this.createVersion({
+      id: versionId,
+      mcpClientId: mcpClient.id,
+      versionNumber: 1,
+      ...snapshotConfig,
+      changedFields: Object.keys(snapshotConfig),
+      changeMessage: "Initial version"
+    });
+    return this.deepCopyConfig(newConfig);
+  }
+  async update(input) {
+    const { id, ...updates } = input;
+    this.logger.debug(`InMemoryMCPClientsStorage: update called for ${id}`);
+    const existingConfig = this.db.mcpClients.get(id);
+    if (!existingConfig) {
+      throw new Error(`MCP client with id ${id} not found`);
+    }
+    const { authorId, activeVersionId, metadata, status, ...configFields } = updates;
+    const configFieldNames = ["name", "description", "servers"];
+    const hasConfigUpdate = configFieldNames.some((field) => field in configFields);
+    const updatedConfig = {
+      ...existingConfig,
+      ...authorId !== void 0 && { authorId },
+      ...activeVersionId !== void 0 && { activeVersionId },
+      ...status !== void 0 && { status },
+      ...metadata !== void 0 && {
+        metadata: { ...existingConfig.metadata, ...metadata }
+      },
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+    if (activeVersionId !== void 0 && status === void 0) {
+      updatedConfig.status = "published";
+    }
+    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();
+        const newVersionNumber = latestVersion.versionNumber + 1;
+        await this.createVersion({
+          id: newVersionId,
+          mcpClientId: id,
+          versionNumber: newVersionNumber,
+          ...newConfig,
+          changedFields,
+          changeMessage: `Updated ${changedFields.join(", ")}`
+        });
+      }
+    }
+    this.db.mcpClients.set(id, updatedConfig);
+    return this.deepCopyConfig(updatedConfig);
+  }
+  async delete(id) {
+    this.logger.debug(`InMemoryMCPClientsStorage: delete called for ${id}`);
+    this.db.mcpClients.delete(id);
+    await this.deleteVersionsByParentId(id);
+  }
+  async list(args) {
+    const { page = 0, perPage: perPageInput, orderBy, authorId, metadata } = args || {};
+    const { field, direction } = this.parseOrderBy(orderBy);
+    this.logger.debug(`InMemoryMCPClientsStorage: list called`);
+    const perPage = normalizePerPage(perPageInput, 100);
+    if (page < 0) {
+      throw new Error("page must be >= 0");
+    }
+    const maxOffset = Number.MAX_SAFE_INTEGER / 2;
+    if (page * perPage > maxOffset) {
+      throw new Error("page value too large");
+    }
+    let configs = Array.from(this.db.mcpClients.values());
+    if (authorId !== void 0) {
+      configs = configs.filter((config) => config.authorId === authorId);
+    }
+    if (metadata && Object.keys(metadata).length > 0) {
+      configs = configs.filter((config) => {
+        if (!config.metadata) return false;
+        return Object.entries(metadata).every(([key, value]) => chunk65PHUUMF_cjs.deepEqual(config.metadata[key], value));
+      });
+    }
+    const sortedConfigs = this.sortConfigs(configs, field, direction);
+    const clonedConfigs = sortedConfigs.map((config) => this.deepCopyConfig(config));
+    const { offset, perPage: perPageForResponse } = calculatePagination(page, perPageInput, perPage);
+    return {
+      mcpClients: clonedConfigs.slice(offset, offset + perPage),
+      total: clonedConfigs.length,
+      page,
+      perPage: perPageForResponse,
+      hasMore: offset + perPage < clonedConfigs.length
+    };
+  }
+  // ==========================================================================
+  // MCP Client Version Methods
+  // ==========================================================================
+  async createVersion(input) {
+    this.logger.debug(`InMemoryMCPClientsStorage: createVersion called for MCP client ${input.mcpClientId}`);
+    if (this.db.mcpClientVersions.has(input.id)) {
+      throw new Error(`Version with id ${input.id} already exists`);
+    }
+    for (const version2 of this.db.mcpClientVersions.values()) {
+      if (version2.mcpClientId === input.mcpClientId && version2.versionNumber === input.versionNumber) {
+        throw new Error(`Version number ${input.versionNumber} already exists for MCP client ${input.mcpClientId}`);
+      }
+    }
+    const version = {
+      ...input,
+      createdAt: /* @__PURE__ */ new Date()
+    };
+    this.db.mcpClientVersions.set(input.id, this.deepCopyVersion(version));
+    return this.deepCopyVersion(version);
+  }
+  async getVersion(id) {
+    this.logger.debug(`InMemoryMCPClientsStorage: getVersion called for ${id}`);
+    const version = this.db.mcpClientVersions.get(id);
+    return version ? this.deepCopyVersion(version) : null;
+  }
+  async getVersionByNumber(mcpClientId, versionNumber) {
+    this.logger.debug(
+      `InMemoryMCPClientsStorage: getVersionByNumber called for MCP client ${mcpClientId}, v${versionNumber}`
+    );
+    for (const version of this.db.mcpClientVersions.values()) {
+      if (version.mcpClientId === mcpClientId && version.versionNumber === versionNumber) {
+        return this.deepCopyVersion(version);
+      }
+    }
+    return null;
+  }
+  async getLatestVersion(mcpClientId) {
+    this.logger.debug(`InMemoryMCPClientsStorage: getLatestVersion called for MCP client ${mcpClientId}`);
+    let latest = null;
+    for (const version of this.db.mcpClientVersions.values()) {
+      if (version.mcpClientId === mcpClientId) {
+        if (!latest || version.versionNumber > latest.versionNumber) {
+          latest = version;
+        }
+      }
+    }
+    return latest ? this.deepCopyVersion(latest) : null;
+  }
+  async listVersions(input) {
+    const { mcpClientId, page = 0, perPage: perPageInput, orderBy } = input;
+    const { field, direction } = this.parseVersionOrderBy(orderBy);
+    this.logger.debug(`InMemoryMCPClientsStorage: listVersions called for MCP client ${mcpClientId}`);
+    const perPage = normalizePerPage(perPageInput, 20);
+    if (page < 0) {
+      throw new Error("page must be >= 0");
+    }
+    const maxOffset = Number.MAX_SAFE_INTEGER / 2;
+    if (page * perPage > maxOffset) {
+      throw new Error("page value too large");
+    }
+    let versions = Array.from(this.db.mcpClientVersions.values()).filter((v) => v.mcpClientId === mcpClientId);
+    versions = this.sortVersions(versions, field, direction);
+    const clonedVersions = versions.map((v) => this.deepCopyVersion(v));
+    const total = clonedVersions.length;
+    const { offset, perPage: perPageForResponse } = calculatePagination(page, perPageInput, perPage);
+    const paginatedVersions = clonedVersions.slice(offset, offset + perPage);
+    return {
+      versions: paginatedVersions,
+      total,
+      page,
+      perPage: perPageForResponse,
+      hasMore: offset + perPage < total
+    };
+  }
+  async deleteVersion(id) {
+    this.logger.debug(`InMemoryMCPClientsStorage: deleteVersion called for ${id}`);
+    this.db.mcpClientVersions.delete(id);
+  }
+  async deleteVersionsByParentId(entityId) {
+    this.logger.debug(`InMemoryMCPClientsStorage: deleteVersionsByParentId called for MCP client ${entityId}`);
+    const idsToDelete = [];
+    for (const [id, version] of this.db.mcpClientVersions.entries()) {
+      if (version.mcpClientId === entityId) {
+        idsToDelete.push(id);
+      }
+    }
+    for (const id of idsToDelete) {
+      this.db.mcpClientVersions.delete(id);
+    }
+  }
+  async countVersions(mcpClientId) {
+    this.logger.debug(`InMemoryMCPClientsStorage: countVersions called for MCP client ${mcpClientId}`);
+    let count = 0;
+    for (const version of this.db.mcpClientVersions.values()) {
+      if (version.mcpClientId === mcpClientId) {
+        count++;
+      }
+    }
+    return count;
+  }
+  // ==========================================================================
+  // Private Helper Methods
+  // ==========================================================================
+  deepCopyConfig(config) {
+    return {
+      ...config,
+      metadata: config.metadata ? { ...config.metadata } : config.metadata
+    };
+  }
+  deepCopyVersion(version) {
+    return {
+      ...version,
+      servers: version.servers ? JSON.parse(JSON.stringify(version.servers)) : version.servers,
+      changedFields: version.changedFields ? [...version.changedFields] : version.changedFields
+    };
+  }
+  sortConfigs(configs, field, direction) {
+    return configs.sort((a, b) => {
+      const aValue = a[field].getTime();
+      const bValue = b[field].getTime();
+      return direction === "ASC" ? aValue - bValue : bValue - aValue;
+    });
+  }
+  sortVersions(versions, field, direction) {
+    return versions.sort((a, b) => {
+      let aVal;
+      let bVal;
+      if (field === "createdAt") {
+        aVal = a.createdAt.getTime();
+        bVal = b.createdAt.getTime();
+      } else {
+        aVal = a.versionNumber;
+        bVal = b.versionNumber;
+      }
+      return direction === "ASC" ? aVal - bVal : bVal - aVal;
+    });
   }
 };
 
@@ -597,7 +933,7 @@ function safelyParseJSON(input) {
 }
 function transformRow(row, tableName, options = {}) {
   const { preferredTimestampFields = {}, convertTimestamps = false, nullValuePattern, fieldMappings = {} } = options;
-  const tableSchema = chunkC3XU7ZDC_cjs.TABLE_SCHEMAS[tableName];
+  const tableSchema = chunkSU5APAM6_cjs.TABLE_SCHEMAS[tableName];
   const result = {};
   for (const [key, columnSchema] of Object.entries(tableSchema)) {
     const sourceKey = fieldMappings[key] ?? key;
@@ -628,7 +964,7 @@ function transformRow(row, tableName, options = {}) {
   return result;
 }
 function transformScoreRow(row, options = {}) {
-  return transformRow(row, chunkC3XU7ZDC_cjs.TABLE_SCORERS, options);
+  return transformRow(row, chunkSU5APAM6_cjs.TABLE_SCORERS, options);
 }
 function toUpperSnakeCase(str) {
   return str.replace(/([a-z])([A-Z])/g, "$1_$2").replace(/([A-Z])([A-Z][a-z])/g, "$1_$2").toUpperCase().replace(/[^A-Z0-9]+/g, "_").replace(/^_+|_+$/g, "");
@@ -1250,7 +1586,7 @@ var InMemoryMemory = class extends MemoryStorage {
     });
     const total = messages.length;
     const paginatedMessages = messages.slice(offset, offset + perPage);
-    const list = new chunkUE2G2LRP_cjs.MessageList().add(
+    const list = new chunkCZ4NQANZ_cjs.MessageList().add(
       paginatedMessages.map((m) => this.parseStoredMessage(m)),
       "memory"
     );
@@ -1284,7 +1620,7 @@ var InMemoryMemory = class extends MemoryStorage {
   async listMessagesById({ messageIds }) {
     this.logger.debug(`InMemoryMemory: listMessagesById called`);
     const rawMessages = messageIds.map((id) => this.db.messages.get(id)).filter((message) => !!message);
-    const list = new chunkUE2G2LRP_cjs.MessageList().add(
+    const list = new chunkCZ4NQANZ_cjs.MessageList().add(
       rawMessages.map((m) => this.parseStoredMessage(m)),
       "memory"
     );
@@ -1316,7 +1652,7 @@ var InMemoryMemory = class extends MemoryStorage {
       };
       this.db.messages.set(key, storageMessage);
     }
-    const list = new chunkUE2G2LRP_cjs.MessageList().add(messages, "memory");
+    const list = new chunkCZ4NQANZ_cjs.MessageList().add(messages, "memory");
     return { messages: list.get.all.db() };
   }
   async updateMessages(args) {
@@ -2157,7 +2493,7 @@ var ObservabilityInMemory = class extends ObservabilityStorage {
     };
   }
   async listTraces(args) {
-    const { filters, pagination, orderBy } = chunkC3XU7ZDC_cjs.listTracesArgsSchema.parse(args);
+    const { filters, pagination, orderBy } = chunkSU5APAM6_cjs.listTracesArgsSchema.parse(args);
     const matchingRootSpans = [];
     for (const [, traceEntry] of this.db.traces) {
       if (!traceEntry.rootSpan) continue;
@@ -2186,7 +2522,7 @@ var ObservabilityInMemory = class extends ObservabilityStorage {
     const end = start + perPage;
     const paged = matchingRootSpans.slice(start, end);
     return {
-      spans: chunkC3XU7ZDC_cjs.toTraceSpans(paged),
+      spans: chunkSU5APAM6_cjs.toTraceSpans(paged),
       pagination: { total, page, perPage, hasMore: end < total }
     };
   }
@@ -2488,7 +2824,7 @@ var InMemoryPromptBlocksStorage = class extends PromptBlocksStorage {
     if (metadata && Object.keys(metadata).length > 0) {
       blocks = blocks.filter((block) => {
         if (!block.metadata) return false;
-        return Object.entries(metadata).every(([key, value]) => chunkOOCEAC6U_cjs.deepEqual(block.metadata[key], value));
+        return Object.entries(metadata).every(([key, value]) => chunk65PHUUMF_cjs.deepEqual(block.metadata[key], value));
       });
     }
     const sortedBlocks = this.sortBlocks(blocks, field, direction);
@@ -2799,7 +3135,7 @@ var InMemoryScorerDefinitionsStorage = class extends ScorerDefinitionsStorage {
     if (metadata && Object.keys(metadata).length > 0) {
       scorers = scorers.filter((scorer) => {
         if (!scorer.metadata) return false;
-        return Object.entries(metadata).every(([key, value]) => chunkOOCEAC6U_cjs.deepEqual(scorer.metadata[key], value));
+        return Object.entries(metadata).every(([key, value]) => chunk65PHUUMF_cjs.deepEqual(scorer.metadata[key], value));
       });
     }
     const sortedScorers = this.sortScorers(scorers, field, direction);
@@ -3393,7 +3729,8 @@ var InMemoryStore = class extends MastraCompositeStore {
       observability: new ObservabilityInMemory({ db: this.#db }),
       agents: new InMemoryAgentsStorage({ db: this.#db }),
       promptBlocks: new InMemoryPromptBlocksStorage({ db: this.#db }),
-      scorerDefinitions: new InMemoryScorerDefinitionsStorage({ db: this.#db })
+      scorerDefinitions: new InMemoryScorerDefinitionsStorage({ db: this.#db }),
+      mcpClients: new InMemoryMCPClientsStorage({ db: this.#db })
     };
   }
   /**
@@ -3532,7 +3869,14 @@ var StoreOperationsInMemory = class extends StoreOperations {
       mastra_prompt_blocks: /* @__PURE__ */ new Map(),
       mastra_prompt_block_versions: /* @__PURE__ */ new Map(),
       mastra_scorer_definitions: /* @__PURE__ */ new Map(),
-      mastra_scorer_definition_versions: /* @__PURE__ */ new Map()
+      mastra_scorer_definition_versions: /* @__PURE__ */ new Map(),
+      mastra_mcp_clients: /* @__PURE__ */ new Map(),
+      mastra_mcp_client_versions: /* @__PURE__ */ new Map(),
+      mastra_datasets: /* @__PURE__ */ new Map(),
+      mastra_dataset_items: /* @__PURE__ */ new Map(),
+      mastra_dataset_versions: /* @__PURE__ */ new Map(),
+      mastra_experiments: /* @__PURE__ */ new Map(),
+      mastra_experiment_results: /* @__PURE__ */ new Map()
     };
   }
   getDatabase() {
@@ -3541,7 +3885,7 @@ var StoreOperationsInMemory = class extends StoreOperations {
   async insert({ tableName, record }) {
     const table = this.data[tableName];
     let key = record.id;
-    if ([chunkC3XU7ZDC_cjs.TABLE_WORKFLOW_SNAPSHOT].includes(tableName) && !record.id && record.run_id) {
+    if ([chunkSU5APAM6_cjs.TABLE_WORKFLOW_SNAPSHOT].includes(tableName) && !record.id && record.run_id) {
       key = record.workflow_name ? `${record.workflow_name}-${record.run_id}` : record.run_id;
       record.id = key;
     } else if (!record.id) {
@@ -3554,7 +3898,7 @@ var StoreOperationsInMemory = class extends StoreOperations {
     const table = this.data[tableName];
     for (const record of records) {
       let key = record.id;
-      if ([chunkC3XU7ZDC_cjs.TABLE_WORKFLOW_SNAPSHOT].includes(tableName) && !record.id && record.run_id) {
+      if ([chunkSU5APAM6_cjs.TABLE_WORKFLOW_SNAPSHOT].includes(tableName) && !record.id && record.run_id) {
         key = record.run_id;
         record.id = key;
       } else if (!record.id) {
@@ -3597,13 +3941,759 @@ var StoreOperationsInMemory = class extends StoreOperations {
   }
 };
 
+// src/datasets/validation/errors.ts
+var SchemaValidationError = class extends Error {
+  constructor(field, errors) {
+    const summary = errors.slice(0, 3).map((e) => e.message).join("; ");
+    super(`Validation failed for ${field}: ${summary}`);
+    this.field = field;
+    this.errors = errors;
+    this.name = "SchemaValidationError";
+  }
+};
+var SchemaUpdateValidationError = class extends Error {
+  constructor(failingItems) {
+    const count = failingItems.length;
+    super(`Cannot update schema: ${count} existing item(s) would fail validation`);
+    this.failingItems = failingItems;
+    this.name = "SchemaUpdateValidationError";
+  }
+};
+
+// src/datasets/validation/validator.ts
+function resolveZodSchema(zodString) {
+  return Function("z", `"use strict";return (${zodString});`)(zod.z);
+}
+var SchemaValidator = class {
+  cache = /* @__PURE__ */ new Map();
+  /** Get or compile validator for schema */
+  getValidator(schema, cacheKey) {
+    let zodSchema = this.cache.get(cacheKey);
+    if (!zodSchema) {
+      const zodString = jsonToZod.jsonSchemaToZod(schema);
+      zodSchema = resolveZodSchema(zodString);
+      this.cache.set(cacheKey, zodSchema);
+    }
+    return zodSchema;
+  }
+  /** Clear cached validator (call when schema changes) */
+  clearCache(cacheKey) {
+    this.cache.delete(cacheKey);
+  }
+  /** Validate data against schema */
+  validate(data, schema, field, cacheKey) {
+    const zodSchema = this.getValidator(schema, cacheKey);
+    const result = zodSchema.safeParse(data);
+    if (!result.success) {
+      throw new SchemaValidationError(field, this.formatErrors(result.error));
+    }
+  }
+  /** Validate multiple items, returning valid/invalid split */
+  validateBatch(items, inputSchema, outputSchema, cacheKeyPrefix, maxErrors = 10) {
+    const result = { valid: [], invalid: [] };
+    const inputValidator = inputSchema ? this.getValidator(inputSchema, `${cacheKeyPrefix}:input`) : null;
+    const outputValidator = outputSchema ? this.getValidator(outputSchema, `${cacheKeyPrefix}:output`) : null;
+    for (const [i, item] of items.entries()) {
+      let hasError = false;
+      if (inputValidator) {
+        const inputResult = inputValidator.safeParse(item.input);
+        if (!inputResult.success) {
+          result.invalid.push({
+            index: i,
+            data: item,
+            field: "input",
+            errors: this.formatErrors(inputResult.error)
+          });
+          hasError = true;
+          if (result.invalid.length >= maxErrors) break;
+        }
+      }
+      if (!hasError && outputValidator && item.groundTruth !== void 0) {
+        const outputResult = outputValidator.safeParse(item.groundTruth);
+        if (!outputResult.success) {
+          result.invalid.push({
+            index: i,
+            data: item,
+            field: "groundTruth",
+            errors: this.formatErrors(outputResult.error)
+          });
+          hasError = true;
+          if (result.invalid.length >= maxErrors) break;
+        }
+      }
+      if (!hasError) {
+        result.valid.push({ index: i, data: item });
+      }
+    }
+    return result;
+  }
+  /** Format Zod errors to FieldError array */
+  formatErrors(error) {
+    return error.issues.slice(0, 5).map((issue) => ({
+      // Convert Zod path array to JSON Pointer string
+      path: issue.path.length > 0 ? "/" + issue.path.join("/") : "/",
+      code: issue.code,
+      message: issue.message
+    }));
+  }
+};
+var validatorInstance = null;
+function getSchemaValidator() {
+  if (!validatorInstance) {
+    validatorInstance = new SchemaValidator();
+  }
+  return validatorInstance;
+}
+function createValidator() {
+  return new SchemaValidator();
+}
+
+// src/storage/domains/datasets/base.ts
+var DatasetsStorage = class extends StorageDomain {
+  constructor() {
+    super({
+      component: "STORAGE",
+      name: "DATASETS"
+    });
+  }
+  async dangerouslyClearAll() {
+  }
+  /**
+   * Update a dataset. Validates existing items against new schemas if schemas are changing.
+   * Subclasses implement _doUpdateDataset for actual storage operation.
+   */
+  async updateDataset(args) {
+    const existing = await this.getDatasetById({ id: args.id });
+    if (!existing) {
+      throw new Error(`Dataset not found: ${args.id}`);
+    }
+    const inputSchemaChanging = args.inputSchema !== void 0 && JSON.stringify(args.inputSchema) !== JSON.stringify(existing.inputSchema);
+    const groundTruthSchemaChanging = args.groundTruthSchema !== void 0 && JSON.stringify(args.groundTruthSchema) !== JSON.stringify(existing.groundTruthSchema);
+    if (inputSchemaChanging || groundTruthSchemaChanging) {
+      const itemsResult = await this.listItems({
+        datasetId: args.id,
+        pagination: { page: 0, perPage: false }
+        // Get all items
+      });
+      const items = itemsResult.items;
+      if (items.length > 0) {
+        const validator = getSchemaValidator();
+        const newInputSchema = args.inputSchema !== void 0 ? args.inputSchema : existing.inputSchema;
+        const newOutputSchema = args.groundTruthSchema !== void 0 ? args.groundTruthSchema : existing.groundTruthSchema;
+        const result = validator.validateBatch(
+          items.map((i) => ({ input: i.input, groundTruth: i.groundTruth })),
+          newInputSchema,
+          newOutputSchema,
+          `dataset:${args.id}:schema-update`,
+          10
+          // Max 10 errors to report
+        );
+        if (result.invalid.length > 0) {
+          throw new SchemaUpdateValidationError(result.invalid);
+        }
+        validator.clearCache(`dataset:${args.id}:input`);
+        validator.clearCache(`dataset:${args.id}:output`);
+      }
+    }
+    return this._doUpdateDataset(args);
+  }
+  /**
+   * Add an item to a dataset. Validates input/groundTruth against dataset schemas.
+   * Subclasses implement _doAddItem which handles SCD-2 versioning internally.
+   */
+  async addItem(args) {
+    const dataset = await this.getDatasetById({ id: args.datasetId });
+    if (!dataset) {
+      throw new Error(`Dataset not found: ${args.datasetId}`);
+    }
+    const validator = getSchemaValidator();
+    const cacheKey = `dataset:${args.datasetId}`;
+    if (dataset.inputSchema) {
+      validator.validate(args.input, dataset.inputSchema, "input", `${cacheKey}:input`);
+    }
+    if (dataset.groundTruthSchema && args.groundTruth !== void 0) {
+      validator.validate(args.groundTruth, dataset.groundTruthSchema, "groundTruth", `${cacheKey}:output`);
+    }
+    return this._doAddItem(args);
+  }
+  /**
+   * Update an item in a dataset. Validates changed fields against dataset schemas.
+   * Subclasses implement _doUpdateItem which handles SCD-2 versioning internally.
+   */
+  async updateItem(args) {
+    const dataset = await this.getDatasetById({ id: args.datasetId });
+    if (!dataset) {
+      throw new Error(`Dataset not found: ${args.datasetId}`);
+    }
+    const validator = getSchemaValidator();
+    const cacheKey = `dataset:${args.datasetId}`;
+    if (args.input !== void 0 && dataset.inputSchema) {
+      validator.validate(args.input, dataset.inputSchema, "input", `${cacheKey}:input`);
+    }
+    if (args.groundTruth !== void 0 && dataset.groundTruthSchema) {
+      validator.validate(args.groundTruth, dataset.groundTruthSchema, "groundTruth", `${cacheKey}:output`);
+    }
+    return this._doUpdateItem(args);
+  }
+  /**
+   * Delete an item from a dataset. Creates a tombstone row via SCD-2.
+   * Subclasses implement _doDeleteItem which handles SCD-2 versioning internally.
+   */
+  async deleteItem(args) {
+    return this._doDeleteItem(args);
+  }
+  /**
+   * Batch insert items to a dataset. Validates all items against dataset schemas,
+   * then delegates to subclass which handles SCD-2 versioning internally.
+   */
+  async batchInsertItems(input) {
+    const dataset = await this.getDatasetById({ id: input.datasetId });
+    if (!dataset) {
+      throw new Error(`Dataset not found: ${input.datasetId}`);
+    }
+    const validator = getSchemaValidator();
+    const cacheKey = `dataset:${input.datasetId}`;
+    for (const itemData of input.items) {
+      if (dataset.inputSchema) {
+        validator.validate(itemData.input, dataset.inputSchema, "input", `${cacheKey}:input`);
+      }
+      if (dataset.groundTruthSchema && itemData.groundTruth !== void 0) {
+        validator.validate(itemData.groundTruth, dataset.groundTruthSchema, "groundTruth", `${cacheKey}:output`);
+      }
+    }
+    return this._doBatchInsertItems(input);
+  }
+  /**
+   * Batch delete items from a dataset. Creates tombstone rows via SCD-2.
+   * Subclasses implement _doBatchDeleteItems which handles SCD-2 versioning internally.
+   */
+  async batchDeleteItems(input) {
+    const dataset = await this.getDatasetById({ id: input.datasetId });
+    if (!dataset) {
+      throw new Error(`Dataset not found: ${input.datasetId}`);
+    }
+    return this._doBatchDeleteItems(input);
+  }
+};
+
+// src/storage/domains/datasets/inmemory.ts
+function toDatasetItem(row) {
+  return {
+    id: row.id,
+    datasetId: row.datasetId,
+    datasetVersion: row.datasetVersion,
+    input: row.input,
+    groundTruth: row.groundTruth,
+    metadata: row.metadata,
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt
+  };
+}
+var DatasetsInMemory = class extends DatasetsStorage {
+  db;
+  constructor({ db }) {
+    super();
+    this.db = db;
+  }
+  async dangerouslyClearAll() {
+    this.db.datasets.clear();
+    this.db.datasetItems.clear();
+    this.db.datasetVersions.clear();
+  }
+  // Dataset CRUD
+  async createDataset(input) {
+    const id = crypto.randomUUID();
+    const now = /* @__PURE__ */ new Date();
+    const dataset = {
+      id,
+      name: input.name,
+      description: input.description,
+      metadata: input.metadata,
+      inputSchema: input.inputSchema,
+      groundTruthSchema: input.groundTruthSchema,
+      version: 0,
+      createdAt: now,
+      updatedAt: now
+    };
+    this.db.datasets.set(id, dataset);
+    return dataset;
+  }
+  async getDatasetById({ id }) {
+    return this.db.datasets.get(id) ?? null;
+  }
+  async _doUpdateDataset(args) {
+    const existing = this.db.datasets.get(args.id);
+    if (!existing) {
+      throw new Error(`Dataset not found: ${args.id}`);
+    }
+    const updated = {
+      ...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: /* @__PURE__ */ new Date()
+    };
+    this.db.datasets.set(args.id, updated);
+    return updated;
+  }
+  async deleteDataset({ id }) {
+    for (const [itemId, rows] of this.db.datasetItems) {
+      if (rows.length > 0 && rows[0].datasetId === id) {
+        this.db.datasetItems.delete(itemId);
+      }
+    }
+    for (const [vId, v] of this.db.datasetVersions) {
+      if (v.datasetId === id) {
+        this.db.datasetVersions.delete(vId);
+      }
+    }
+    for (const [expId, exp] of this.db.experiments) {
+      if (exp.datasetId === id) {
+        this.db.experiments.set(expId, { ...exp, datasetId: null, datasetVersion: null });
+      }
+    }
+    this.db.datasets.delete(id);
+  }
+  async listDatasets(args) {
+    const datasets = Array.from(this.db.datasets.values());
+    datasets.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
+    const { page, perPage: perPageInput } = args.pagination;
+    const perPage = normalizePerPage(perPageInput, 100);
+    const { offset: start, perPage: perPageForResponse } = calculatePagination(page, perPageInput, perPage);
+    const end = perPageInput === false ? datasets.length : start + perPage;
+    return {
+      datasets: datasets.slice(start, end),
+      pagination: {
+        total: datasets.length,
+        page,
+        perPage: perPageForResponse,
+        hasMore: perPageInput === false ? false : datasets.length > end
+      }
+    };
+  }
+  // --- SCD-2 item mutations ---
+  async _doAddItem(args) {
+    const dataset = this.db.datasets.get(args.datasetId);
+    if (!dataset) {
+      throw new Error(`Dataset not found: ${args.datasetId}`);
+    }
+    const newVersion = dataset.version + 1;
+    this.db.datasets.set(args.datasetId, { ...dataset, version: newVersion });
+    const now = /* @__PURE__ */ new Date();
+    const id = crypto.randomUUID();
+    const row = {
+      id,
+      datasetId: args.datasetId,
+      datasetVersion: newVersion,
+      validTo: null,
+      isDeleted: false,
+      input: args.input,
+      groundTruth: args.groundTruth,
+      metadata: args.metadata,
+      createdAt: now,
+      updatedAt: now
+    };
+    this.db.datasetItems.set(id, [row]);
+    await this.createDatasetVersion(args.datasetId, newVersion);
+    return toDatasetItem(row);
+  }
+  async _doUpdateItem(args) {
+    const rows = this.db.datasetItems.get(args.id);
+    if (!rows || rows.length === 0) {
+      throw new Error(`Item not found: ${args.id}`);
+    }
+    const currentRow = rows.find((r) => r.validTo === null && !r.isDeleted);
+    if (!currentRow) {
+      throw new Error(`Item not found: ${args.id}`);
+    }
+    if (currentRow.datasetId !== args.datasetId) {
+      throw new Error(`Item ${args.id} does not belong to dataset ${args.datasetId}`);
+    }
+    const dataset = this.db.datasets.get(args.datasetId);
+    if (!dataset) {
+      throw new Error(`Dataset not found: ${args.datasetId}`);
+    }
+    const newVersion = dataset.version + 1;
+    this.db.datasets.set(args.datasetId, { ...dataset, version: newVersion });
+    currentRow.validTo = newVersion;
+    const now = /* @__PURE__ */ new Date();
+    const newRow = {
+      id: args.id,
+      datasetId: args.datasetId,
+      datasetVersion: newVersion,
+      validTo: null,
+      isDeleted: false,
+      input: args.input ?? currentRow.input,
+      groundTruth: args.groundTruth ?? currentRow.groundTruth,
+      metadata: args.metadata ?? currentRow.metadata,
+      createdAt: currentRow.createdAt,
+      updatedAt: now
+    };
+    rows.push(newRow);
+    await this.createDatasetVersion(args.datasetId, newVersion);
+    return toDatasetItem(newRow);
+  }
+  async _doDeleteItem({ id, datasetId }) {
+    const rows = this.db.datasetItems.get(id);
+    if (!rows || rows.length === 0) {
+      return;
+    }
+    const currentRow = rows.find((r) => r.validTo === null && !r.isDeleted);
+    if (!currentRow) {
+      return;
+    }
+    if (currentRow.datasetId !== datasetId) {
+      throw new Error(`Item ${id} does not belong to dataset ${datasetId}`);
+    }
+    const dataset = this.db.datasets.get(datasetId);
+    if (!dataset) {
+      throw new Error(`Dataset not found: ${datasetId}`);
+    }
+    const newVersion = dataset.version + 1;
+    this.db.datasets.set(datasetId, { ...dataset, version: newVersion });
+    currentRow.validTo = newVersion;
+    const now = /* @__PURE__ */ new Date();
+    rows.push({
+      id,
+      datasetId,
+      datasetVersion: newVersion,
+      validTo: null,
+      isDeleted: true,
+      input: currentRow.input,
+      groundTruth: currentRow.groundTruth,
+      metadata: currentRow.metadata,
+      createdAt: currentRow.createdAt,
+      updatedAt: now
+    });
+    await this.createDatasetVersion(datasetId, newVersion);
+  }
+  // --- SCD-2 queries ---
+  async getItemById(args) {
+    const rows = this.db.datasetItems.get(args.id);
+    if (!rows || rows.length === 0) return null;
+    if (args.datasetVersion !== void 0) {
+      const row = rows.find((r) => r.datasetVersion === args.datasetVersion && !r.isDeleted);
+      return row ? toDatasetItem(row) : null;
+    }
+    const current = rows.find((r) => r.validTo === null && !r.isDeleted);
+    return current ? toDatasetItem(current) : null;
+  }
+  async getItemsByVersion({ datasetId, version }) {
+    const items = [];
+    for (const rows of this.db.datasetItems.values()) {
+      if (rows.length === 0 || rows[0].datasetId !== datasetId) continue;
+      const visible = rows.find(
+        (r) => r.datasetVersion <= version && (r.validTo === null || r.validTo > version) && !r.isDeleted
+      );
+      if (visible) {
+        items.push(toDatasetItem(visible));
+      }
+    }
+    items.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime() || b.id.localeCompare(a.id));
+    return items;
+  }
+  async getItemHistory(itemId) {
+    const rows = this.db.datasetItems.get(itemId);
+    if (!rows) return [];
+    return [...rows].sort((a, b) => b.datasetVersion - a.datasetVersion);
+  }
+  async listItems(args) {
+    let items;
+    if (args.version !== void 0) {
+      items = await this.getItemsByVersion({ datasetId: args.datasetId, version: args.version });
+    } else {
+      items = [];
+      for (const rows of this.db.datasetItems.values()) {
+        if (rows.length === 0 || rows[0].datasetId !== args.datasetId) continue;
+        const current = rows.find((r) => r.validTo === null && !r.isDeleted);
+        if (current) {
+          items.push(toDatasetItem(current));
+        }
+      }
+    }
+    if (args.search) {
+      const searchLower = args.search.toLowerCase();
+      items = items.filter((item) => {
+        const inputStr = typeof item.input === "string" ? item.input : JSON.stringify(item.input);
+        const outputStr = item.groundTruth ? typeof item.groundTruth === "string" ? item.groundTruth : JSON.stringify(item.groundTruth) : "";
+        return inputStr.toLowerCase().includes(searchLower) || outputStr.toLowerCase().includes(searchLower);
+      });
+    }
+    items.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime() || b.id.localeCompare(a.id));
+    const { page, perPage: perPageInput } = args.pagination;
+    const perPage = normalizePerPage(perPageInput, 100);
+    const { offset: start, perPage: perPageForResponse } = calculatePagination(page, perPageInput, perPage);
+    const end = perPageInput === false ? items.length : start + perPage;
+    return {
+      items: items.slice(start, end),
+      pagination: {
+        total: items.length,
+        page,
+        perPage: perPageForResponse,
+        hasMore: perPageInput === false ? false : items.length > end
+      }
+    };
+  }
+  // --- Dataset version methods ---
+  async createDatasetVersion(datasetId, version) {
+    const id = crypto.randomUUID();
+    const dsVersion = {
+      id,
+      datasetId,
+      version,
+      createdAt: /* @__PURE__ */ new Date()
+    };
+    this.db.datasetVersions.set(id, dsVersion);
+    return dsVersion;
+  }
+  async listDatasetVersions(input) {
+    const versions = [];
+    for (const v of this.db.datasetVersions.values()) {
+      if (v.datasetId === input.datasetId) {
+        versions.push(v);
+      }
+    }
+    versions.sort((a, b) => b.version - a.version);
+    const { page, perPage: perPageInput } = input.pagination;
+    const perPage = normalizePerPage(perPageInput, 100);
+    const { offset: start, perPage: perPageForResponse } = calculatePagination(page, perPageInput, perPage);
+    const end = perPageInput === false ? versions.length : start + perPage;
+    return {
+      versions: versions.slice(start, end),
+      pagination: {
+        total: versions.length,
+        page,
+        perPage: perPageForResponse,
+        hasMore: perPageInput === false ? false : versions.length > end
+      }
+    };
+  }
+  // --- Bulk operations (SCD-2 internally) ---
+  async _doBatchInsertItems(input) {
+    const dataset = this.db.datasets.get(input.datasetId);
+    if (!dataset) {
+      throw new Error(`Dataset not found: ${input.datasetId}`);
+    }
+    const newVersion = dataset.version + 1;
+    this.db.datasets.set(input.datasetId, { ...dataset, version: newVersion });
+    const now = /* @__PURE__ */ new Date();
+    const items = [];
+    for (const itemInput of input.items) {
+      const id = crypto.randomUUID();
+      const row = {
+        id,
+        datasetId: input.datasetId,
+        datasetVersion: newVersion,
+        validTo: null,
+        isDeleted: false,
+        input: itemInput.input,
+        groundTruth: itemInput.groundTruth,
+        metadata: itemInput.metadata,
+        createdAt: now,
+        updatedAt: now
+      };
+      this.db.datasetItems.set(id, [row]);
+      items.push(toDatasetItem(row));
+    }
+    await this.createDatasetVersion(input.datasetId, newVersion);
+    return items;
+  }
+  async _doBatchDeleteItems(input) {
+    const dataset = this.db.datasets.get(input.datasetId);
+    if (!dataset) {
+      throw new Error(`Dataset not found: ${input.datasetId}`);
+    }
+    const newVersion = dataset.version + 1;
+    this.db.datasets.set(input.datasetId, { ...dataset, version: newVersion });
+    const now = /* @__PURE__ */ new Date();
+    for (const itemId of input.itemIds) {
+      const rows = this.db.datasetItems.get(itemId);
+      if (!rows) continue;
+      const currentRow = rows.find((r) => r.validTo === null && !r.isDeleted);
+      if (!currentRow || currentRow.datasetId !== input.datasetId) continue;
+      currentRow.validTo = newVersion;
+      rows.push({
+        id: itemId,
+        datasetId: input.datasetId,
+        datasetVersion: newVersion,
+        validTo: null,
+        isDeleted: true,
+        input: currentRow.input,
+        groundTruth: currentRow.groundTruth,
+        metadata: currentRow.metadata,
+        createdAt: currentRow.createdAt,
+        updatedAt: now
+      });
+    }
+    await this.createDatasetVersion(input.datasetId, newVersion);
+  }
+};
+
+// src/storage/domains/experiments/base.ts
+var ExperimentsStorage = class extends StorageDomain {
+  constructor() {
+    super({
+      component: "STORAGE",
+      name: "EXPERIMENTS"
+    });
+  }
+  async dangerouslyClearAll() {
+  }
+};
+
+// src/storage/domains/experiments/inmemory.ts
+var ExperimentsInMemory = class extends ExperimentsStorage {
+  db;
+  constructor({ db }) {
+    super();
+    this.db = db;
+  }
+  async dangerouslyClearAll() {
+    this.db.experiments.clear();
+    this.db.experimentResults.clear();
+  }
+  // Experiment lifecycle
+  async createExperiment(input) {
+    const now = /* @__PURE__ */ new Date();
+    const experiment = {
+      id: input.id ?? crypto.randomUUID(),
+      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
+    };
+    this.db.experiments.set(experiment.id, experiment);
+    return experiment;
+  }
+  async updateExperiment(input) {
+    const existing = this.db.experiments.get(input.id);
+    if (!existing) {
+      throw new Error(`Experiment not found: ${input.id}`);
+    }
+    const updated = {
+      ...existing,
+      status: input.status ?? existing.status,
+      succeededCount: input.succeededCount ?? existing.succeededCount,
+      failedCount: input.failedCount ?? existing.failedCount,
+      skippedCount: input.skippedCount ?? existing.skippedCount,
+      startedAt: input.startedAt ?? existing.startedAt,
+      completedAt: input.completedAt ?? existing.completedAt,
+      name: input.name ?? existing.name,
+      description: input.description ?? existing.description,
+      metadata: input.metadata ?? existing.metadata,
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+    this.db.experiments.set(input.id, updated);
+    return updated;
+  }
+  async getExperimentById(args) {
+    return this.db.experiments.get(args.id) ?? null;
+  }
+  async listExperiments(args) {
+    let experiments = Array.from(this.db.experiments.values());
+    if (args.datasetId) {
+      experiments = experiments.filter((r) => r.datasetId === args.datasetId);
+    }
+    experiments.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
+    const { page, perPage: perPageInput } = args.pagination;
+    const perPage = normalizePerPage(perPageInput, 100);
+    const { offset: start, perPage: perPageForResponse } = calculatePagination(page, perPageInput, perPage);
+    const end = perPageInput === false ? experiments.length : start + perPage;
+    return {
+      experiments: experiments.slice(start, end),
+      pagination: {
+        total: experiments.length,
+        page,
+        perPage: perPageForResponse,
+        hasMore: perPageInput === false ? false : experiments.length > end
+      }
+    };
+  }
+  async deleteExperiment(args) {
+    this.db.experiments.delete(args.id);
+    for (const [resultId, result] of this.db.experimentResults) {
+      if (result.experimentId === args.id) {
+        this.db.experimentResults.delete(resultId);
+      }
+    }
+  }
+  // Results (per-item)
+  async addExperimentResult(input) {
+    const now = /* @__PURE__ */ new Date();
+    const result = {
+      id: input.id ?? crypto.randomUUID(),
+      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
+    };
+    this.db.experimentResults.set(result.id, result);
+    return result;
+  }
+  async getExperimentResultById(args) {
+    return this.db.experimentResults.get(args.id) ?? null;
+  }
+  async listExperimentResults(args) {
+    let results = Array.from(this.db.experimentResults.values()).filter((r) => r.experimentId === args.experimentId);
+    results.sort((a, b) => a.startedAt.getTime() - b.startedAt.getTime());
+    const { page, perPage: perPageInput } = args.pagination;
+    const perPage = normalizePerPage(perPageInput, 100);
+    const { offset: start, perPage: perPageForResponse } = calculatePagination(page, perPageInput, perPage);
+    const end = perPageInput === false ? results.length : start + perPage;
+    return {
+      results: results.slice(start, end),
+      pagination: {
+        total: results.length,
+        page,
+        perPage: perPageForResponse,
+        hasMore: perPageInput === false ? false : results.length > end
+      }
+    };
+  }
+  async deleteExperimentResults(args) {
+    for (const [resultId, result] of this.db.experimentResults) {
+      if (result.experimentId === args.experimentId) {
+        this.db.experimentResults.delete(resultId);
+      }
+    }
+  }
+};
+
 exports.AgentsStorage = AgentsStorage;
+exports.DatasetsInMemory = DatasetsInMemory;
+exports.DatasetsStorage = DatasetsStorage;
+exports.ExperimentsInMemory = ExperimentsInMemory;
+exports.ExperimentsStorage = ExperimentsStorage;
 exports.InMemoryAgentsStorage = InMemoryAgentsStorage;
 exports.InMemoryDB = InMemoryDB;
+exports.InMemoryMCPClientsStorage = InMemoryMCPClientsStorage;
 exports.InMemoryMemory = InMemoryMemory;
 exports.InMemoryPromptBlocksStorage = InMemoryPromptBlocksStorage;
 exports.InMemoryScorerDefinitionsStorage = InMemoryScorerDefinitionsStorage;
 exports.InMemoryStore = InMemoryStore;
+exports.MCPClientsStorage = MCPClientsStorage;
 exports.MastraCompositeStore = MastraCompositeStore;
 exports.MastraStorage = MastraStorage;
 exports.MemoryStorage = MemoryStorage;
@@ -3611,6 +4701,9 @@ exports.MockStore = MockStore;
 exports.ObservabilityInMemory = ObservabilityInMemory;
 exports.ObservabilityStorage = ObservabilityStorage;
 exports.PromptBlocksStorage = PromptBlocksStorage;
+exports.SchemaUpdateValidationError = SchemaUpdateValidationError;
+exports.SchemaValidationError = SchemaValidationError;
+exports.SchemaValidator = SchemaValidator;
 exports.ScorerDefinitionsStorage = ScorerDefinitionsStorage;
 exports.ScoresInMemory = ScoresInMemory;
 exports.ScoresStorage = ScoresStorage;
@@ -3624,10 +4717,12 @@ exports.calculatePagination = calculatePagination;
 exports.createPendingMarker = createPendingMarker;
 exports.createStorageErrorId = createStorageErrorId;
 exports.createStoreErrorId = createStoreErrorId;
+exports.createValidator = createValidator;
 exports.createVectorErrorId = createVectorErrorId;
 exports.ensureDate = ensureDate;
 exports.filterByDateRange = filterByDateRange;
 exports.getDefaultValue = getDefaultValue;
+exports.getSchemaValidator = getSchemaValidator;
 exports.getSqlType = getSqlType;
 exports.jsonValueEquals = jsonValueEquals;
 exports.normalizePerPage = normalizePerPage;
@@ -3635,5 +4730,5 @@ exports.safelyParseJSON = safelyParseJSON;
 exports.serializeDate = serializeDate;
 exports.transformRow = transformRow;
 exports.transformScoreRow = transformScoreRow;
-//# sourceMappingURL=chunk-TERSHTY5.cjs.map
-//# sourceMappingURL=chunk-TERSHTY5.cjs.map
+//# sourceMappingURL=chunk-BP7VYTOP.cjs.map
+//# sourceMappingURL=chunk-BP7VYTOP.cjs.map