@mastra/editor 0.0.0-auth-rbac-cms-20260211172515

package/dist/index.cjs

@@ -0,0 +1,715 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  MastraEditor: () => MastraEditor,
+  evaluateRuleGroup: () => evaluateRuleGroup,
+  renderTemplate: () => renderTemplate,
+  resolveInstructionBlocks: () => resolveInstructionBlocks
+});
+module.exports = __toCommonJS(index_exports);
+var import_memory = require("@mastra/memory");
+var import_core = require("@mastra/core");
+
+// src/template-engine.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;
+}
+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 = resolvePath(context, variablePath);
+      if (resolved !== void 0 && resolved !== null) {
+        return String(resolved);
+      }
+      const fallback = singleFallback ?? doubleFallback;
+      if (fallback !== void 0) {
+        return fallback;
+      }
+      return match;
+    }
+  );
+}
+
+// src/rule-evaluator.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;
+    }
+    current = current[segment];
+  }
+  return current;
+}
+function evaluateRule(rule, context) {
+  const fieldValue = resolvePath2(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);
+      }
+      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);
+      }
+      if (Array.isArray(fieldValue)) {
+        return !fieldValue.includes(rule.value);
+      }
+      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/instruction-builder.ts
+async function resolveInstructionBlocks(blocks, context, deps) {
+  const segments = [];
+  const blockIds = [
+    ...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.getPromptBlockByIdResolved({ id }))
+    );
+    for (let i = 0; i < blockIds.length; i++) {
+      const result = fetchResults[i];
+      if (result) {
+        resolvedBlocksMap.set(blockIds[i], result);
+      }
+    }
+  }
+  for (const block of blocks) {
+    if (block.type === "text") {
+      const rendered2 = renderTemplate(block.content, context);
+      if (rendered2.trim()) {
+        segments.push(rendered2);
+      }
+      continue;
+    }
+    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;
+    }
+    const resolved = resolvedBlocksMap.get(block.id);
+    if (!resolved) {
+      continue;
+    }
+    if (resolved.status !== "published") {
+      continue;
+    }
+    if (resolved.rules) {
+      const passes = evaluateRuleGroup(resolved.rules, context);
+      if (!passes) {
+        continue;
+      }
+    }
+    const rendered = renderTemplate(resolved.content, context);
+    if (rendered.trim()) {
+      segments.push(rendered);
+    }
+  }
+  return segments.join("\n\n");
+}
+
+// src/index.ts
+var MastraEditor = class {
+  constructor(config) {
+    this.logger = config?.logger;
+  }
+  /**
+   * 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();
+    }
+  }
+  /**
+   * Get the agents storage domain from the Mastra storage.
+   */
+  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;
+  }
+  /**
+   * Get the prompt blocks storage domain from the Mastra storage.
+   */
+  async getPromptBlocksStore() {
+    const storage = this.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");
+    return promptBlocksStore;
+  }
+  async getStoredAgentById(id, options) {
+    if (!this.mastra) {
+      throw new Error("MastraEditor is not registered with a Mastra instance");
+    }
+    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.`);
+    }
+    if (options?.versionId) {
+      const version = await agentsStore.getVersion(options.versionId);
+      if (!version) {
+        return null;
+      }
+      if (version.agentId !== id) {
+        return null;
+      }
+      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 { activeVersionId: _activeVersionId, ...agentRecordWithoutActiveVersion } = agentRecord;
+      const resolvedAgent = { ...agentRecordWithoutActiveVersion, ...snapshotConfig };
+      if (options?.returnRaw) {
+        return resolvedAgent;
+      }
+      return this.createAgentFromStoredConfig(resolvedAgent);
+    }
+    if (options?.versionNumber !== void 0) {
+      const version = await agentsStore.getVersionByNumber(id, options.versionNumber);
+      if (!version) {
+        return null;
+      }
+      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 { activeVersionId: _activeVersionId, ...agentRecordWithoutActiveVersion } = agentRecord;
+      const resolvedAgent = { ...agentRecordWithoutActiveVersion, ...snapshotConfig };
+      if (options?.returnRaw) {
+        return resolvedAgent;
+      }
+      return this.createAgentFromStoredConfig(resolvedAgent);
+    }
+    if (!options?.returnRaw) {
+      const agentCache2 = this.mastra.getStoredAgentCache();
+      if (agentCache2) {
+        const cached = agentCache2.get(id);
+        if (cached) {
+          return cached;
+        }
+        this.logger?.debug(`[getStoredAgentById] Cache miss for agent "${id}", fetching from storage`);
+      }
+    }
+    const storedAgent = await agentsStore.getAgentByIdResolved({ id });
+    if (!storedAgent) {
+      return null;
+    }
+    if (options?.returnRaw) {
+      return storedAgent;
+    }
+    const agent = this.createAgentFromStoredConfig(storedAgent);
+    const agentCache = this.mastra.getStoredAgentCache();
+    if (agentCache) {
+      agentCache.set(id, agent);
+    }
+    return agent;
+  }
+  async listStoredAgents(options) {
+    if (!this.mastra) {
+      throw new Error("MastraEditor is not registered with a Mastra instance");
+    }
+    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 agents = result.agents.map(
+      (storedAgent) => this.createAgentFromStoredConfig(storedAgent)
+    );
+    return {
+      agents,
+      total: result.total,
+      page: result.page,
+      perPage: result.perPage,
+      hasMore: result.hasMore
+    };
+  }
+  // ==========================================================================
+  // Prompt Block CRUD Methods
+  // ==========================================================================
+  /**
+   * Create a new prompt block with an initial version.
+   */
+  async createPromptBlock(input) {
+    if (!this.mastra) throw new Error("MastraEditor is not registered with a Mastra instance");
+    const store = await this.getPromptBlocksStore();
+    await store.createPromptBlock({ promptBlock: input });
+    const resolved = await store.getPromptBlockByIdResolved({ id: input.id });
+    if (!resolved) {
+      throw new Error(`Failed to resolve prompt block ${input.id} after creation`);
+    }
+    return resolved;
+  }
+  /**
+   * Get a prompt block by ID, resolved with its active version.
+   */
+  async getPromptBlock(id) {
+    if (!this.mastra) throw new Error("MastraEditor is not registered with a Mastra instance");
+    const store = await this.getPromptBlocksStore();
+    return store.getPromptBlockByIdResolved({ id });
+  }
+  /**
+   * Update a prompt block, creating a new version with the changes.
+   */
+  async updatePromptBlock(input) {
+    if (!this.mastra) throw new Error("MastraEditor is not registered with a Mastra instance");
+    const store = await this.getPromptBlocksStore();
+    await store.updatePromptBlock(input);
+    const resolved = await store.getPromptBlockByIdResolved({ id: input.id });
+    if (!resolved) {
+      throw new Error(`Failed to resolve prompt block ${input.id} after update`);
+    }
+    return resolved;
+  }
+  /**
+   * Delete a prompt block and all its versions.
+   */
+  async deletePromptBlock(id) {
+    if (!this.mastra) throw new Error("MastraEditor is not registered with a Mastra instance");
+    const store = await this.getPromptBlocksStore();
+    await store.deletePromptBlock({ id });
+  }
+  /**
+   * List prompt blocks with optional pagination and filtering.
+   */
+  async listPromptBlocks(args) {
+    if (!this.mastra) throw new Error("MastraEditor is not registered with a Mastra instance");
+    const store = await this.getPromptBlocksStore();
+    return store.listPromptBlocks(args);
+  }
+  /**
+   * List prompt blocks resolved with their active version config.
+   */
+  async listPromptBlocksResolved(args) {
+    if (!this.mastra) throw new Error("MastraEditor is not registered with a Mastra instance");
+    const store = await this.getPromptBlocksStore();
+    return store.listPromptBlocksResolved(args);
+  }
+  /**
+   * Preview the resolved instructions for a given set of instruction blocks and context.
+   * Useful for UI preview endpoints.
+   */
+  async previewInstructions(blocks, context) {
+    if (!this.mastra) throw new Error("MastraEditor is not registered with a Mastra instance");
+    const store = await this.getPromptBlocksStore();
+    return resolveInstructionBlocks(blocks, context, { promptBlocksStorage: store });
+  }
+  /**
+   * Clear the stored agent cache for a specific agent ID, or all cached agents.
+   * When clearing a specific agent, also removes it from Mastra's agent registry
+   * so that fresh data is loaded on next access.
+   */
+  clearStoredAgentCache(agentId) {
+    if (!this.mastra) return;
+    const agentCache = this.mastra.getStoredAgentCache();
+    if (agentId) {
+      if (agentCache) {
+        agentCache.delete(agentId);
+      }
+      this.mastra.removeAgent(agentId);
+      this.logger?.debug(`[clearStoredAgentCache] Cleared cache and registry for agent "${agentId}"`);
+    } else {
+      if (agentCache) {
+        agentCache.clear();
+      }
+      this.logger?.debug("[clearStoredAgentCache] Cleared all cached agents");
+    }
+  }
+  /**
+   * Create an Agent instance from stored configuration.
+   * Resolves all stored references (tools, workflows, agents, memory, scorers)
+   * and registers the agent with the Mastra instance.
+   */
+  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);
+    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 model = `${modelConfig.provider}/${modelConfig.name}`;
+    const defaultOptions = storedAgent.defaultOptions;
+    const instructions = this.resolveStoredInstructions(storedAgent.instructions);
+    const agent = new import_core.Agent({
+      id: storedAgent.id,
+      name: storedAgent.name,
+      description: storedAgent.description,
+      instructions: instructions ?? "",
+      model,
+      memory,
+      tools,
+      workflows,
+      agents,
+      scorers,
+      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
+        }
+      }
+    });
+    this.mastra?.addAgent(agent, storedAgent.id, { source: "stored" });
+    this.logger?.debug(`[createAgentFromStoredConfig] Successfully created agent "${storedAgent.id}"`);
+    return agent;
+  }
+  /**
+   * Resolve stored instructions to a value compatible with the Agent constructor.
+   * - `string` → pass through as-is (backward compatible)
+   * - `AgentInstructionBlock[]` → wrap in a DynamicArgument function that resolves at runtime
+   * - `undefined` → return undefined
+   */
+  resolveStoredInstructions(instructions) {
+    if (instructions === void 0 || instructions === null) {
+      return void 0;
+    }
+    if (typeof instructions === "string") {
+      return instructions;
+    }
+    const blocks = instructions;
+    return async ({ requestContext }) => {
+      const store = await this.getPromptBlocksStore();
+      const context = requestContext.toJSON();
+      return resolveInstructionBlocks(blocks, context, { promptBlocksStorage: store });
+    };
+  }
+  /**
+   * Resolve stored tool IDs to actual tool instances from Mastra's registry.
+   */
+  resolveStoredTools(storedTools) {
+    if (!storedTools || storedTools.length === 0) {
+      return {};
+    }
+    if (!this.mastra) {
+      return {};
+    }
+    const resolvedTools = {};
+    for (const toolKey of storedTools) {
+      try {
+        const tool = this.mastra.getToolById(toolKey);
+        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 {};
+    }
+    const resolvedWorkflows = {};
+    for (const workflowKey of storedWorkflows) {
+      try {
+        const workflow = this.mastra.getWorkflow(workflowKey);
+        resolvedWorkflows[workflowKey] = workflow;
+      } catch {
+        try {
+          const workflow = this.mastra.getWorkflowById(workflowKey);
+          resolvedWorkflows[workflowKey] = workflow;
+        } catch {
+          this.logger?.warn(`Workflow "${workflowKey}" referenced in stored agent but not registered in Mastra`);
+        }
+      }
+    }
+    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 {};
+    }
+    const resolvedAgents = {};
+    for (const agentKey of storedAgents) {
+      try {
+        const agent = this.mastra.getAgent(agentKey);
+        resolvedAgents[agentKey] = agent;
+      } catch {
+        try {
+          const agent = this.mastra.getAgentById(agentKey);
+          resolvedAgents[agentKey] = agent;
+        } catch {
+          this.logger?.warn(`Agent "${agentKey}" referenced in stored agent but not registered in Mastra`);
+        }
+      }
+    }
+    return resolvedAgents;
+  }
+  /**
+   * Resolve stored memory config to a MastraMemory instance.
+   * Uses @mastra/memory Memory class to instantiate from serialized config.
+   */
+  resolveStoredMemory(memoryConfig) {
+    if (!memoryConfig) {
+      this.logger?.debug(`[resolveStoredMemory] No memory config provided`);
+      return void 0;
+    }
+    if (!this.mastra) {
+      this.logger?.warn("MastraEditor not registered with Mastra instance. Cannot instantiate memory.");
+      return void 0;
+    }
+    try {
+      let vector;
+      if (memoryConfig.vector) {
+        const vectors = this.mastra.listVectors();
+        vector = vectors?.[memoryConfig.vector];
+        if (!vector) {
+          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
+        };
+        const memoryInstance2 = new import_memory.Memory(sharedConfig2);
+        return memoryInstance2;
+      }
+      const storage = this.mastra.getStorage();
+      const sharedConfig = {
+        storage,
+        vector,
+        options: memoryConfig.options,
+        embedder: memoryConfig.embedder,
+        embedderOptions: memoryConfig.embedderOptions
+      };
+      const memoryInstance = new import_memory.Memory(sharedConfig);
+      return memoryInstance;
+    } catch (error) {
+      this.logger?.error("Failed to resolve memory from config", { error });
+      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;
+    }
+    const resolvedScorers = {};
+    for (const [scorerKey, scorerConfig] of Object.entries(storedScorers)) {
+      try {
+        const scorer = this.mastra.getScorer(scorerKey);
+        resolvedScorers[scorerKey] = {
+          scorer,
+          sampling: scorerConfig.sampling
+        };
+      } catch {
+        try {
+          const scorer = this.mastra.getScorerById(scorerKey);
+          resolvedScorers[scorerKey] = {
+            scorer,
+            sampling: scorerConfig.sampling
+          };
+        } catch {
+          this.logger?.warn(`Scorer "${scorerKey}" referenced in stored agent but not registered in Mastra`);
+        }
+      }
+    }
+    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 {
+      return this.mastra.getProcessor(processorKey);
+    } catch {
+      try {
+        return this.mastra.getProcessorById(processorKey);
+      } catch {
+        this.logger?.warn(`Processor "${processorKey}" referenced in stored agent but not registered in Mastra`);
+        return void 0;
+      }
+    }
+  }
+  /**
+   * Resolve stored input processor keys to actual processor instances.
+   */
+  resolveStoredInputProcessors(storedProcessors) {
+    if (!storedProcessors || storedProcessors.length === 0) return void 0;
+    const resolved = [];
+    for (const key of storedProcessors) {
+      const processor = this.findProcessor(key);
+      if (processor && (processor.processInput || processor.processInputStep)) {
+        resolved.push(processor);
+      }
+    }
+    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 = [];
+    for (const key of storedProcessors) {
+      const processor = this.findProcessor(key);
+      if (processor && (processor.processOutputStream || processor.processOutputResult || processor.processOutputStep)) {
+        resolved.push(processor);
+      }
+    }
+    return resolved.length > 0 ? resolved : void 0;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MastraEditor,
+  evaluateRuleGroup,
+  renderTemplate,
+  resolveInstructionBlocks
+});