@mastra/editor 0.11.0-alpha.2 → 0.11.0-alpha.4

package/dist/index.cjs

@@ -146,7 +146,7 @@ var init_agent_builder = __esm({
 // src/ee/agent-builder-agent.ts
 function createBuilderAgent(args) {
   const memory = new import_memory2.Memory();
-  return new import_agent3.Agent({
+  const config = {
     instructions: `You are the Agent Builder.
 
 Your job: turn a non-technical user's plain-language request into a fully configured, production-quality agent in a single turn.
@@ -167,6 +167,10 @@ Examples of communication style:
 - Bad: "Agent created with weatherTool and recipeWorkflow attached."
 - Good: "Your agent can check the weather and suggest recipes that match the day's conditions."
 
+# Form snapshot
+
+A "Current agent configuration (authoritative)" block is injected into your context every turn. It lists every form field with its current value AND a directive telling you exactly which setter to call (or skip) for that field. Treat the snapshot as the single source of truth for what is and isn't already set \u2014 do not try to infer state from anywhere else, and do not re-call setters for fields whose directive says "already set".
+
 # Authoring loop
 
 Follow these five steps in order, every time:
@@ -184,20 +188,19 @@ Ask yourself:
 
 ## Step B \u2014 Define the agent's identity
 
-Before building the agent, define:
-- Agent name: short, memorable, anchored to the outcome. Never "Agent X" or generic labels
+Decide on:
+- Agent name: short, memorable, anchored to the outcome. Never "Agent X" or generic labels.
 - Description: exactly one sentence in plain user-facing language explaining what the agent helps with.
 
-Call \`set-agent-name\` and \`set-agent-description\` to set the agent's identity. Skip any whose feature is not available in the form snapshot.
+The snapshot will tell you whether to call \`set-agent-name\` and \`set-agent-description\` or skip them.
 
 ## Step C \u2014 Decide capabilities
 
-Read the form snapshot already injected into your context. It lists the user's current selections plus the available tools, agents, workflows, stored skills, models, and workspaces.
+The form snapshot lists what's currently attached. Use it together with the available tools, agents, workflows, stored skills, and models listed in the corresponding tool descriptions to decide:
 
-Then:
 - Pick the *minimum* set of existing tools/agents/workflows/stored skills that satisfies the outcome. Adding irrelevant capabilities makes the agent worse, not better.
 - Prefer existing tools, workflows, agents, and stored skills before creating anything new.
-- \`set-agent-skills\` attaches user-available stored skills from the form snapshot.
+- \`set-agent-skills\` attaches user-available stored skills.
 - Only call \`createSkillTool\` when (a) no existing stored skill matches reusable operating instructions the produced agent needs, AND (b) that operating instruction is genuinely needed for the outcome. Do not use stored skills as a substitute for missing integrations or tools.
 - If a specific external connection is required (e.g. a sheet tool for a spreadsheet-driven outcome) and none is available, the new agent's system prompt must instruct it to refuse cleanly and explain what the user needs to connect.
 
@@ -214,15 +217,7 @@ Before calling \`set-agent-instructions\`, privately write a concrete run contra
 
 ## Step E \u2014 Write the agent
 
-Call the capability tools. Skip any whose feature is not available in the form snapshot.
-
-1. \`set-agent-model\` \u2014 pick the best model for the use case from the available models list. Rules:
-   - Choose only a model id that appears in the available models list. Never invent, assume, or copy example model ids.
-   - For coding, reasoning-heavy, or planning agents, prefer the most capable available model.
-   - For short, simple, structured, or high-volume tasks, prefer a lower-latency/lower-cost available model when quality will not materially suffer.
-   - If several plausible models are available, choose the newest or strongest option based on the metadata visible in the snapshot.
-2. \`set-agent-tools\` \u2014 attach the minimum set chosen in Step C. Also use \`set-agent-skills\` and \`set-agent-browser-enabled\` only when applicable and supported by the snapshot.
-3. \`set-agent-instructions\` \u2014 write the new agent's system prompt from scratch, tailored to the user's specific outcome and the run contract from Step D.
+Read the per-field directives in the form snapshot. Call only the setters the snapshot tells you to call, each at most once, with the final value. Skip every field marked "already set" or "no setter". Skip any field that isn't listed at all (its feature is disabled).
 
 Before calling \`set-agent-instructions\`, self-audit the draft. It must pass every check:
 - No placeholders remain (no \`<...>\`, "TBD", "TODO", "your tool", or generic policy gaps).
@@ -282,7 +277,8 @@ The system prompt written into \`set-agent-instructions\` MUST include all of th
     id: "builder-agent",
     name: "Agent Builder Agent",
     description: "An agent that can build agents"
-  });
+  };
+  return new import_agent3.Agent(config);
 }
 var import_agent3, import_memory2, import_workspace7, import_node_path, import_node_url, import_meta, __filename, __dirname, workspacePath, workspace;
 var init_agent_builder_agent = __esm({
@@ -342,6 +338,7 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 var import_processor_provider2 = require("@mastra/core/processor-provider");
+var import_storage = require("@mastra/core/storage");
 var import_tool_provider2 = require("@mastra/core/tool-provider");
 
 // src/namespaces/base.ts
@@ -1045,6 +1042,14 @@ var EditorAgentNamespace = class extends CrudEditorNamespace {
    * Returns the (possibly mutated) agent.
    */
   async applyStoredOverrides(agent, options, requestContext) {
+    const editorConfig = agent.__getEditorConfig?.();
+    if (editorConfig === false) {
+      return agent;
+    }
+    const instructionsEditable = editorConfig === void 0 ? true : editorConfig.instructions === true;
+    const toolsConfig = editorConfig === void 0 ? true : editorConfig.tools;
+    const toolsEditable = toolsConfig === true;
+    const toolDescriptionsEditable = typeof toolsConfig === "object" && toolsConfig !== null && toolsConfig.description === true;
     let storedConfig = null;
     try {
       this.ensureRegistered();
@@ -1066,7 +1071,7 @@ var EditorAgentNamespace = class extends CrudEditorNamespace {
     }
     const fork = agent.__fork();
     this.logger?.debug(`[applyStoredOverrides] Applying stored overrides to code agent "${agent.id}"`);
-    if (storedConfig.instructions !== void 0 && storedConfig.instructions !== null) {
+    if (instructionsEditable && storedConfig.instructions !== void 0 && storedConfig.instructions !== null) {
       const resolved = this.resolveStoredInstructions(storedConfig.instructions);
       if (resolved !== void 0) {
         fork.__updateInstructions(resolved);
@@ -1076,7 +1081,7 @@ var EditorAgentNamespace = class extends CrudEditorNamespace {
     const hasStoredMCPClients = storedConfig.mcpClients != null;
     const hasStoredIntegrationTools = storedConfig.integrationTools != null;
     const hasStoredToolProviders = storedConfig.toolProviders != null && Object.keys(storedConfig.toolProviders).length > 0;
-    if (hasStoredTools || hasStoredMCPClients || hasStoredIntegrationTools || hasStoredToolProviders) {
+    if (toolsEditable && (hasStoredTools || hasStoredMCPClients || hasStoredIntegrationTools || hasStoredToolProviders)) {
       const hasConditionalTools = this.isConditionalVariants(storedConfig.tools);
       const hasConditionalMCPClients = storedConfig.mcpClients != null && this.isConditionalVariants(storedConfig.mcpClients);
       const hasConditionalIntegrationTools = storedConfig.integrationTools != null && this.isConditionalVariants(storedConfig.integrationTools);
@@ -1135,6 +1140,28 @@ var EditorAgentNamespace = class extends CrudEditorNamespace {
         );
         fork.__setTools({ ...codeTools, ...registryTools, ...mcpTools, ...integrationTools });
       }
+    } else if (toolDescriptionsEditable && hasStoredTools) {
+      const hasConditionalTools = this.isConditionalVariants(storedConfig.tools);
+      if (hasConditionalTools) {
+        const originalTools = agent.listTools.bind(agent);
+        const toolsFn = async ({ requestContext: requestContext2 }) => {
+          const codeTools = await originalTools({ requestContext: requestContext2 });
+          const resolvedToolsConfig = this.accumulateObjectVariants(
+            storedConfig.tools,
+            requestContext2.toJSON()
+          );
+          return this.applyStoredToolDescriptions(codeTools, resolvedToolsConfig);
+        };
+        fork.__setTools(toolsFn);
+      } else {
+        const codeTools = await fork.listTools();
+        fork.__setTools(
+          this.applyStoredToolDescriptions(
+            codeTools,
+            storedConfig.tools
+          )
+        );
+      }
     }
     if (storedConfig.resolvedVersionId) {
       const existing = fork.toRawConfig() ?? {};
@@ -1435,6 +1462,20 @@ var EditorAgentNamespace = class extends CrudEditorNamespace {
       return resolveInstructionBlocks(blocks, context, { promptBlocksStorage: promptBlocksStore });
     };
   }
+  applyStoredToolDescriptions(codeTools, storedTools) {
+    if (!storedTools || Array.isArray(storedTools)) {
+      return codeTools;
+    }
+    let nextTools;
+    for (const [toolKey, toolConfig] of Object.entries(storedTools)) {
+      if (!toolConfig.description || !(toolKey in codeTools)) {
+        continue;
+      }
+      nextTools ?? (nextTools = { ...codeTools });
+      nextTools[toolKey] = { ...codeTools[toolKey], description: toolConfig.description };
+    }
+    return nextTools ?? codeTools;
+  }
   /**
    * Resolve stored tool IDs to actual tool instances from Mastra's registry.
    * Applies description overrides from per-tool config when present.
@@ -2549,6 +2590,8 @@ var MastraEditor = class {
     this.__logger = config?.logger;
     this.__toolProviders = config?.toolProviders ?? {};
     this.__processorProviders = { ...import_processor_provider2.BUILT_IN_PROCESSOR_PROVIDERS, ...config?.processorProviders };
+    this.__source = config?.source;
+    this.__codePath = config?.codePath ?? "./mastra/editor";
     this.__filesystems = /* @__PURE__ */ new Map();
     this.__filesystems.set(localFilesystemProvider.id, localFilesystemProvider);
     for (const [id, provider] of Object.entries(config?.filesystems ?? {})) {
@@ -2586,6 +2629,21 @@ var MastraEditor = class {
     if (!this.__logger) {
       this.__logger = mastra.getLogger();
     }
+    if (this.__source === "code") {
+      const filesystemStore = new import_storage.FilesystemStore({ dir: this.__codePath });
+      const existingStorage = mastra.getStorage();
+      if (existingStorage) {
+        mastra.setStorage(
+          new import_storage.MastraCompositeStore({
+            id: `${existingStorage.id}-with-editor-filesystem`,
+            default: existingStorage,
+            editor: filesystemStore
+          })
+        );
+      } else {
+        mastra.setStorage(filesystemStore);
+      }
+    }
     this.ensureBuilderWorkspaces().then(() => this.reconcileBuilderWorkspaces()).catch((err) => {
       this.__logger?.warn("[MastraEditor] Failed to persist/reconcile builder workspaces on startup", {
         error: err
@@ -2734,6 +2792,10 @@ var MastraEditor = class {
       );
     }
   }
+  /** Returns the editor's configured source, or undefined if unset. */
+  getSource() {
+    return this.__source;
+  }
   /** Registered tool providers */
   getToolProvider(id) {
     return this.__toolProviders[id];