@mastra/core 1.4.0 → 1.5.0-alpha.1

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

@@ -1,10 +1,11 @@
 'use strict';
 
-var chunkCZ4NQANZ_cjs = require('./chunk-CZ4NQANZ.cjs');
-var chunkSU5APAM6_cjs = require('./chunk-SU5APAM6.cjs');
-var chunk65PHUUMF_cjs = require('./chunk-65PHUUMF.cjs');
+var chunkYW54RH77_cjs = require('./chunk-YW54RH77.cjs');
+var chunkKNXZ7KYL_cjs = require('./chunk-KNXZ7KYL.cjs');
+var chunkQDH6MVJ7_cjs = require('./chunk-QDH6MVJ7.cjs');
 var chunk4U7ZLI36_cjs = require('./chunk-4U7ZLI36.cjs');
 var chunkRO47SMI7_cjs = require('./chunk-RO47SMI7.cjs');
+var crypto$1 = require('crypto');
 var jsonToZod = require('@mastra/schema-compat/json-to-zod');
 var zod = require('zod');
 
@@ -67,7 +68,9 @@ var MastraCompositeStore = class extends chunkRO47SMI7_cjs.MastraBase {
         experiments: domainOverrides.experiments ?? defaultStores?.experiments,
         promptBlocks: domainOverrides.promptBlocks ?? defaultStores?.promptBlocks,
         scorerDefinitions: domainOverrides.scorerDefinitions ?? defaultStores?.scorerDefinitions,
-        mcpClients: domainOverrides.mcpClients ?? defaultStores?.mcpClients
+        mcpClients: domainOverrides.mcpClients ?? defaultStores?.mcpClients,
+        workspaces: domainOverrides.workspaces ?? defaultStores?.workspaces,
+        skills: domainOverrides.skills ?? defaultStores?.skills
       };
     }
   }
@@ -127,6 +130,15 @@ var MastraCompositeStore = class extends chunkRO47SMI7_cjs.MastraBase {
     if (this.stores?.mcpClients) {
       initTasks.push(this.stores.mcpClients.init());
     }
+    if (this.stores?.workspaces) {
+      initTasks.push(this.stores.workspaces.init());
+    }
+    if (this.stores?.skills) {
+      initTasks.push(this.stores.skills.init());
+    }
+    if (this.stores?.blobs) {
+      initTasks.push(this.stores.blobs.init());
+    }
     this.hasInitialized = Promise.all(initTasks).then(() => true);
     await this.hasInitialized;
   }
@@ -176,22 +188,28 @@ var VersionedStorageDomain = class extends StorageDomain {
     return result;
   }
   /**
-   * Resolves an entity by merging its thin record with the active (or latest) version config.
+   * Resolves an entity by merging its thin record with the active or latest version config.
+   * Pass `{ status: 'draft' }` to resolve with the latest version instead of the active one.
    */
-  async getByIdResolved(id) {
+  async getByIdResolved(id, options) {
     const entity = await this.getById(id);
     if (!entity) {
       return null;
     }
-    return this.resolveEntity(entity);
+    return this.resolveEntity(entity, options);
   }
   /**
    * Lists entities with version resolution.
+   * When `status` is `'draft'`, each entity is resolved with its latest version.
+   * When `status` is `'published'` (default), each entity is resolved with its active version.
    */
   async listResolved(args) {
     const result = await this.list(args);
+    const status = args?.status;
     const entities = result[this.listKey];
-    const resolved = await Promise.all(entities.map((entity) => this.resolveEntity(entity)));
+    const resolved = await Promise.all(
+      entities.map((entity) => this.resolveEntity(entity, { status }))
+    );
     return {
       ...result,
       [this.listKey]: resolved
@@ -199,25 +217,33 @@ var VersionedStorageDomain = class extends StorageDomain {
   }
   /**
    * Resolves a single entity by merging it with its active or latest version.
+   * - `status: 'published'` (default) — use activeVersionId, fall back to latest.
+   * - `status: 'draft'` — always use the latest version.
    */
-  async resolveEntity(entity) {
+  async resolveEntity(entity, options) {
+    const status = options?.status || "published";
     let version = null;
-    if (entity.activeVersionId) {
-      version = await this.getVersion(entity.activeVersionId);
+    if (status === "draft") {
+      version = await this.getLatestVersion(entity.id);
+    } else {
+      if (entity.activeVersionId) {
+        version = await this.getVersion(entity.activeVersionId);
+        if (!version) {
+          this.logger?.warn?.(
+            `Entity ${entity.id} has activeVersionId ${entity.activeVersionId} but version not found. Falling back to latest version.`
+          );
+        }
+      }
       if (!version) {
-        this.logger?.warn?.(
-          `Entity ${entity.id} has activeVersionId ${entity.activeVersionId} but version not found. Falling back to latest version.`
-        );
+        version = await this.getLatestVersion(entity.id);
       }
     }
-    if (!version) {
-      version = await this.getLatestVersion(entity.id);
-    }
     if (version) {
       const snapshotConfig = this.extractSnapshotConfig(version);
       return {
         ...entity,
-        ...snapshotConfig
+        ...snapshotConfig,
+        resolvedVersionId: version.id
       };
     }
     return entity;
@@ -313,25 +339,7 @@ var InMemoryAgentsStorage = class extends AgentsStorage {
     if (!existingAgent) {
       throw new Error(`Agent with id ${id} not found`);
     }
-    const { authorId, activeVersionId, metadata, ...configFields } = updates;
-    const configFieldNames = [
-      "name",
-      "description",
-      "instructions",
-      "model",
-      "tools",
-      "defaultOptions",
-      "workflows",
-      "agents",
-      "integrationTools",
-      "inputProcessors",
-      "outputProcessors",
-      "memory",
-      "scorers",
-      "mcpClients",
-      "requestContextSchema"
-    ];
-    const hasConfigUpdate = configFieldNames.some((field) => field in configFields);
+    const { authorId, activeVersionId, metadata, status } = updates;
     const updatedAgent = {
       ...existingAgent,
       ...authorId !== void 0 && { authorId },
@@ -339,48 +347,9 @@ var InMemoryAgentsStorage = class extends AgentsStorage {
       ...metadata !== void 0 && {
         metadata: { ...existingAgent.metadata, ...metadata }
       },
+      ...status !== void 0 && { status },
       updatedAt: /* @__PURE__ */ new Date()
     };
-    if (activeVersionId !== void 0) {
-      updatedAgent.status = "published";
-    }
-    if (hasConfigUpdate) {
-      const latestVersion = await this.getLatestVersion(id);
-      if (!latestVersion) {
-        throw new Error(`No versions found for agent ${id}`);
-      }
-      const {
-        id: _versionId,
-        agentId: _agentId,
-        versionNumber: _versionNumber,
-        changedFields: _changedFields,
-        changeMessage: _changeMessage,
-        createdAt: _createdAt,
-        ...latestConfig
-      } = latestVersion;
-      const sanitizedConfigFields = Object.fromEntries(
-        Object.entries(configFields).map(([key, value]) => [key, value === null ? void 0 : value])
-      );
-      const newConfig = {
-        ...latestConfig,
-        ...sanitizedConfigFields
-      };
-      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,
-          agentId: id,
-          versionNumber: newVersionNumber,
-          ...newConfig,
-          changedFields,
-          changeMessage: `Updated ${changedFields.join(", ")}`
-        });
-      }
-    }
     this.db.agents.set(id, updatedAgent);
     return this.deepCopyAgent(updatedAgent);
   }
@@ -390,7 +359,7 @@ var InMemoryAgentsStorage = class extends AgentsStorage {
     await this.deleteVersionsByParentId(id);
   }
   async list(args) {
-    const { page = 0, perPage: perPageInput, orderBy, authorId, metadata } = args || {};
+    const { page = 0, perPage: perPageInput, orderBy, authorId, metadata, status } = args || {};
     const { field, direction } = this.parseOrderBy(orderBy);
     this.logger.debug(`InMemoryAgentsStorage: list called`);
     const perPage = normalizePerPage(perPageInput, 100);
@@ -402,13 +371,16 @@ var InMemoryAgentsStorage = class extends AgentsStorage {
       throw new Error("page value too large");
     }
     let agents = Array.from(this.db.agents.values());
+    if (status) {
+      agents = agents.filter((agent) => agent.status === status);
+    }
     if (authorId !== void 0) {
       agents = agents.filter((agent) => agent.authorId === authorId);
     }
     if (metadata && Object.keys(metadata).length > 0) {
       agents = agents.filter((agent) => {
         if (!agent.metadata) return false;
-        return Object.entries(metadata).every(([key, value]) => chunk65PHUUMF_cjs.deepEqual(agent.metadata[key], value));
+        return Object.entries(metadata).every(([key, value]) => chunkQDH6MVJ7_cjs.deepEqual(agent.metadata[key], value));
       });
     }
     const sortedAgents = this.sortAgents(agents, field, direction);
@@ -577,6 +549,10 @@ var InMemoryDB = class {
   scorerDefinitionVersions = /* @__PURE__ */ new Map();
   mcpClients = /* @__PURE__ */ new Map();
   mcpClientVersions = /* @__PURE__ */ new Map();
+  workspaces = /* @__PURE__ */ new Map();
+  workspaceVersions = /* @__PURE__ */ new Map();
+  skills = /* @__PURE__ */ new Map();
+  skillVersions = /* @__PURE__ */ new Map();
   /** Observational memory records, keyed by resourceId, each holding array of records (generations) */
   observationalMemory = /* @__PURE__ */ new Map();
   // Dataset domain maps
@@ -605,6 +581,10 @@ var InMemoryDB = class {
     this.scorerDefinitionVersions.clear();
     this.mcpClients.clear();
     this.mcpClientVersions.clear();
+    this.workspaces.clear();
+    this.workspaceVersions.clear();
+    this.skills.clear();
+    this.skillVersions.clear();
     this.observationalMemory.clear();
     this.datasets.clear();
     this.datasetItems.clear();
@@ -688,9 +668,7 @@ var InMemoryMCPClientsStorage = class extends MCPClientsStorage {
     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 { authorId, activeVersionId, metadata, status } = updates;
     const updatedConfig = {
       ...existingConfig,
       ...authorId !== void 0 && { authorId },
@@ -701,43 +679,6 @@ var InMemoryMCPClientsStorage = class extends MCPClientsStorage {
       },
       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);
   }
@@ -747,7 +688,7 @@ var InMemoryMCPClientsStorage = class extends MCPClientsStorage {
     await this.deleteVersionsByParentId(id);
   }
   async list(args) {
-    const { page = 0, perPage: perPageInput, orderBy, authorId, metadata } = args || {};
+    const { page = 0, perPage: perPageInput, orderBy, authorId, metadata, status } = args || {};
     const { field, direction } = this.parseOrderBy(orderBy);
     this.logger.debug(`InMemoryMCPClientsStorage: list called`);
     const perPage = normalizePerPage(perPageInput, 100);
@@ -759,13 +700,16 @@ var InMemoryMCPClientsStorage = class extends MCPClientsStorage {
       throw new Error("page value too large");
     }
     let configs = Array.from(this.db.mcpClients.values());
+    if (status) {
+      configs = configs.filter((config) => config.status === status);
+    }
     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));
+        return Object.entries(metadata).every(([key, value]) => chunkQDH6MVJ7_cjs.deepEqual(config.metadata[key], value));
       });
     }
     const sortedConfigs = this.sortConfigs(configs, field, direction);
@@ -933,7 +877,7 @@ function safelyParseJSON(input) {
 }
 function transformRow(row, tableName, options = {}) {
   const { preferredTimestampFields = {}, convertTimestamps = false, nullValuePattern, fieldMappings = {} } = options;
-  const tableSchema = chunkSU5APAM6_cjs.TABLE_SCHEMAS[tableName];
+  const tableSchema = chunkKNXZ7KYL_cjs.TABLE_SCHEMAS[tableName];
   const result = {};
   for (const [key, columnSchema] of Object.entries(tableSchema)) {
     const sourceKey = fieldMappings[key] ?? key;
@@ -964,7 +908,7 @@ function transformRow(row, tableName, options = {}) {
   return result;
 }
 function transformScoreRow(row, options = {}) {
-  return transformRow(row, chunkSU5APAM6_cjs.TABLE_SCORERS, options);
+  return transformRow(row, chunkKNXZ7KYL_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, "");
@@ -1586,7 +1530,7 @@ var InMemoryMemory = class extends MemoryStorage {
     });
     const total = messages.length;
     const paginatedMessages = messages.slice(offset, offset + perPage);
-    const list = new chunkCZ4NQANZ_cjs.MessageList().add(
+    const list = new chunkYW54RH77_cjs.MessageList().add(
       paginatedMessages.map((m) => this.parseStoredMessage(m)),
       "memory"
     );
@@ -1620,7 +1564,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 chunkCZ4NQANZ_cjs.MessageList().add(
+    const list = new chunkYW54RH77_cjs.MessageList().add(
       rawMessages.map((m) => this.parseStoredMessage(m)),
       "memory"
     );
@@ -1652,7 +1596,7 @@ var InMemoryMemory = class extends MemoryStorage {
       };
       this.db.messages.set(key, storageMessage);
     }
-    const list = new chunkCZ4NQANZ_cjs.MessageList().add(messages, "memory");
+    const list = new chunkYW54RH77_cjs.MessageList().add(messages, "memory");
     return { messages: list.get.all.db() };
   }
   async updateMessages(args) {
@@ -2493,7 +2437,7 @@ var ObservabilityInMemory = class extends ObservabilityStorage {
     };
   }
   async listTraces(args) {
-    const { filters, pagination, orderBy } = chunkSU5APAM6_cjs.listTracesArgsSchema.parse(args);
+    const { filters, pagination, orderBy } = chunkKNXZ7KYL_cjs.listTracesArgsSchema.parse(args);
     const matchingRootSpans = [];
     for (const [, traceEntry] of this.db.traces) {
       if (!traceEntry.rootSpan) continue;
@@ -2522,7 +2466,7 @@ var ObservabilityInMemory = class extends ObservabilityStorage {
     const end = start + perPage;
     const paged = matchingRootSpans.slice(start, end);
     return {
-      spans: chunkSU5APAM6_cjs.toTraceSpans(paged),
+      spans: chunkKNXZ7KYL_cjs.toTraceSpans(paged),
       pagination: { total, page, perPage, hasMore: end < total }
     };
   }
@@ -2747,9 +2691,7 @@ var InMemoryPromptBlocksStorage = class extends PromptBlocksStorage {
     if (!existingBlock) {
       throw new Error(`Prompt block with id ${id} not found`);
     }
-    const { authorId, activeVersionId, metadata, status, ...configFields } = updates;
-    const configFieldNames = ["name", "description", "content", "rules"];
-    const hasConfigUpdate = configFieldNames.some((field) => field in configFields);
+    const { authorId, activeVersionId, metadata, status } = updates;
     const updatedBlock = {
       ...existingBlock,
       ...authorId !== void 0 && { authorId },
@@ -2760,43 +2702,6 @@ var InMemoryPromptBlocksStorage = class extends PromptBlocksStorage {
       },
       updatedAt: /* @__PURE__ */ new Date()
     };
-    if (activeVersionId !== void 0) {
-      updatedBlock.status = "published";
-    }
-    if (hasConfigUpdate) {
-      const latestVersion = await this.getLatestVersion(id);
-      if (!latestVersion) {
-        throw new Error(`No versions found for prompt block ${id}`);
-      }
-      const {
-        id: _versionId,
-        blockId: _blockId,
-        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,
-          blockId: id,
-          versionNumber: newVersionNumber,
-          ...newConfig,
-          changedFields,
-          changeMessage: `Updated ${changedFields.join(", ")}`
-        });
-      }
-    }
     this.db.promptBlocks.set(id, updatedBlock);
     return this.deepCopyBlock(updatedBlock);
   }
@@ -2806,7 +2711,7 @@ var InMemoryPromptBlocksStorage = class extends PromptBlocksStorage {
     await this.deleteVersionsByParentId(id);
   }
   async list(args) {
-    const { page = 0, perPage: perPageInput, orderBy, authorId, metadata } = args || {};
+    const { page = 0, perPage: perPageInput, orderBy, authorId, metadata, status } = args || {};
     const { field, direction } = this.parseOrderBy(orderBy);
     this.logger.debug(`InMemoryPromptBlocksStorage: list called`);
     const perPage = normalizePerPage(perPageInput, 100);
@@ -2818,13 +2723,16 @@ var InMemoryPromptBlocksStorage = class extends PromptBlocksStorage {
       throw new Error("page value too large");
     }
     let blocks = Array.from(this.db.promptBlocks.values());
+    if (status) {
+      blocks = blocks.filter((block) => block.status === status);
+    }
     if (authorId !== void 0) {
       blocks = blocks.filter((block) => block.authorId === authorId);
     }
     if (metadata && Object.keys(metadata).length > 0) {
       blocks = blocks.filter((block) => {
         if (!block.metadata) return false;
-        return Object.entries(metadata).every(([key, value]) => chunk65PHUUMF_cjs.deepEqual(block.metadata[key], value));
+        return Object.entries(metadata).every(([key, value]) => chunkQDH6MVJ7_cjs.deepEqual(block.metadata[key], value));
       });
     }
     const sortedBlocks = this.sortBlocks(blocks, field, direction);
@@ -3049,18 +2957,7 @@ var InMemoryScorerDefinitionsStorage = class extends ScorerDefinitionsStorage {
     if (!existingScorer) {
       throw new Error(`Scorer definition with id ${id} not found`);
     }
-    const { authorId, activeVersionId, metadata, status, ...configFields } = updates;
-    const configFieldNames = [
-      "name",
-      "description",
-      "type",
-      "model",
-      "instructions",
-      "scoreRange",
-      "presetConfig",
-      "defaultSampling"
-    ];
-    const hasConfigUpdate = configFieldNames.some((field) => field in configFields);
+    const { authorId, activeVersionId, metadata, status } = updates;
     const updatedScorer = {
       ...existingScorer,
       ...authorId !== void 0 && { authorId },
@@ -3071,43 +2968,6 @@ var InMemoryScorerDefinitionsStorage = class extends ScorerDefinitionsStorage {
       },
       updatedAt: /* @__PURE__ */ new Date()
     };
-    if (activeVersionId !== void 0) {
-      updatedScorer.status = "published";
-    }
-    if (hasConfigUpdate) {
-      const latestVersion = await this.getLatestVersion(id);
-      if (!latestVersion) {
-        throw new Error(`No versions found for scorer definition ${id}`);
-      }
-      const {
-        id: _versionId,
-        scorerDefinitionId: _scorerDefinitionId,
-        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,
-          scorerDefinitionId: id,
-          versionNumber: newVersionNumber,
-          ...newConfig,
-          changedFields,
-          changeMessage: `Updated ${changedFields.join(", ")}`
-        });
-      }
-    }
     this.db.scorerDefinitions.set(id, updatedScorer);
     return this.deepCopyScorer(updatedScorer);
   }
@@ -3117,7 +2977,7 @@ var InMemoryScorerDefinitionsStorage = class extends ScorerDefinitionsStorage {
     await this.deleteVersionsByParentId(id);
   }
   async list(args) {
-    const { page = 0, perPage: perPageInput, orderBy, authorId, metadata } = args || {};
+    const { page = 0, perPage: perPageInput, orderBy, authorId, metadata, status } = args || {};
     const { field, direction } = this.parseOrderBy(orderBy);
     this.logger.debug(`InMemoryScorerDefinitionsStorage: list called`);
     const perPage = normalizePerPage(perPageInput, 100);
@@ -3129,13 +2989,16 @@ var InMemoryScorerDefinitionsStorage = class extends ScorerDefinitionsStorage {
       throw new Error("page value too large");
     }
     let scorers = Array.from(this.db.scorerDefinitions.values());
+    if (status) {
+      scorers = scorers.filter((scorer) => scorer.status === status);
+    }
     if (authorId !== void 0) {
       scorers = scorers.filter((scorer) => scorer.authorId === authorId);
     }
     if (metadata && Object.keys(metadata).length > 0) {
       scorers = scorers.filter((scorer) => {
         if (!scorer.metadata) return false;
-        return Object.entries(metadata).every(([key, value]) => chunk65PHUUMF_cjs.deepEqual(scorer.metadata[key], value));
+        return Object.entries(metadata).every(([key, value]) => chunkQDH6MVJ7_cjs.deepEqual(scorer.metadata[key], value));
       });
     }
     const sortedScorers = this.sortScorers(scorers, field, direction);
@@ -3448,84 +3311,393 @@ var ScoresInMemory = class extends ScoresStorage {
   }
 };
 
-// src/workflows/evented/types.ts
-var PENDING_MARKER_KEY = "__mastra_pending__";
-function createPendingMarker() {
-  return { [PENDING_MARKER_KEY]: true };
-}
-function isPendingMarker(val) {
-  return val !== null && typeof val === "object" && PENDING_MARKER_KEY in val && val[PENDING_MARKER_KEY] === true;
-}
-
-// src/storage/domains/workflows/base.ts
-var WorkflowsStorage = class extends StorageDomain {
+// src/storage/domains/skills/base.ts
+var SkillsStorage = class extends VersionedStorageDomain {
+  listKey = "skills";
+  versionMetadataFields = [
+    "id",
+    "skillId",
+    "versionNumber",
+    "changedFields",
+    "changeMessage",
+    "createdAt"
+  ];
   constructor() {
     super({
       component: "STORAGE",
-      name: "WORKFLOWS"
+      name: "SKILLS"
     });
   }
 };
 
-// src/storage/domains/workflows/inmemory.ts
-var WorkflowsInMemory = class extends WorkflowsStorage {
+// src/storage/domains/skills/inmemory.ts
+var InMemorySkillsStorage = class extends SkillsStorage {
   db;
   constructor({ db }) {
     super();
     this.db = db;
   }
   async dangerouslyClearAll() {
-    this.db.workflows.clear();
+    this.db.skills.clear();
+    this.db.skillVersions.clear();
   }
-  getWorkflowKey(workflowName, runId) {
-    return `${workflowName}-${runId}`;
+  // ==========================================================================
+  // Skill CRUD Methods
+  // ==========================================================================
+  async getById(id) {
+    this.logger.debug(`InMemorySkillsStorage: getById called for ${id}`);
+    const config = this.db.skills.get(id);
+    return config ? this.deepCopyConfig(config) : null;
   }
-  async updateWorkflowResults({
-    workflowName,
-    runId,
-    stepId,
-    result,
-    requestContext
-  }) {
-    this.logger.debug(`WorkflowsInMemory: updateWorkflowResults called for ${workflowName} ${runId} ${stepId}`, result);
-    const key = this.getWorkflowKey(workflowName, runId);
-    const run = this.db.workflows.get(key);
-    if (!run) {
-      return {};
+  async create(input) {
+    const { skill } = input;
+    this.logger.debug(`InMemorySkillsStorage: create called for ${skill.id}`);
+    if (this.db.skills.has(skill.id)) {
+      throw new Error(`Skill with id ${skill.id} already exists`);
     }
-    let snapshot;
-    if (!run.snapshot) {
-      snapshot = {
-        context: {},
-        activePaths: [],
-        activeStepsPath: {},
-        timestamp: Date.now(),
-        suspendedPaths: {},
-        resumeLabels: {},
-        serializedStepGraph: [],
-        value: {},
-        waitingPaths: {},
-        status: "pending",
-        runId: run.run_id
-      };
-      this.db.workflows.set(key, {
-        ...run,
-        snapshot
+    const now = /* @__PURE__ */ new Date();
+    const newConfig = {
+      id: skill.id,
+      status: "draft",
+      activeVersionId: void 0,
+      authorId: skill.authorId,
+      createdAt: now,
+      updatedAt: now
+    };
+    this.db.skills.set(skill.id, newConfig);
+    const { id: _id, authorId: _authorId, ...snapshotConfig } = skill;
+    const versionId = crypto$1.randomUUID();
+    try {
+      await this.createVersion({
+        id: versionId,
+        skillId: skill.id,
+        versionNumber: 1,
+        ...snapshotConfig,
+        changedFields: Object.keys(snapshotConfig),
+        changeMessage: "Initial version"
       });
-    } else {
-      snapshot = typeof run.snapshot === "string" ? JSON.parse(run.snapshot) : run.snapshot;
+    } catch (error) {
+      this.db.skills.delete(skill.id);
+      throw error;
     }
-    if (!snapshot || !snapshot?.context) {
-      throw new Error(`Snapshot not found for runId ${runId}`);
+    return this.deepCopyConfig(newConfig);
+  }
+  async update(input) {
+    const { id, ...updates } = input;
+    this.logger.debug(`InMemorySkillsStorage: update called for ${id}`);
+    const existingConfig = this.db.skills.get(id);
+    if (!existingConfig) {
+      throw new Error(`Skill with id ${id} not found`);
     }
-    const existingResult = snapshot.context[stepId];
-    if (existingResult && "output" in existingResult && Array.isArray(existingResult.output) && result && typeof result === "object" && "output" in result && Array.isArray(result.output)) {
-      const existingOutput = existingResult.output;
-      const newOutput = result.output;
-      const mergedOutput = [...existingOutput];
-      for (let i = 0; i < Math.max(existingOutput.length, newOutput.length); i++) {
-        if (i < newOutput.length) {
-          const newVal = newOutput[i];
+    const { authorId, activeVersionId, status, ...configFields } = updates;
+    const configFieldNames = [
+      "name",
+      "description",
+      "instructions",
+      "license",
+      "compatibility",
+      "source",
+      "references",
+      "scripts",
+      "assets",
+      "metadata",
+      "tree"
+    ];
+    const hasConfigUpdate = configFieldNames.some((field) => field in configFields);
+    const updatedConfig = {
+      ...existingConfig,
+      ...authorId !== void 0 && { authorId },
+      ...activeVersionId !== void 0 && { activeVersionId },
+      ...status !== void 0 && { status },
+      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 skill ${id}`);
+      }
+      const {
+        id: _versionId,
+        skillId: _skillId,
+        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$1.randomUUID();
+        const newVersionNumber = latestVersion.versionNumber + 1;
+        await this.createVersion({
+          id: newVersionId,
+          skillId: id,
+          versionNumber: newVersionNumber,
+          ...newConfig,
+          changedFields,
+          changeMessage: `Updated ${changedFields.join(", ")}`
+        });
+      }
+    }
+    this.db.skills.set(id, updatedConfig);
+    return this.deepCopyConfig(updatedConfig);
+  }
+  async delete(id) {
+    this.logger.debug(`InMemorySkillsStorage: delete called for ${id}`);
+    this.db.skills.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(`InMemorySkillsStorage: 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.skills.values());
+    if (authorId !== void 0) {
+      configs = configs.filter((config) => config.authorId === authorId);
+    }
+    if (metadata && Object.keys(metadata).length > 0) {
+      configs = configs.filter((_config) => {
+        return false;
+      });
+    }
+    const sortedConfigs = this.sortConfigs(configs, field, direction);
+    const clonedConfigs = sortedConfigs.map((config) => this.deepCopyConfig(config));
+    const { offset, perPage: perPageForResponse } = calculatePagination(page, perPageInput, perPage);
+    return {
+      skills: clonedConfigs.slice(offset, offset + perPage),
+      total: clonedConfigs.length,
+      page,
+      perPage: perPageForResponse,
+      hasMore: offset + perPage < clonedConfigs.length
+    };
+  }
+  // ==========================================================================
+  // Skill Version Methods
+  // ==========================================================================
+  async createVersion(input) {
+    this.logger.debug(`InMemorySkillsStorage: createVersion called for skill ${input.skillId}`);
+    if (this.db.skillVersions.has(input.id)) {
+      throw new Error(`Version with id ${input.id} already exists`);
+    }
+    for (const version2 of this.db.skillVersions.values()) {
+      if (version2.skillId === input.skillId && version2.versionNumber === input.versionNumber) {
+        throw new Error(`Version number ${input.versionNumber} already exists for skill ${input.skillId}`);
+      }
+    }
+    const version = {
+      ...input,
+      createdAt: /* @__PURE__ */ new Date()
+    };
+    this.db.skillVersions.set(input.id, this.deepCopyVersion(version));
+    return this.deepCopyVersion(version);
+  }
+  async getVersion(id) {
+    this.logger.debug(`InMemorySkillsStorage: getVersion called for ${id}`);
+    const version = this.db.skillVersions.get(id);
+    return version ? this.deepCopyVersion(version) : null;
+  }
+  async getVersionByNumber(skillId, versionNumber) {
+    this.logger.debug(`InMemorySkillsStorage: getVersionByNumber called for skill ${skillId}, v${versionNumber}`);
+    for (const version of this.db.skillVersions.values()) {
+      if (version.skillId === skillId && version.versionNumber === versionNumber) {
+        return this.deepCopyVersion(version);
+      }
+    }
+    return null;
+  }
+  async getLatestVersion(skillId) {
+    this.logger.debug(`InMemorySkillsStorage: getLatestVersion called for skill ${skillId}`);
+    let latest = null;
+    for (const version of this.db.skillVersions.values()) {
+      if (version.skillId === skillId) {
+        if (!latest || version.versionNumber > latest.versionNumber) {
+          latest = version;
+        }
+      }
+    }
+    return latest ? this.deepCopyVersion(latest) : null;
+  }
+  async listVersions(input) {
+    const { skillId, page = 0, perPage: perPageInput, orderBy } = input;
+    const { field, direction } = this.parseVersionOrderBy(orderBy);
+    this.logger.debug(`InMemorySkillsStorage: listVersions called for skill ${skillId}`);
+    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.skillVersions.values()).filter((v) => v.skillId === skillId);
+    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(`InMemorySkillsStorage: deleteVersion called for ${id}`);
+    this.db.skillVersions.delete(id);
+  }
+  async deleteVersionsByParentId(entityId) {
+    this.logger.debug(`InMemorySkillsStorage: deleteVersionsByParentId called for skill ${entityId}`);
+    const idsToDelete = [];
+    for (const [id, version] of this.db.skillVersions.entries()) {
+      if (version.skillId === entityId) {
+        idsToDelete.push(id);
+      }
+    }
+    for (const id of idsToDelete) {
+      this.db.skillVersions.delete(id);
+    }
+  }
+  async countVersions(skillId) {
+    this.logger.debug(`InMemorySkillsStorage: countVersions called for skill ${skillId}`);
+    let count = 0;
+    for (const version of this.db.skillVersions.values()) {
+      if (version.skillId === skillId) {
+        count++;
+      }
+    }
+    return count;
+  }
+  // ==========================================================================
+  // Private Helper Methods
+  // ==========================================================================
+  deepCopyConfig(config) {
+    return {
+      ...config
+    };
+  }
+  deepCopyVersion(version) {
+    return structuredClone(version);
+  }
+  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;
+    });
+  }
+};
+
+// src/workflows/evented/types.ts
+var PENDING_MARKER_KEY = "__mastra_pending__";
+function createPendingMarker() {
+  return { [PENDING_MARKER_KEY]: true };
+}
+function isPendingMarker(val) {
+  return val !== null && typeof val === "object" && PENDING_MARKER_KEY in val && val[PENDING_MARKER_KEY] === true;
+}
+
+// src/storage/domains/workflows/base.ts
+var WorkflowsStorage = class extends StorageDomain {
+  constructor() {
+    super({
+      component: "STORAGE",
+      name: "WORKFLOWS"
+    });
+  }
+};
+
+// src/storage/domains/workflows/inmemory.ts
+var WorkflowsInMemory = class extends WorkflowsStorage {
+  db;
+  constructor({ db }) {
+    super();
+    this.db = db;
+  }
+  async dangerouslyClearAll() {
+    this.db.workflows.clear();
+  }
+  getWorkflowKey(workflowName, runId) {
+    return `${workflowName}-${runId}`;
+  }
+  async updateWorkflowResults({
+    workflowName,
+    runId,
+    stepId,
+    result,
+    requestContext
+  }) {
+    this.logger.debug(`WorkflowsInMemory: updateWorkflowResults called for ${workflowName} ${runId} ${stepId}`, result);
+    const key = this.getWorkflowKey(workflowName, runId);
+    const run = this.db.workflows.get(key);
+    if (!run) {
+      return {};
+    }
+    let snapshot;
+    if (!run.snapshot) {
+      snapshot = {
+        context: {},
+        activePaths: [],
+        activeStepsPath: {},
+        timestamp: Date.now(),
+        suspendedPaths: {},
+        resumeLabels: {},
+        serializedStepGraph: [],
+        value: {},
+        waitingPaths: {},
+        status: "pending",
+        runId: run.run_id
+      };
+      this.db.workflows.set(key, {
+        ...run,
+        snapshot
+      });
+    } else {
+      snapshot = typeof run.snapshot === "string" ? JSON.parse(run.snapshot) : run.snapshot;
+    }
+    if (!snapshot || !snapshot?.context) {
+      throw new Error(`Snapshot not found for runId ${runId}`);
+    }
+    const existingResult = snapshot.context[stepId];
+    if (existingResult && "output" in existingResult && Array.isArray(existingResult.output) && result && typeof result === "object" && "output" in result && Array.isArray(result.output)) {
+      const existingOutput = existingResult.output;
+      const newOutput = result.output;
+      const mergedOutput = [...existingOutput];
+      for (let i = 0; i < Math.max(existingOutput.length, newOutput.length); i++) {
+        if (i < newOutput.length) {
+          const newVal = newOutput[i];
           if (isPendingMarker(newVal)) {
             mergedOutput[i] = null;
           } else if (newVal !== null) {
@@ -3580,132 +3752,443 @@ var WorkflowsInMemory = class extends WorkflowsStorage {
     } else {
       snapshot = typeof run.snapshot === "string" ? JSON.parse(run.snapshot) : run.snapshot;
     }
-    if (!snapshot || !snapshot?.context) {
-      throw new Error(`Snapshot not found for runId ${runId}`);
+    if (!snapshot || !snapshot?.context) {
+      throw new Error(`Snapshot not found for runId ${runId}`);
+    }
+    snapshot = { ...snapshot, ...opts };
+    this.db.workflows.set(key, {
+      ...run,
+      snapshot
+    });
+    return snapshot;
+  }
+  async persistWorkflowSnapshot({
+    workflowName,
+    runId,
+    resourceId,
+    snapshot,
+    createdAt,
+    updatedAt
+  }) {
+    const key = this.getWorkflowKey(workflowName, runId);
+    const now = /* @__PURE__ */ new Date();
+    const data = {
+      workflow_name: workflowName,
+      run_id: runId,
+      resourceId,
+      snapshot,
+      createdAt: createdAt ?? now,
+      updatedAt: updatedAt ?? now
+    };
+    this.db.workflows.set(key, data);
+  }
+  async loadWorkflowSnapshot({
+    workflowName,
+    runId
+  }) {
+    this.logger.debug("Loading workflow snapshot", { workflowName, runId });
+    const key = this.getWorkflowKey(workflowName, runId);
+    const run = this.db.workflows.get(key);
+    if (!run) {
+      return null;
+    }
+    const snapshot = typeof run.snapshot === "string" ? JSON.parse(run.snapshot) : run.snapshot;
+    return snapshot ? JSON.parse(JSON.stringify(snapshot)) : null;
+  }
+  async listWorkflowRuns({
+    workflowName,
+    fromDate,
+    toDate,
+    perPage,
+    page,
+    resourceId,
+    status
+  } = {}) {
+    if (page !== void 0 && page < 0) {
+      throw new Error("page must be >= 0");
+    }
+    let runs = Array.from(this.db.workflows.values());
+    if (workflowName) runs = runs.filter((run) => run.workflow_name === workflowName);
+    if (status) {
+      runs = runs.filter((run) => {
+        let snapshot = run?.snapshot;
+        if (!snapshot) {
+          return false;
+        }
+        if (typeof snapshot === "string") {
+          try {
+            snapshot = JSON.parse(snapshot);
+          } catch {
+            return false;
+          }
+        } else {
+          snapshot = JSON.parse(JSON.stringify(snapshot));
+        }
+        return snapshot.status === status;
+      });
+    }
+    if (fromDate && toDate) {
+      runs = runs.filter(
+        (run) => new Date(run.createdAt).getTime() >= fromDate.getTime() && new Date(run.createdAt).getTime() <= toDate.getTime()
+      );
+    } else if (fromDate) {
+      runs = runs.filter((run) => new Date(run.createdAt).getTime() >= fromDate.getTime());
+    } else if (toDate) {
+      runs = runs.filter((run) => new Date(run.createdAt).getTime() <= toDate.getTime());
+    }
+    if (resourceId) runs = runs.filter((run) => run.resourceId === resourceId);
+    const total = runs.length;
+    runs.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+    if (perPage !== void 0 && page !== void 0) {
+      const normalizedPerPage = normalizePerPage(perPage, Number.MAX_SAFE_INTEGER);
+      const offset = page * normalizedPerPage;
+      const start = offset;
+      const end = start + normalizedPerPage;
+      runs = runs.slice(start, end);
+    }
+    const parsedRuns = runs.map((run) => ({
+      ...run,
+      snapshot: typeof run.snapshot === "string" ? JSON.parse(run.snapshot) : JSON.parse(JSON.stringify(run.snapshot)),
+      createdAt: new Date(run.createdAt),
+      updatedAt: new Date(run.updatedAt),
+      runId: run.run_id,
+      workflowName: run.workflow_name,
+      resourceId: run.resourceId
+    }));
+    return { runs: parsedRuns, total };
+  }
+  async getWorkflowRunById({
+    runId,
+    workflowName
+  }) {
+    const runs = Array.from(this.db.workflows.values()).filter((r) => r.run_id === runId);
+    let run = runs.find((r) => r.workflow_name === workflowName);
+    if (!run) return null;
+    const parsedRun = {
+      ...run,
+      snapshot: typeof run.snapshot === "string" ? JSON.parse(run.snapshot) : JSON.parse(JSON.stringify(run.snapshot)),
+      createdAt: new Date(run.createdAt),
+      updatedAt: new Date(run.updatedAt),
+      runId: run.run_id,
+      workflowName: run.workflow_name,
+      resourceId: run.resourceId
+    };
+    return parsedRun;
+  }
+  async deleteWorkflowRunById({ runId, workflowName }) {
+    const key = this.getWorkflowKey(workflowName, runId);
+    this.db.workflows.delete(key);
+  }
+};
+
+// src/storage/domains/workspaces/base.ts
+var WorkspacesStorage = class extends VersionedStorageDomain {
+  listKey = "workspaces";
+  versionMetadataFields = [
+    "id",
+    "workspaceId",
+    "versionNumber",
+    "changedFields",
+    "changeMessage",
+    "createdAt"
+  ];
+  constructor() {
+    super({
+      component: "STORAGE",
+      name: "WORKSPACES"
+    });
+  }
+};
+
+// src/storage/domains/workspaces/inmemory.ts
+var InMemoryWorkspacesStorage = class extends WorkspacesStorage {
+  db;
+  constructor({ db }) {
+    super();
+    this.db = db;
+  }
+  async dangerouslyClearAll() {
+    this.db.workspaces.clear();
+    this.db.workspaceVersions.clear();
+  }
+  // ==========================================================================
+  // Workspace CRUD Methods
+  // ==========================================================================
+  async getById(id) {
+    this.logger.debug(`InMemoryWorkspacesStorage: getById called for ${id}`);
+    const config = this.db.workspaces.get(id);
+    return config ? this.deepCopyConfig(config) : null;
+  }
+  async create(input) {
+    const { workspace } = input;
+    this.logger.debug(`InMemoryWorkspacesStorage: create called for ${workspace.id}`);
+    if (this.db.workspaces.has(workspace.id)) {
+      throw new Error(`Workspace with id ${workspace.id} already exists`);
+    }
+    const now = /* @__PURE__ */ new Date();
+    const newConfig = {
+      id: workspace.id,
+      status: "draft",
+      activeVersionId: void 0,
+      authorId: workspace.authorId,
+      metadata: workspace.metadata,
+      createdAt: now,
+      updatedAt: now
+    };
+    this.db.workspaces.set(workspace.id, newConfig);
+    const { id: _id, authorId: _authorId, metadata: _metadata, ...snapshotConfig } = workspace;
+    const versionId = crypto.randomUUID();
+    await this.createVersion({
+      id: versionId,
+      workspaceId: workspace.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(`InMemoryWorkspacesStorage: update called for ${id}`);
+    const existingConfig = this.db.workspaces.get(id);
+    if (!existingConfig) {
+      throw new Error(`Workspace with id ${id} not found`);
+    }
+    const { authorId, activeVersionId, metadata, status, ...configFields } = updates;
+    const configFieldNames = [
+      "name",
+      "description",
+      "filesystem",
+      "sandbox",
+      "mounts",
+      "search",
+      "skills",
+      "tools",
+      "autoSync",
+      "operationTimeout"
+    ];
+    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 workspace ${id}`);
+      }
+      const {
+        id: _versionId,
+        workspaceId: _workspaceId,
+        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,
+          workspaceId: id,
+          versionNumber: newVersionNumber,
+          ...newConfig,
+          changedFields,
+          changeMessage: `Updated ${changedFields.join(", ")}`
+        });
+      }
+    }
+    this.db.workspaces.set(id, updatedConfig);
+    return this.deepCopyConfig(updatedConfig);
+  }
+  async delete(id) {
+    this.logger.debug(`InMemoryWorkspacesStorage: delete called for ${id}`);
+    this.db.workspaces.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(`InMemoryWorkspacesStorage: 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");
     }
-    snapshot = { ...snapshot, ...opts };
-    this.db.workflows.set(key, {
-      ...run,
-      snapshot
-    });
-    return snapshot;
+    let configs = Array.from(this.db.workspaces.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]) => chunkQDH6MVJ7_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 {
+      workspaces: clonedConfigs.slice(offset, offset + perPage),
+      total: clonedConfigs.length,
+      page,
+      perPage: perPageForResponse,
+      hasMore: offset + perPage < clonedConfigs.length
+    };
   }
-  async persistWorkflowSnapshot({
-    workflowName,
-    runId,
-    resourceId,
-    snapshot,
-    createdAt,
-    updatedAt
-  }) {
-    const key = this.getWorkflowKey(workflowName, runId);
-    const now = /* @__PURE__ */ new Date();
-    const data = {
-      workflow_name: workflowName,
-      run_id: runId,
-      resourceId,
-      snapshot,
-      createdAt: createdAt ?? now,
-      updatedAt: updatedAt ?? now
+  // ==========================================================================
+  // Workspace Version Methods
+  // ==========================================================================
+  async createVersion(input) {
+    this.logger.debug(`InMemoryWorkspacesStorage: createVersion called for workspace ${input.workspaceId}`);
+    if (this.db.workspaceVersions.has(input.id)) {
+      throw new Error(`Version with id ${input.id} already exists`);
+    }
+    for (const version2 of this.db.workspaceVersions.values()) {
+      if (version2.workspaceId === input.workspaceId && version2.versionNumber === input.versionNumber) {
+        throw new Error(`Version number ${input.versionNumber} already exists for workspace ${input.workspaceId}`);
+      }
+    }
+    const version = {
+      ...input,
+      createdAt: /* @__PURE__ */ new Date()
     };
-    this.db.workflows.set(key, data);
+    this.db.workspaceVersions.set(input.id, this.deepCopyVersion(version));
+    return this.deepCopyVersion(version);
   }
-  async loadWorkflowSnapshot({
-    workflowName,
-    runId
-  }) {
-    this.logger.debug("Loading workflow snapshot", { workflowName, runId });
-    const key = this.getWorkflowKey(workflowName, runId);
-    const run = this.db.workflows.get(key);
-    if (!run) {
-      return null;
+  async getVersion(id) {
+    this.logger.debug(`InMemoryWorkspacesStorage: getVersion called for ${id}`);
+    const version = this.db.workspaceVersions.get(id);
+    return version ? this.deepCopyVersion(version) : null;
+  }
+  async getVersionByNumber(workspaceId, versionNumber) {
+    this.logger.debug(
+      `InMemoryWorkspacesStorage: getVersionByNumber called for workspace ${workspaceId}, v${versionNumber}`
+    );
+    for (const version of this.db.workspaceVersions.values()) {
+      if (version.workspaceId === workspaceId && version.versionNumber === versionNumber) {
+        return this.deepCopyVersion(version);
+      }
     }
-    const snapshot = typeof run.snapshot === "string" ? JSON.parse(run.snapshot) : run.snapshot;
-    return snapshot ? JSON.parse(JSON.stringify(snapshot)) : null;
+    return null;
   }
-  async listWorkflowRuns({
-    workflowName,
-    fromDate,
-    toDate,
-    perPage,
-    page,
-    resourceId,
-    status
-  } = {}) {
-    if (page !== void 0 && page < 0) {
+  async getLatestVersion(workspaceId) {
+    this.logger.debug(`InMemoryWorkspacesStorage: getLatestVersion called for workspace ${workspaceId}`);
+    let latest = null;
+    for (const version of this.db.workspaceVersions.values()) {
+      if (version.workspaceId === workspaceId) {
+        if (!latest || version.versionNumber > latest.versionNumber) {
+          latest = version;
+        }
+      }
+    }
+    return latest ? this.deepCopyVersion(latest) : null;
+  }
+  async listVersions(input) {
+    const { workspaceId, page = 0, perPage: perPageInput, orderBy } = input;
+    const { field, direction } = this.parseVersionOrderBy(orderBy);
+    this.logger.debug(`InMemoryWorkspacesStorage: listVersions called for workspace ${workspaceId}`);
+    const perPage = normalizePerPage(perPageInput, 20);
+    if (page < 0) {
       throw new Error("page must be >= 0");
     }
-    let runs = Array.from(this.db.workflows.values());
-    if (workflowName) runs = runs.filter((run) => run.workflow_name === workflowName);
-    if (status) {
-      runs = runs.filter((run) => {
-        let snapshot = run?.snapshot;
-        if (!snapshot) {
-          return false;
-        }
-        if (typeof snapshot === "string") {
-          try {
-            snapshot = JSON.parse(snapshot);
-          } catch {
-            return false;
-          }
-        } else {
-          snapshot = JSON.parse(JSON.stringify(snapshot));
-        }
-        return snapshot.status === status;
-      });
+    const maxOffset = Number.MAX_SAFE_INTEGER / 2;
+    if (page * perPage > maxOffset) {
+      throw new Error("page value too large");
     }
-    if (fromDate && toDate) {
-      runs = runs.filter(
-        (run) => new Date(run.createdAt).getTime() >= fromDate.getTime() && new Date(run.createdAt).getTime() <= toDate.getTime()
-      );
-    } else if (fromDate) {
-      runs = runs.filter((run) => new Date(run.createdAt).getTime() >= fromDate.getTime());
-    } else if (toDate) {
-      runs = runs.filter((run) => new Date(run.createdAt).getTime() <= toDate.getTime());
+    let versions = Array.from(this.db.workspaceVersions.values()).filter((v) => v.workspaceId === workspaceId);
+    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(`InMemoryWorkspacesStorage: deleteVersion called for ${id}`);
+    this.db.workspaceVersions.delete(id);
+  }
+  async deleteVersionsByParentId(entityId) {
+    this.logger.debug(`InMemoryWorkspacesStorage: deleteVersionsByParentId called for workspace ${entityId}`);
+    const idsToDelete = [];
+    for (const [id, version] of this.db.workspaceVersions.entries()) {
+      if (version.workspaceId === entityId) {
+        idsToDelete.push(id);
+      }
     }
-    if (resourceId) runs = runs.filter((run) => run.resourceId === resourceId);
-    const total = runs.length;
-    runs.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
-    if (perPage !== void 0 && page !== void 0) {
-      const normalizedPerPage = normalizePerPage(perPage, Number.MAX_SAFE_INTEGER);
-      const offset = page * normalizedPerPage;
-      const start = offset;
-      const end = start + normalizedPerPage;
-      runs = runs.slice(start, end);
+    for (const id of idsToDelete) {
+      this.db.workspaceVersions.delete(id);
     }
-    const parsedRuns = runs.map((run) => ({
-      ...run,
-      snapshot: typeof run.snapshot === "string" ? JSON.parse(run.snapshot) : JSON.parse(JSON.stringify(run.snapshot)),
-      createdAt: new Date(run.createdAt),
-      updatedAt: new Date(run.updatedAt),
-      runId: run.run_id,
-      workflowName: run.workflow_name,
-      resourceId: run.resourceId
-    }));
-    return { runs: parsedRuns, total };
   }
-  async getWorkflowRunById({
-    runId,
-    workflowName
-  }) {
-    const runs = Array.from(this.db.workflows.values()).filter((r) => r.run_id === runId);
-    let run = runs.find((r) => r.workflow_name === workflowName);
-    if (!run) return null;
-    const parsedRun = {
-      ...run,
-      snapshot: typeof run.snapshot === "string" ? JSON.parse(run.snapshot) : JSON.parse(JSON.stringify(run.snapshot)),
-      createdAt: new Date(run.createdAt),
-      updatedAt: new Date(run.updatedAt),
-      runId: run.run_id,
-      workflowName: run.workflow_name,
-      resourceId: run.resourceId
+  async countVersions(workspaceId) {
+    this.logger.debug(`InMemoryWorkspacesStorage: countVersions called for workspace ${workspaceId}`);
+    let count = 0;
+    for (const version of this.db.workspaceVersions.values()) {
+      if (version.workspaceId === workspaceId) {
+        count++;
+      }
+    }
+    return count;
+  }
+  // ==========================================================================
+  // Private Helper Methods
+  // ==========================================================================
+  deepCopyConfig(config) {
+    return {
+      ...config,
+      metadata: config.metadata ? { ...config.metadata } : config.metadata
     };
-    return parsedRun;
   }
-  async deleteWorkflowRunById({ runId, workflowName }) {
-    const key = this.getWorkflowKey(workflowName, runId);
-    this.db.workflows.delete(key);
+  deepCopyVersion(version) {
+    return structuredClone(version);
+  }
+  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;
+    });
   }
 };
 
@@ -3730,7 +4213,9 @@ var InMemoryStore = class extends MastraCompositeStore {
       agents: new InMemoryAgentsStorage({ db: this.#db }),
       promptBlocks: new InMemoryPromptBlocksStorage({ db: this.#db }),
       scorerDefinitions: new InMemoryScorerDefinitionsStorage({ db: this.#db }),
-      mcpClients: new InMemoryMCPClientsStorage({ db: this.#db })
+      mcpClients: new InMemoryMCPClientsStorage({ db: this.#db }),
+      workspaces: new InMemoryWorkspacesStorage({ db: this.#db }),
+      skills: new InMemorySkillsStorage({ db: this.#db })
     };
   }
   /**
@@ -3744,6 +4229,55 @@ var InMemoryStore = class extends MastraCompositeStore {
 };
 var MockStore = InMemoryStore;
 
+// src/storage/domains/blobs/base.ts
+var BlobStore = class extends chunkRO47SMI7_cjs.MastraBase {
+  constructor() {
+    super({
+      component: "STORAGE",
+      name: "BLOBS"
+    });
+  }
+};
+
+// src/storage/domains/blobs/inmemory.ts
+var InMemoryBlobStore = class extends BlobStore {
+  #blobs = /* @__PURE__ */ new Map();
+  async init() {
+  }
+  async put(entry) {
+    if (!this.#blobs.has(entry.hash)) {
+      this.#blobs.set(entry.hash, entry);
+    }
+  }
+  async get(hash) {
+    return this.#blobs.get(hash) ?? null;
+  }
+  async has(hash) {
+    return this.#blobs.has(hash);
+  }
+  async delete(hash) {
+    return this.#blobs.delete(hash);
+  }
+  async putMany(entries) {
+    for (const entry of entries) {
+      await this.put(entry);
+    }
+  }
+  async getMany(hashes) {
+    const result = /* @__PURE__ */ new Map();
+    for (const hash of hashes) {
+      const blob = this.#blobs.get(hash);
+      if (blob) {
+        result.set(hash, blob);
+      }
+    }
+    return result;
+  }
+  async dangerouslyClearAll() {
+    this.#blobs.clear();
+  }
+};
+
 // src/storage/domains/operations/base.ts
 var StoreOperations = class extends chunkRO47SMI7_cjs.MastraBase {
   constructor() {
@@ -3872,6 +4406,11 @@ var StoreOperationsInMemory = class extends StoreOperations {
       mastra_scorer_definition_versions: /* @__PURE__ */ new Map(),
       mastra_mcp_clients: /* @__PURE__ */ new Map(),
       mastra_mcp_client_versions: /* @__PURE__ */ new Map(),
+      mastra_workspaces: /* @__PURE__ */ new Map(),
+      mastra_workspace_versions: /* @__PURE__ */ new Map(),
+      mastra_skills: /* @__PURE__ */ new Map(),
+      mastra_skill_versions: /* @__PURE__ */ new Map(),
+      mastra_skill_blobs: /* @__PURE__ */ new Map(),
       mastra_datasets: /* @__PURE__ */ new Map(),
       mastra_dataset_items: /* @__PURE__ */ new Map(),
       mastra_dataset_versions: /* @__PURE__ */ new Map(),
@@ -3885,7 +4424,7 @@ var StoreOperationsInMemory = class extends StoreOperations {
   async insert({ tableName, record }) {
     const table = this.data[tableName];
     let key = record.id;
-    if ([chunkSU5APAM6_cjs.TABLE_WORKFLOW_SNAPSHOT].includes(tableName) && !record.id && record.run_id) {
+    if ([chunkKNXZ7KYL_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) {
@@ -3898,7 +4437,7 @@ var StoreOperationsInMemory = class extends StoreOperations {
     const table = this.data[tableName];
     for (const record of records) {
       let key = record.id;
-      if ([chunkSU5APAM6_cjs.TABLE_WORKFLOW_SNAPSHOT].includes(tableName) && !record.id && record.run_id) {
+      if ([chunkKNXZ7KYL_cjs.TABLE_WORKFLOW_SNAPSHOT].includes(tableName) && !record.id && record.run_id) {
         key = record.run_id;
         record.id = key;
       } else if (!record.id) {
@@ -4189,6 +4728,13 @@ function toDatasetItem(row) {
     updatedAt: row.updatedAt
   };
 }
+function toDatasetRecord(record) {
+  return {
+    ...record,
+    inputSchema: record.inputSchema ?? void 0,
+    groundTruthSchema: record.groundTruthSchema ?? void 0
+  };
+}
 var DatasetsInMemory = class extends DatasetsStorage {
   db;
   constructor({ db }) {
@@ -4216,10 +4762,11 @@ var DatasetsInMemory = class extends DatasetsStorage {
       updatedAt: now
     };
     this.db.datasets.set(id, dataset);
-    return dataset;
+    return toDatasetRecord(dataset);
   }
   async getDatasetById({ id }) {
-    return this.db.datasets.get(id) ?? null;
+    const record = this.db.datasets.get(id);
+    return record ? toDatasetRecord(record) : null;
   }
   async _doUpdateDataset(args) {
     const existing = this.db.datasets.get(args.id);
@@ -4236,7 +4783,7 @@ var DatasetsInMemory = class extends DatasetsStorage {
       updatedAt: /* @__PURE__ */ new Date()
     };
     this.db.datasets.set(args.id, updated);
-    return updated;
+    return toDatasetRecord(updated);
   }
   async deleteDataset({ id }) {
     for (const [itemId, rows] of this.db.datasetItems) {
@@ -4264,7 +4811,7 @@ var DatasetsInMemory = class extends DatasetsStorage {
     const { offset: start, perPage: perPageForResponse } = calculatePagination(page, perPageInput, perPage);
     const end = perPageInput === false ? datasets.length : start + perPage;
     return {
-      datasets: datasets.slice(start, end),
+      datasets: datasets.slice(start, end).map(toDatasetRecord),
       pagination: {
         total: datasets.length,
         page,
@@ -4682,17 +5229,21 @@ var ExperimentsInMemory = class extends ExperimentsStorage {
 };
 
 exports.AgentsStorage = AgentsStorage;
+exports.BlobStore = BlobStore;
 exports.DatasetsInMemory = DatasetsInMemory;
 exports.DatasetsStorage = DatasetsStorage;
 exports.ExperimentsInMemory = ExperimentsInMemory;
 exports.ExperimentsStorage = ExperimentsStorage;
 exports.InMemoryAgentsStorage = InMemoryAgentsStorage;
+exports.InMemoryBlobStore = InMemoryBlobStore;
 exports.InMemoryDB = InMemoryDB;
 exports.InMemoryMCPClientsStorage = InMemoryMCPClientsStorage;
 exports.InMemoryMemory = InMemoryMemory;
 exports.InMemoryPromptBlocksStorage = InMemoryPromptBlocksStorage;
 exports.InMemoryScorerDefinitionsStorage = InMemoryScorerDefinitionsStorage;
+exports.InMemorySkillsStorage = InMemorySkillsStorage;
 exports.InMemoryStore = InMemoryStore;
+exports.InMemoryWorkspacesStorage = InMemoryWorkspacesStorage;
 exports.MCPClientsStorage = MCPClientsStorage;
 exports.MastraCompositeStore = MastraCompositeStore;
 exports.MastraStorage = MastraStorage;
@@ -4707,12 +5258,14 @@ exports.SchemaValidator = SchemaValidator;
 exports.ScorerDefinitionsStorage = ScorerDefinitionsStorage;
 exports.ScoresInMemory = ScoresInMemory;
 exports.ScoresStorage = ScoresStorage;
+exports.SkillsStorage = SkillsStorage;
 exports.StorageDomain = StorageDomain;
 exports.StoreOperations = StoreOperations;
 exports.StoreOperationsInMemory = StoreOperationsInMemory;
 exports.VersionedStorageDomain = VersionedStorageDomain;
 exports.WorkflowsInMemory = WorkflowsInMemory;
 exports.WorkflowsStorage = WorkflowsStorage;
+exports.WorkspacesStorage = WorkspacesStorage;
 exports.calculatePagination = calculatePagination;
 exports.createPendingMarker = createPendingMarker;
 exports.createStorageErrorId = createStorageErrorId;
@@ -4730,5 +5283,5 @@ exports.safelyParseJSON = safelyParseJSON;
 exports.serializeDate = serializeDate;
 exports.transformRow = transformRow;
 exports.transformScoreRow = transformScoreRow;
-//# sourceMappingURL=chunk-BP7VYTOP.cjs.map
-//# sourceMappingURL=chunk-BP7VYTOP.cjs.map
+//# sourceMappingURL=chunk-JZ6TH4HQ.cjs.map
+//# sourceMappingURL=chunk-JZ6TH4HQ.cjs.map