@mastra/editor 0.2.0 → 0.3.0-alpha.1

package/dist/index.js

@@ -1,189 +1,515 @@
-// src/index.ts
-import { Memory } from "@mastra/memory";
-import { Agent } from "@mastra/core";
-var MastraEditor = class {
-  constructor(config) {
-    this.logger = config?.logger;
+// src/namespaces/base.ts
+var EditorNamespace = class {
+  constructor(editor) {
+    this.editor = editor;
+  }
+  get mastra() {
+    return this.editor.__mastra;
+  }
+  get logger() {
+    return this.editor.__logger;
+  }
+  ensureRegistered() {
+    if (!this.editor.__mastra) {
+      throw new Error("MastraEditor is not registered with a Mastra instance");
+    }
+  }
+};
+var CrudEditorNamespace = class extends EditorNamespace {
+  constructor() {
+    super(...arguments);
+    this._cache = /* @__PURE__ */ new Map();
   }
   /**
-   * Register this editor with a Mastra instance.
-   * This gives the editor access to Mastra's storage, tools, workflows, etc.
+   * Convert a raw resolved config into a runtime primitive.
+   * Override in subclasses that need hydration (e.g. agents → Agent instance).
+   * Default implementation returns the resolved config as-is.
    */
-  registerWithMastra(mastra) {
-    this.mastra = mastra;
-    if (!this.logger) {
-      this.logger = mastra.getLogger();
-    }
+  async hydrate(resolved) {
+    return resolved;
   }
   /**
-   * Get the agents storage domain from the Mastra storage.
+   * Hook called when an entity is evicted from the cache (on delete, update, or clearCache).
+   * Override in subclasses to also remove the entity from the Mastra runtime registry.
    */
-  async getAgentsStore() {
-    const storage = this.mastra.getStorage();
-    if (!storage) throw new Error("Storage is not configured");
-    const agentsStore = await storage.getStore("agents");
-    if (!agentsStore) throw new Error("Agents storage domain is not available");
-    return agentsStore;
+  onCacheEvict(_id) {
   }
-  async getStoredAgentById(id, options) {
-    if (!this.mastra) {
-      throw new Error("MastraEditor is not registered with a Mastra instance");
+  async create(input) {
+    this.ensureRegistered();
+    const adapter = await this.getStorageAdapter();
+    await adapter.create(input);
+    const resolved = await adapter.getByIdResolved(input.id);
+    if (!resolved) {
+      throw new Error(`Failed to resolve entity ${input.id} after creation`);
+    }
+    const hydrated = await this.hydrate(resolved);
+    this._cache.set(input.id, hydrated);
+    return hydrated;
+  }
+  async getById(id, options) {
+    this.ensureRegistered();
+    const isVersionRequest = options?.versionId || options?.versionNumber;
+    if (!isVersionRequest) {
+      const cached = this._cache.get(id);
+      if (cached) {
+        this.logger?.debug(`[getById] Cache hit for "${id}"`);
+        return cached;
+      }
     }
-    const agentsStore = await this.getAgentsStore();
-    if (options?.versionId && options?.versionNumber !== void 0) {
-      this.logger?.warn(`Both versionId and versionNumber provided for agent "${id}". Using versionId.`);
+    this.logger?.debug(`[getById] Cache miss for "${id}", fetching from storage`);
+    const adapter = await this.getStorageAdapter();
+    const resolved = await adapter.getByIdResolved(id, options);
+    if (!resolved) return null;
+    const hydrated = await this.hydrate(resolved);
+    if (!isVersionRequest) {
+      this._cache.set(id, hydrated);
     }
-    if (options?.versionId) {
-      const version = await agentsStore.getVersion(options.versionId);
-      if (!version) {
-        return null;
+    return hydrated;
+  }
+  async update(input) {
+    this.ensureRegistered();
+    const adapter = await this.getStorageAdapter();
+    await adapter.update(input);
+    this._cache.delete(input.id);
+    this.onCacheEvict(input.id);
+    const resolved = await adapter.getByIdResolved(input.id);
+    if (!resolved) {
+      throw new Error(`Failed to resolve entity ${input.id} after update`);
+    }
+    const hydrated = await this.hydrate(resolved);
+    this._cache.set(input.id, hydrated);
+    return hydrated;
+  }
+  async delete(id) {
+    this.ensureRegistered();
+    const adapter = await this.getStorageAdapter();
+    await adapter.delete(id);
+    this._cache.delete(id);
+    this.onCacheEvict(id);
+  }
+  async list(args) {
+    this.ensureRegistered();
+    const adapter = await this.getStorageAdapter();
+    return adapter.list(args);
+  }
+  async listResolved(args) {
+    this.ensureRegistered();
+    const adapter = await this.getStorageAdapter();
+    return adapter.listResolved(args);
+  }
+  /**
+   * Clear cached entities. If an id is provided, only that entity is cleared.
+   * Otherwise all cached entities in this namespace are cleared.
+   */
+  clearCache(id) {
+    if (id) {
+      this._cache.delete(id);
+      this.onCacheEvict(id);
+      this.logger?.debug(`[clearCache] Cleared cache for "${id}"`);
+    } else {
+      for (const cachedId of Array.from(this._cache.keys())) {
+        this.onCacheEvict(cachedId);
       }
-      if (version.agentId !== id) {
-        return null;
+      this._cache.clear();
+      this.logger?.debug("[clearCache] Cleared all cached entities");
+    }
+  }
+};
+
+// src/namespaces/agent.ts
+import { Memory } from "@mastra/memory";
+import { Agent } from "@mastra/core";
+import { convertSchemaToZod } from "@mastra/schema-compat";
+import { RequestContext } from "@mastra/core/request-context";
+
+// src/rule-evaluator.ts
+function resolvePath(context, path) {
+  const segments = path.split(".");
+  let current = context;
+  for (const segment of segments) {
+    if (current === null || current === void 0 || typeof current !== "object") {
+      return void 0;
+    }
+    current = current[segment];
+  }
+  return current;
+}
+function evaluateRule(rule, context) {
+  const fieldValue = resolvePath(context, rule.field);
+  switch (rule.operator) {
+    case "equals":
+      return fieldValue === rule.value;
+    case "not_equals":
+      return fieldValue !== rule.value;
+    case "contains": {
+      if (typeof fieldValue === "string" && typeof rule.value === "string") {
+        return fieldValue.includes(rule.value);
       }
-      const {
-        id: _versionId,
-        agentId: _agentId,
-        versionNumber: _versionNumber,
-        changedFields: _changedFields,
-        changeMessage: _changeMessage,
-        createdAt: _createdAt,
-        ...snapshotConfig
-      } = version;
-      const agentRecord = await agentsStore.getAgentById({ id });
-      if (!agentRecord) {
-        return null;
+      if (Array.isArray(fieldValue)) {
+        return fieldValue.includes(rule.value);
+      }
+      return false;
+    }
+    case "not_contains": {
+      if (typeof fieldValue === "string" && typeof rule.value === "string") {
+        return !fieldValue.includes(rule.value);
       }
-      const { activeVersionId: _activeVersionId, ...agentRecordWithoutActiveVersion } = agentRecord;
-      const resolvedAgent = { ...agentRecordWithoutActiveVersion, ...snapshotConfig };
-      if (options?.returnRaw) {
-        return resolvedAgent;
+      if (Array.isArray(fieldValue)) {
+        return !fieldValue.includes(rule.value);
       }
-      return this.createAgentFromStoredConfig(resolvedAgent);
+      return true;
+    }
+    case "greater_than":
+      return typeof fieldValue === "number" && typeof rule.value === "number" && fieldValue > rule.value;
+    case "less_than":
+      return typeof fieldValue === "number" && typeof rule.value === "number" && fieldValue < rule.value;
+    case "greater_than_or_equal":
+      return typeof fieldValue === "number" && typeof rule.value === "number" && fieldValue >= rule.value;
+    case "less_than_or_equal":
+      return typeof fieldValue === "number" && typeof rule.value === "number" && fieldValue <= rule.value;
+    case "in":
+      return Array.isArray(rule.value) && rule.value.includes(fieldValue);
+    case "not_in":
+      return Array.isArray(rule.value) && !rule.value.includes(fieldValue);
+    case "exists":
+      return fieldValue !== void 0 && fieldValue !== null;
+    case "not_exists":
+      return fieldValue === void 0 || fieldValue === null;
+    default:
+      return false;
+  }
+}
+function evaluateRuleGroup(ruleGroup, context) {
+  if (ruleGroup.conditions.length === 0) {
+    return true;
+  }
+  const results = ruleGroup.conditions.map((condition) => {
+    if ("conditions" in condition) {
+      return evaluateRuleGroup(condition, context);
+    }
+    return evaluateRule(condition, context);
+  });
+  if (ruleGroup.operator === "AND") {
+    return results.every(Boolean);
+  }
+  return results.some(Boolean);
+}
+
+// src/template-engine.ts
+function resolvePath2(context, path) {
+  const segments = path.split(".");
+  let current = context;
+  for (const segment of segments) {
+    if (current === null || current === void 0 || typeof current !== "object") {
+      return void 0;
     }
-    if (options?.versionNumber !== void 0) {
-      const version = await agentsStore.getVersionByNumber(id, options.versionNumber);
-      if (!version) {
-        return null;
+    current = current[segment];
+  }
+  return current;
+}
+var TEMPLATE_PATTERN = /\{\{\s*([a-zA-Z_][\w.]*)\s*(?:\|\|\s*(?:'([^']*)'|"([^"]*)")\s*)?\}\}/g;
+function renderTemplate(template, context) {
+  return template.replace(
+    TEMPLATE_PATTERN,
+    (match, variablePath, singleFallback, doubleFallback) => {
+      const resolved = resolvePath2(context, variablePath);
+      if (resolved !== void 0 && resolved !== null) {
+        return String(resolved);
       }
-      const {
-        id: _versionId,
-        agentId: _agentId,
-        versionNumber: _versionNumber,
-        changedFields: _changedFields,
-        changeMessage: _changeMessage,
-        createdAt: _createdAt,
-        ...snapshotConfig
-      } = version;
-      const agentRecord = await agentsStore.getAgentById({ id });
-      if (!agentRecord) {
-        return null;
+      const fallback = singleFallback ?? doubleFallback;
+      if (fallback !== void 0) {
+        return fallback;
       }
-      const { activeVersionId: _activeVersionId, ...agentRecordWithoutActiveVersion } = agentRecord;
-      const resolvedAgent = { ...agentRecordWithoutActiveVersion, ...snapshotConfig };
-      if (options?.returnRaw) {
-        return resolvedAgent;
+      return match;
+    }
+  );
+}
+
+// src/instruction-builder.ts
+async function resolveInstructionBlocks(blocks, context, deps) {
+  const segments = [];
+  const blockIds = Array.from(
+    new Set(
+      blocks.filter((b) => b.type === "prompt_block_ref").map((b) => b.id)
+    )
+  );
+  const resolvedBlocksMap = /* @__PURE__ */ new Map();
+  if (blockIds.length > 0) {
+    const fetchResults = await Promise.all(blockIds.map((id) => deps.promptBlocksStorage.getByIdResolved(id)));
+    for (let i = 0; i < blockIds.length; i++) {
+      const result = fetchResults[i];
+      if (result) {
+        resolvedBlocksMap.set(blockIds[i], result);
       }
-      return this.createAgentFromStoredConfig(resolvedAgent);
-    }
-    if (!options?.returnRaw) {
-      const agentCache2 = this.mastra.getStoredAgentCache();
-      if (agentCache2) {
-        const cached = agentCache2.get(id);
-        if (cached) {
-          this.logger?.debug(`[getStoredAgentById] Returning cached agent "${id}"`);
-          return cached;
-        }
-        this.logger?.debug(`[getStoredAgentById] Cache miss for agent "${id}", fetching from storage`);
+    }
+  }
+  for (const block of blocks) {
+    if (block.type === "text") {
+      const rendered2 = renderTemplate(block.content, context);
+      if (rendered2.trim()) {
+        segments.push(rendered2);
       }
+      continue;
     }
-    const storedAgent = await agentsStore.getAgentByIdResolved({ id });
-    if (!storedAgent) {
-      return null;
+    if (block.type === "prompt_block") {
+      if (block.rules) {
+        const passes = evaluateRuleGroup(block.rules, context);
+        if (!passes) {
+          continue;
+        }
+      }
+      const rendered2 = renderTemplate(block.content, context);
+      if (rendered2.trim()) {
+        segments.push(rendered2);
+      }
+      continue;
     }
-    if (options?.returnRaw) {
-      return storedAgent;
+    const resolved = resolvedBlocksMap.get(block.id);
+    if (!resolved) {
+      continue;
     }
-    const agent = this.createAgentFromStoredConfig(storedAgent);
-    const agentCache = this.mastra.getStoredAgentCache();
-    if (agentCache) {
-      agentCache.set(id, agent);
+    if (resolved.status !== "published") {
+      continue;
     }
-    return agent;
-  }
-  async listStoredAgents(options) {
-    if (!this.mastra) {
-      throw new Error("MastraEditor is not registered with a Mastra instance");
+    if (resolved.rules) {
+      const passes = evaluateRuleGroup(resolved.rules, context);
+      if (!passes) {
+        continue;
+      }
     }
-    const agentsStore = await this.getAgentsStore();
-    const result = await agentsStore.listAgentsResolved({
-      page: options?.page,
-      perPage: options?.pageSize,
-      orderBy: { field: "createdAt", direction: "DESC" }
-    });
-    if (options?.returnRaw) {
-      return result;
+    const rendered = renderTemplate(resolved.content, context);
+    if (rendered.trim()) {
+      segments.push(rendered);
     }
-    const agents = result.agents.map(
-      (storedAgent) => this.createAgentFromStoredConfig(storedAgent)
-    );
+  }
+  return segments.join("\n\n");
+}
+
+// src/namespaces/agent.ts
+var EditorAgentNamespace = class extends CrudEditorNamespace {
+  async getStorageAdapter() {
+    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");
     return {
-      agents,
-      total: result.total,
-      page: result.page,
-      perPage: result.perPage,
-      hasMore: result.hasMore
+      create: (input) => store.create({ agent: input }),
+      getByIdResolved: async (id, options) => {
+        if (options?.versionId || options?.versionNumber) {
+          const agent = await store.getById(id);
+          if (!agent) return null;
+          const version = options.versionId ? await store.getVersion(options.versionId) : await store.getVersionByNumber(id, options.versionNumber);
+          if (!version) return null;
+          const {
+            id: _vId,
+            agentId: _aId,
+            versionNumber: _vn,
+            changedFields: _cf,
+            changeMessage: _cm,
+            createdAt: _ca,
+            ...snapshotConfig
+          } = version;
+          return { ...agent, ...snapshotConfig };
+        }
+        return store.getByIdResolved(id);
+      },
+      update: (input) => store.update(input),
+      delete: (id) => store.delete(id),
+      list: (args) => store.list(args),
+      listResolved: (args) => store.listResolved(args)
     };
   }
   /**
-   * Clear the stored agent cache for a specific agent ID, or all cached agents.
+   * Hydrate a stored agent config into a runtime Agent instance.
    */
-  clearStoredAgentCache(agentId) {
-    if (!this.mastra) return;
-    const agentCache = this.mastra.getStoredAgentCache();
-    if (!agentCache) return;
-    if (agentId) {
-      agentCache.delete(agentId);
-      this.logger?.debug(`[clearStoredAgentCache] Cleared cache for agent "${agentId}"`);
-    } else {
-      agentCache.clear();
-      this.logger?.debug("[clearStoredAgentCache] Cleared all cached agents");
+  async hydrate(storedAgent) {
+    return this.createAgentFromStoredConfig(storedAgent);
+  }
+  onCacheEvict(id) {
+    this.mastra?.removeAgent(id);
+  }
+  // ============================================================================
+  // Private helpers
+  // ============================================================================
+  /**
+   * Detect whether a StorageConditionalField value is a conditional variant array
+   * (as opposed to the plain static value T).
+   */
+  isConditionalVariants(field) {
+    return Array.isArray(field) && field.length > 0 && typeof field[0] === "object" && field[0] !== null && "value" in field[0];
+  }
+  /**
+   * Accumulate all matching variants for an array-typed field.
+   * Each matching variant's value (an array) is concatenated in order.
+   * Variants with no rules are treated as unconditional (always included).
+   */
+  accumulateArrayVariants(variants, context) {
+    const result = [];
+    for (const variant of variants) {
+      if (!variant.rules || evaluateRuleGroup(variant.rules, context)) {
+        result.push(...variant.value);
+      }
     }
+    return result;
   }
   /**
-   * Create an Agent instance from stored configuration.
-   * Resolves all stored references (tools, workflows, agents, memory, scorers)
-   * and registers the agent with the Mastra instance.
+   * Accumulate all matching variants for an object/record-typed field.
+   * Each matching variant's value is shallow-merged in order, so later
+   * matches override keys from earlier ones.
+   * Variants with no rules are treated as unconditional (always included).
    */
-  createAgentFromStoredConfig(storedAgent) {
+  accumulateObjectVariants(variants, context) {
+    let result;
+    for (const variant of variants) {
+      if (!variant.rules || evaluateRuleGroup(variant.rules, context)) {
+        result = result ? { ...result, ...variant.value } : { ...variant.value };
+      }
+    }
+    return result;
+  }
+  async createAgentFromStoredConfig(storedAgent) {
     if (!this.mastra) {
       throw new Error("MastraEditor is not registered with a Mastra instance");
     }
     this.logger?.debug(`[createAgentFromStoredConfig] Creating agent from stored config "${storedAgent.id}"`);
-    const tools = this.resolveStoredTools(storedAgent.tools);
-    const workflows = this.resolveStoredWorkflows(storedAgent.workflows);
-    const agents = this.resolveStoredAgents(storedAgent.agents);
-    const memory = this.resolveStoredMemory(storedAgent.memory);
-    console.log(
-      `[createAgentFromStoredConfig] Resolved memory: ${memory ? "Memory instance created" : "No memory"} for agent "${storedAgent.id}"`,
-      { memory }
-    );
-    const scorers = this.resolveStoredScorers(storedAgent.scorers);
-    const inputProcessors = this.resolveStoredInputProcessors(storedAgent.inputProcessors);
-    const outputProcessors = this.resolveStoredOutputProcessors(storedAgent.outputProcessors);
-    const modelConfig = storedAgent.model;
-    if (!modelConfig || !modelConfig.provider || !modelConfig.name) {
-      throw new Error(
-        `Stored agent "${storedAgent.id}" has no active version or invalid model configuration. Both provider and name are required.`
+    const instructions = this.resolveStoredInstructions(storedAgent.instructions);
+    const hasConditionalTools = storedAgent.tools != null && this.isConditionalVariants(storedAgent.tools);
+    const hasConditionalWorkflows = storedAgent.workflows != null && this.isConditionalVariants(storedAgent.workflows);
+    const hasConditionalAgents = storedAgent.agents != null && this.isConditionalVariants(storedAgent.agents);
+    const hasConditionalMemory = storedAgent.memory != null && this.isConditionalVariants(storedAgent.memory);
+    const hasConditionalScorers = storedAgent.scorers != null && this.isConditionalVariants(storedAgent.scorers);
+    const hasConditionalInputProcessors = storedAgent.inputProcessors != null && this.isConditionalVariants(storedAgent.inputProcessors);
+    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 tools = hasConditionalTools ? ({ requestContext }) => {
+      const ctx = requestContext.toJSON();
+      const resolved = this.accumulateObjectVariants(
+        storedAgent.tools,
+        ctx
+      );
+      return this.resolveStoredTools(resolved);
+    } : this.resolveStoredTools(storedAgent.tools);
+    const workflows = hasConditionalWorkflows ? ({ requestContext }) => {
+      const ctx = requestContext.toJSON();
+      const resolved = this.accumulateArrayVariants(
+        storedAgent.workflows,
+        ctx
+      );
+      return this.resolveStoredWorkflows(resolved);
+    } : this.resolveStoredWorkflows(storedAgent.workflows);
+    const agents = hasConditionalAgents ? ({ requestContext }) => {
+      const ctx = requestContext.toJSON();
+      const resolved = this.accumulateArrayVariants(
+        storedAgent.agents,
+        ctx
+      );
+      return this.resolveStoredAgents(resolved);
+    } : this.resolveStoredAgents(storedAgent.agents);
+    const memory = hasConditionalMemory ? ({ requestContext }) => {
+      const ctx = requestContext.toJSON();
+      const resolved = this.accumulateObjectVariants(
+        storedAgent.memory,
+        ctx
       );
+      return this.resolveStoredMemory(resolved);
+    } : this.resolveStoredMemory(storedAgent.memory);
+    const scorers = hasConditionalScorers ? async ({ requestContext }) => {
+      const ctx = requestContext.toJSON();
+      const resolved = this.accumulateObjectVariants(
+        storedAgent.scorers,
+        ctx
+      );
+      return this.resolveStoredScorers(resolved);
+    } : await this.resolveStoredScorers(storedAgent.scorers);
+    const inputProcessors = hasConditionalInputProcessors ? ({ requestContext }) => {
+      const ctx = requestContext.toJSON();
+      const resolved = this.accumulateArrayVariants(
+        storedAgent.inputProcessors,
+        ctx
+      );
+      return this.resolveStoredInputProcessors(resolved);
+    } : this.resolveStoredInputProcessors(storedAgent.inputProcessors);
+    const outputProcessors = hasConditionalOutputProcessors ? ({ requestContext }) => {
+      const ctx = requestContext.toJSON();
+      const resolved = this.accumulateArrayVariants(
+        storedAgent.outputProcessors,
+        ctx
+      );
+      return this.resolveStoredOutputProcessors(resolved);
+    } : this.resolveStoredOutputProcessors(storedAgent.outputProcessors);
+    let model;
+    let staticModelConfig;
+    const modelSettingsFrom = (cfg) => ({
+      temperature: cfg.temperature,
+      topP: cfg.topP,
+      frequencyPenalty: cfg.frequencyPenalty,
+      presencePenalty: cfg.presencePenalty,
+      maxOutputTokens: cfg.maxCompletionTokens
+    });
+    if (hasConditionalModel) {
+      model = ({ requestContext }) => {
+        const ctx = requestContext.toJSON();
+        const resolved = this.accumulateObjectVariants(
+          storedAgent.model,
+          ctx
+        );
+        if (!resolved || !resolved.provider || !resolved.name) {
+          throw new Error(
+            `Stored agent "${storedAgent.id}" conditional model resolved to invalid configuration. Both provider and name are required.`
+          );
+        }
+        return `${resolved.provider}/${resolved.name}`;
+      };
+    } else {
+      staticModelConfig = storedAgent.model;
+      if (!staticModelConfig || !staticModelConfig.provider || !staticModelConfig.name) {
+        throw new Error(
+          `Stored agent "${storedAgent.id}" has no active version or invalid model configuration. Both provider and name are required.`
+        );
+      }
+      model = `${staticModelConfig.provider}/${staticModelConfig.name}`;
+    }
+    const staticDefaultOptions = hasConditionalDefaultOptions || hasConditionalModel ? void 0 : storedAgent.defaultOptions;
+    const resolveModelSettings = (ctx) => {
+      const resolved = this.accumulateObjectVariants(
+        storedAgent.model,
+        ctx
+      );
+      return resolved ? modelSettingsFrom(resolved) : {};
+    };
+    let defaultOptions;
+    if (hasConditionalDefaultOptions || hasConditionalModel) {
+      defaultOptions = ({ requestContext }) => {
+        const ctx = requestContext.toJSON();
+        const baseOptions = hasConditionalDefaultOptions ? this.accumulateObjectVariants(
+          storedAgent.defaultOptions,
+          ctx
+        ) ?? {} : storedAgent.defaultOptions ?? {};
+        const mSettings = hasConditionalModel ? resolveModelSettings(ctx) : staticModelConfig ? modelSettingsFrom(staticModelConfig) : {};
+        return {
+          ...baseOptions,
+          modelSettings: {
+            ...baseOptions.modelSettings,
+            ...mSettings
+          }
+        };
+      };
+    } else {
+      defaultOptions = {
+        ...staticDefaultOptions,
+        modelSettings: {
+          ...staticDefaultOptions?.modelSettings,
+          ...staticModelConfig ? modelSettingsFrom(staticModelConfig) : void 0
+        }
+      };
     }
-    const model = `${modelConfig.provider}/${modelConfig.name}`;
-    const defaultOptions = storedAgent.defaultOptions;
+    const requestContextSchema = storedAgent.requestContextSchema ? convertSchemaToZod(storedAgent.requestContextSchema) : void 0;
     const agent = new Agent({
       id: storedAgent.id,
       name: storedAgent.name,
       description: storedAgent.description,
-      instructions: storedAgent.instructions,
+      instructions: instructions ?? "",
       model,
       memory,
       tools,
@@ -193,61 +519,64 @@ var MastraEditor = class {
       mastra: this.mastra,
       inputProcessors,
       outputProcessors,
-      defaultOptions: {
-        maxSteps: defaultOptions?.maxSteps,
-        modelSettings: {
-          temperature: modelConfig.temperature,
-          topP: modelConfig.topP,
-          frequencyPenalty: modelConfig.frequencyPenalty,
-          presencePenalty: modelConfig.presencePenalty,
-          maxOutputTokens: modelConfig.maxCompletionTokens
-        }
-      }
+      rawConfig: storedAgent,
+      defaultOptions,
+      requestContextSchema
     });
     this.mastra?.addAgent(agent, storedAgent.id, { source: "stored" });
     this.logger?.debug(`[createAgentFromStoredConfig] Successfully created agent "${storedAgent.id}"`);
     return agent;
   }
+  resolveStoredInstructions(instructions) {
+    if (instructions === void 0 || instructions === null) return void 0;
+    if (typeof instructions === "string") return instructions;
+    const blocks = instructions;
+    return async ({ requestContext }) => {
+      const storage = this.editor.__mastra.getStorage();
+      if (!storage) throw new Error("Storage is not configured");
+      const promptBlocksStore = await storage.getStore("promptBlocks");
+      if (!promptBlocksStore) throw new Error("Prompt blocks storage domain is not available");
+      const context = requestContext.toJSON();
+      return resolveInstructionBlocks(blocks, context, { promptBlocksStorage: promptBlocksStore });
+    };
+  }
   /**
    * Resolve stored tool IDs to actual tool instances from Mastra's registry.
+   * Applies description overrides from per-tool config when present.
    */
   resolveStoredTools(storedTools) {
-    if (!storedTools || storedTools.length === 0) {
+    if (!storedTools || (Array.isArray(storedTools) ? storedTools.length === 0 : Object.keys(storedTools).length === 0)) {
       return {};
     }
     if (!this.mastra) {
       return {};
     }
+    const normalized = Array.isArray(storedTools) ? Object.fromEntries(storedTools.map((key) => [key, {}])) : storedTools;
     const resolvedTools = {};
-    for (const toolKey of storedTools) {
+    for (const [toolKey, toolConfig] of Object.entries(normalized)) {
       try {
         const tool = this.mastra.getToolById(toolKey);
-        resolvedTools[toolKey] = tool;
+        if (toolConfig.description) {
+          resolvedTools[toolKey] = { ...tool, description: toolConfig.description };
+        } else {
+          resolvedTools[toolKey] = tool;
+        }
       } catch {
         this.logger?.warn(`Tool "${toolKey}" referenced in stored agent but not registered in Mastra`);
       }
     }
     return resolvedTools;
   }
-  /**
-   * Resolve stored workflow IDs to actual workflow instances from Mastra's registry.
-   */
   resolveStoredWorkflows(storedWorkflows) {
-    if (!storedWorkflows || storedWorkflows.length === 0) {
-      return {};
-    }
-    if (!this.mastra) {
-      return {};
-    }
+    if (!storedWorkflows || storedWorkflows.length === 0) return {};
+    if (!this.mastra) return {};
     const resolvedWorkflows = {};
     for (const workflowKey of storedWorkflows) {
       try {
-        const workflow = this.mastra.getWorkflow(workflowKey);
-        resolvedWorkflows[workflowKey] = workflow;
+        resolvedWorkflows[workflowKey] = this.mastra.getWorkflow(workflowKey);
       } catch {
         try {
-          const workflow = this.mastra.getWorkflowById(workflowKey);
-          resolvedWorkflows[workflowKey] = workflow;
+          resolvedWorkflows[workflowKey] = this.mastra.getWorkflowById(workflowKey);
         } catch {
           this.logger?.warn(`Workflow "${workflowKey}" referenced in stored agent but not registered in Mastra`);
         }
@@ -255,25 +584,16 @@ var MastraEditor = class {
     }
     return resolvedWorkflows;
   }
-  /**
-   * Resolve stored agent IDs to actual agent instances from Mastra's registry.
-   */
   resolveStoredAgents(storedAgents) {
-    if (!storedAgents || storedAgents.length === 0) {
-      return {};
-    }
-    if (!this.mastra) {
-      return {};
-    }
+    if (!storedAgents || storedAgents.length === 0) return {};
+    if (!this.mastra) return {};
     const resolvedAgents = {};
     for (const agentKey of storedAgents) {
       try {
-        const agent = this.mastra.getAgent(agentKey);
-        resolvedAgents[agentKey] = agent;
+        resolvedAgents[agentKey] = this.mastra.getAgent(agentKey);
       } catch {
         try {
-          const agent = this.mastra.getAgentById(agentKey);
-          resolvedAgents[agentKey] = agent;
+          resolvedAgents[agentKey] = this.mastra.getAgentById(agentKey);
         } catch {
           this.logger?.warn(`Agent "${agentKey}" referenced in stored agent but not registered in Mastra`);
         }
@@ -281,12 +601,7 @@ var MastraEditor = class {
     }
     return resolvedAgents;
   }
-  /**
-   * Resolve stored memory config to a MastraMemory instance.
-   * Uses @mastra/memory Memory class to instantiate from serialized config.
-   */
   resolveStoredMemory(memoryConfig) {
-    this.logger?.debug(`[resolveStoredMemory] Called with config:`, { memoryConfig });
     if (!memoryConfig) {
       this.logger?.debug(`[resolveStoredMemory] No memory config provided`);
       return void 0;
@@ -304,6 +619,20 @@ var MastraEditor = class {
           this.logger?.warn(`Vector provider "${memoryConfig.vector}" not found in Mastra instance`);
         }
       }
+      if (memoryConfig.options?.semanticRecall && (!vector || !memoryConfig.embedder)) {
+        this.logger?.warn(
+          "Semantic recall is enabled but no vector store or embedder are configured. Creating memory without semantic recall. To use semantic recall, configure a vector store and embedder in your Mastra instance."
+        );
+        const adjustedOptions = { ...memoryConfig.options, semanticRecall: false };
+        const sharedConfig2 = {
+          storage: this.mastra.getStorage(),
+          vector,
+          options: adjustedOptions,
+          embedder: memoryConfig.embedder,
+          embedderOptions: memoryConfig.embedderOptions
+        };
+        return new Memory(sharedConfig2);
+      }
       const sharedConfig = {
         storage: this.mastra.getStorage(),
         vector,
@@ -317,41 +646,40 @@ var MastraEditor = class {
       return void 0;
     }
   }
-  /**
-   * Resolve stored scorer configs to MastraScorers instances.
-   */
-  resolveStoredScorers(storedScorers) {
-    if (!storedScorers || Object.keys(storedScorers).length === 0) {
-      return void 0;
-    }
-    if (!this.mastra) {
-      return void 0;
-    }
+  async resolveStoredScorers(storedScorers) {
+    if (!storedScorers || Object.keys(storedScorers).length === 0) return void 0;
+    if (!this.mastra) return void 0;
     const resolvedScorers = {};
+    const storage = this.mastra.getStorage();
+    const scorerStore = storage ? await storage.getStore("scorerDefinitions") : null;
     for (const [scorerKey, scorerConfig] of Object.entries(storedScorers)) {
+      if (scorerStore) {
+        try {
+          const storedDef = await scorerStore.getByIdResolved(scorerKey);
+          if (storedDef) {
+            const scorer = this.editor.scorer.resolve(storedDef);
+            if (scorer) {
+              resolvedScorers[scorerKey] = { scorer, sampling: scorerConfig.sampling };
+              continue;
+            }
+          }
+        } catch {
+        }
+      }
       try {
         const scorer = this.mastra.getScorer(scorerKey);
-        resolvedScorers[scorerKey] = {
-          scorer,
-          sampling: scorerConfig.sampling
-        };
+        resolvedScorers[scorerKey] = { scorer, sampling: scorerConfig.sampling };
       } catch {
         try {
           const scorer = this.mastra.getScorerById(scorerKey);
-          resolvedScorers[scorerKey] = {
-            scorer,
-            sampling: scorerConfig.sampling
-          };
+          resolvedScorers[scorerKey] = { scorer, sampling: scorerConfig.sampling };
         } catch {
-          this.logger?.warn(`Scorer "${scorerKey}" referenced in stored agent but not registered in Mastra`);
+          this.logger?.warn(`Scorer "${scorerKey}" referenced in stored agent but not found in registry or storage`);
         }
       }
     }
     return Object.keys(resolvedScorers).length > 0 ? resolvedScorers : void 0;
   }
-  /**
-   * Look up a processor by key or ID from Mastra's registry.
-   */
   findProcessor(processorKey) {
     if (!this.mastra) return void 0;
     try {
@@ -365,9 +693,6 @@ var MastraEditor = class {
       }
     }
   }
-  /**
-   * Resolve stored input processor keys to actual processor instances.
-   */
   resolveStoredInputProcessors(storedProcessors) {
     if (!storedProcessors || storedProcessors.length === 0) return void 0;
     const resolved = [];
@@ -379,9 +704,6 @@ var MastraEditor = class {
     }
     return resolved.length > 0 ? resolved : void 0;
   }
-  /**
-   * Resolve stored output processor keys to actual processor instances.
-   */
   resolveStoredOutputProcessors(storedProcessors) {
     if (!storedProcessors || storedProcessors.length === 0) return void 0;
     const resolved = [];
@@ -393,7 +715,263 @@ var MastraEditor = class {
     }
     return resolved.length > 0 ? resolved : void 0;
   }
+  // ============================================================================
+  // Clone
+  // ============================================================================
+  /**
+   * Clone a runtime Agent instance into storage, creating a new stored agent
+   * with the resolved configuration of the source agent.
+   */
+  async clone(agent, options) {
+    const requestContext = options.requestContext ?? new RequestContext();
+    const llm = await agent.getLLM({ requestContext });
+    const provider = llm.getProvider();
+    const modelId = llm.getModelId();
+    const defaultOptions = await agent.getDefaultOptions({ requestContext });
+    const modelSettings = defaultOptions?.modelSettings;
+    const model = {
+      provider,
+      name: modelId,
+      ...modelSettings?.temperature !== void 0 && { temperature: modelSettings.temperature },
+      ...modelSettings?.topP !== void 0 && { topP: modelSettings.topP },
+      ...modelSettings?.frequencyPenalty !== void 0 && { frequencyPenalty: modelSettings.frequencyPenalty },
+      ...modelSettings?.presencePenalty !== void 0 && { presencePenalty: modelSettings.presencePenalty },
+      ...modelSettings?.maxOutputTokens !== void 0 && { maxCompletionTokens: modelSettings.maxOutputTokens }
+    };
+    const instructions = await agent.getInstructions({ requestContext });
+    let instructionsStr;
+    if (typeof instructions === "string") {
+      instructionsStr = instructions;
+    } else if (Array.isArray(instructions)) {
+      instructionsStr = instructions.map((msg) => {
+        if (typeof msg === "string") {
+          return msg;
+        }
+        return typeof msg.content === "string" ? msg.content : "";
+      }).filter(Boolean).join("\n\n");
+    } else if (instructions && typeof instructions === "object" && "content" in instructions) {
+      instructionsStr = typeof instructions.content === "string" ? instructions.content : "";
+    } else {
+      instructionsStr = "";
+    }
+    const tools = await agent.listTools({ requestContext });
+    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 memory = await agent.getMemory({ requestContext });
+    const memoryConfig = memory?.getConfig();
+    const { inputProcessorIds, outputProcessorIds } = await agent.getConfiguredProcessorIds(requestContext);
+    const inputProcessorKeys = inputProcessorIds.length > 0 ? inputProcessorIds : void 0;
+    const outputProcessorKeys = outputProcessorIds.length > 0 ? outputProcessorIds : void 0;
+    let storedScorers;
+    const resolvedScorers = await agent.listScorers({ requestContext });
+    if (resolvedScorers && Object.keys(resolvedScorers).length > 0) {
+      storedScorers = {};
+      for (const [key, entry] of Object.entries(resolvedScorers)) {
+        storedScorers[key] = {
+          ...entry.sampling && { sampling: entry.sampling }
+        };
+      }
+    }
+    const storageDefaultOptions = defaultOptions ? {
+      maxSteps: defaultOptions?.maxSteps,
+      runId: defaultOptions?.runId,
+      savePerStep: defaultOptions?.savePerStep,
+      activeTools: defaultOptions?.activeTools,
+      toolChoice: defaultOptions?.toolChoice,
+      modelSettings: defaultOptions?.modelSettings,
+      returnScorerData: defaultOptions?.returnScorerData,
+      requireToolApproval: defaultOptions?.requireToolApproval,
+      autoResumeSuspendedTools: defaultOptions?.autoResumeSuspendedTools,
+      toolCallConcurrency: defaultOptions?.toolCallConcurrency,
+      maxProcessorRetries: defaultOptions?.maxProcessorRetries,
+      includeRawChunks: defaultOptions?.includeRawChunks
+    } : void 0;
+    const createInput = {
+      id: options.newId,
+      name: options.newName || `${agent.name} (Clone)`,
+      description: agent.getDescription() || void 0,
+      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,
+      memory: memoryConfig,
+      inputProcessors: inputProcessorKeys,
+      outputProcessors: outputProcessorKeys,
+      scorers: storedScorers,
+      defaultOptions: storageDefaultOptions,
+      metadata: options.metadata,
+      authorId: options.authorId
+    };
+    const adapter = await this.getStorageAdapter();
+    await adapter.create(createInput);
+    const resolved = await adapter.getByIdResolved(options.newId);
+    if (!resolved) {
+      throw new Error(`Failed to resolve cloned agent '${options.newId}' after creation.`);
+    }
+    return resolved;
+  }
+};
+
+// src/namespaces/prompt.ts
+var EditorPromptNamespace = class extends CrudEditorNamespace {
+  onCacheEvict(id) {
+    this.mastra?.removePromptBlock(id);
+  }
+  async getStorageAdapter() {
+    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");
+    return {
+      create: (input) => store.create({ promptBlock: 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)
+    };
+  }
+  async preview(blocks, context) {
+    this.ensureRegistered();
+    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");
+    return resolveInstructionBlocks(blocks, context, { promptBlocksStorage: store });
+  }
+};
+
+// src/namespaces/scorer.ts
+import { createScorer } from "@mastra/core/evals";
+var EditorScorerNamespace = class extends CrudEditorNamespace {
+  onCacheEvict(id) {
+    this.mastra?.removeScorer(id);
+  }
+  /**
+   * Hydrate a stored scorer definition into a runtime MastraScorer instance
+   * and register it on the Mastra instance so it can be discovered via
+   * `mastra.getScorer()` / `mastra.getScorerById()`.
+   */
+  async hydrate(storedScorer) {
+    const scorer = this.resolve(storedScorer);
+    if (scorer && this.mastra) {
+      this.mastra.addScorer(scorer, storedScorer.id, { source: "stored" });
+    }
+    return storedScorer;
+  }
+  async getStorageAdapter() {
+    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");
+    return {
+      create: (input) => store.create({ scorerDefinition: 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)
+    };
+  }
+  /**
+   * Create a MastraScorer instance from a stored scorer definition.
+   * Supports:
+   * - 'llm-judge': Creates a scorer with a single LLM call using custom instructions
+   * - Preset types (e.g., 'bias', 'toxicity'): Not yet supported, returns null
+   */
+  resolve(storedScorer) {
+    if (storedScorer.type === "llm-judge") {
+      if (!storedScorer.instructions) {
+        this.logger?.warn(`Stored scorer "${storedScorer.id}" is llm-judge but has no instructions`);
+        return null;
+      }
+      const modelConfig = storedScorer.model;
+      if (!modelConfig?.provider || !modelConfig?.name) {
+        this.logger?.warn(`Stored scorer "${storedScorer.id}" has no valid model configuration`);
+        return null;
+      }
+      const model = `${modelConfig.provider}/${modelConfig.name}`;
+      const min = storedScorer.scoreRange?.min ?? 0;
+      const max = storedScorer.scoreRange?.max ?? 1;
+      const scorer = createScorer({
+        id: storedScorer.id,
+        name: storedScorer.name,
+        description: storedScorer.description || `Custom LLM judge scorer: ${storedScorer.name}`,
+        type: "agent",
+        judge: {
+          model,
+          instructions: storedScorer.instructions
+        }
+      }).generateScore({
+        description: `Score the output on a scale of ${min} to ${max}`,
+        createPrompt: ({ run }) => {
+          const input = typeof run.input === "string" ? run.input : JSON.stringify(run.input);
+          const output = typeof run.output === "string" ? run.output : JSON.stringify(run.output);
+          return `Evaluate the following interaction and provide a score between ${min} and ${max}.
+
+Input: ${input}
+
+Output: ${output}
+
+Provide your score as a JSON object with a "score" field containing a number between ${min} and ${max}.`;
+        }
+      }).generateReason({
+        description: "Explain the reasoning behind the score",
+        createPrompt: ({ run, score }) => {
+          const input = typeof run.input === "string" ? run.input : JSON.stringify(run.input);
+          const output = typeof run.output === "string" ? run.output : JSON.stringify(run.output);
+          return `You scored the following interaction ${score} out of ${max}.
+
+Input: ${input}
+
+Output: ${output}
+
+Explain your reasoning for this score in a clear, concise paragraph.`;
+        }
+      });
+      if (this.mastra) {
+        scorer.__registerMastra(this.mastra);
+      }
+      return scorer;
+    }
+    this.logger?.warn(
+      `Stored scorer "${storedScorer.id}" has type "${storedScorer.type}" which is a preset type. Preset instantiation from stored config is not yet supported.`
+    );
+    return null;
+  }
+};
+
+// src/index.ts
+var MastraEditor = class {
+  constructor(config) {
+    this.__logger = config?.logger;
+    this.agent = new EditorAgentNamespace(this);
+    this.prompt = new EditorPromptNamespace(this);
+    this.scorer = new EditorScorerNamespace(this);
+  }
+  /**
+   * Register this editor with a Mastra instance.
+   * This gives the editor access to Mastra's storage, tools, workflows, etc.
+   */
+  registerWithMastra(mastra) {
+    this.__mastra = mastra;
+    if (!this.__logger) {
+      this.__logger = mastra.getLogger();
+    }
+  }
 };
 export {
-  MastraEditor
+  CrudEditorNamespace,
+  EditorAgentNamespace,
+  EditorNamespace,
+  EditorPromptNamespace,
+  EditorScorerNamespace,
+  MastraEditor,
+  evaluateRuleGroup,
+  renderTemplate,
+  resolveInstructionBlocks
 };