@mastra/editor 0.4.0 → 0.5.0-alpha.0

package/dist/index.cjs

@@ -36,8 +36,12 @@ __export(index_exports, {
   EditorNamespace: () => EditorNamespace,
   EditorPromptNamespace: () => EditorPromptNamespace,
   EditorScorerNamespace: () => EditorScorerNamespace,
+  EditorSkillNamespace: () => EditorSkillNamespace,
+  EditorWorkspaceNamespace: () => EditorWorkspaceNamespace,
   MastraEditor: () => MastraEditor,
   evaluateRuleGroup: () => evaluateRuleGroup,
+  localFilesystemProvider: () => localFilesystemProvider,
+  localSandboxProvider: () => localSandboxProvider,
   renderTemplate: () => renderTemplate,
   resolveInstructionBlocks: () => resolveInstructionBlocks
 });
@@ -93,7 +97,7 @@ var CrudEditorNamespace = class extends EditorNamespace {
   }
   async getById(id, options) {
     this.ensureRegistered();
-    const isVersionRequest = options?.versionId || options?.versionNumber;
+    const isVersionRequest = options?.versionId || options?.versionNumber || options?.status;
     if (!isVersionRequest) {
       const cached = this._cache.get(id);
       if (cached) {
@@ -162,8 +166,10 @@ var CrudEditorNamespace = class extends EditorNamespace {
 };
 
 // src/namespaces/agent.ts
+var import_node_crypto = require("crypto");
 var import_memory = require("@mastra/memory");
 var import_agent = require("@mastra/core/agent");
+var import_workspace = require("@mastra/core/workspace");
 var import_schema_compat = require("@mastra/schema-compat");
 var import_request_context = require("@mastra/core/request-context");
 
@@ -335,7 +341,7 @@ var EditorMCPNamespace = class _EditorMCPNamespace extends CrudEditorNamespace {
   onCacheEvict(_id) {
   }
   async getStorageAdapter() {
-    const storage = this.mastra.getStorage();
+    const storage = this.mastra?.getStorage();
     if (!storage) throw new Error("Storage is not configured");
     const store = await storage.getStore("mcpClients");
     if (!store) throw new Error("MCP clients storage domain is not available");
@@ -382,7 +388,7 @@ var EditorMCPNamespace = class _EditorMCPNamespace extends CrudEditorNamespace {
 // src/namespaces/agent.ts
 var EditorAgentNamespace = class extends CrudEditorNamespace {
   async getStorageAdapter() {
-    const storage = this.mastra.getStorage();
+    const storage = this.mastra?.getStorage();
     if (!storage) throw new Error("Storage is not configured");
     const store = await storage.getStore("agents");
     if (!store) throw new Error("Agents storage domain is not available");
@@ -395,7 +401,7 @@ var EditorAgentNamespace = class extends CrudEditorNamespace {
           const version = options.versionId ? await store.getVersion(options.versionId) : await store.getVersionByNumber(id, options.versionNumber);
           if (!version) return null;
           const {
-            id: _vId,
+            id: versionId,
             agentId: _aId,
             versionNumber: _vn,
             changedFields: _cf,
@@ -403,9 +409,9 @@ var EditorAgentNamespace = class extends CrudEditorNamespace {
             createdAt: _ca,
             ...snapshotConfig
           } = version;
-          return { ...agent, ...snapshotConfig };
+          return { ...agent, ...snapshotConfig, resolvedVersionId: versionId };
         }
-        return store.getByIdResolved(id);
+        return store.getByIdResolved(id, options?.status ? { status: options.status } : void 0);
       },
       update: (input) => store.update(input),
       delete: (id) => store.delete(id),
@@ -422,6 +428,33 @@ var EditorAgentNamespace = class extends CrudEditorNamespace {
   onCacheEvict(id) {
     this.mastra?.removeAgent(id);
   }
+  /**
+   * Evict all cached agents that reference a given skill ID.
+   * Called by EditorSkillNamespace after a skill is published so that
+   * subsequent agent.getById() calls re-hydrate with the updated skill version.
+   */
+  invalidateAgentsReferencingSkill(skillId) {
+    for (const [agentId, agent] of this._cache.entries()) {
+      const raw = agent.toRawConfig?.();
+      if (!raw?.skills) continue;
+      const skillsField = raw.skills;
+      let found = false;
+      if (Array.isArray(skillsField)) {
+        found = skillsField.some(
+          (variant) => variant?.value && skillId in variant.value
+        );
+      } else if (typeof skillsField === "object" && skillsField !== null) {
+        found = skillId in skillsField;
+      }
+      if (found) {
+        this.logger?.debug(
+          `[invalidateAgentsReferencingSkill] Evicting agent "${agentId}" (references skill "${skillId}")`
+        );
+        this._cache.delete(agentId);
+        this.onCacheEvict(agentId);
+      }
+    }
+  }
   // ============================================================================
   // Private helpers
   // ============================================================================
@@ -478,6 +511,7 @@ var EditorAgentNamespace = class extends CrudEditorNamespace {
     const hasConditionalOutputProcessors = storedAgent.outputProcessors != null && this.isConditionalVariants(storedAgent.outputProcessors);
     const hasConditionalDefaultOptions = storedAgent.defaultOptions != null && this.isConditionalVariants(storedAgent.defaultOptions);
     const hasConditionalModel = this.isConditionalVariants(storedAgent.model);
+    const hasConditionalWorkspace = storedAgent.workspace != null && this.isConditionalVariants(storedAgent.workspace);
     const isDynamicTools = hasConditionalTools || hasConditionalMCPClients || hasConditionalIntegrationTools;
     let tools;
     if (isDynamicTools) {
@@ -512,16 +546,20 @@ var EditorAgentNamespace = class extends CrudEditorNamespace {
     }
     const workflows = hasConditionalWorkflows ? ({ requestContext }) => {
       const ctx = requestContext.toJSON();
-      const resolved = this.accumulateArrayVariants(
-        storedAgent.workflows,
+      const variants = storedAgent.workflows;
+      const isArrayVariant = Array.isArray(variants[0]?.value);
+      const resolved = isArrayVariant ? this.accumulateArrayVariants(variants, ctx) : this.accumulateObjectVariants(
+        variants,
         ctx
       );
       return this.resolveStoredWorkflows(resolved);
     } : this.resolveStoredWorkflows(storedAgent.workflows);
     const agents = hasConditionalAgents ? ({ requestContext }) => {
       const ctx = requestContext.toJSON();
-      const resolved = this.accumulateArrayVariants(
-        storedAgent.agents,
+      const variants = storedAgent.agents;
+      const isArrayVariant = Array.isArray(variants[0]?.value);
+      const resolved = isArrayVariant ? this.accumulateArrayVariants(variants, ctx) : this.accumulateObjectVariants(
+        variants,
         ctx
       );
       return this.resolveStoredAgents(resolved);
@@ -625,6 +663,16 @@ var EditorAgentNamespace = class extends CrudEditorNamespace {
       };
     }
     const requestContextSchema = storedAgent.requestContextSchema ? (0, import_schema_compat.convertSchemaToZod)(storedAgent.requestContextSchema) : void 0;
+    const skillSource = await this.resolveAgentSkillSource(storedAgent.skills);
+    const workspace = hasConditionalWorkspace ? async ({ requestContext }) => {
+      const ctx = requestContext.toJSON();
+      const resolvedRef = this.accumulateObjectVariants(
+        storedAgent.workspace,
+        ctx
+      );
+      return this.resolveStoredWorkspace(resolvedRef, skillSource);
+    } : await this.resolveStoredWorkspace(storedAgent.workspace, skillSource);
+    const skillsFormat = storedAgent.skillsFormat;
     const agent = new import_agent.Agent({
       id: storedAgent.id,
       name: storedAgent.name,
@@ -641,7 +689,9 @@ var EditorAgentNamespace = class extends CrudEditorNamespace {
       outputProcessors,
       rawConfig: storedAgent,
       defaultOptions,
-      requestContextSchema
+      requestContextSchema,
+      workspace,
+      ...skillsFormat && { skillsFormat }
     });
     this.mastra?.addAgent(agent, storedAgent.id, { source: "stored" });
     this.logger?.debug(`[createAgentFromStoredConfig] Successfully created agent "${storedAgent.id}"`);
@@ -810,10 +860,13 @@ var EditorAgentNamespace = class extends CrudEditorNamespace {
     return allTools;
   }
   resolveStoredWorkflows(storedWorkflows) {
-    if (!storedWorkflows || storedWorkflows.length === 0) return {};
+    if (!storedWorkflows || (Array.isArray(storedWorkflows) ? storedWorkflows.length === 0 : Object.keys(storedWorkflows).length === 0)) {
+      return {};
+    }
     if (!this.mastra) return {};
+    const normalized = Array.isArray(storedWorkflows) ? Object.fromEntries(storedWorkflows.map((key) => [key, {}])) : storedWorkflows;
     const resolvedWorkflows = {};
-    for (const workflowKey of storedWorkflows) {
+    for (const workflowKey of Object.keys(normalized)) {
       try {
         resolvedWorkflows[workflowKey] = this.mastra.getWorkflow(workflowKey);
       } catch {
@@ -827,10 +880,13 @@ var EditorAgentNamespace = class extends CrudEditorNamespace {
     return resolvedWorkflows;
   }
   resolveStoredAgents(storedAgents) {
-    if (!storedAgents || storedAgents.length === 0) return {};
+    if (!storedAgents || (Array.isArray(storedAgents) ? storedAgents.length === 0 : Object.keys(storedAgents).length === 0)) {
+      return {};
+    }
     if (!this.mastra) return {};
+    const normalized = Array.isArray(storedAgents) ? Object.fromEntries(storedAgents.map((key) => [key, {}])) : storedAgents;
     const resolvedAgents = {};
-    for (const agentKey of storedAgents) {
+    for (const agentKey of Object.keys(normalized)) {
       try {
         resolvedAgents[agentKey] = this.mastra.getAgent(agentKey);
       } catch {
@@ -1007,8 +1063,8 @@ var EditorAgentNamespace = class extends CrudEditorNamespace {
     const toolKeys = Object.keys(tools || {});
     const workflows = await agent.listWorkflows({ requestContext });
     const workflowKeys = Object.keys(workflows || {});
-    const agents = await agent.listAgents({ requestContext });
-    const agentKeys = Object.keys(agents || {});
+    const agentsResolved = await agent.listAgents({ requestContext });
+    const agentKeys = Object.keys(agentsResolved || {});
     const memory = await agent.getMemory({ requestContext });
     const memoryConfig = memory?.getConfig();
     const { inputProcessorIds, outputProcessorIds } = await agent.getConfiguredProcessorIds(requestContext);
@@ -1045,8 +1101,8 @@ var EditorAgentNamespace = class extends CrudEditorNamespace {
       instructions: instructionsStr,
       model,
       tools: toolKeys.length > 0 ? Object.fromEntries(toolKeys.map((key) => [key, {}])) : void 0,
-      workflows: workflowKeys.length > 0 ? workflowKeys : void 0,
-      agents: agentKeys.length > 0 ? agentKeys : void 0,
+      workflows: workflowKeys.length > 0 ? Object.fromEntries(workflowKeys.map((key) => [key, {}])) : void 0,
+      agents: agentKeys.length > 0 ? Object.fromEntries(agentKeys.map((key) => [key, {}])) : void 0,
       memory: memoryConfig,
       inputProcessors: inputProcessorKeys,
       outputProcessors: outputProcessorKeys,
@@ -1063,6 +1119,105 @@ var EditorAgentNamespace = class extends CrudEditorNamespace {
     }
     return resolved;
   }
+  // ============================================================================
+  // Workspace Resolution
+  // ============================================================================
+  /**
+   * Resolve a stored workspace reference to a runtime Workspace instance.
+   * Handles both ID-based references (looked up from editor.workspace) and
+   * inline workspace configurations (hydrated directly).
+   *
+   * When a skillSource is provided (from resolveAgentSkillSource), it is passed
+   * to the workspace hydration so the workspace uses versioned blob-backed skills
+   * instead of filesystem-based discovery.
+   */
+  async resolveStoredWorkspace(workspaceRef, skillSource) {
+    if (!workspaceRef) return void 0;
+    const workspaceNs = this.editor.workspace;
+    if (!workspaceNs) {
+      this.logger?.warn("[resolveStoredWorkspace] No workspace namespace available on editor");
+      return void 0;
+    }
+    const hydrateOptions = skillSource ? { skillSource } : void 0;
+    if (workspaceRef.type === "id") {
+      const resolved = await workspaceNs.getById(workspaceRef.workspaceId);
+      if (!resolved) {
+        this.logger?.warn(
+          `[resolveStoredWorkspace] Workspace '${workspaceRef.workspaceId}' not found in storage, skipping`
+        );
+        return void 0;
+      }
+      return workspaceNs.hydrateSnapshotToWorkspace(workspaceRef.workspaceId, resolved, hydrateOptions);
+    }
+    if (workspaceRef.type === "inline") {
+      const configHash = (0, import_node_crypto.createHash)("sha256").update(JSON.stringify(workspaceRef.config)).digest("hex").slice(0, 12);
+      return workspaceNs.hydrateSnapshotToWorkspace(`inline-${configHash}`, workspaceRef.config, hydrateOptions);
+    }
+    return void 0;
+  }
+  /**
+   * Resolve agent-level skill configurations into a CompositeVersionedSkillSource.
+   *
+   * For each skill in the agent's `skills` map, checks the resolution strategy:
+   * - `pin: '<versionId>'` → reads the specific version's tree from the DB
+   * - `strategy: 'latest'` → reads the skill's active version tree
+   * - `strategy: 'live'` or no strategy → skips (uses filesystem-based discovery)
+   *
+   * Returns a CompositeVersionedSkillSource if any versioned skills were resolved,
+   * or undefined if all skills use filesystem-based discovery.
+   */
+  async resolveAgentSkillSource(skills) {
+    if (!skills || typeof skills !== "object") return void 0;
+    const skillConfigs = Array.isArray(skills) ? void 0 : skills;
+    if (!skillConfigs || Object.keys(skillConfigs).length === 0) return void 0;
+    const storage = this.mastra?.getStorage();
+    if (!storage) return void 0;
+    const skillStore = await storage.getStore("skills");
+    if (!skillStore) return void 0;
+    const blobStore = await this.editor.resolveBlobStore();
+    if (!blobStore) return void 0;
+    const versionedEntries = [];
+    for (const [skillId, config] of Object.entries(skillConfigs)) {
+      if (!config) continue;
+      const isPinned = !!config.pin;
+      const isLatest = config.strategy === "latest";
+      if (!isPinned && !isLatest) {
+        continue;
+      }
+      try {
+        let version;
+        let dirName;
+        if (isPinned) {
+          version = await skillStore.getVersion(config.pin);
+          dirName = version?.name || skillId;
+        } else {
+          const resolved = await skillStore.getByIdResolved(skillId);
+          if (resolved?.activeVersionId) {
+            version = await skillStore.getVersion(resolved.activeVersionId);
+          }
+          if (!version) {
+            version = await skillStore.getLatestVersion(skillId);
+          }
+          dirName = resolved?.name || version?.name || skillId;
+        }
+        if (!version?.tree) {
+          this.logger?.warn(
+            `[resolveAgentSkillSource] Skill '${skillId}' version has no tree manifest, skipping versioned resolution`
+          );
+          continue;
+        }
+        versionedEntries.push({
+          dirName,
+          tree: version.tree,
+          versionCreatedAt: version.createdAt
+        });
+      } catch (error) {
+        this.logger?.warn(`[resolveAgentSkillSource] Failed to resolve version for skill '${skillId}': ${error}`);
+      }
+    }
+    if (versionedEntries.length === 0) return void 0;
+    return new import_workspace.CompositeVersionedSkillSource(versionedEntries, blobStore);
+  }
 };
 
 // src/namespaces/prompt.ts
@@ -1071,7 +1226,7 @@ var EditorPromptNamespace = class extends CrudEditorNamespace {
     this.mastra?.removePromptBlock(id);
   }
   async getStorageAdapter() {
-    const storage = this.mastra.getStorage();
+    const storage = this.mastra?.getStorage();
     if (!storage) throw new Error("Storage is not configured");
     const store = await storage.getStore("promptBlocks");
     if (!store) throw new Error("Prompt blocks storage domain is not available");
@@ -1086,7 +1241,7 @@ var EditorPromptNamespace = class extends CrudEditorNamespace {
   }
   async preview(blocks, context) {
     this.ensureRegistered();
-    const storage = this.mastra.getStorage();
+    const storage = this.mastra?.getStorage();
     if (!storage) throw new Error("Storage is not configured");
     const store = await storage.getStore("promptBlocks");
     if (!store) throw new Error("Prompt blocks storage domain is not available");
@@ -1113,7 +1268,7 @@ var EditorScorerNamespace = class extends CrudEditorNamespace {
     return storedScorer;
   }
   async getStorageAdapter() {
-    const storage = this.mastra.getStorage();
+    const storage = this.mastra?.getStorage();
     if (!storage) throw new Error("Storage is not configured");
     const store = await storage.getStore("scorerDefinitions");
     if (!store) throw new Error("Scorer definitions storage domain is not available");
@@ -1194,15 +1349,255 @@ Explain your reasoning for this score in a clear, concise paragraph.`;
   }
 };
 
+// src/namespaces/workspace.ts
+var import_workspace2 = require("@mastra/core/workspace");
+var EditorWorkspaceNamespace = class extends CrudEditorNamespace {
+  onCacheEvict(_id) {
+  }
+  /**
+   * Hydrate a stored workspace snapshot config into a runtime Workspace instance.
+   * Resolves provider strings to actual instances using the editor's registries.
+   *
+   * This is NOT called from the CrudEditorNamespace flow — it is a public utility
+   * used by EditorAgentNamespace during agent hydration.
+   */
+  async hydrateSnapshotToWorkspace(id, snapshot, options) {
+    const config = {
+      id,
+      name: snapshot.name
+    };
+    if (snapshot.filesystem) {
+      config.filesystem = await this.resolveFilesystem(snapshot.filesystem);
+    }
+    if (snapshot.sandbox) {
+      config.sandbox = await this.resolveSandbox(snapshot.sandbox);
+    }
+    if (snapshot.mounts) {
+      const mounts = {};
+      for (const [path, fsConfig] of Object.entries(snapshot.mounts)) {
+        mounts[path] = await this.resolveFilesystem(fsConfig);
+      }
+      config.mounts = mounts;
+    }
+    if (snapshot.search) {
+      if (snapshot.search.bm25) {
+        config.bm25 = snapshot.search.bm25;
+      }
+      if (snapshot.search.searchIndexName) {
+        config.searchIndexName = snapshot.search.searchIndexName;
+      }
+      if (snapshot.search.autoIndexPaths) {
+        config.autoIndexPaths = snapshot.search.autoIndexPaths;
+      }
+      if (snapshot.search.vectorProvider && this.mastra) {
+        const vectors = this.mastra.listVectors();
+        const vectorStore = vectors?.[snapshot.search.vectorProvider];
+        if (vectorStore) {
+          config.vectorStore = vectorStore;
+        } else {
+          this.logger?.warn(
+            `Vector provider "${snapshot.search.vectorProvider}" not found in Mastra instance. Workspace search will be limited to BM25 only.`
+          );
+        }
+      }
+      if (config.vectorStore && !config.embedder) {
+        this.logger?.warn(
+          `Workspace has a vector store configured but no embedder. Vector/hybrid search will not be available. Configure an embedder to enable semantic search.`
+        );
+      }
+    }
+    if (options?.skillSource) {
+      config.skillSource = options.skillSource;
+      config.skills = ["."];
+    } else if (snapshot.skills && snapshot.skills.length > 0) {
+      config.skills = snapshot.skills;
+    }
+    if (snapshot.tools) {
+      config.tools = snapshot.tools;
+    }
+    if (snapshot.autoSync !== void 0) {
+      config.autoSync = snapshot.autoSync;
+    }
+    if (snapshot.operationTimeout !== void 0) {
+      config.operationTimeout = snapshot.operationTimeout;
+    }
+    return new import_workspace2.Workspace(config);
+  }
+  /**
+   * Resolve a stored filesystem config to a runtime WorkspaceFilesystem instance.
+   * Looks up the provider by ID in the editor's registry (which includes built-in providers).
+   */
+  async resolveFilesystem(fsConfig) {
+    const provider = this.editor.__filesystems.get(fsConfig.provider);
+    if (!provider) {
+      throw new Error(
+        `Filesystem provider "${fsConfig.provider}" is not registered. Register it via new MastraEditor({ filesystems: [yourProvider] })`
+      );
+    }
+    const config = { ...fsConfig.config, readOnly: fsConfig.readOnly };
+    return await provider.createFilesystem(config);
+  }
+  /**
+   * Resolve a stored sandbox config to a runtime WorkspaceSandbox instance.
+   * Looks up the provider by ID in the editor's registry (which includes built-in providers).
+   */
+  async resolveSandbox(sandboxConfig) {
+    const provider = this.editor.__sandboxes.get(sandboxConfig.provider);
+    if (!provider) {
+      throw new Error(
+        `Sandbox provider "${sandboxConfig.provider}" is not registered. Register it via new MastraEditor({ sandboxes: [yourProvider] })`
+      );
+    }
+    return await provider.createSandbox(sandboxConfig.config);
+  }
+  async getStorageAdapter() {
+    const storage = this.mastra?.getStorage();
+    if (!storage) throw new Error("Storage is not configured");
+    const store = await storage.getStore("workspaces");
+    if (!store) throw new Error("Workspaces storage domain is not available");
+    return {
+      create: (input) => store.create({ workspace: input }),
+      getByIdResolved: (id) => store.getByIdResolved(id),
+      update: (input) => store.update(input),
+      delete: (id) => store.delete(id),
+      list: (args) => store.list(args),
+      listResolved: (args) => store.listResolved(args)
+    };
+  }
+};
+
+// src/namespaces/skill.ts
+var import_workspace3 = require("@mastra/core/workspace");
+var EditorSkillNamespace = class extends CrudEditorNamespace {
+  onCacheEvict(_id) {
+  }
+  async getStorageAdapter() {
+    const storage = this.mastra?.getStorage();
+    if (!storage) throw new Error("Storage is not configured");
+    const store = await storage.getStore("skills");
+    if (!store) throw new Error("Skills storage domain is not available");
+    return {
+      create: (input) => store.create({ skill: input }),
+      getByIdResolved: (id) => store.getByIdResolved(id),
+      update: (input) => store.update(input),
+      delete: (id) => store.delete(id),
+      list: (args) => store.list(args),
+      listResolved: (args) => store.listResolved(args)
+    };
+  }
+  /**
+   * Publish a skill from a live filesystem source.
+   * Walks the skill directory, hashes files into the blob store,
+   * creates a new version with the tree manifest, and sets activeVersionId.
+   */
+  async publish(skillId, source, skillPath) {
+    this.ensureRegistered();
+    const storage = this.mastra?.getStorage();
+    if (!storage) throw new Error("Storage is not configured");
+    const skillStore = await storage.getStore("skills");
+    if (!skillStore) throw new Error("Skills storage domain is not available");
+    const blobStore = await this.editor.resolveBlobStore();
+    if (!blobStore)
+      throw new Error("No blob store is configured. Register one via new MastraEditor({ blobStores: [...] })");
+    const { snapshot, tree } = await (0, import_workspace3.publishSkillFromSource)(source, skillPath, blobStore);
+    await skillStore.update({
+      id: skillId,
+      ...snapshot,
+      tree,
+      status: "published"
+    });
+    const latestVersion = await skillStore.getLatestVersion(skillId);
+    if (!latestVersion) {
+      throw new Error(`Failed to retrieve version after publishing skill "${skillId}"`);
+    }
+    await skillStore.update({
+      id: skillId,
+      activeVersionId: latestVersion.id
+    });
+    const resolved = await skillStore.getByIdResolved(skillId);
+    if (!resolved) throw new Error(`Failed to resolve skill ${skillId} after publish`);
+    this.clearCache(skillId);
+    this.editor.agent.invalidateAgentsReferencingSkill(skillId);
+    return resolved;
+  }
+};
+
+// src/providers.ts
+var import_workspace5 = require("@mastra/core/workspace");
+var import_workspace6 = require("@mastra/core/workspace");
+var localFilesystemProvider = {
+  id: "local",
+  name: "Local Filesystem",
+  description: "A folder on the local disk",
+  configSchema: {
+    type: "object",
+    required: ["basePath"],
+    properties: {
+      basePath: { type: "string", description: "Base directory path on disk" },
+      contained: {
+        type: "boolean",
+        description: "Restrict operations to stay within basePath",
+        default: true
+      },
+      readOnly: {
+        type: "boolean",
+        description: "Block all write operations",
+        default: false
+      }
+    }
+  },
+  createFilesystem: (config) => new import_workspace5.LocalFilesystem(config)
+};
+var localSandboxProvider = {
+  id: "local",
+  name: "Local Sandbox",
+  description: "Execute commands on the local machine",
+  configSchema: {
+    type: "object",
+    properties: {
+      workingDirectory: { type: "string", description: "Working directory for command execution" },
+      timeout: { type: "number", description: "Default timeout for operations in ms" },
+      isolation: {
+        type: "string",
+        enum: ["none", "seatbelt", "bwrap"],
+        description: "Isolation backend for sandboxed execution",
+        default: "none"
+      },
+      env: {
+        type: "object",
+        description: "Environment variables for command execution",
+        additionalProperties: { type: "string" }
+      }
+    }
+  },
+  createSandbox: (config) => new import_workspace6.LocalSandbox(config)
+};
+
 // src/index.ts
 var MastraEditor = class {
   constructor(config) {
     this.__logger = config?.logger;
     this.__toolProviders = config?.toolProviders ?? {};
+    this.__filesystems = /* @__PURE__ */ new Map();
+    this.__filesystems.set(localFilesystemProvider.id, localFilesystemProvider);
+    for (const [id, provider] of Object.entries(config?.filesystems ?? {})) {
+      this.__filesystems.set(id, provider);
+    }
+    this.__sandboxes = /* @__PURE__ */ new Map();
+    this.__sandboxes.set(localSandboxProvider.id, localSandboxProvider);
+    for (const [id, provider] of Object.entries(config?.sandboxes ?? {})) {
+      this.__sandboxes.set(id, provider);
+    }
+    this.__blobStores = /* @__PURE__ */ new Map();
+    for (const [id, provider] of Object.entries(config?.blobStores ?? {})) {
+      this.__blobStores.set(id, provider);
+    }
     this.agent = new EditorAgentNamespace(this);
     this.mcp = new EditorMCPNamespace(this);
     this.prompt = new EditorPromptNamespace(this);
     this.scorer = new EditorScorerNamespace(this);
+    this.workspace = new EditorWorkspaceNamespace(this);
+    this.skill = new EditorSkillNamespace(this);
   }
   /**
    * Register this editor with a Mastra instance.
@@ -1222,6 +1617,46 @@ var MastraEditor = class {
   getToolProviders() {
     return this.__toolProviders;
   }
+  /** List all registered filesystem providers */
+  getFilesystemProviders() {
+    return Array.from(this.__filesystems.values());
+  }
+  /** List all registered sandbox providers */
+  getSandboxProviders() {
+    return Array.from(this.__sandboxes.values());
+  }
+  /** List all registered blob store providers */
+  getBlobStoreProviders() {
+    return Array.from(this.__blobStores.values());
+  }
+  /**
+   * Resolve a blob store from the provider registry, or fall back to the
+   * storage backend's blobs domain.
+   *
+   * @param providerId - If specified, look up a registered provider by ID
+   *   and create a blob store from the given config. If omitted, falls back
+   *   to `storage.getStore('blobs')`.
+   * @param providerConfig - Provider-specific configuration (only used when
+   *   `providerId` is specified).
+   */
+  async resolveBlobStore(providerId, providerConfig) {
+    if (providerId) {
+      const provider = this.__blobStores.get(providerId);
+      if (!provider) {
+        throw new Error(
+          `Blob store provider "${providerId}" is not registered. Register it via new MastraEditor({ blobStores: { '${providerId}': yourProvider } })`
+        );
+      }
+      const blobStore2 = await provider.createBlobStore(providerConfig ?? {});
+      await blobStore2.init();
+      return blobStore2;
+    }
+    const storage = this.__mastra?.getStorage();
+    if (!storage) throw new Error("Storage is not configured");
+    const blobStore = await storage.getStore("blobs");
+    if (!blobStore) throw new Error("Blob storage domain is not available");
+    return blobStore;
+  }
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
@@ -1231,8 +1666,12 @@ var MastraEditor = class {
   EditorNamespace,
   EditorPromptNamespace,
   EditorScorerNamespace,
+  EditorSkillNamespace,
+  EditorWorkspaceNamespace,
   MastraEditor,
   evaluateRuleGroup,
+  localFilesystemProvider,
+  localSandboxProvider,
   renderTemplate,
   resolveInstructionBlocks
 });