@mastra/core 0.10.12 → 0.10.13

package/dist/chunk-EWCOOO3H.js

@@ -1,5007 +0,0 @@
-import { DefaultVoice } from './chunk-5HTMDAXP.js';
-import { MessageList } from './chunk-4UBOJFSL.js';
-import { executeHook } from './chunk-BB4KXGBU.js';
-import { MastraLLM } from './chunk-YJEHXYK5.js';
-import { InstrumentClass } from './chunk-TC2SCOTE.js';
-import { ensureToolProperties, makeCoreTool, createMastraProxy } from './chunk-DFFVEKIG.js';
-import { MastraError } from './chunk-6UNGH46J.js';
-import { MastraBase } from './chunk-5IEKR756.js';
-import { RegisteredLogger } from './chunk-5YDTZN2X.js';
-import { RuntimeContext } from './chunk-SGGPJWRQ.js';
-import { __commonJS, __toESM, __decoratorStart, __decorateElement, __runInitializers } from './chunk-WQNOATKB.js';
-import { context, trace } from '@opentelemetry/api';
-import { z } from 'zod';
-import { get } from 'radash';
-import { randomUUID } from 'crypto';
-import EventEmitter from 'events';
-import sift from 'sift';
-import { createActor, assign, fromPromise, setup } from 'xstate';
-
-// ../../node_modules/.pnpm/fast-deep-equal@3.1.3/node_modules/fast-deep-equal/index.js
-var require_fast_deep_equal = __commonJS({
-  "../../node_modules/.pnpm/fast-deep-equal@3.1.3/node_modules/fast-deep-equal/index.js"(exports, module) {
-
-    module.exports = function equal(a, b) {
-      if (a === b) return true;
-      if (a && b && typeof a == "object" && typeof b == "object") {
-        if (a.constructor !== b.constructor) return false;
-        var length, i, keys;
-        if (Array.isArray(a)) {
-          length = a.length;
-          if (length != b.length) return false;
-          for (i = length; i-- !== 0;) if (!equal(a[i], b[i])) return false;
-          return true;
-        }
-        if (a.constructor === RegExp) return a.source === b.source && a.flags === b.flags;
-        if (a.valueOf !== Object.prototype.valueOf) return a.valueOf() === b.valueOf();
-        if (a.toString !== Object.prototype.toString) return a.toString() === b.toString();
-        keys = Object.keys(a);
-        length = keys.length;
-        if (length !== Object.keys(b).length) return false;
-        for (i = length; i-- !== 0;) if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false;
-        for (i = length; i-- !== 0;) {
-          var key = keys[i];
-          if (!equal(a[key], b[key])) return false;
-        }
-        return true;
-      }
-      return a !== a && b !== b;
-    };
-  }
-});
-
-// src/workflows/legacy/step.ts
-var LegacyStep = class {
-  id;
-  description;
-  inputSchema;
-  outputSchema;
-  payload;
-  execute;
-  retryConfig;
-  mastra;
-  constructor({
-    id,
-    description,
-    execute,
-    payload,
-    outputSchema,
-    inputSchema,
-    retryConfig
-  }) {
-    this.id = id;
-    this.description = description ?? "";
-    this.inputSchema = inputSchema;
-    this.payload = payload;
-    this.outputSchema = outputSchema;
-    this.execute = execute;
-    this.retryConfig = retryConfig;
-  }
-};
-
-// src/workflows/legacy/types.ts
-var WhenConditionReturnValue = /* @__PURE__ */(WhenConditionReturnValue2 => {
-  WhenConditionReturnValue2["CONTINUE"] = "continue";
-  WhenConditionReturnValue2["CONTINUE_FAILED"] = "continue_failed";
-  WhenConditionReturnValue2["ABORT"] = "abort";
-  WhenConditionReturnValue2["LIMBO"] = "limbo";
-  return WhenConditionReturnValue2;
-})(WhenConditionReturnValue || {});
-
-// src/agent/index.ts
-var import_fast_deep_equal = __toESM(require_fast_deep_equal(), 1);
-
-// src/agent/save-queue/index.ts
-var SaveQueueManager = class _SaveQueueManager {
-  logger;
-  debounceMs;
-  memory;
-  static MAX_STALENESS_MS = 1e3;
-  constructor({
-    logger,
-    debounceMs,
-    memory
-  }) {
-    this.logger = logger;
-    this.debounceMs = debounceMs || 100;
-    this.memory = memory;
-  }
-  saveQueues = /* @__PURE__ */new Map();
-  saveDebounceTimers = /* @__PURE__ */new Map();
-  /**
-   * Debounces save operations for a thread, ensuring that consecutive save requests
-   * are batched and only the latest is executed after a short delay.
-   * @param threadId - The ID of the thread to debounce saves for.
-   * @param saveFn - The save function to debounce.
-   */
-  debounceSave(threadId, messageList, memoryConfig) {
-    if (this.saveDebounceTimers.has(threadId)) {
-      clearTimeout(this.saveDebounceTimers.get(threadId));
-    }
-    this.saveDebounceTimers.set(threadId, setTimeout(() => {
-      this.enqueueSave(threadId, messageList, memoryConfig).catch(err => {
-        this.logger?.error?.("Error in debounceSave", {
-          err,
-          threadId
-        });
-      });
-      this.saveDebounceTimers.delete(threadId);
-    }, this.debounceMs));
-  }
-  /**
-   * Enqueues a save operation for a thread, ensuring that saves are executed in order and
-   * only one save runs at a time per thread. If a save is already in progress for the thread,
-   * the new save is queued to run after the previous completes.
-   *
-   * @param threadId - The ID of the thread whose messages should be saved.
-   * @param messageList - The MessageList instance containing unsaved messages.
-   * @param memoryConfig - Optional memory configuration to use for saving.
-   */
-  enqueueSave(threadId, messageList, memoryConfig) {
-    const prev = this.saveQueues.get(threadId) || Promise.resolve();
-    const next = prev.then(() => this.persistUnsavedMessages(messageList, memoryConfig)).catch(err => {
-      this.logger?.error?.("Error in enqueueSave", {
-        err,
-        threadId
-      });
-    }).then(() => {
-      if (this.saveQueues.get(threadId) === next) {
-        this.saveQueues.delete(threadId);
-      }
-    });
-    this.saveQueues.set(threadId, next);
-    return next;
-  }
-  /**
-   * Clears any pending debounced save for a thread, preventing the scheduled save
-   * from executing if it hasn't already fired.
-   *
-   * @param threadId - The ID of the thread whose debounced save should be cleared.
-   */
-  clearDebounce(threadId) {
-    if (this.saveDebounceTimers.has(threadId)) {
-      clearTimeout(this.saveDebounceTimers.get(threadId));
-      this.saveDebounceTimers.delete(threadId);
-    }
-  }
-  /**
-   * Persists any unsaved messages from the MessageList to memory storage.
-   * Drains the list of unsaved messages and writes them using the memory backend.
-   * @param messageList - The MessageList instance for the current thread.
-   * @param memoryConfig - The memory configuration for saving.
-   */
-  async persistUnsavedMessages(messageList, memoryConfig) {
-    const newMessages = messageList.drainUnsavedMessages();
-    if (newMessages.length > 0 && this.memory) {
-      await this.memory.saveMessages({
-        messages: newMessages,
-        memoryConfig
-      });
-    }
-  }
-  /**
-   * Batches a save of unsaved messages for a thread, using debouncing to batch rapid updates.
-   * If the oldest unsaved message is stale (older than MAX_STALENESS_MS), the save is performed immediately.
-   * Otherwise, the save is delayed to batch multiple updates and reduce redundant writes.
-   *
-   * @param messageList - The MessageList instance containing unsaved messages.
-   * @param threadId - The ID of the thread whose messages are being saved.
-   * @param memoryConfig - Optional memory configuration for saving.
-   */
-  async batchMessages(messageList, threadId, memoryConfig) {
-    if (!threadId) return;
-    const earliest = messageList.getEarliestUnsavedMessageTimestamp();
-    const now = Date.now();
-    if (earliest && now - earliest > _SaveQueueManager.MAX_STALENESS_MS) {
-      return this.flushMessages(messageList, threadId, memoryConfig);
-    } else {
-      return this.debounceSave(threadId, messageList, memoryConfig);
-    }
-  }
-  /**
-   * Forces an immediate save of unsaved messages for a thread, bypassing any debounce delay.
-   * This is used when a flush to persistent storage is required (e.g., on shutdown or critical transitions).
-   *
-   * @param messageList - The MessageList instance containing unsaved messages.
-   * @param threadId - The ID of the thread whose messages are being saved.
-   * @param memoryConfig - Optional memory configuration for saving.
-   */
-  async flushMessages(messageList, threadId, memoryConfig) {
-    if (!threadId) return;
-    this.clearDebounce(threadId);
-    return this.enqueueSave(threadId, messageList, memoryConfig);
-  }
-};
-
-// src/agent/index.ts
-function resolveMaybePromise(value, cb) {
-  if (value instanceof Promise) {
-    return value.then(cb);
-  }
-  return cb(value);
-}
-function resolveThreadIdFromArgs(args) {
-  if (args?.memory?.thread) {
-    if (typeof args.memory.thread === "string") return {
-      id: args.memory.thread
-    };
-    if (typeof args.memory.thread === "object" && args.memory.thread.id) return args.memory.thread;
-  }
-  if (args?.threadId) return {
-    id: args.threadId
-  };
-  return void 0;
-}
-var _Agent_decorators, _init, _a;
-_Agent_decorators = [InstrumentClass({
-  prefix: "agent",
-  excludeMethods: ["hasOwnMemory", "getMemory", "__primitive", "__registerMastra", "__registerPrimitives", "__setTools", "__setLogger", "__setTelemetry", "log", "getModel", "getInstructions", "getTools", "getLLM", "getWorkflows", "getDefaultGenerateOptions", "getDefaultStreamOptions", "getDescription"]
-})];
-var Agent = class extends (_a = MastraBase) {
-  id;
-  name;
-  #instructions;
-  #description;
-  model;
-  #mastra;
-  #memory;
-  #workflows;
-  #defaultGenerateOptions;
-  #defaultStreamOptions;
-  #tools;
-  /** @deprecated This property is deprecated. Use evals instead. */
-  metrics;
-  evals;
-  #voice;
-  constructor(config) {
-    super({
-      component: RegisteredLogger.AGENT
-    });
-    this.name = config.name;
-    this.id = config.name;
-    this.#instructions = config.instructions;
-    this.#description = config.description;
-    if (!config.model) {
-      const mastraError = new MastraError({
-        id: "AGENT_CONSTRUCTOR_MODEL_REQUIRED",
-        domain: "AGENT" /* AGENT */,
-        category: "USER" /* USER */,
-        details: {
-          agentName: config.name
-        },
-        text: `LanguageModel is required to create an Agent. Please provide the 'model'.`
-      });
-      this.logger.trackException(mastraError);
-      this.logger.error(mastraError.toString());
-      throw mastraError;
-    }
-    this.model = config.model;
-    if (config.workflows) {
-      this.#workflows = config.workflows;
-    }
-    this.#defaultGenerateOptions = config.defaultGenerateOptions || {};
-    this.#defaultStreamOptions = config.defaultStreamOptions || {};
-    this.#tools = config.tools || {};
-    this.metrics = {};
-    this.evals = {};
-    if (config.mastra) {
-      this.__registerMastra(config.mastra);
-      this.__registerPrimitives({
-        telemetry: config.mastra.getTelemetry(),
-        logger: config.mastra.getLogger()
-      });
-    }
-    if (config.metrics) {
-      this.logger.warn("The metrics property is deprecated. Please use evals instead to add evaluation metrics.");
-      this.metrics = config.metrics;
-      this.evals = config.metrics;
-    }
-    if (config.evals) {
-      this.evals = config.evals;
-    }
-    if (config.memory) {
-      this.#memory = config.memory;
-    }
-    if (config.voice) {
-      this.#voice = config.voice;
-      if (typeof config.tools !== "function") {
-        this.#voice?.addTools(this.tools);
-      }
-      if (typeof config.instructions === "string") {
-        this.#voice?.addInstructions(config.instructions);
-      }
-    } else {
-      this.#voice = new DefaultVoice();
-    }
-  }
-  hasOwnMemory() {
-    return Boolean(this.#memory);
-  }
-  getMemory() {
-    const memory = this.#memory;
-    if (memory && !memory.hasOwnStorage && this.#mastra) {
-      const storage = this.#mastra.getStorage();
-      if (storage) {
-        memory.setStorage(storage);
-      }
-    }
-    return memory;
-  }
-  get voice() {
-    if (typeof this.#instructions === "function") {
-      const mastraError = new MastraError({
-        id: "AGENT_VOICE_INCOMPATIBLE_WITH_FUNCTION_INSTRUCTIONS",
-        domain: "AGENT" /* AGENT */,
-        category: "USER" /* USER */,
-        details: {
-          agentName: this.name
-        },
-        text: "Voice is not compatible when instructions are a function. Please use getVoice() instead."
-      });
-      this.logger.trackException(mastraError);
-      this.logger.error(mastraError.toString());
-      throw mastraError;
-    }
-    return this.#voice;
-  }
-  async getWorkflows({
-    runtimeContext = new RuntimeContext()
-  } = {}) {
-    let workflowRecord;
-    if (typeof this.#workflows === "function") {
-      workflowRecord = await Promise.resolve(this.#workflows({
-        runtimeContext
-      }));
-    } else {
-      workflowRecord = this.#workflows ?? {};
-    }
-    Object.entries(workflowRecord || {}).forEach(([_workflowName, workflow]) => {
-      if (this.#mastra) {
-        workflow.__registerMastra(this.#mastra);
-      }
-    });
-    return workflowRecord;
-  }
-  async getVoice({
-    runtimeContext
-  } = {}) {
-    if (this.#voice) {
-      const voice = this.#voice;
-      voice?.addTools(await this.getTools({
-        runtimeContext
-      }));
-      voice?.addInstructions(await this.getInstructions({
-        runtimeContext
-      }));
-      return voice;
-    } else {
-      return new DefaultVoice();
-    }
-  }
-  get instructions() {
-    this.logger.warn("The instructions property is deprecated. Please use getInstructions() instead.");
-    if (typeof this.#instructions === "function") {
-      const mastraError = new MastraError({
-        id: "AGENT_INSTRUCTIONS_INCOMPATIBLE_WITH_FUNCTION_INSTRUCTIONS",
-        domain: "AGENT" /* AGENT */,
-        category: "USER" /* USER */,
-        details: {
-          agentName: this.name
-        },
-        text: "Instructions are not compatible when instructions are a function. Please use getInstructions() instead."
-      });
-      this.logger.trackException(mastraError);
-      this.logger.error(mastraError.toString());
-      throw mastraError;
-    }
-    return this.#instructions;
-  }
-  getInstructions({
-    runtimeContext = new RuntimeContext()
-  } = {}) {
-    if (typeof this.#instructions === "string") {
-      return this.#instructions;
-    }
-    const result = this.#instructions({
-      runtimeContext
-    });
-    return resolveMaybePromise(result, instructions => {
-      if (!instructions) {
-        const mastraError = new MastraError({
-          id: "AGENT_GET_INSTRUCTIONS_FUNCTION_EMPTY_RETURN",
-          domain: "AGENT" /* AGENT */,
-          category: "USER" /* USER */,
-          details: {
-            agentName: this.name
-          },
-          text: "Instructions are required to use an Agent. The function-based instructions returned an empty value."
-        });
-        this.logger.trackException(mastraError);
-        this.logger.error(mastraError.toString());
-        throw mastraError;
-      }
-      return instructions;
-    });
-  }
-  getDescription() {
-    return this.#description ?? "";
-  }
-  getDefaultGenerateOptions({
-    runtimeContext = new RuntimeContext()
-  } = {}) {
-    if (typeof this.#defaultGenerateOptions !== "function") {
-      return this.#defaultGenerateOptions;
-    }
-    const result = this.#defaultGenerateOptions({
-      runtimeContext
-    });
-    return resolveMaybePromise(result, options => {
-      if (!options) {
-        const mastraError = new MastraError({
-          id: "AGENT_GET_DEFAULT_GENERATE_OPTIONS_FUNCTION_EMPTY_RETURN",
-          domain: "AGENT" /* AGENT */,
-          category: "USER" /* USER */,
-          details: {
-            agentName: this.name
-          },
-          text: `[Agent:${this.name}] - Function-based default generate options returned empty value`
-        });
-        this.logger.trackException(mastraError);
-        this.logger.error(mastraError.toString());
-        throw mastraError;
-      }
-      return options;
-    });
-  }
-  getDefaultStreamOptions({
-    runtimeContext = new RuntimeContext()
-  } = {}) {
-    if (typeof this.#defaultStreamOptions !== "function") {
-      return this.#defaultStreamOptions;
-    }
-    const result = this.#defaultStreamOptions({
-      runtimeContext
-    });
-    return resolveMaybePromise(result, options => {
-      if (!options) {
-        const mastraError = new MastraError({
-          id: "AGENT_GET_DEFAULT_STREAM_OPTIONS_FUNCTION_EMPTY_RETURN",
-          domain: "AGENT" /* AGENT */,
-          category: "USER" /* USER */,
-          details: {
-            agentName: this.name
-          },
-          text: `[Agent:${this.name}] - Function-based default stream options returned empty value`
-        });
-        this.logger.trackException(mastraError);
-        this.logger.error(mastraError.toString());
-        throw mastraError;
-      }
-      return options;
-    });
-  }
-  get tools() {
-    this.logger.warn("The tools property is deprecated. Please use getTools() instead.");
-    if (typeof this.#tools === "function") {
-      const mastraError = new MastraError({
-        id: "AGENT_GET_TOOLS_FUNCTION_INCOMPATIBLE_WITH_TOOL_FUNCTION_TYPE",
-        domain: "AGENT" /* AGENT */,
-        category: "USER" /* USER */,
-        details: {
-          agentName: this.name
-        },
-        text: "Tools are not compatible when tools are a function. Please use getTools() instead."
-      });
-      this.logger.trackException(mastraError);
-      this.logger.error(mastraError.toString());
-      throw mastraError;
-    }
-    return ensureToolProperties(this.#tools);
-  }
-  getTools({
-    runtimeContext = new RuntimeContext()
-  } = {}) {
-    if (typeof this.#tools !== "function") {
-      return ensureToolProperties(this.#tools);
-    }
-    const result = this.#tools({
-      runtimeContext
-    });
-    return resolveMaybePromise(result, tools => {
-      if (!tools) {
-        const mastraError = new MastraError({
-          id: "AGENT_GET_TOOLS_FUNCTION_EMPTY_RETURN",
-          domain: "AGENT" /* AGENT */,
-          category: "USER" /* USER */,
-          details: {
-            agentName: this.name
-          },
-          text: `[Agent:${this.name}] - Function-based tools returned empty value`
-        });
-        this.logger.trackException(mastraError);
-        this.logger.error(mastraError.toString());
-        throw mastraError;
-      }
-      return ensureToolProperties(tools);
-    });
-  }
-  get llm() {
-    this.logger.warn("The llm property is deprecated. Please use getLLM() instead.");
-    if (typeof this.model === "function") {
-      const mastraError = new MastraError({
-        id: "AGENT_LLM_GETTER_INCOMPATIBLE_WITH_FUNCTION_MODEL",
-        domain: "AGENT" /* AGENT */,
-        category: "USER" /* USER */,
-        details: {
-          agentName: this.name
-        },
-        text: "LLM is not compatible when model is a function. Please use getLLM() instead."
-      });
-      this.logger.trackException(mastraError);
-      this.logger.error(mastraError.toString());
-      throw mastraError;
-    }
-    return this.getLLM();
-  }
-  /**
-   * Gets or creates an LLM instance based on the current model
-   * @param options Options for getting the LLM
-   * @returns A promise that resolves to the LLM instance
-   */
-  getLLM({
-    runtimeContext = new RuntimeContext(),
-    model
-  } = {}) {
-    const modelToUse = model ? typeof model === "function" ? model({
-      runtimeContext
-    }) : model : this.getModel({
-      runtimeContext
-    });
-    return resolveMaybePromise(modelToUse, resolvedModel => {
-      const llm = new MastraLLM({
-        model: resolvedModel,
-        mastra: this.#mastra
-      });
-      if (this.#primitives) {
-        llm.__registerPrimitives(this.#primitives);
-      }
-      if (this.#mastra) {
-        llm.__registerMastra(this.#mastra);
-      }
-      return llm;
-    });
-  }
-  /**
-   * Gets the model, resolving it if it's a function
-   * @param options Options for getting the model
-   * @returns A promise that resolves to the model
-   */
-  getModel({
-    runtimeContext = new RuntimeContext()
-  } = {}) {
-    if (typeof this.model !== "function") {
-      if (!this.model) {
-        const mastraError = new MastraError({
-          id: "AGENT_GET_MODEL_MISSING_MODEL_INSTANCE",
-          domain: "AGENT" /* AGENT */,
-          category: "USER" /* USER */,
-          details: {
-            agentName: this.name
-          },
-          text: `[Agent:${this.name}] - No model provided`
-        });
-        this.logger.trackException(mastraError);
-        this.logger.error(mastraError.toString());
-        throw mastraError;
-      }
-      return this.model;
-    }
-    const result = this.model({
-      runtimeContext
-    });
-    return resolveMaybePromise(result, model => {
-      if (!model) {
-        const mastraError = new MastraError({
-          id: "AGENT_GET_MODEL_FUNCTION_EMPTY_RETURN",
-          domain: "AGENT" /* AGENT */,
-          category: "USER" /* USER */,
-          details: {
-            agentName: this.name
-          },
-          text: `[Agent:${this.name}] - Function-based model returned empty value`
-        });
-        this.logger.trackException(mastraError);
-        this.logger.error(mastraError.toString());
-        throw mastraError;
-      }
-      return model;
-    });
-  }
-  __updateInstructions(newInstructions) {
-    this.#instructions = newInstructions;
-    this.logger.debug(`[Agents:${this.name}] Instructions updated.`, {
-      model: this.model,
-      name: this.name
-    });
-  }
-  #primitives;
-  __registerPrimitives(p) {
-    if (p.telemetry) {
-      this.__setTelemetry(p.telemetry);
-    }
-    if (p.logger) {
-      this.__setLogger(p.logger);
-    }
-    this.#primitives = p;
-    this.logger.debug(`[Agents:${this.name}] initialized.`, {
-      model: this.model,
-      name: this.name
-    });
-  }
-  __registerMastra(mastra) {
-    this.#mastra = mastra;
-  }
-  /**
-   * Set the concrete tools for the agent
-   * @param tools
-   */
-  __setTools(tools) {
-    this.#tools = tools;
-    this.logger.debug(`[Agents:${this.name}] Tools set for agent ${this.name}`, {
-      model: this.model,
-      name: this.name
-    });
-  }
-  async generateTitleFromUserMessage({
-    message,
-    runtimeContext = new RuntimeContext(),
-    model,
-    instructions
-  }) {
-    const llm = await this.getLLM({
-      runtimeContext,
-      model
-    });
-    const normMessage = new MessageList().add(message, "user").get.all.ui().at(-1);
-    if (!normMessage) {
-      throw new Error(`Could not generate title from input ${JSON.stringify(message)}`);
-    }
-    const partsToGen = [];
-    for (const part of normMessage.parts) {
-      if (part.type === `text`) {
-        partsToGen.push(part);
-      } else if (part.type === `source`) {
-        partsToGen.push({
-          type: "text",
-          text: `User added URL: ${part.source.url.substring(0, 100)}`
-        });
-      } else if (part.type === `file`) {
-        partsToGen.push({
-          type: "text",
-          text: `User added ${part.mimeType} file: ${part.data.substring(0, 100)}`
-        });
-      }
-    }
-    const systemInstructions = await this.resolveTitleInstructions(runtimeContext, instructions);
-    const {
-      text
-    } = await llm.__text({
-      runtimeContext,
-      messages: [{
-        role: "system",
-        content: systemInstructions
-      }, {
-        role: "user",
-        content: JSON.stringify(partsToGen)
-      }]
-    });
-    const cleanedText = text.replace(/<think>[\s\S]*?<\/think>/g, "").trim();
-    return cleanedText;
-  }
-  getMostRecentUserMessage(messages) {
-    const userMessages = messages.filter(message => message.role === "user");
-    return userMessages.at(-1);
-  }
-  async genTitle(userMessage, runtimeContext, model, instructions) {
-    try {
-      if (userMessage) {
-        const normMessage = new MessageList().add(userMessage, "user").get.all.ui().at(-1);
-        if (normMessage) {
-          return await this.generateTitleFromUserMessage({
-            message: normMessage,
-            runtimeContext,
-            model,
-            instructions
-          });
-        }
-      }
-      return `New Thread ${(/* @__PURE__ */new Date()).toISOString()}`;
-    } catch (e) {
-      this.logger.error("Error generating title:", e);
-      return void 0;
-    }
-  }
-  /* @deprecated use agent.getMemory() and query memory directly */
-  async fetchMemory({
-    threadId,
-    thread: passedThread,
-    memoryConfig,
-    resourceId,
-    runId,
-    userMessages,
-    systemMessage,
-    messageList = new MessageList({
-      threadId,
-      resourceId
-    })
-  }) {
-    const memory = this.getMemory();
-    if (memory) {
-      const thread = passedThread ?? (await memory.getThreadById({
-        threadId
-      }));
-      if (!thread) {
-        return {
-          threadId: threadId || "",
-          messages: userMessages || []
-        };
-      }
-      if (userMessages && userMessages.length > 0) {
-        messageList.add(userMessages, "memory");
-      }
-      if (systemMessage?.role === "system") {
-        messageList.addSystem(systemMessage, "memory");
-      }
-      const [memoryMessages, memorySystemMessage] = threadId && memory ? await Promise.all([memory.rememberMessages({
-        threadId,
-        resourceId,
-        config: memoryConfig,
-        vectorMessageSearch: messageList.getLatestUserContent() || ""
-      }).then(r => r.messagesV2), memory.getSystemMessage({
-        threadId,
-        memoryConfig
-      })]) : [[], null];
-      this.logger.debug("Fetched messages from memory", {
-        threadId,
-        runId,
-        fetchedCount: memoryMessages.length
-      });
-      if (memorySystemMessage) {
-        messageList.addSystem(memorySystemMessage, "memory");
-      }
-      messageList.add(memoryMessages, "memory");
-      const systemMessages = messageList.getSystemMessages()?.map(m => m.content)?.join(`
-`) ?? void 0;
-      const newMessages = messageList.get.input.v1();
-      const processedMemoryMessages = memory.processMessages({
-        // these will be processed
-        messages: messageList.get.remembered.v1(),
-        // these are here for inspecting but shouldn't be returned by the processor
-        // - ex TokenLimiter needs to measure all tokens even though it's only processing remembered messages
-        newMessages,
-        systemMessage: systemMessages,
-        memorySystemMessage: memorySystemMessage || void 0
-      });
-      const returnList = new MessageList().addSystem(systemMessages).add(processedMemoryMessages, "memory").add(newMessages, "user");
-      return {
-        threadId: thread.id,
-        messages: returnList.get.all.prompt()
-      };
-    }
-    return {
-      threadId: threadId || "",
-      messages: userMessages || []
-    };
-  }
-  async getMemoryTools({
-    runId,
-    resourceId,
-    threadId,
-    runtimeContext,
-    mastraProxy
-  }) {
-    let convertedMemoryTools = {};
-    const memory = this.getMemory();
-    const memoryTools = memory?.getTools?.();
-    if (memoryTools) {
-      const memoryToolEntries = await Promise.all(Object.entries(memoryTools).map(async ([k, tool]) => {
-        return [k, {
-          description: tool.description,
-          parameters: tool.parameters,
-          execute: typeof tool?.execute === "function" ? async (args, options) => {
-            try {
-              this.logger.debug(`[Agent:${this.name}] - Executing memory tool ${k}`, {
-                name: k,
-                description: tool.description,
-                args,
-                runId,
-                threadId,
-                resourceId
-              });
-              return tool?.execute?.({
-                context: args,
-                mastra: mastraProxy,
-                memory,
-                runId,
-                threadId,
-                resourceId,
-                logger: this.logger,
-                agentName: this.name,
-                runtimeContext
-              }, options) ?? void 0;
-            } catch (err) {
-              const mastraError = new MastraError({
-                id: "AGENT_MEMORY_TOOL_EXECUTION_FAILED",
-                domain: "AGENT" /* AGENT */,
-                category: "USER" /* USER */,
-                details: {
-                  agentName: this.name,
-                  runId: runId || "",
-                  threadId: threadId || "",
-                  resourceId: resourceId || ""
-                },
-                text: `[Agent:${this.name}] - Failed memory tool execution`
-              }, err);
-              this.logger.trackException(mastraError);
-              this.logger.error(mastraError.toString());
-              throw mastraError;
-            }
-          } : void 0
-        }];
-      }));
-      convertedMemoryTools = Object.fromEntries(memoryToolEntries.filter(entry => Boolean(entry)));
-    }
-    return convertedMemoryTools;
-  }
-  async getMemoryMessages({
-    resourceId,
-    threadId,
-    vectorMessageSearch,
-    memoryConfig
-  }) {
-    const memory = this.getMemory();
-    if (!memory) {
-      return [];
-    }
-    return memory.rememberMessages({
-      threadId,
-      resourceId,
-      config: memoryConfig,
-      // The new user messages aren't in the list yet cause we add memory messages first to try to make sure ordering is correct (memory comes before new user messages)
-      vectorMessageSearch
-    }).then(r => r.messagesV2);
-  }
-  async getAssignedTools({
-    runtimeContext,
-    runId,
-    resourceId,
-    threadId,
-    mastraProxy
-  }) {
-    let toolsForRequest = {};
-    this.logger.debug(`[Agents:${this.name}] - Assembling assigned tools`, {
-      runId,
-      threadId,
-      resourceId
-    });
-    const memory = this.getMemory();
-    const assignedTools = await this.getTools({
-      runtimeContext
-    });
-    const assignedToolEntries = Object.entries(assignedTools || {});
-    const assignedCoreToolEntries = await Promise.all(assignedToolEntries.map(async ([k, tool]) => {
-      if (!tool) {
-        return;
-      }
-      const options = {
-        name: k,
-        runId,
-        threadId,
-        resourceId,
-        logger: this.logger,
-        mastra: mastraProxy,
-        memory,
-        agentName: this.name,
-        runtimeContext,
-        model: typeof this.model === "function" ? await this.getModel({
-          runtimeContext
-        }) : this.model
-      };
-      return [k, makeCoreTool(tool, options)];
-    }));
-    const assignedToolEntriesConverted = Object.fromEntries(assignedCoreToolEntries.filter(entry => Boolean(entry)));
-    toolsForRequest = {
-      ...assignedToolEntriesConverted
-    };
-    return toolsForRequest;
-  }
-  async getToolsets({
-    runId,
-    threadId,
-    resourceId,
-    toolsets,
-    runtimeContext,
-    mastraProxy
-  }) {
-    let toolsForRequest = {};
-    const memory = this.getMemory();
-    const toolsFromToolsets = Object.values(toolsets || {});
-    if (toolsFromToolsets.length > 0) {
-      this.logger.debug(`[Agent:${this.name}] - Adding tools from toolsets ${Object.keys(toolsets || {}).join(", ")}`, {
-        runId
-      });
-      for (const toolset of toolsFromToolsets) {
-        for (const [toolName, tool] of Object.entries(toolset)) {
-          const toolObj = tool;
-          const options = {
-            name: toolName,
-            runId,
-            threadId,
-            resourceId,
-            logger: this.logger,
-            mastra: mastraProxy,
-            memory,
-            agentName: this.name,
-            runtimeContext,
-            model: typeof this.model === "function" ? await this.getModel({
-              runtimeContext
-            }) : this.model
-          };
-          const convertedToCoreTool = makeCoreTool(toolObj, options, "toolset");
-          toolsForRequest[toolName] = convertedToCoreTool;
-        }
-      }
-    }
-    return toolsForRequest;
-  }
-  async getClientTools({
-    runId,
-    threadId,
-    resourceId,
-    runtimeContext,
-    mastraProxy,
-    clientTools
-  }) {
-    let toolsForRequest = {};
-    const memory = this.getMemory();
-    const clientToolsForInput = Object.entries(clientTools || {});
-    if (clientToolsForInput.length > 0) {
-      this.logger.debug(`[Agent:${this.name}] - Adding client tools ${Object.keys(clientTools || {}).join(", ")}`, {
-        runId
-      });
-      for (const [toolName, tool] of clientToolsForInput) {
-        const {
-          execute,
-          ...rest
-        } = tool;
-        const options = {
-          name: toolName,
-          runId,
-          threadId,
-          resourceId,
-          logger: this.logger,
-          mastra: mastraProxy,
-          memory,
-          agentName: this.name,
-          runtimeContext,
-          model: typeof this.model === "function" ? await this.getModel({
-            runtimeContext
-          }) : this.model
-        };
-        const convertedToCoreTool = makeCoreTool(rest, options, "client-tool");
-        toolsForRequest[toolName] = convertedToCoreTool;
-      }
-    }
-    return toolsForRequest;
-  }
-  async getWorkflowTools({
-    runId,
-    threadId,
-    resourceId,
-    runtimeContext
-  }) {
-    let convertedWorkflowTools = {};
-    const workflows = await this.getWorkflows({
-      runtimeContext
-    });
-    if (Object.keys(workflows).length > 0) {
-      convertedWorkflowTools = Object.entries(workflows).reduce((memo, [workflowName, workflow]) => {
-        memo[workflowName] = {
-          description: workflow.description || `Workflow: ${workflowName}`,
-          parameters: workflow.inputSchema || {
-            type: "object",
-            properties: {}
-          },
-          execute: async args => {
-            try {
-              this.logger.debug(`[Agent:${this.name}] - Executing workflow as tool ${workflowName}`, {
-                name: workflowName,
-                description: workflow.description,
-                args,
-                runId,
-                threadId,
-                resourceId
-              });
-              const run = workflow.createRun();
-              const result = await run.start({
-                inputData: args,
-                runtimeContext
-              });
-              return result;
-            } catch (err) {
-              const mastraError = new MastraError({
-                id: "AGENT_WORKFLOW_TOOL_EXECUTION_FAILED",
-                domain: "AGENT" /* AGENT */,
-                category: "USER" /* USER */,
-                details: {
-                  agentName: this.name,
-                  runId: runId || "",
-                  threadId: threadId || "",
-                  resourceId: resourceId || ""
-                },
-                text: `[Agent:${this.name}] - Failed workflow tool execution`
-              }, err);
-              this.logger.trackException(mastraError);
-              this.logger.error(mastraError.toString());
-              throw mastraError;
-            }
-          }
-        };
-        return memo;
-      }, {});
-    }
-    return convertedWorkflowTools;
-  }
-  async convertTools({
-    toolsets,
-    clientTools,
-    threadId,
-    resourceId,
-    runId,
-    runtimeContext
-  }) {
-    let mastraProxy = void 0;
-    const logger = this.logger;
-    if (this.#mastra) {
-      mastraProxy = createMastraProxy({
-        mastra: this.#mastra,
-        logger
-      });
-    }
-    const assignedTools = await this.getAssignedTools({
-      runId,
-      resourceId,
-      threadId,
-      runtimeContext,
-      mastraProxy
-    });
-    const memoryTools = await this.getMemoryTools({
-      runId,
-      resourceId,
-      threadId,
-      runtimeContext,
-      mastraProxy
-    });
-    const toolsetTools = await this.getToolsets({
-      runId,
-      resourceId,
-      threadId,
-      runtimeContext,
-      mastraProxy,
-      toolsets
-    });
-    const clientsideTools = await this.getClientTools({
-      runId,
-      resourceId,
-      threadId,
-      runtimeContext,
-      mastraProxy,
-      clientTools
-    });
-    const workflowTools = await this.getWorkflowTools({
-      runId,
-      resourceId,
-      threadId,
-      runtimeContext
-    });
-    return {
-      ...assignedTools,
-      ...memoryTools,
-      ...toolsetTools,
-      ...clientsideTools,
-      ...workflowTools
-    };
-  }
-  /**
-   * Adds response messages from a step to the MessageList and schedules persistence.
-   * This is used for incremental saving: after each agent step, messages are added to a save queue
-   * and a debounced save operation is triggered to avoid redundant writes.
-   *
-   * @param result - The step result containing response messages.
-   * @param messageList - The MessageList instance for the current thread.
-   * @param threadId - The thread ID.
-   * @param memoryConfig - The memory configuration for saving.
-   * @param runId - (Optional) The run ID for logging.
-   */
-  async saveStepMessages({
-    saveQueueManager,
-    result,
-    messageList,
-    threadId,
-    memoryConfig,
-    runId
-  }) {
-    try {
-      messageList.add(result.response.messages, "response");
-      await saveQueueManager.batchMessages(messageList, threadId, memoryConfig);
-    } catch (e) {
-      await saveQueueManager.flushMessages(messageList, threadId, memoryConfig);
-      this.logger.error("Error saving memory on step finish", {
-        error: e,
-        runId
-      });
-      throw e;
-    }
-  }
-  __primitive({
-    instructions,
-    messages,
-    context,
-    thread,
-    memoryConfig,
-    resourceId,
-    runId,
-    toolsets,
-    clientTools,
-    runtimeContext,
-    generateMessageId,
-    saveQueueManager
-  }) {
-    return {
-      before: async () => {
-        if (process.env.NODE_ENV !== "test") {
-          this.logger.debug(`[Agents:${this.name}] - Starting generation`, {
-            runId
-          });
-        }
-        const memory = this.getMemory();
-        const toolEnhancements = [
-        // toolsets
-        toolsets && Object.keys(toolsets || {}).length > 0 ? `toolsets present (${Object.keys(toolsets || {}).length} tools)` : void 0,
-        // memory tools
-        memory && resourceId ? "memory and resourceId available" : void 0].filter(Boolean).join(", ");
-        this.logger.debug(`[Agent:${this.name}] - Enhancing tools: ${toolEnhancements}`, {
-          runId,
-          toolsets: toolsets ? Object.keys(toolsets) : void 0,
-          clientTools: clientTools ? Object.keys(clientTools) : void 0,
-          hasMemory: !!this.getMemory(),
-          hasResourceId: !!resourceId
-        });
-        const threadId = thread?.id;
-        const convertedTools = await this.convertTools({
-          toolsets,
-          clientTools,
-          threadId,
-          resourceId,
-          runId,
-          runtimeContext
-        });
-        const messageList = new MessageList({
-          threadId,
-          resourceId,
-          generateMessageId
-        }).addSystem({
-          role: "system",
-          content: instructions || `${this.instructions}.`
-        }).add(context || [], "context");
-        if (!memory || !threadId && !resourceId) {
-          messageList.add(messages, "user");
-          return {
-            messageObjects: messageList.get.all.prompt(),
-            convertedTools,
-            messageList
-          };
-        }
-        if (!threadId || !resourceId) {
-          const mastraError = new MastraError({
-            id: "AGENT_MEMORY_MISSING_RESOURCE_ID",
-            domain: "AGENT" /* AGENT */,
-            category: "USER" /* USER */,
-            details: {
-              agentName: this.name,
-              threadId: threadId || "",
-              resourceId: resourceId || ""
-            },
-            text: `A resourceId must be provided when passing a threadId and using Memory. Saw threadId ${threadId} but resourceId is ${resourceId}`
-          });
-          this.logger.trackException(mastraError);
-          this.logger.error(mastraError.toString());
-          throw mastraError;
-        }
-        const store = memory.constructor.name;
-        this.logger.debug(`[Agent:${this.name}] - Memory persistence enabled: store=${store}, resourceId=${resourceId}`, {
-          runId,
-          resourceId,
-          threadId,
-          memoryStore: store
-        });
-        let threadObject = void 0;
-        const existingThread = await memory.getThreadById({
-          threadId
-        });
-        if (existingThread) {
-          if (!existingThread.metadata && thread.metadata || thread.metadata && !(0, import_fast_deep_equal.default)(existingThread.metadata, thread.metadata)) {
-            threadObject = await memory.saveThread({
-              thread: {
-                ...existingThread,
-                metadata: thread.metadata
-              },
-              memoryConfig
-            });
-          } else {
-            threadObject = existingThread;
-          }
-        } else {
-          threadObject = await memory.createThread({
-            threadId,
-            metadata: thread.metadata,
-            title: thread.title,
-            memoryConfig,
-            resourceId
-          });
-        }
-        let [memoryMessages, memorySystemMessage] = thread.id && memory ? await Promise.all([this.getMemoryMessages({
-          resourceId,
-          threadId: threadObject.id,
-          vectorMessageSearch: new MessageList().add(messages, `user`).getLatestUserContent() || "",
-          memoryConfig
-        }), memory.getSystemMessage({
-          threadId: threadObject.id,
-          resourceId,
-          memoryConfig
-        })]) : [[], null];
-        this.logger.debug("Fetched messages from memory", {
-          threadId: threadObject.id,
-          runId,
-          fetchedCount: memoryMessages.length
-        });
-        const resultsFromOtherThreads = memoryMessages.filter(m => m.threadId !== threadObject.id);
-        if (resultsFromOtherThreads.length && !memorySystemMessage) {
-          memorySystemMessage = ``;
-        }
-        if (resultsFromOtherThreads.length) {
-          memorySystemMessage += `
-The following messages were remembered from a different conversation:
-<remembered_from_other_conversation>
-${JSON.stringify(
-          // get v1 since they're closer to CoreMessages (which get sent to the LLM) but also include timestamps
-          new MessageList().add(resultsFromOtherThreads, "memory").get.all.v1())}
-<end_remembered_from_other_conversation>`;
-        }
-        if (memorySystemMessage) {
-          messageList.addSystem(memorySystemMessage, "memory");
-        }
-        messageList.add(memoryMessages.filter(m => m.threadId === threadObject.id),
-        // filter out messages from other threads. those are added to system message above
-        "memory").add(messages, "user");
-        const systemMessage = [...messageList.getSystemMessages(), ...messageList.getSystemMessages("memory")]?.map(m => m.content)?.join(`
-`) ?? void 0;
-        const processedMemoryMessages = memory.processMessages({
-          // these will be processed
-          messages: messageList.get.remembered.v1(),
-          // these are here for inspecting but shouldn't be returned by the processor
-          // - ex TokenLimiter needs to measure all tokens even though it's only processing remembered messages
-          newMessages: messageList.get.input.v1(),
-          systemMessage,
-          memorySystemMessage: memorySystemMessage || void 0
-        });
-        const processedList = new MessageList({
-          threadId: threadObject.id,
-          resourceId
-        }).addSystem(instructions || `${this.instructions}.`).addSystem(memorySystemMessage).add(context || [], "context").add(processedMemoryMessages, "memory").add(messageList.get.input.v2(), "user").get.all.prompt();
-        return {
-          convertedTools,
-          thread: threadObject,
-          messageList,
-          // add old processed messages + new input messages
-          messageObjects: processedList
-        };
-      },
-      after: async ({
-        result,
-        thread: threadAfter,
-        threadId,
-        memoryConfig: memoryConfig2,
-        outputText,
-        runId: runId2,
-        messageList
-      }) => {
-        const resToLog = {
-          text: result?.text,
-          object: result?.object,
-          toolResults: result?.toolResults,
-          toolCalls: result?.toolCalls,
-          usage: result?.usage,
-          steps: result?.steps?.map(s => {
-            return {
-              stepType: s?.stepType,
-              text: result?.text,
-              object: result?.object,
-              toolResults: result?.toolResults,
-              toolCalls: result?.toolCalls,
-              usage: result?.usage
-            };
-          })
-        };
-        this.logger.debug(`[Agent:${this.name}] - Post processing LLM response`, {
-          runId: runId2,
-          result: resToLog,
-          threadId
-        });
-        const memory = this.getMemory();
-        const messageListResponses = new MessageList({
-          threadId,
-          resourceId
-        }).add(result.response.messages, "response").get.all.core();
-        const usedWorkingMemory = messageListResponses?.some(m => m.role === "tool" && m?.content?.some(c => c?.toolName === "updateWorkingMemory"));
-        const thread2 = usedWorkingMemory ? threadId ? await memory?.getThreadById({
-          threadId
-        }) : void 0 : threadAfter;
-        if (memory && resourceId && thread2) {
-          try {
-            let responseMessages = result.response.messages;
-            if (!responseMessages && result.object) {
-              responseMessages = [{
-                role: "assistant",
-                content: [{
-                  type: "text",
-                  text: outputText
-                  // outputText contains the stringified object
-                }]
-              }];
-            }
-            if (responseMessages) {
-              messageList.add(responseMessages, "response");
-            }
-            const promises = [saveQueueManager.flushMessages(messageList, threadId, memoryConfig2)];
-            if (thread2.title?.startsWith("New Thread")) {
-              const config = memory.getMergedThreadConfig(memoryConfig2);
-              const userMessage = this.getMostRecentUserMessage(messageList.get.all.ui());
-              const {
-                shouldGenerate,
-                model: titleModel,
-                instructions: titleInstructions
-              } = this.resolveTitleGenerationConfig(config?.threads?.generateTitle);
-              if (shouldGenerate && userMessage) {
-                promises.push(this.genTitle(userMessage, runtimeContext, titleModel, titleInstructions).then(title => {
-                  if (title) {
-                    return memory.createThread({
-                      threadId: thread2.id,
-                      resourceId,
-                      memoryConfig: memoryConfig2,
-                      title,
-                      metadata: thread2.metadata
-                    });
-                  }
-                }));
-              }
-            }
-            await Promise.all(promises);
-          } catch (e) {
-            await saveQueueManager.flushMessages(messageList, threadId, memoryConfig2);
-            if (e instanceof MastraError) {
-              throw e;
-            }
-            const mastraError = new MastraError({
-              id: "AGENT_MEMORY_PERSIST_RESPONSE_MESSAGES_FAILED",
-              domain: "AGENT" /* AGENT */,
-              category: "SYSTEM" /* SYSTEM */,
-              details: {
-                agentName: this.name,
-                runId: runId2 || "",
-                threadId: threadId || "",
-                result: JSON.stringify(resToLog)
-              }
-            }, e);
-            this.logger.trackException(mastraError);
-            this.logger.error(mastraError.toString());
-            throw mastraError;
-          }
-        }
-        if (Object.keys(this.evals || {}).length > 0) {
-          const userInputMessages = messageList.get.all.ui().filter(m => m.role === "user");
-          const input = userInputMessages.map(message => typeof message.content === "string" ? message.content : "").join("\n");
-          const runIdToUse = runId2 || crypto.randomUUID();
-          for (const metric of Object.values(this.evals || {})) {
-            executeHook("onGeneration" /* ON_GENERATION */, {
-              input,
-              output: outputText,
-              runId: runIdToUse,
-              metric,
-              agentName: this.name,
-              instructions: instructions || this.instructions
-            });
-          }
-        }
-      }
-    };
-  }
-  async generate(messages, generateOptions = {}) {
-    const defaultGenerateOptions = await this.getDefaultGenerateOptions({
-      runtimeContext: generateOptions.runtimeContext
-    });
-    const {
-      context,
-      memoryOptions: memoryConfigFromArgs,
-      resourceId: resourceIdFromArgs,
-      maxSteps,
-      onStepFinish,
-      output,
-      toolsets,
-      clientTools,
-      temperature,
-      toolChoice = "auto",
-      experimental_output,
-      telemetry,
-      runtimeContext = new RuntimeContext(),
-      savePerStep = false,
-      ...args
-    } = Object.assign({}, defaultGenerateOptions, generateOptions);
-    const generateMessageId = `experimental_generateMessageId` in args && typeof args.experimental_generateMessageId === `function` ? args.experimental_generateMessageId : void 0;
-    const threadFromArgs = resolveThreadIdFromArgs({
-      ...args,
-      ...generateOptions
-    });
-    const resourceId = args.memory?.resource || resourceIdFromArgs;
-    const memoryConfig = args.memory?.options || memoryConfigFromArgs;
-    const runId = args.runId || randomUUID();
-    const instructions = args.instructions || (await this.getInstructions({
-      runtimeContext
-    }));
-    const llm = await this.getLLM({
-      runtimeContext
-    });
-    const memory = this.getMemory();
-    const saveQueueManager = new SaveQueueManager({
-      logger: this.logger,
-      memory
-    });
-    const {
-      before,
-      after
-    } = this.__primitive({
-      messages,
-      instructions,
-      context,
-      thread: threadFromArgs,
-      memoryConfig,
-      resourceId,
-      runId,
-      toolsets,
-      clientTools,
-      runtimeContext,
-      generateMessageId,
-      saveQueueManager
-    });
-    const {
-      thread,
-      messageObjects,
-      convertedTools,
-      messageList
-    } = await before();
-    const threadId = thread?.id;
-    if (!output && experimental_output) {
-      const result2 = await llm.__text({
-        messages: messageObjects,
-        tools: convertedTools,
-        onStepFinish: async result3 => {
-          if (savePerStep) {
-            await this.saveStepMessages({
-              saveQueueManager,
-              result: result3,
-              messageList,
-              threadId,
-              memoryConfig,
-              runId
-            });
-          }
-          return onStepFinish?.({
-            ...result3,
-            runId
-          });
-        },
-        maxSteps,
-        runId,
-        temperature,
-        toolChoice: toolChoice || "auto",
-        experimental_output,
-        threadId,
-        resourceId,
-        memory: this.getMemory(),
-        runtimeContext,
-        telemetry,
-        ...args
-      });
-      const outputText2 = result2.text;
-      await after({
-        result: result2,
-        threadId,
-        thread,
-        memoryConfig,
-        outputText: outputText2,
-        runId,
-        messageList
-      });
-      const newResult = result2;
-      newResult.object = result2.experimental_output;
-      return newResult;
-    }
-    if (!output) {
-      const result2 = await llm.__text({
-        messages: messageObjects,
-        tools: convertedTools,
-        onStepFinish: async result3 => {
-          if (savePerStep) {
-            await this.saveStepMessages({
-              saveQueueManager,
-              result: result3,
-              messageList,
-              threadId,
-              memoryConfig,
-              runId
-            });
-          }
-          return onStepFinish?.({
-            ...result3,
-            runId
-          });
-        },
-        maxSteps,
-        runId,
-        temperature,
-        toolChoice,
-        telemetry,
-        threadId,
-        resourceId,
-        memory: this.getMemory(),
-        runtimeContext,
-        ...args
-      });
-      const outputText2 = result2.text;
-      await after({
-        result: result2,
-        thread,
-        threadId,
-        memoryConfig,
-        outputText: outputText2,
-        runId,
-        messageList
-      });
-      return result2;
-    }
-    const result = await llm.__textObject({
-      messages: messageObjects,
-      tools: convertedTools,
-      structuredOutput: output,
-      onStepFinish: async result2 => {
-        if (savePerStep) {
-          await this.saveStepMessages({
-            saveQueueManager,
-            result: result2,
-            messageList,
-            threadId,
-            memoryConfig,
-            runId
-          });
-        }
-        return onStepFinish?.({
-          ...result2,
-          runId
-        });
-      },
-      maxSteps,
-      runId,
-      temperature,
-      toolChoice,
-      telemetry,
-      memory: this.getMemory(),
-      runtimeContext,
-      ...args
-    });
-    const outputText = JSON.stringify(result.object);
-    await after({
-      result,
-      thread,
-      threadId,
-      memoryConfig,
-      outputText,
-      runId,
-      messageList
-    });
-    return result;
-  }
-  async stream(messages, streamOptions = {}) {
-    const defaultStreamOptions = await this.getDefaultStreamOptions({
-      runtimeContext: streamOptions.runtimeContext
-    });
-    const {
-      context,
-      memoryOptions: memoryConfigFromArgs,
-      resourceId: resourceIdFromArgs,
-      maxSteps,
-      onFinish,
-      onStepFinish,
-      toolsets,
-      clientTools,
-      output,
-      temperature,
-      toolChoice = "auto",
-      experimental_output,
-      telemetry,
-      runtimeContext = new RuntimeContext(),
-      savePerStep = false,
-      ...args
-    } = Object.assign({}, defaultStreamOptions, streamOptions);
-    const generateMessageId = `experimental_generateMessageId` in args && typeof args.experimental_generateMessageId === `function` ? args.experimental_generateMessageId : void 0;
-    const threadFromArgs = resolveThreadIdFromArgs({
-      ...args,
-      ...streamOptions
-    });
-    const resourceId = args.memory?.resource || resourceIdFromArgs;
-    const memoryConfig = args.memory?.options || memoryConfigFromArgs;
-    const runId = args.runId || randomUUID();
-    const instructions = args.instructions || (await this.getInstructions({
-      runtimeContext
-    }));
-    const llm = await this.getLLM({
-      runtimeContext
-    });
-    const memory = this.getMemory();
-    const saveQueueManager = new SaveQueueManager({
-      logger: this.logger,
-      memory
-    });
-    const {
-      before,
-      after
-    } = this.__primitive({
-      instructions,
-      messages,
-      context,
-      thread: threadFromArgs,
-      memoryConfig,
-      resourceId,
-      runId,
-      toolsets,
-      clientTools,
-      runtimeContext,
-      generateMessageId,
-      saveQueueManager
-    });
-    const {
-      thread,
-      messageObjects,
-      convertedTools,
-      messageList
-    } = await before();
-    const threadId = thread?.id;
-    if (!output && experimental_output) {
-      this.logger.debug(`Starting agent ${this.name} llm stream call`, {
-        runId
-      });
-      const streamResult = llm.__stream({
-        messages: messageObjects,
-        temperature,
-        tools: convertedTools,
-        onStepFinish: async result => {
-          if (savePerStep) {
-            await this.saveStepMessages({
-              saveQueueManager,
-              result,
-              messageList,
-              threadId,
-              memoryConfig,
-              runId
-            });
-          }
-          return onStepFinish?.({
-            ...result,
-            runId
-          });
-        },
-        onFinish: async result => {
-          try {
-            const outputText = result.text;
-            await after({
-              result,
-              thread,
-              threadId,
-              memoryConfig,
-              outputText,
-              runId,
-              messageList
-            });
-          } catch (e) {
-            this.logger.error("Error saving memory on finish", {
-              error: e,
-              runId
-            });
-          }
-          await onFinish?.({
-            ...result,
-            runId
-          });
-        },
-        maxSteps,
-        runId,
-        toolChoice,
-        experimental_output,
-        telemetry,
-        memory: this.getMemory(),
-        runtimeContext,
-        threadId: thread?.id,
-        resourceId,
-        ...args
-      });
-      const newStreamResult = streamResult;
-      newStreamResult.partialObjectStream = streamResult.experimental_partialOutputStream;
-      return newStreamResult;
-    } else if (!output) {
-      this.logger.debug(`Starting agent ${this.name} llm stream call`, {
-        runId
-      });
-      return llm.__stream({
-        messages: messageObjects,
-        temperature,
-        tools: convertedTools,
-        onStepFinish: async result => {
-          if (savePerStep) {
-            await this.saveStepMessages({
-              saveQueueManager,
-              result,
-              messageList,
-              threadId,
-              memoryConfig,
-              runId
-            });
-          }
-          return onStepFinish?.({
-            ...result,
-            runId
-          });
-        },
-        onFinish: async result => {
-          try {
-            const outputText = result.text;
-            await after({
-              result,
-              thread,
-              threadId,
-              memoryConfig,
-              outputText,
-              runId,
-              messageList
-            });
-          } catch (e) {
-            this.logger.error("Error saving memory on finish", {
-              error: e,
-              runId
-            });
-          }
-          await onFinish?.({
-            ...result,
-            runId
-          });
-        },
-        maxSteps,
-        runId,
-        toolChoice,
-        telemetry,
-        memory: this.getMemory(),
-        runtimeContext,
-        threadId: thread?.id,
-        resourceId,
-        ...args
-      });
-    }
-    this.logger.debug(`Starting agent ${this.name} llm streamObject call`, {
-      runId
-    });
-    return llm.__streamObject({
-      messages: messageObjects,
-      tools: convertedTools,
-      temperature,
-      structuredOutput: output,
-      onStepFinish: async result => {
-        if (savePerStep) {
-          await this.saveStepMessages({
-            saveQueueManager,
-            result,
-            messageList,
-            threadId,
-            memoryConfig,
-            runId
-          });
-        }
-        return onStepFinish?.({
-          ...result,
-          runId
-        });
-      },
-      onFinish: async result => {
-        try {
-          const outputText = JSON.stringify(result.object);
-          await after({
-            result,
-            thread,
-            threadId,
-            memoryConfig,
-            outputText,
-            runId,
-            messageList
-          });
-        } catch (e) {
-          this.logger.error("Error saving memory on finish", {
-            error: e,
-            runId
-          });
-        }
-        await onFinish?.({
-          ...result,
-          runId
-        });
-      },
-      runId,
-      toolChoice,
-      telemetry,
-      memory: this.getMemory(),
-      runtimeContext,
-      threadId: thread?.id,
-      resourceId,
-      ...args
-    });
-  }
-  /**
-   * Convert text to speech using the configured voice provider
-   * @param input Text or text stream to convert to speech
-   * @param options Speech options including speaker and provider-specific options
-   * @returns Audio stream
-   * @deprecated Use agent.voice.speak() instead
-   */
-  async speak(input, options) {
-    if (!this.voice) {
-      const mastraError = new MastraError({
-        id: "AGENT_SPEAK_METHOD_VOICE_NOT_CONFIGURED",
-        domain: "AGENT" /* AGENT */,
-        category: "USER" /* USER */,
-        details: {
-          agentName: this.name
-        },
-        text: "No voice provider configured"
-      });
-      this.logger.trackException(mastraError);
-      this.logger.error(mastraError.toString());
-      throw mastraError;
-    }
-    this.logger.warn("Warning: agent.speak() is deprecated. Please use agent.voice.speak() instead.");
-    try {
-      return this.voice.speak(input, options);
-    } catch (e) {
-      let err;
-      if (e instanceof MastraError) {
-        err = e;
-      } else {
-        err = new MastraError({
-          id: "AGENT_SPEAK_METHOD_ERROR",
-          domain: "AGENT" /* AGENT */,
-          category: "UNKNOWN" /* UNKNOWN */,
-          details: {
-            agentName: this.name
-          },
-          text: "Error during agent speak"
-        }, e);
-      }
-      this.logger.trackException(err);
-      this.logger.error(err.toString());
-      throw err;
-    }
-  }
-  /**
-   * Convert speech to text using the configured voice provider
-   * @param audioStream Audio stream to transcribe
-   * @param options Provider-specific transcription options
-   * @returns Text or text stream
-   * @deprecated Use agent.voice.listen() instead
-   */
-  async listen(audioStream, options) {
-    if (!this.voice) {
-      const mastraError = new MastraError({
-        id: "AGENT_LISTEN_METHOD_VOICE_NOT_CONFIGURED",
-        domain: "AGENT" /* AGENT */,
-        category: "USER" /* USER */,
-        details: {
-          agentName: this.name
-        },
-        text: "No voice provider configured"
-      });
-      this.logger.trackException(mastraError);
-      this.logger.error(mastraError.toString());
-      throw mastraError;
-    }
-    this.logger.warn("Warning: agent.listen() is deprecated. Please use agent.voice.listen() instead");
-    try {
-      return this.voice.listen(audioStream, options);
-    } catch (e) {
-      let err;
-      if (e instanceof MastraError) {
-        err = e;
-      } else {
-        err = new MastraError({
-          id: "AGENT_LISTEN_METHOD_ERROR",
-          domain: "AGENT" /* AGENT */,
-          category: "UNKNOWN" /* UNKNOWN */,
-          details: {
-            agentName: this.name
-          },
-          text: "Error during agent listen"
-        }, e);
-      }
-      this.logger.trackException(err);
-      this.logger.error(err.toString());
-      throw err;
-    }
-  }
-  /**
-   * Get a list of available speakers from the configured voice provider
-   * @throws {Error} If no voice provider is configured
-   * @returns {Promise<Array<{voiceId: string}>>} List of available speakers
-   * @deprecated Use agent.voice.getSpeakers() instead
-   */
-  async getSpeakers() {
-    if (!this.voice) {
-      const mastraError = new MastraError({
-        id: "AGENT_SPEAKERS_METHOD_VOICE_NOT_CONFIGURED",
-        domain: "AGENT" /* AGENT */,
-        category: "USER" /* USER */,
-        details: {
-          agentName: this.name
-        },
-        text: "No voice provider configured"
-      });
-      this.logger.trackException(mastraError);
-      this.logger.error(mastraError.toString());
-      throw mastraError;
-    }
-    this.logger.warn("Warning: agent.getSpeakers() is deprecated. Please use agent.voice.getSpeakers() instead.");
-    try {
-      return await this.voice.getSpeakers();
-    } catch (e) {
-      let err;
-      if (e instanceof MastraError) {
-        err = e;
-      } else {
-        err = new MastraError({
-          id: "AGENT_GET_SPEAKERS_METHOD_ERROR",
-          domain: "AGENT" /* AGENT */,
-          category: "UNKNOWN" /* UNKNOWN */,
-          details: {
-            agentName: this.name
-          },
-          text: "Error during agent getSpeakers"
-        }, e);
-      }
-      this.logger.trackException(err);
-      this.logger.error(err.toString());
-      throw err;
-    }
-  }
-  toStep() {
-    const x = agentToStep(this);
-    return new LegacyStep(x);
-  }
-  /**
-   * Resolves the configuration for title generation.
-   * @private
-   */
-  resolveTitleGenerationConfig(generateTitleConfig) {
-    if (typeof generateTitleConfig === "boolean") {
-      return {
-        shouldGenerate: generateTitleConfig
-      };
-    }
-    if (typeof generateTitleConfig === "object" && generateTitleConfig !== null) {
-      return {
-        shouldGenerate: true,
-        model: generateTitleConfig.model,
-        instructions: generateTitleConfig.instructions
-      };
-    }
-    return {
-      shouldGenerate: false
-    };
-  }
-  /**
-   * Resolves title generation instructions, handling both static strings and dynamic functions
-   * @private
-   */
-  async resolveTitleInstructions(runtimeContext, instructions) {
-    const DEFAULT_TITLE_INSTRUCTIONS = `
-    - you will generate a short title based on the first message a user begins a conversation with
-    - ensure it is not more than 80 characters long
-    - the title should be a summary of the user's message
-    - do not use quotes or colons
-    - the entire text you return will be used as the title`;
-    if (!instructions) {
-      return DEFAULT_TITLE_INSTRUCTIONS;
-    }
-    if (typeof instructions === "string") {
-      return instructions;
-    } else {
-      const result = instructions({
-        runtimeContext
-      });
-      return resolveMaybePromise(result, resolvedInstructions => {
-        return resolvedInstructions || DEFAULT_TITLE_INSTRUCTIONS;
-      });
-    }
-  }
-};
-Agent = /*@__PURE__*/(_ => {
-  _init = __decoratorStart(_a);
-  Agent = __decorateElement(_init, 0, "Agent", _Agent_decorators, Agent);
-  __runInitializers(_init, 1, Agent);
-
-  // src/workflows/legacy/utils.ts
-  return Agent;
-})();
-// src/workflows/legacy/utils.ts
-function isErrorEvent(stateEvent) {
-  return stateEvent.type.startsWith("xstate.error.actor.");
-}
-function isTransitionEvent(stateEvent) {
-  return stateEvent.type.startsWith("xstate.done.actor.");
-}
-function isVariableReference(value) {
-  return typeof value === "object" && "step" in value && "path" in value;
-}
-function getStepResult(result) {
-  if (result?.status === "success") return result.output;
-  return void 0;
-}
-function getSuspendedPaths({
-  value,
-  path,
-  suspendedPaths
-}) {
-  if (typeof value === "string") {
-    if (value === "suspended") {
-      suspendedPaths.add(path);
-    }
-  } else {
-    Object.keys(value).forEach(key => getSuspendedPaths({
-      value: value[key],
-      path: path ? `${path}.${key}` : key,
-      suspendedPaths
-    }));
-  }
-}
-function isFinalState(status) {
-  return ["completed", "failed"].includes(status);
-}
-function isLimboState(status) {
-  return status === "limbo";
-}
-function recursivelyCheckForFinalState({
-  value,
-  suspendedPaths,
-  path
-}) {
-  if (typeof value === "string") {
-    return isFinalState(value) || isLimboState(value) || suspendedPaths.has(path);
-  }
-  return Object.keys(value).every(key => recursivelyCheckForFinalState({
-    value: value[key],
-    suspendedPaths,
-    path: path ? `${path}.${key}` : key
-  }));
-}
-function getActivePathsAndStatus(value) {
-  const paths = [];
-  const traverse = (current, path = []) => {
-    for (const [key, value2] of Object.entries(current)) {
-      const currentPath = [...path, key];
-      if (typeof value2 === "string") {
-        paths.push({
-          stepPath: currentPath,
-          stepId: key,
-          status: value2
-        });
-      } else if (typeof value2 === "object" && value2 !== null) {
-        traverse(value2, currentPath);
-      }
-    }
-  };
-  traverse(value);
-  return paths;
-}
-function mergeChildValue(startStepId, parent, child) {
-  const traverse = current => {
-    const obj = {};
-    for (const [key, value] of Object.entries(current)) {
-      if (key === startStepId) {
-        obj[key] = {
-          ...child
-        };
-      } else if (typeof value === "string") {
-        obj[key] = value;
-      } else if (typeof value === "object" && value !== null) {
-        obj[key] = traverse(value);
-      }
-    }
-    return obj;
-  };
-  return traverse(parent);
-}
-var updateStepInHierarchy = (value, targetStepId) => {
-  const result = {};
-  for (const key of Object.keys(value)) {
-    const currentValue = value[key];
-    if (key === targetStepId) {
-      result[key] = "pending";
-    } else if (typeof currentValue === "object" && currentValue !== null) {
-      result[key] = updateStepInHierarchy(currentValue, targetStepId);
-    } else {
-      result[key] = currentValue;
-    }
-  }
-  return result;
-};
-function getResultActivePaths(state) {
-  const activePaths = getActivePathsAndStatus(state.value);
-  const activePathsAndStatus = activePaths.reduce((acc, curr) => {
-    const entry = {
-      status: curr.status,
-      stepPath: curr.stepPath
-    };
-    if (curr.status === "suspended") {
-      entry.suspendPayload = state.context.steps[curr.stepId].suspendPayload;
-      entry.stepPath = curr.stepPath;
-    }
-    acc.set(curr.stepId, entry);
-    return acc;
-  }, /* @__PURE__ */new Map());
-  return activePathsAndStatus;
-}
-function isWorkflow(step) {
-  return step instanceof LegacyWorkflow;
-}
-function isAgent(step) {
-  return step instanceof Agent;
-}
-function resolveVariables({
-  runId,
-  logger,
-  variables,
-  context
-}) {
-  const resolvedData = {};
-  for (const [key, variable] of Object.entries(variables)) {
-    const sourceData = variable.step === "trigger" ? context.triggerData : getStepResult(context.steps[variable.step.id ?? variable.step.name]);
-    logger.debug(`Got source data for ${key} variable from ${variable.step === "trigger" ? "trigger" : variable.step.id ?? variable.step.name}`, {
-      sourceData,
-      path: variable.path,
-      runId
-    });
-    if (!sourceData && variable.step !== "trigger") {
-      resolvedData[key] = void 0;
-      continue;
-    }
-    const value = variable.path === "" || variable.path === "." ? sourceData : get(sourceData, variable.path);
-    logger.debug(`Resolved variable ${key}`, {
-      value,
-      runId
-    });
-    resolvedData[key] = value;
-  }
-  return resolvedData;
-}
-function agentToStep(agent, {
-  mastra
-} = {}) {
-  return {
-    id: agent.name,
-    inputSchema: z.object({
-      prompt: z.string(),
-      resourceId: z.string().optional(),
-      threadId: z.string().optional()
-    }),
-    outputSchema: z.object({
-      text: z.string()
-    }),
-    execute: async ({
-      context,
-      runId,
-      mastra: mastraFromExecute
-    }) => {
-      const realMastra = mastraFromExecute ?? mastra;
-      if (!realMastra) {
-        throw new Error("Mastra instance not found");
-      }
-      agent.__registerMastra(realMastra);
-      agent.__registerPrimitives({
-        logger: realMastra.getLogger(),
-        telemetry: realMastra.getTelemetry()
-      });
-      const result = await agent.generate(context.inputData.prompt, {
-        runId,
-        resourceId: context.inputData.resourceId,
-        threadId: context.inputData.threadId
-      });
-      return {
-        text: result.text
-      };
-    }
-  };
-}
-function workflowToStep(workflow, {
-  mastra
-}) {
-  workflow.setNested(true);
-  return {
-    id: workflow.name,
-    workflow,
-    workflowId: toCamelCaseWithRandomSuffix(workflow.name),
-    execute: async ({
-      context,
-      suspend,
-      emit,
-      mastra: mastraFromExecute,
-      runtimeContext
-    }) => {
-      const realMastra = mastraFromExecute ?? mastra;
-      if (realMastra) {
-        workflow.__registerMastra(realMastra);
-        workflow.__registerPrimitives({
-          logger: realMastra.getLogger(),
-          telemetry: realMastra.getTelemetry()
-        });
-      }
-      const run = context.isResume ? workflow.createRun({
-        runId: context.isResume.runId
-      }) : workflow.createRun();
-      const unwatch = run.watch(state => {
-        emit("state-update", workflow.name, state.results, {
-          ...context,
-          ...{
-            [workflow.name]: state.results
-          }
-        });
-      });
-      const awaitedResult = context.isResume && context.isResume.stepId.includes(".") ? await run.resume({
-        stepId: context.isResume.stepId.split(".").slice(1).join("."),
-        context: context.inputData,
-        runtimeContext
-      }) : await run.start({
-        triggerData: context.inputData,
-        runtimeContext
-      });
-      unwatch();
-      if (!awaitedResult) {
-        throw new Error("LegacyWorkflow run failed");
-      }
-      if (awaitedResult.activePaths?.size > 0) {
-        const suspendedStep = [...awaitedResult.activePaths.entries()].find(([, {
-          status
-        }]) => {
-          return status === "suspended";
-        });
-        if (suspendedStep) {
-          await suspend(suspendedStep[1].suspendPayload, {
-            ...awaitedResult,
-            runId: run.runId
-          });
-        }
-      }
-      return {
-        ...awaitedResult,
-        runId: run.runId
-      };
-    }
-  };
-}
-function toCamelCaseWithRandomSuffix(str) {
-  if (!str) return "";
-  const normalizedStr = str.replace(/[-_]/g, " ");
-  const words = normalizedStr.split(" ").filter(word => word.length > 0);
-  const camelCase = words.map((word, index) => {
-    word = word.replace(/[^a-zA-Z0-9]/g, "");
-    if (index === 0) {
-      return word.toLowerCase();
-    }
-    return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
-  }).join("");
-  const randomString = generateRandomLetters(3);
-  return camelCase + randomString;
-}
-function generateRandomLetters(length) {
-  const characters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
-  let result = "";
-  for (let i = 0; i < length; i++) {
-    const randomIndex = Math.floor(Math.random() * characters.length);
-    result += characters.charAt(randomIndex);
-  }
-  return result;
-}
-function isConditionalKey(key) {
-  return key.startsWith("__") && (key.includes("_if") || key.includes("_else"));
-}
-var Machine = class extends EventEmitter {
-  logger;
-  #mastra;
-  #runtimeContext;
-  #workflowInstance;
-  #executionSpan;
-  #stepGraph;
-  #machine;
-  #runId;
-  #startStepId;
-  name;
-  #actor = null;
-  #steps = {};
-  #retryConfig;
-  constructor({
-    logger,
-    mastra,
-    runtimeContext,
-    workflowInstance,
-    executionSpan,
-    name,
-    runId,
-    steps,
-    stepGraph,
-    retryConfig,
-    startStepId
-  }) {
-    super();
-    this.#mastra = mastra;
-    this.#workflowInstance = workflowInstance;
-    this.#runtimeContext = runtimeContext;
-    this.#executionSpan = executionSpan;
-    this.logger = logger;
-    this.#runId = runId;
-    this.#startStepId = startStepId;
-    this.name = name;
-    this.#stepGraph = stepGraph;
-    this.#steps = steps;
-    this.#retryConfig = retryConfig;
-    this.initializeMachine();
-  }
-  get startStepId() {
-    return this.#startStepId;
-  }
-  async execute({
-    stepId,
-    input,
-    snapshot,
-    resumeData
-  } = {}) {
-    if (snapshot) {
-      this.logger.debug(`Workflow snapshot received`, {
-        runId: this.#runId,
-        snapshot
-      });
-    }
-    const origSteps = input.steps;
-    const isResumedInitialStep = this.#stepGraph?.initial[0]?.step?.id === stepId;
-    if (isResumedInitialStep) {
-      snapshot = void 0;
-      input.steps = {};
-    }
-    this.logger.debug(`Machine input prepared`, {
-      runId: this.#runId,
-      input
-    });
-    const actorSnapshot = snapshot ? {
-      ...snapshot,
-      context: {
-        ...input,
-        inputData: {
-          ...(snapshot?.context?.inputData || {}),
-          ...resumeData
-        },
-        // ts-ignore is needed here because our snapshot types don't really match xstate snapshot types right now. We should fix this in general.
-        // @ts-ignore
-        isResume: {
-          runId: snapshot?.context?.steps[stepId.split(".")?.[0]]?.output?.runId || this.#runId,
-          stepId
-        }
-      }
-    } : void 0;
-    this.logger.debug(`Creating actor with configuration`, {
-      input,
-      actorSnapshot,
-      runId: this.#runId,
-      machineStates: this.#machine.config.states
-    });
-    this.#actor = createActor(this.#machine, {
-      inspect: inspectionEvent => {
-        this.logger.debug("XState inspection event", {
-          type: inspectionEvent.type,
-          event: inspectionEvent.event,
-          runId: this.#runId
-        });
-      },
-      input: {
-        ...input,
-        inputData: {
-          ...(snapshot?.context?.inputData || {}),
-          ...resumeData
-        }
-      },
-      snapshot: actorSnapshot
-    });
-    this.#actor.start();
-    if (stepId) {
-      this.#actor.send({
-        type: "RESET_TO_PENDING",
-        stepId
-      });
-    }
-    this.logger.debug("Actor started", {
-      runId: this.#runId
-    });
-    return new Promise((resolve, reject) => {
-      if (!this.#actor) {
-        this.logger.error("Actor not initialized", {
-          runId: this.#runId
-        });
-        const e = new Error("Actor not initialized");
-        this.#executionSpan?.recordException(e);
-        this.#executionSpan?.end();
-        reject(e);
-        return;
-      }
-      const suspendedPaths = /* @__PURE__ */new Set();
-      this.#actor.subscribe(async state => {
-        this.emit("state-update", this.#startStepId, state);
-        getSuspendedPaths({
-          value: state.value,
-          path: "",
-          suspendedPaths
-        });
-        const allStatesValue = state.value;
-        const allStatesComplete = recursivelyCheckForFinalState({
-          value: allStatesValue,
-          suspendedPaths,
-          path: ""
-        });
-        this.logger.debug("State completion check", {
-          allStatesComplete,
-          suspendedPaths: Array.from(suspendedPaths),
-          runId: this.#runId
-        });
-        if (!allStatesComplete) {
-          this.logger.debug("Not all states complete", {
-            allStatesComplete,
-            suspendedPaths: Array.from(suspendedPaths),
-            runId: this.#runId
-          });
-          return;
-        }
-        try {
-          this.logger.debug("All states complete", {
-            runId: this.#runId
-          });
-          await this.#workflowInstance.persistWorkflowSnapshot();
-          this.#cleanup();
-          this.#executionSpan?.end();
-          resolve({
-            runId: this.#runId,
-            results: isResumedInitialStep ? {
-              ...origSteps,
-              ...state.context.steps
-            } : state.context.steps,
-            activePaths: getResultActivePaths(state),
-            timestamp: Date.now()
-          });
-        } catch (error) {
-          this.logger.debug("Failed to persist final snapshot", {
-            error
-          });
-          this.#cleanup();
-          this.#executionSpan?.end();
-          resolve({
-            runId: this.#runId,
-            results: isResumedInitialStep ? {
-              ...origSteps,
-              ...state.context.steps
-            } : state.context.steps,
-            activePaths: getResultActivePaths(state),
-            timestamp: Date.now()
-          });
-        }
-      });
-    });
-  }
-  #cleanup() {
-    if (this.#actor) {
-      this.#actor.stop();
-      this.#actor = null;
-    }
-    this.removeAllListeners();
-  }
-  #makeDelayMap() {
-    const delayMap = {};
-    Object.keys(this.#steps).forEach(stepId => {
-      delayMap[stepId] = this.#steps[stepId]?.step?.retryConfig?.delay || this.#retryConfig?.delay || 1e3;
-    });
-    return delayMap;
-  }
-  #getDefaultActions() {
-    return {
-      updateStepResult: assign({
-        steps: ({
-          context,
-          event
-        }) => {
-          if (!isTransitionEvent(event)) return context.steps;
-          const {
-            stepId,
-            result
-          } = event.output;
-          return {
-            ...context.steps,
-            [stepId]: {
-              status: "success",
-              output: result
-            }
-          };
-        }
-      }),
-      setStepError: assign({
-        steps: ({
-          context,
-          event
-        }, params) => {
-          if (!isErrorEvent(event)) return context.steps;
-          const {
-            stepId
-          } = params;
-          if (!stepId) return context.steps;
-          return {
-            ...context.steps,
-            [stepId]: {
-              status: "failed",
-              error: event.error.message
-            }
-          };
-        }
-      }),
-      notifyStepCompletion: async (_, params) => {
-        const {
-          stepId
-        } = params;
-        this.logger.debug(`Step ${stepId} completed`);
-      },
-      snapshotStep: assign({
-        _snapshot: ({}, params) => {
-          const {
-            stepId
-          } = params;
-          return {
-            stepId
-          };
-        }
-      }),
-      persistSnapshot: async ({
-        context
-      }) => {
-        if (context._snapshot) {
-          await this.#workflowInstance.persistWorkflowSnapshot();
-        }
-        return;
-      },
-      decrementAttemptCount: assign({
-        attempts: ({
-          context,
-          event
-        }, params) => {
-          if (!isTransitionEvent(event)) return context.attempts;
-          const {
-            stepId
-          } = params;
-          const attemptCount = context.attempts[stepId];
-          if (attemptCount === void 0) return context.attempts;
-          return {
-            ...context.attempts,
-            [stepId]: attemptCount - 1
-          };
-        }
-      })
-    };
-  }
-  #getDefaultActors() {
-    return {
-      resolverFunction: fromPromise(async ({
-        input
-      }) => {
-        const {
-          stepNode,
-          context
-        } = input;
-        const attemptCount = context.attempts[stepNode.id];
-        const resolvedData = this.#resolveVariables({
-          stepConfig: stepNode.config,
-          context,
-          stepId: stepNode.id
-        });
-        this.logger.debug(`Resolved variables for ${stepNode.id}`, {
-          resolvedData,
-          runId: this.#runId
-        });
-        const logger = this.logger;
-        let mastraProxy = void 0;
-        if (this.#mastra) {
-          mastraProxy = createMastraProxy({
-            mastra: this.#mastra,
-            logger
-          });
-        }
-        let result = void 0;
-        try {
-          result = await stepNode.config.handler({
-            context: {
-              ...context,
-              inputData: {
-                ...(context?.inputData || {}),
-                ...resolvedData
-              },
-              getStepResult: stepId => {
-                const resolvedStepId = typeof stepId === "string" ? stepId : stepId.id;
-                if (resolvedStepId === "trigger") {
-                  return context.triggerData;
-                }
-                const result2 = context.steps[resolvedStepId];
-                if (result2 && result2.status === "success") {
-                  return result2.output;
-                }
-                return void 0;
-              }
-            },
-            emit: (event, ...args) => {
-              this.emit(event, ...args);
-            },
-            suspend: async (payload, softSuspend) => {
-              await this.#workflowInstance.suspend(stepNode.id, this);
-              if (this.#actor) {
-                context.steps[stepNode.id] = {
-                  status: "suspended",
-                  suspendPayload: payload,
-                  output: softSuspend
-                };
-                this.logger.debug(`Sending SUSPENDED event for step ${stepNode.id}`);
-                this.#actor?.send({
-                  type: "SUSPENDED",
-                  suspendPayload: payload,
-                  stepId: stepNode.id,
-                  softSuspend
-                });
-              } else {
-                this.logger.debug(`Actor not available for step ${stepNode.id}`);
-              }
-            },
-            runId: this.#runId,
-            mastra: mastraProxy,
-            runtimeContext: this.#runtimeContext
-          });
-        } catch (error) {
-          this.logger.debug(`Step ${stepNode.id} failed`, {
-            stepId: stepNode.id,
-            error,
-            runId: this.#runId
-          });
-          this.logger.debug(`Attempt count for step ${stepNode.id}`, {
-            attemptCount,
-            attempts: context.attempts,
-            runId: this.#runId,
-            stepId: stepNode.id
-          });
-          if (!attemptCount || attemptCount < 0) {
-            return {
-              type: "STEP_FAILED",
-              error: error instanceof Error ? error.message : `Step:${stepNode.id} failed with error: ${error}`,
-              stepId: stepNode.id
-            };
-          }
-          return {
-            type: "STEP_WAITING",
-            stepId: stepNode.id
-          };
-        }
-        this.logger.debug(`Step ${stepNode.id} result`, {
-          stepId: stepNode.id,
-          result,
-          runId: this.#runId
-        });
-        return {
-          type: "STEP_SUCCESS",
-          result,
-          stepId: stepNode.id
-        };
-      }),
-      conditionCheck: fromPromise(async ({
-        input
-      }) => {
-        const {
-          context,
-          stepNode
-        } = input;
-        const stepConfig = stepNode.config;
-        this.logger.debug(`Checking conditions for step ${stepNode.id}`, {
-          stepId: stepNode.id,
-          runId: this.#runId
-        });
-        if (!stepConfig?.when) {
-          return {
-            type: "CONDITIONS_MET"
-          };
-        }
-        this.logger.debug(`Checking conditions for step ${stepNode.id}`, {
-          stepId: stepNode.id,
-          runId: this.#runId
-        });
-        if (typeof stepConfig?.when === "function") {
-          let conditionMet = await stepConfig.when({
-            context: {
-              ...context,
-              getStepResult: stepId => {
-                const resolvedStepId = typeof stepId === "string" ? stepId : stepId.id;
-                if (resolvedStepId === "trigger") {
-                  return context.triggerData;
-                }
-                const result = context.steps[resolvedStepId];
-                if (result && result.status === "success") {
-                  return result.output;
-                }
-                return void 0;
-              }
-            },
-            mastra: this.#mastra
-          });
-          if (conditionMet === "abort" /* ABORT */) {
-            conditionMet = false;
-          } else if (conditionMet === "continue_failed" /* CONTINUE_FAILED */) {
-            return {
-              type: "CONDITIONS_SKIP_TO_COMPLETED"
-            };
-          } else if (conditionMet === "limbo" /* LIMBO */) {
-            return {
-              type: "CONDITIONS_LIMBO"
-            };
-          } else if (conditionMet) {
-            this.logger.debug(`Condition met for step ${stepNode.id}`, {
-              stepId: stepNode.id,
-              runId: this.#runId
-            });
-            return {
-              type: "CONDITIONS_MET"
-            };
-          }
-          if (isConditionalKey(stepNode.id)) {
-            return {
-              type: "CONDITIONS_LIMBO"
-            };
-          }
-          return this.#workflowInstance.hasSubscribers(stepNode.id) ? {
-            type: "CONDITIONS_SKIPPED"
-          } : {
-            type: "CONDITIONS_LIMBO"
-          };
-        } else {
-          const conditionMet = this.#evaluateCondition(stepConfig.when, context);
-          if (!conditionMet) {
-            return {
-              type: "CONDITION_FAILED",
-              error: `Step:${stepNode.id} condition check failed`
-            };
-          }
-        }
-        return {
-          type: "CONDITIONS_MET"
-        };
-      }),
-      spawnSubscriberFunction: fromPromise(async ({
-        input
-      }) => {
-        const {
-          parentStepId,
-          context
-        } = input;
-        const result = await this.#workflowInstance.runMachine(parentStepId, context, this.#runtimeContext);
-        return Promise.resolve({
-          steps: result.reduce((acc, r) => {
-            return {
-              ...acc,
-              ...r?.results
-            };
-          }, {})
-        });
-      })
-    };
-  }
-  #resolveVariables({
-    stepConfig,
-    context,
-    stepId
-  }) {
-    this.logger.debug(`Resolving variables for step ${stepId}`, {
-      stepId,
-      runId: this.#runId
-    });
-    const resolvedData = {};
-    for (const [key, variable] of Object.entries(stepConfig.data)) {
-      const sourceData = variable.step === "trigger" ? context.triggerData : getStepResult(context.steps[variable.step.id]);
-      this.logger.debug(`Got source data for ${key} variable from ${variable.step === "trigger" ? "trigger" : variable.step.id}`, {
-        sourceData,
-        path: variable.path,
-        runId: this.#runId
-      });
-      if (!sourceData && variable.step !== "trigger") {
-        resolvedData[key] = void 0;
-        continue;
-      }
-      const value = variable.path === "" || variable.path === "." ? sourceData : get(sourceData, variable.path);
-      this.logger.debug(`Resolved variable ${key}`, {
-        value,
-        runId: this.#runId
-      });
-      resolvedData[key] = value;
-    }
-    return resolvedData;
-  }
-  initializeMachine() {
-    const machine = setup({
-      types: {},
-      delays: this.#makeDelayMap(),
-      actions: this.#getDefaultActions(),
-      actors: this.#getDefaultActors()
-    }).createMachine({
-      id: this.name,
-      type: "parallel",
-      context: ({
-        input
-      }) => ({
-        ...input
-      }),
-      states: this.#buildStateHierarchy(this.#stepGraph)
-    });
-    this.#machine = machine;
-    return machine;
-  }
-  #buildStateHierarchy(stepGraph) {
-    const states = {};
-    stepGraph.initial.forEach(stepNode => {
-      const nextSteps = [...(stepGraph[stepNode.id] || [])];
-      states[stepNode.id] = {
-        ...this.#buildBaseState(stepNode, nextSteps)
-      };
-    });
-    return states;
-  }
-  #buildBaseState(stepNode, nextSteps = []) {
-    const nextStep = nextSteps.shift();
-    return {
-      initial: "pending",
-      on: {
-        RESET_TO_PENDING: {
-          target: ".pending"
-          // Note the dot to target child state
-        }
-      },
-      states: {
-        pending: {
-          entry: () => {
-            this.logger.debug(`Step ${stepNode.id} pending`, {
-              stepId: stepNode.id,
-              runId: this.#runId
-            });
-          },
-          exit: () => {
-            this.logger.debug(`Step ${stepNode.id} finished pending`, {
-              stepId: stepNode.id,
-              runId: this.#runId
-            });
-          },
-          invoke: {
-            src: "conditionCheck",
-            input: ({
-              context
-            }) => {
-              return {
-                context,
-                stepNode
-              };
-            },
-            onDone: [{
-              guard: ({
-                event
-              }) => {
-                return event.output.type === "SUSPENDED";
-              },
-              target: "suspended",
-              actions: [assign({
-                steps: ({
-                  context,
-                  event
-                }) => {
-                  if (event.output.type !== "SUSPENDED") return context.steps;
-                  if (event.output.softSuspend) {
-                    return {
-                      ...context.steps,
-                      [stepNode.id]: {
-                        status: "suspended",
-                        ...(context.steps?.[stepNode.id] || {}),
-                        output: event.output.softSuspend
-                      }
-                    };
-                  }
-                  return {
-                    ...context.steps,
-                    [stepNode.id]: {
-                      status: "suspended",
-                      ...(context.steps?.[stepNode.id] || {})
-                    }
-                  };
-                },
-                attempts: ({
-                  context,
-                  event
-                }) => {
-                  if (event.output.type !== "SUSPENDED") return context.attempts;
-                  return {
-                    ...context.attempts,
-                    [stepNode.id]: stepNode.step.retryConfig?.attempts || 0
-                  };
-                }
-              })]
-            }, {
-              guard: ({
-                event
-              }) => {
-                return event.output.type === "WAITING";
-              },
-              target: "waiting",
-              actions: [{
-                type: "decrementAttemptCount",
-                params: {
-                  stepId: stepNode.id
-                }
-              }, assign({
-                steps: ({
-                  context,
-                  event
-                }) => {
-                  if (event.output.type !== "WAITING") return context.steps;
-                  return {
-                    ...context.steps,
-                    [stepNode.id]: {
-                      status: "waiting"
-                    }
-                  };
-                }
-              })]
-            }, {
-              guard: ({
-                event
-              }) => {
-                return event.output.type === "CONDITIONS_MET";
-              },
-              target: "executing"
-            }, {
-              guard: ({
-                event
-              }) => {
-                return event.output.type === "CONDITIONS_SKIP_TO_COMPLETED";
-              },
-              target: "completed"
-            }, {
-              guard: ({
-                event
-              }) => {
-                return event.output.type === "CONDITIONS_SKIPPED";
-              },
-              actions: assign({
-                steps: ({
-                  context
-                }) => {
-                  const newStep = {
-                    ...context.steps,
-                    [stepNode.id]: {
-                      status: "skipped"
-                    }
-                  };
-                  this.logger.debug(`Step ${stepNode.id} skipped`, {
-                    stepId: stepNode.id,
-                    runId: this.#runId
-                  });
-                  return newStep;
-                }
-              }),
-              target: "runningSubscribers"
-            }, {
-              guard: ({
-                event
-              }) => {
-                return event.output.type === "CONDITIONS_LIMBO";
-              },
-              target: "limbo",
-              actions: assign({
-                steps: ({
-                  context
-                }) => {
-                  const newStep = {
-                    ...context.steps,
-                    [stepNode.id]: {
-                      status: "skipped"
-                    }
-                  };
-                  this.logger.debug(`Step ${stepNode.id} skipped`, {
-                    stepId: stepNode.id,
-                    runId: this.#runId
-                  });
-                  return newStep;
-                }
-              })
-            }, {
-              guard: ({
-                event
-              }) => {
-                return event.output.type === "CONDITION_FAILED";
-              },
-              target: "failed",
-              actions: assign({
-                steps: ({
-                  context,
-                  event
-                }) => {
-                  if (event.output.type !== "CONDITION_FAILED") return context.steps;
-                  this.logger.debug(`Workflow condition check failed`, {
-                    error: event.output.error,
-                    stepId: stepNode.id
-                  });
-                  return {
-                    ...context.steps,
-                    [stepNode.id]: {
-                      status: "failed",
-                      error: event.output.error
-                    }
-                  };
-                }
-              })
-            }]
-          }
-        },
-        waiting: {
-          entry: () => {
-            this.logger.debug(`Step ${stepNode.id} waiting`, {
-              stepId: stepNode.id,
-              timestamp: (/* @__PURE__ */new Date()).toISOString(),
-              runId: this.#runId
-            });
-          },
-          exit: () => {
-            this.logger.debug(`Step ${stepNode.id} finished waiting`, {
-              stepId: stepNode.id,
-              timestamp: (/* @__PURE__ */new Date()).toISOString(),
-              runId: this.#runId
-            });
-          },
-          after: {
-            [stepNode.id]: {
-              target: "pending"
-            }
-          }
-        },
-        limbo: {
-          // no target, will stay in limbo indefinitely
-          entry: () => {
-            this.logger.debug(`Step ${stepNode.id} limbo`, {
-              stepId: stepNode.id,
-              timestamp: (/* @__PURE__ */new Date()).toISOString(),
-              runId: this.#runId
-            });
-          },
-          exit: () => {
-            this.logger.debug(`Step ${stepNode.id} finished limbo`, {
-              stepId: stepNode.id,
-              timestamp: (/* @__PURE__ */new Date()).toISOString(),
-              runId: this.#runId
-            });
-          }
-        },
-        suspended: {
-          type: "final",
-          entry: [() => {
-            this.logger.debug(`Step ${stepNode.id} suspended`, {
-              stepId: stepNode.id,
-              runId: this.#runId
-            });
-          }, assign({
-            steps: ({
-              context,
-              event
-            }) => {
-              return {
-                ...context.steps,
-                [stepNode.id]: {
-                  ...(context?.steps?.[stepNode.id] || {}),
-                  status: "suspended",
-                  suspendPayload: event.type === "SUSPENDED" ? event.suspendPayload : void 0,
-                  output: event.type === "SUSPENDED" ? event.softSuspend : void 0
-                }
-              };
-            }
-          })]
-        },
-        executing: {
-          entry: () => {
-            this.logger.debug(`Step ${stepNode.id} executing`, {
-              stepId: stepNode.id,
-              runId: this.#runId
-            });
-          },
-          on: {
-            SUSPENDED: {
-              target: "suspended",
-              actions: [assign({
-                steps: ({
-                  context,
-                  event
-                }) => {
-                  return {
-                    ...context.steps,
-                    [stepNode.id]: {
-                      status: "suspended",
-                      suspendPayload: event.type === "SUSPENDED" ? event.suspendPayload : void 0,
-                      output: event.type === "SUSPENDED" ? event.softSuspend : void 0
-                    }
-                  };
-                }
-              })]
-            }
-          },
-          invoke: {
-            src: "resolverFunction",
-            input: ({
-              context
-            }) => ({
-              context,
-              stepNode
-            }),
-            onDone: [{
-              guard: ({
-                event
-              }) => {
-                return event.output.type === "STEP_FAILED";
-              },
-              target: "failed",
-              actions: assign({
-                steps: ({
-                  context,
-                  event
-                }) => {
-                  if (event.output.type !== "STEP_FAILED") return context.steps;
-                  const newStep = {
-                    ...context.steps,
-                    [stepNode.id]: {
-                      status: "failed",
-                      error: event.output.error
-                    }
-                  };
-                  this.logger.debug(`Step ${stepNode.id} failed`, {
-                    error: event.output.error,
-                    stepId: stepNode.id
-                  });
-                  return newStep;
-                }
-              })
-            }, {
-              guard: ({
-                event
-              }) => {
-                return event.output.type === "STEP_SUCCESS";
-              },
-              actions: [({
-                event
-              }) => {
-                this.logger.debug(`Step ${stepNode.id} finished executing`, {
-                  stepId: stepNode.id,
-                  output: event.output,
-                  runId: this.#runId
-                });
-              }, {
-                type: "updateStepResult",
-                params: {
-                  stepId: stepNode.id
-                }
-              }, {
-                type: "spawnSubscribers",
-                params: {
-                  stepId: stepNode.id
-                }
-              }],
-              target: "runningSubscribers"
-            }, {
-              guard: ({
-                event
-              }) => {
-                return event.output.type === "STEP_WAITING";
-              },
-              target: "waiting",
-              actions: [{
-                type: "decrementAttemptCount",
-                params: {
-                  stepId: stepNode.id
-                }
-              }, assign({
-                steps: ({
-                  context,
-                  event
-                }) => {
-                  if (event.output.type !== "STEP_WAITING") return context.steps;
-                  return {
-                    ...context.steps,
-                    [stepNode.id]: {
-                      status: "waiting"
-                    }
-                  };
-                }
-              })]
-            }],
-            onError: {
-              target: "failed",
-              actions: [{
-                type: "setStepError",
-                params: {
-                  stepId: stepNode.id
-                }
-              }]
-            }
-          }
-        },
-        runningSubscribers: {
-          entry: () => {
-            this.logger.debug(`Step ${stepNode.id} running subscribers`, {
-              stepId: stepNode.id,
-              runId: this.#runId
-            });
-          },
-          exit: () => {
-            this.logger.debug(`Step ${stepNode.id} finished running subscribers`, {
-              stepId: stepNode.id,
-              runId: this.#runId
-            });
-          },
-          invoke: {
-            src: "spawnSubscriberFunction",
-            input: ({
-              context
-            }) => ({
-              parentStepId: stepNode.id,
-              context
-            }),
-            onDone: {
-              target: nextStep ? nextStep.id : "completed",
-              actions: [assign({
-                steps: ({
-                  context,
-                  event
-                }) => ({
-                  ...context.steps,
-                  ...event.output.steps
-                })
-              }), () => this.logger.debug(`Subscriber execution completed`, {
-                stepId: stepNode.id
-              })]
-            },
-            onError: {
-              target: nextStep ? nextStep.id : "completed",
-              actions: ({
-                event
-              }) => {
-                this.logger.debug(`Subscriber execution failed`, {
-                  error: event.error,
-                  stepId: stepNode.id
-                });
-              }
-            }
-          }
-        },
-        completed: {
-          type: "final",
-          entry: [{
-            type: "notifyStepCompletion",
-            params: {
-              stepId: stepNode.id
-            }
-          }, {
-            type: "snapshotStep",
-            params: {
-              stepId: stepNode.id
-            }
-          }, {
-            type: "persistSnapshot"
-          }]
-        },
-        failed: {
-          type: "final",
-          entry: [{
-            type: "notifyStepCompletion",
-            params: {
-              stepId: stepNode.id
-            }
-          }, {
-            type: "snapshotStep",
-            params: {
-              stepId: stepNode.id
-            }
-          }, {
-            type: "persistSnapshot"
-          }]
-        },
-        // build chain of next steps recursively
-        ...(nextStep ? {
-          [nextStep.id]: {
-            ...this.#buildBaseState(nextStep, nextSteps)
-          }
-        } : {})
-      }
-    };
-  }
-  #evaluateCondition(condition, context) {
-    let andBranchResult = true;
-    let baseResult = true;
-    let orBranchResult = true;
-    const simpleCondition = Object.entries(condition).find(([key]) => key.includes("."));
-    if (simpleCondition) {
-      const [key, queryValue] = simpleCondition;
-      const [stepId, ...pathParts] = key.split(".");
-      const path = pathParts.join(".");
-      const sourceData = stepId === "trigger" ? context.triggerData : getStepResult(context.steps[stepId]);
-      this.logger.debug(`Got condition data from step ${stepId}`, {
-        stepId,
-        sourceData,
-        runId: this.#runId
-      });
-      if (!sourceData) {
-        return false;
-      }
-      let value = get(sourceData, path);
-      if (stepId !== "trigger" && path === "status" && !value) {
-        value = "success";
-      }
-      if (typeof queryValue === "object" && queryValue !== null) {
-        baseResult = sift(queryValue)(value);
-      } else {
-        baseResult = value === queryValue;
-      }
-    }
-    if ("ref" in condition) {
-      const {
-        ref,
-        query
-      } = condition;
-      const sourceData = ref.step === "trigger" ? context.triggerData : getStepResult(context.steps[ref.step.id]);
-      this.logger.debug(`Got condition data from ${ref.step === "trigger" ? "trigger" : ref.step.id}`, {
-        sourceData,
-        runId: this.#runId
-      });
-      if (!sourceData) {
-        return false;
-      }
-      let value = get(sourceData, ref.path);
-      if (ref.step !== "trigger" && ref.path === "status" && !value) {
-        value = "success";
-      }
-      baseResult = sift(query)(value);
-    }
-    if ("and" in condition) {
-      andBranchResult = condition.and.every(cond => this.#evaluateCondition(cond, context));
-      this.logger.debug(`Evaluated AND condition`, {
-        andBranchResult,
-        runId: this.#runId
-      });
-    }
-    if ("or" in condition) {
-      orBranchResult = condition.or.some(cond => this.#evaluateCondition(cond, context));
-      this.logger.debug(`Evaluated OR condition`, {
-        orBranchResult,
-        runId: this.#runId
-      });
-    }
-    if ("not" in condition) {
-      baseResult = !this.#evaluateCondition(condition.not, context);
-      this.logger.debug(`Evaluated NOT condition`, {
-        baseResult,
-        runId: this.#runId
-      });
-    }
-    const finalResult = baseResult && andBranchResult && orBranchResult;
-    this.logger.debug(`Evaluated condition`, {
-      finalResult,
-      runId: this.#runId
-    });
-    return finalResult;
-  }
-  getSnapshot() {
-    const snapshot = this.#actor?.getSnapshot();
-    return snapshot;
-  }
-};
-
-// src/workflows/legacy/workflow-instance.ts
-var WorkflowInstance = class {
-  name;
-  #mastra;
-  #machines = {};
-  logger;
-  #steps = {};
-  #stepGraph;
-  #stepSubscriberGraph = {};
-  #retryConfig;
-  events;
-  #runId;
-  #state = null;
-  #executionSpan;
-  #onStepTransition = /* @__PURE__ */new Set();
-  #onFinish;
-  #resultMapping;
-  // indexed by stepId
-  #suspendedMachines = {};
-  // {step1&&step2: {step1: true, step2: true}}
-  #compoundDependencies = {};
-  constructor({
-    name,
-    logger,
-    steps,
-    runId,
-    retryConfig,
-    mastra,
-    stepGraph,
-    stepSubscriberGraph,
-    onFinish,
-    onStepTransition,
-    resultMapping,
-    events
-  }) {
-    this.name = name;
-    this.logger = logger;
-    this.#steps = steps;
-    this.#stepGraph = stepGraph;
-    this.#stepSubscriberGraph = stepSubscriberGraph;
-    this.#retryConfig = retryConfig;
-    this.#mastra = mastra;
-    this.#runId = runId ?? crypto.randomUUID();
-    this.#onFinish = onFinish;
-    this.#resultMapping = resultMapping;
-    this.events = events;
-    onStepTransition?.forEach(handler => this.#onStepTransition.add(handler));
-    this.#initializeCompoundDependencies();
-  }
-  setState(state) {
-    this.#state = state;
-  }
-  get runId() {
-    return this.#runId;
-  }
-  get executionSpan() {
-    return this.#executionSpan;
-  }
-  watch(onTransition) {
-    this.#onStepTransition.add(onTransition);
-    return () => {
-      this.#onStepTransition.delete(onTransition);
-    };
-  }
-  async start({
-    triggerData,
-    runtimeContext
-  } = {}) {
-    const results = await this.execute({
-      triggerData,
-      runtimeContext: runtimeContext ?? new RuntimeContext()
-    });
-    if (this.#onFinish) {
-      const activePathsObj = Object.fromEntries(results.activePaths);
-      const hasSuspendedActivePaths = Object.values(activePathsObj).some(value => value.status === "suspended");
-      if (!hasSuspendedActivePaths) {
-        this.#onFinish();
-      }
-    }
-    return {
-      ...results,
-      runId: this.runId
-    };
-  }
-  isCompoundDependencyMet(stepKey) {
-    if (!this.#isCompoundKey(stepKey)) return true;
-    const dependencies = this.#compoundDependencies[stepKey];
-    return dependencies ? Object.values(dependencies).every(status => status === true) : true;
-  }
-  async execute({
-    triggerData,
-    snapshot,
-    stepId,
-    resumeData,
-    runtimeContext
-  } = {
-    runtimeContext: new RuntimeContext()
-  }) {
-    this.#executionSpan = this.#mastra?.getTelemetry()?.tracer.startSpan(`workflow.${this.name}.execute`, {
-      attributes: {
-        componentName: this.name,
-        runId: this.runId
-      }
-    });
-    let machineInput = {
-      // Maintain the original step results and their output
-      steps: {},
-      triggerData: triggerData || {},
-      attempts: Object.keys(this.#steps).reduce((acc, stepKey) => {
-        acc[stepKey] = this.#steps[stepKey]?.step?.retryConfig?.attempts || this.#retryConfig?.attempts || 0;
-        return acc;
-      }, {})
-    };
-    let stepGraph = this.#stepGraph;
-    let startStepId = "trigger";
-    if (snapshot) {
-      const runState = snapshot;
-      if (stepId && runState?.suspendedSteps?.[stepId]) {
-        startStepId = runState.suspendedSteps[stepId];
-        stepGraph = this.#stepSubscriberGraph[startStepId] ?? this.#stepGraph;
-        machineInput = runState.context;
-      }
-    }
-    const defaultMachine = new Machine({
-      logger: this.logger,
-      mastra: this.#mastra,
-      runtimeContext,
-      workflowInstance: this,
-      name: this.name,
-      runId: this.runId,
-      steps: this.#steps,
-      stepGraph,
-      executionSpan: this.#executionSpan,
-      startStepId,
-      retryConfig: this.#retryConfig
-    });
-    this.#machines[startStepId] = defaultMachine;
-    const stateUpdateHandler = (startStepId2, state, ctx) => {
-      let fullState = {
-        value: {},
-        context: {}
-      };
-      if (ctx) {
-        fullState["value"] = state;
-        fullState["context"] = ctx;
-      } else {
-        fullState = state;
-      }
-      if (startStepId2 === "trigger") {
-        this.#state = fullState.value;
-      } else {
-        this.#state = mergeChildValue(startStepId2, this.#state, fullState.value);
-      }
-      const now = Date.now();
-      if (this.#onStepTransition) {
-        this.#onStepTransition.forEach(onTransition => {
-          void onTransition({
-            runId: this.#runId,
-            results: fullState.context.steps,
-            activePaths: getResultActivePaths(fullState),
-            timestamp: now
-          });
-        });
-      }
-    };
-    defaultMachine.on("state-update", stateUpdateHandler);
-    const {
-      results,
-      activePaths
-    } = await defaultMachine.execute({
-      snapshot,
-      stepId,
-      input: machineInput,
-      resumeData
-    });
-    await this.persistWorkflowSnapshot();
-    const result = {
-      results,
-      activePaths,
-      timestamp: Date.now()
-    };
-    if (this.#resultMapping) {
-      result.result = resolveVariables({
-        runId: this.#runId,
-        logger: this.logger,
-        variables: this.#resultMapping,
-        context: {
-          steps: results,
-          triggerData}
-      });
-    }
-    return result;
-  }
-  hasSubscribers(stepId) {
-    return Object.keys(this.#stepSubscriberGraph).some(key => key.split("&&").includes(stepId));
-  }
-  async runMachine(parentStepId, input, runtimeContext = new RuntimeContext()) {
-    const stepStatus = input.steps[parentStepId]?.status;
-    const subscriberKeys = Object.keys(this.#stepSubscriberGraph).filter(key => key.split("&&").includes(parentStepId));
-    subscriberKeys.forEach(key => {
-      if (["success", "failure", "skipped"].includes(stepStatus) && this.#isCompoundKey(key)) {
-        this.#compoundDependencies[key][parentStepId] = true;
-      }
-    });
-    const stateUpdateHandler = (startStepId, state, ctx) => {
-      let fullState = {
-        value: {},
-        context: {}
-      };
-      if (ctx) {
-        fullState["value"] = state;
-        fullState["context"] = ctx;
-      } else {
-        fullState = state;
-      }
-      if (startStepId === "trigger") {
-        this.#state = fullState.value;
-      } else {
-        this.#state = mergeChildValue(startStepId, this.#state, fullState.value);
-      }
-      const now = Date.now();
-      if (this.#onStepTransition) {
-        this.#onStepTransition.forEach(onTransition => {
-          void onTransition({
-            runId: this.#runId,
-            results: fullState.context.steps,
-            activePaths: getResultActivePaths(fullState),
-            timestamp: now
-          });
-        });
-      }
-    };
-    const results = await Promise.all(subscriberKeys.map(async key => {
-      if (!this.#stepSubscriberGraph[key] || !this.isCompoundDependencyMet(key)) {
-        return;
-      }
-      this.#resetCompoundDependency(key);
-      const machine = new Machine({
-        logger: this.logger,
-        mastra: this.#mastra,
-        runtimeContext,
-        workflowInstance: this,
-        name: parentStepId === "trigger" ? this.name : `${this.name}-${parentStepId}`,
-        runId: this.runId,
-        steps: this.#steps,
-        stepGraph: this.#stepSubscriberGraph[key],
-        executionSpan: this.#executionSpan,
-        startStepId: parentStepId
-      });
-      machine.on("state-update", stateUpdateHandler);
-      this.#machines[parentStepId] = machine;
-      return machine.execute({
-        input
-      });
-    }));
-    return results;
-  }
-  async suspend(stepId, machine) {
-    this.#suspendedMachines[stepId] = machine;
-  }
-  /**
-   * Persists the workflow state to the database
-   */
-  async persistWorkflowSnapshot() {
-    const storage = this.#mastra?.getStorage();
-    if (!storage) {
-      this.logger.debug("Snapshot cannot be persisted. Mastra engine is not initialized", {
-        runId: this.#runId
-      });
-      return;
-    }
-    const existingSnapshot = await storage.loadWorkflowSnapshot({
-      workflowName: this.name,
-      runId: this.#runId
-    });
-    const machineSnapshots = {};
-    for (const [stepId, machine] of Object.entries(this.#machines)) {
-      const machineSnapshot = machine?.getSnapshot();
-      if (machineSnapshot) {
-        machineSnapshots[stepId] = {
-          ...machineSnapshot
-        };
-      }
-    }
-    let snapshot = machineSnapshots["trigger"];
-    delete machineSnapshots["trigger"];
-    const suspendedSteps = Object.entries(this.#suspendedMachines).reduce((acc, [stepId, machine]) => {
-      acc[stepId] = machine.startStepId;
-      return acc;
-    }, {});
-    if (!snapshot && existingSnapshot) {
-      existingSnapshot.childStates = {
-        ...existingSnapshot.childStates,
-        ...machineSnapshots
-      };
-      existingSnapshot.suspendedSteps = {
-        ...existingSnapshot.suspendedSteps,
-        ...suspendedSteps
-      };
-      await storage.persistWorkflowSnapshot({
-        workflowName: this.name,
-        runId: this.#runId,
-        snapshot: existingSnapshot
-      });
-      return;
-    } else if (snapshot && !existingSnapshot) {
-      snapshot.suspendedSteps = suspendedSteps;
-      snapshot.childStates = {
-        ...machineSnapshots
-      };
-      await storage.persistWorkflowSnapshot({
-        workflowName: this.name,
-        runId: this.#runId,
-        snapshot
-      });
-      return;
-    } else if (!snapshot) {
-      this.logger.debug("Snapshot cannot be persisted. No snapshot received.", {
-        runId: this.#runId
-      });
-      return;
-    }
-    snapshot.suspendedSteps = {
-      ...existingSnapshot.suspendedSteps,
-      ...suspendedSteps
-    };
-    if (!existingSnapshot || snapshot === existingSnapshot) {
-      await storage.persistWorkflowSnapshot({
-        workflowName: this.name,
-        runId: this.#runId,
-        snapshot
-      });
-      return;
-    }
-    if (existingSnapshot?.childStates) {
-      snapshot.childStates = {
-        ...existingSnapshot.childStates,
-        ...machineSnapshots
-      };
-    } else {
-      snapshot.childStates = machineSnapshots;
-    }
-    await storage.persistWorkflowSnapshot({
-      workflowName: this.name,
-      runId: this.#runId,
-      snapshot
-    });
-  }
-  async getState() {
-    const storedSnapshot = await this.#mastra?.storage?.loadWorkflowSnapshot({
-      workflowName: this.name,
-      runId: this.runId
-    });
-    const prevSnapshot = storedSnapshot ? {
-      trigger: storedSnapshot,
-      ...Object.entries(storedSnapshot?.childStates ?? {}).reduce((acc, [stepId, snapshot2]) => ({
-        ...acc,
-        [stepId]: snapshot2
-      }), {})
-    } : {};
-    const currentSnapshot = Object.entries(this.#machines).reduce((acc, [stepId, machine]) => {
-      const snapshot2 = machine.getSnapshot();
-      if (!snapshot2) {
-        return acc;
-      }
-      return {
-        ...acc,
-        [stepId]: snapshot2
-      };
-    }, {});
-    Object.assign(prevSnapshot, currentSnapshot);
-    const trigger = prevSnapshot.trigger;
-    delete prevSnapshot.trigger;
-    const snapshot = {
-      ...trigger};
-    const m = getActivePathsAndStatus(prevSnapshot.value);
-    return {
-      runId: this.runId,
-      value: snapshot.value,
-      context: snapshot.context,
-      activePaths: m,
-      timestamp: Date.now()
-    };
-  }
-  async resumeWithEvent(eventName, data, runtimeContext = new RuntimeContext()) {
-    const event = this.events?.[eventName];
-    if (!event) {
-      throw new Error(`Event ${eventName} not found`);
-    }
-    const results = await this.resume({
-      stepId: `__${eventName}_event`,
-      context: {
-        resumedEvent: data
-      },
-      runtimeContext
-    });
-    return results;
-  }
-  async resume({
-    stepId,
-    context: resumeContext,
-    runtimeContext = new RuntimeContext()
-  }) {
-    await new Promise(resolve => setTimeout(resolve, 0));
-    return this._resume({
-      stepId,
-      context: resumeContext,
-      runtimeContext
-    });
-  }
-  async #loadWorkflowSnapshot(runId) {
-    const storage = this.#mastra?.getStorage();
-    if (!storage) {
-      this.logger.debug("Snapshot cannot be loaded. Mastra engine is not initialized", {
-        runId
-      });
-      return;
-    }
-    await this.persistWorkflowSnapshot();
-    return storage.loadWorkflowSnapshot({
-      runId,
-      workflowName: this.name
-    });
-  }
-  async _resume({
-    stepId,
-    context: resumeContext,
-    runtimeContext
-  }) {
-    const snapshot = await this.#loadWorkflowSnapshot(this.runId);
-    if (!snapshot) {
-      throw new Error(`No snapshot found for workflow run ${this.runId}`);
-    }
-    const stepParts = stepId.split(".");
-    const stepPath = stepParts.join(".");
-    if (stepParts.length > 1) {
-      stepId = stepParts[0] ?? stepId;
-    }
-    let parsedSnapshot;
-    try {
-      parsedSnapshot = typeof snapshot === "string" ? JSON.parse(snapshot) : snapshot;
-    } catch (error) {
-      this.logger.debug("Failed to parse workflow snapshot for resume", {
-        error,
-        runId: this.runId
-      });
-      throw new Error("Failed to parse workflow snapshot");
-    }
-    const startStepId = parsedSnapshot.suspendedSteps?.[stepId];
-    if (!startStepId) {
-      return;
-    }
-    parsedSnapshot = startStepId === "trigger" ? parsedSnapshot : {
-      ...parsedSnapshot?.childStates?.[startStepId],
-      ...{
-        suspendedSteps: parsedSnapshot.suspendedSteps
-      }
-    };
-    if (!parsedSnapshot) {
-      throw new Error(`No snapshot found for step: ${stepId} starting at ${startStepId}`);
-    }
-    if (resumeContext) {
-      parsedSnapshot.context.steps[stepId] = {
-        status: "success",
-        output: {
-          ...(parsedSnapshot?.context?.steps?.[stepId]?.output || {}),
-          ...resumeContext
-        }
-      };
-    }
-    if (parsedSnapshot.children) {
-      Object.entries(parsedSnapshot.children).forEach(([, child]) => {
-        if (child.snapshot?.input?.stepNode) {
-          const stepDef = this.#makeStepDef(child.snapshot.input.stepNode.step.id);
-          child.snapshot.input.stepNode.config = {
-            ...child.snapshot.input.stepNode.config,
-            ...stepDef
-          };
-          child.snapshot.input.context = parsedSnapshot.context;
-        }
-      });
-    }
-    parsedSnapshot.value = updateStepInHierarchy(parsedSnapshot.value, stepId);
-    if (parsedSnapshot.context?.attempts) {
-      parsedSnapshot.context.attempts[stepId] = this.#steps[stepId]?.step?.retryConfig?.attempts || this.#retryConfig?.attempts || 0;
-    }
-    this.logger.debug("Resuming workflow with updated snapshot", {
-      updatedSnapshot: parsedSnapshot,
-      runId: this.runId,
-      stepId
-    });
-    return this.execute({
-      snapshot: parsedSnapshot,
-      stepId: stepPath,
-      resumeData: resumeContext,
-      runtimeContext
-    });
-  }
-  #initializeCompoundDependencies() {
-    Object.keys(this.#stepSubscriberGraph).forEach(stepKey => {
-      if (this.#isCompoundKey(stepKey)) {
-        const requiredSteps = stepKey.split("&&");
-        this.#compoundDependencies[stepKey] = requiredSteps.reduce((acc, step) => {
-          acc[step] = false;
-          return acc;
-        }, {});
-      }
-    });
-  }
-  #resetCompoundDependency(key) {
-    if (this.#isCompoundKey(key)) {
-      const requiredSteps = key.split("&&");
-      this.#compoundDependencies[key] = requiredSteps.reduce((acc, step) => {
-        acc[step] = false;
-        return acc;
-      }, {});
-    }
-  }
-  #makeStepDef(stepId) {
-    const executeStep = (handler2, spanName, attributes) => {
-      return async data => {
-        return await context.with(trace.setSpan(context.active(), this.#executionSpan), async () => {
-          if (this.#mastra?.getTelemetry()) {
-            return this.#mastra.getTelemetry()?.traceMethod(handler2, {
-              spanName,
-              attributes
-            })(data);
-          } else {
-            return handler2(data);
-          }
-        });
-      };
-    };
-    const handler = async ({
-      context,
-      ...rest
-    }) => {
-      const targetStep = this.#steps[stepId];
-      if (!targetStep) throw new Error(`Step not found`);
-      const {
-        payload = {},
-        execute = async () => {}
-      } = targetStep.step;
-      const mergedData = {
-        ...payload,
-        ...context
-      };
-      const finalAction = this.#mastra?.getTelemetry() ? executeStep(execute, `workflow.${this.name}.action.${stepId}`, {
-        componentName: this.name,
-        runId: rest.runId
-      }) : execute;
-      return finalAction ? await finalAction({
-        context: mergedData,
-        ...rest
-      }) : {};
-    };
-    const finalHandler = ({
-      context,
-      ...rest
-    }) => {
-      if (this.#executionSpan) {
-        return executeStep(handler, `workflow.${this.name}.step.${stepId}`, {
-          componentName: this.name,
-          runId: rest?.runId
-        })({
-          context,
-          ...rest
-        });
-      }
-      return handler({
-        context,
-        ...rest
-      });
-    };
-    return {
-      handler: finalHandler,
-      data: {}
-    };
-  }
-  #isCompoundKey(key) {
-    return key.includes("&&");
-  }
-};
-
-// src/workflows/legacy/workflow.ts
-var LegacyWorkflow = class extends MastraBase {
-  name;
-  triggerSchema;
-  resultSchema;
-  resultMapping;
-  events;
-  #retryConfig;
-  #mastra;
-  #runs = /* @__PURE__ */new Map();
-  isNested = false;
-  #onStepTransition = /* @__PURE__ */new Set();
-  // registers stepIds on `after` calls
-  #afterStepStack = [];
-  #lastStepStack = [];
-  #lastBuilderType = null;
-  #ifStack = [];
-  #stepGraph = {
-    initial: []
-  };
-  #serializedStepGraph = {
-    initial: []
-  };
-  #stepSubscriberGraph = {};
-  #serializedStepSubscriberGraph = {};
-  #steps = {};
-  #ifCount = 0;
-  /**
-   * Creates a new LegacyWorkflow instance
-   * @param name - Identifier for the workflow (not necessarily unique)
-   * @param logger - Optional logger instance
-   */
-  constructor({
-    name,
-    triggerSchema,
-    result,
-    retryConfig,
-    mastra,
-    events
-  }) {
-    super({
-      component: "WORKFLOW",
-      name
-    });
-    this.name = name;
-    this.#retryConfig = retryConfig;
-    this.triggerSchema = triggerSchema;
-    this.resultSchema = result?.schema;
-    this.resultMapping = result?.mapping;
-    this.events = events;
-    if (mastra) {
-      this.__registerPrimitives({
-        telemetry: mastra.getTelemetry(),
-        logger: mastra.getLogger()
-      });
-      this.#mastra = mastra;
-    }
-  }
-  step(next, config) {
-    const that = this;
-    if (Array.isArray(next)) {
-      const nextSteps = next.map(step2 => {
-        if (isWorkflow(step2)) {
-          const asStep = step2.toStep();
-          return asStep;
-        } else if (isAgent(step2)) {
-          return agentToStep(step2);
-        } else {
-          return step2;
-        }
-      });
-      nextSteps.forEach(step2 => this.step(step2, config));
-      this.after(nextSteps);
-      this.step(new LegacyStep({
-        id: `__after_${next.map(step2 => config?.id ?? step2?.id ?? step2?.name).join("_")}`,
-        execute: async () => {
-          return {
-            success: true
-          };
-        }
-      }));
-      return this;
-    }
-    const {
-      variables = {}
-    } = config || {};
-    const requiredData = {};
-    for (const [key, variable] of Object.entries(variables)) {
-      if (variable && isVariableReference(variable)) {
-        requiredData[key] = variable;
-      }
-    }
-    const step = isWorkflow(next) ?
-    // @ts-ignore
-    workflowToStep(next, {
-      mastra: this.#mastra
-    }) : isAgent(next) ?
-    // @ts-ignore
-    agentToStep(next, {
-      mastra: this.#mastra
-    }) : next;
-    const stepKey = this.#makeStepKey(step, config);
-    const when = config?.["#internal"]?.when || config?.when;
-    const graphEntry = {
-      step,
-      config: {
-        ...this.#makeStepDef(stepKey),
-        ...config,
-        loopLabel: config?.["#internal"]?.loopLabel,
-        loopType: config?.["#internal"]?.loopType,
-        serializedWhen: typeof when === "function" ? when.toString() : when,
-        data: requiredData
-      },
-      get id() {
-        return that.#makeStepKey(this.step, this.config);
-      }
-    };
-    this.#steps[stepKey] = graphEntry;
-    const parentStepKey = this.#getParentStepKey({
-      loop_check: true
-    });
-    const stepGraph = this.#stepSubscriberGraph[parentStepKey || ""];
-    const serializedStepGraph = this.#serializedStepSubscriberGraph[parentStepKey || ""];
-    if (parentStepKey && stepGraph) {
-      if (!stepGraph.initial.some(step2 => step2.config.id === stepKey || step2.step.id === stepKey)) {
-        stepGraph.initial.push(graphEntry);
-        if (serializedStepGraph) serializedStepGraph.initial.push(graphEntry);
-      }
-      stepGraph[stepKey] = [];
-      if (serializedStepGraph) serializedStepGraph[stepKey] = [];
-    } else {
-      if (!this.#stepGraph[stepKey]) this.#stepGraph[stepKey] = [];
-      this.#stepGraph.initial.push(graphEntry);
-      this.#serializedStepGraph.initial.push(graphEntry);
-    }
-    this.#lastStepStack.push(stepKey);
-    this.#lastBuilderType = "step";
-    return this;
-  }
-  #__internalStep(next, config, internalUse) {
-    const that = this;
-    if (Array.isArray(next)) {
-      const nextSteps = next.map(step2 => {
-        if (isWorkflow(step2)) {
-          const asStep = step2.toStep();
-          return asStep;
-        } else {
-          return step2;
-        }
-      });
-      nextSteps.forEach(step2 => this.#__internalStep(step2, config, internalUse));
-      this.after(nextSteps);
-      this.#__internalStep(new LegacyStep({
-        id: `__after_${next.map(step2 => step2?.id ?? step2?.name).join("_")}`,
-        execute: async () => {
-          return {
-            success: true
-          };
-        }
-      }), void 0, internalUse);
-      return this;
-    }
-    const {
-      variables = {}
-    } = config || {};
-    const requiredData = {};
-    for (const [key, variable] of Object.entries(variables)) {
-      if (variable && isVariableReference(variable)) {
-        requiredData[key] = variable;
-      }
-    }
-    const step = isWorkflow(next) ?
-    // @ts-ignore
-    workflowToStep(next, {
-      mastra: this.#mastra
-    }) : next;
-    const stepKey = this.#makeStepKey(step, config);
-    const when = config?.["#internal"]?.when || config?.when;
-    const graphEntry = {
-      step,
-      config: {
-        ...this.#makeStepDef(stepKey),
-        ...config,
-        loopLabel: config?.["#internal"]?.loopLabel,
-        loopType: config?.["#internal"]?.loopType,
-        serializedWhen: typeof when === "function" ? when.toString() : when,
-        data: requiredData
-      },
-      get id() {
-        return that.#makeStepKey(this.step, this.config);
-      }
-    };
-    this.#steps[stepKey] = graphEntry;
-    const parentStepKey = this.#getParentStepKey();
-    const stepGraph = this.#stepSubscriberGraph[parentStepKey || ""];
-    const serializedStepGraph = this.#serializedStepSubscriberGraph[parentStepKey || ""];
-    if (parentStepKey && stepGraph) {
-      if (!stepGraph.initial.some(step2 => step2.step.id === stepKey)) {
-        stepGraph.initial.push(graphEntry);
-        if (serializedStepGraph) serializedStepGraph.initial.push(graphEntry);
-      }
-      stepGraph[stepKey] = [];
-      if (serializedStepGraph) serializedStepGraph[stepKey] = [];
-    } else {
-      if (!this.#stepGraph[stepKey]) this.#stepGraph[stepKey] = [];
-      this.#stepGraph.initial.push(graphEntry);
-      this.#serializedStepGraph.initial.push(graphEntry);
-    }
-    this.#lastStepStack.push(stepKey);
-    this.#lastBuilderType = "step";
-    return this;
-  }
-  #makeStepKey(step, config) {
-    if (typeof step === "string") return step;
-    return `${config?.id ?? step.id ?? step.name}`;
-  }
-  then(next, config) {
-    const that = this;
-    if (Array.isArray(next)) {
-      const lastStep = this.#steps[this.#lastStepStack[this.#lastStepStack.length - 1] ?? ""];
-      if (!lastStep) {
-        throw new Error("Condition requires a step to be executed after");
-      }
-      this.after(lastStep.step);
-      const nextSteps = next.map(step2 => {
-        if (isWorkflow(step2)) {
-          return workflowToStep(step2, {
-            mastra: this.#mastra
-          });
-        }
-        if (isAgent(step2)) {
-          return agentToStep(step2);
-        }
-        return step2;
-      });
-      nextSteps.forEach(step2 => this.step(step2, config));
-      this.step(new LegacyStep({
-        // @ts-ignore
-        id: `__after_${next.map(step2 => step2?.id ?? step2?.name).join("_")}`,
-        execute: async () => {
-          return {
-            success: true
-          };
-        }
-      }));
-      return this;
-    }
-    const {
-      variables = {}
-    } = config || {};
-    const requiredData = {};
-    for (const [key, variable] of Object.entries(variables)) {
-      if (variable && isVariableReference(variable)) {
-        requiredData[key] = variable;
-      }
-    }
-    const lastStepKey = this.#lastStepStack[this.#lastStepStack.length - 1];
-    const step = isWorkflow(next) ? workflowToStep(next, {
-      mastra: this.#mastra
-    }) : isAgent(next) ? agentToStep(next) : next;
-    const stepKey = this.#makeStepKey(step, config);
-    const when = config?.["#internal"]?.when || config?.when;
-    const graphEntry = {
-      step,
-      config: {
-        ...this.#makeStepDef(stepKey),
-        ...config,
-        loopLabel: config?.["#internal"]?.loopLabel,
-        loopType: config?.["#internal"]?.loopType,
-        serializedWhen: typeof when === "function" ? when.toString() : when,
-        data: requiredData
-      },
-      get id() {
-        return that.#makeStepKey(this.step, this.config);
-      }
-    };
-    this.#steps[stepKey] = graphEntry;
-    if (!lastStepKey) return this;
-    const parentStepKey = this.#getParentStepKey();
-    const stepGraph = this.#stepSubscriberGraph[parentStepKey || ""];
-    const serializedStepGraph = this.#serializedStepSubscriberGraph[parentStepKey || ""];
-    if (parentStepKey && this.#lastBuilderType === "after") {
-      return this.step(step, config);
-    }
-    if (parentStepKey && stepGraph && stepGraph[lastStepKey]) {
-      stepGraph[lastStepKey].push(graphEntry);
-      if (serializedStepGraph && serializedStepGraph[lastStepKey]) serializedStepGraph[lastStepKey].push(graphEntry);
-    } else {
-      if (!this.#stepGraph[lastStepKey]) this.#stepGraph[lastStepKey] = [];
-      if (!this.#serializedStepGraph[lastStepKey]) this.#serializedStepGraph[lastStepKey] = [];
-      this.#stepGraph[lastStepKey].push(graphEntry);
-      this.#serializedStepGraph[lastStepKey].push(graphEntry);
-    }
-    this.#lastBuilderType = "then";
-    return this;
-  }
-  loop(applyOperator, condition, fallbackStep, loopType, variables) {
-    const lastStepKey = this.#lastStepStack[this.#lastStepStack.length - 1];
-    if (!lastStepKey) return this;
-    const fallbackStepKey = this.#makeStepKey(fallbackStep);
-    const fallbackStepNode = {
-      step: fallbackStep,
-      config: {
-        ...this.#makeStepDef(fallbackStepKey)
-      },
-      get id() {
-        return fallbackStepKey;
-      }
-    };
-    this.#steps[fallbackStepKey] = fallbackStepNode;
-    const checkStepKey = `__${fallbackStepKey}_${loopType}_loop_check`;
-    const checkStep = {
-      id: checkStepKey,
-      execute: async ({
-        context
-      }) => {
-        if (typeof condition === "function") {
-          const result = await condition({
-            context
-          });
-          switch (loopType) {
-            case "while":
-              return {
-                status: result ? "continue" : "complete"
-              };
-            case "until":
-              return {
-                status: result ? "complete" : "continue"
-              };
-            default:
-              throw new Error(`Invalid loop type: ${loopType}`);
-          }
-        }
-        if (condition && "ref" in condition) {
-          const {
-            ref,
-            query
-          } = condition;
-          const stepId = typeof ref.step === "string" ? ref.step : "id" in ref.step ? ref.step.id : null;
-          if (!stepId) {
-            return {
-              status: "continue"
-            };
-          }
-          const stepOutput = context.steps?.[stepId]?.output;
-          if (!stepOutput) {
-            return {
-              status: "continue"
-            };
-          }
-          const value = ref.path.split(".").reduce((obj, key) => obj?.[key], stepOutput);
-          const operator = Object.keys(query)[0];
-          const target = query[operator];
-          return applyOperator(operator, value, target);
-        }
-        return {
-          status: "continue"
-        };
-      },
-      outputSchema: z.object({
-        status: z.enum(["continue", "complete"])
-      })
-    };
-    const checkStepNode = {
-      step: checkStep,
-      config: {
-        ...this.#makeStepDef(checkStepKey)
-      },
-      get id() {
-        return checkStepKey;
-      }
-    };
-    this.#steps[checkStepKey] = checkStepNode;
-    const loopFinishedStepKey = `__${fallbackStepKey}_${loopType}_loop_finished`;
-    const loopFinishedStep = {
-      id: loopFinishedStepKey,
-      execute: async () => {
-        return {
-          success: true
-        };
-      }
-    };
-    const loopFinishedStepNode = {
-      step: loopFinishedStep,
-      config: {
-        ...this.#makeStepDef(loopFinishedStepKey)
-      },
-      get id() {
-        return loopFinishedStepKey;
-      }
-    };
-    this.#steps[loopFinishedStepKey] = loopFinishedStepNode;
-    this.then(checkStep, {
-      id: checkStepKey,
-      "#internal": {
-        loopLabel: `${fallbackStepKey} ${loopType} loop check`
-      }
-    });
-    this.after(checkStep);
-    this.#__internalStep(fallbackStep, {
-      when: async ({
-        context
-      }) => {
-        const checkStepResult = context.steps?.[checkStepKey];
-        if (checkStepResult?.status !== "success") {
-          return "abort" /* ABORT */;
-        }
-        const status = checkStepResult?.output?.status;
-        return status === "continue" ? "continue" /* CONTINUE */ : "continue_failed" /* CONTINUE_FAILED */;
-      },
-      variables,
-      "#internal": {
-        // @ts-ignore
-        when: condition,
-        loopType
-      }
-    }).then(checkStep, {
-      id: checkStepKey,
-      "#internal": {
-        loopLabel: `${fallbackStepKey} ${loopType} loop check`
-      }
-    });
-    this.#__internalStep(loopFinishedStep, {
-      id: loopFinishedStepKey,
-      when: async ({
-        context
-      }) => {
-        const checkStepResult = context.steps?.[checkStepKey];
-        if (checkStepResult?.status !== "success") {
-          return "continue_failed" /* CONTINUE_FAILED */;
-        }
-        const status = checkStepResult?.output?.status;
-        return status === "complete" ? "continue" /* CONTINUE */ : "continue_failed" /* CONTINUE_FAILED */;
-      },
-      "#internal": {
-        loopLabel: `${fallbackStepKey} ${loopType} loop finished`,
-        //@ts-ignore
-        loopType
-      }
-    });
-    return this;
-  }
-  while(condition, fallbackStep, variables) {
-    const applyOperator = (operator, value, target) => {
-      switch (operator) {
-        case "$eq":
-          return {
-            status: value !== target ? "complete" : "continue"
-          };
-        case "$ne":
-          return {
-            status: value === target ? "complete" : "continue"
-          };
-        case "$gt":
-          return {
-            status: value <= target ? "complete" : "continue"
-          };
-        case "$gte":
-          return {
-            status: value < target ? "complete" : "continue"
-          };
-        case "$lt":
-          return {
-            status: value >= target ? "complete" : "continue"
-          };
-        case "$lte":
-          return {
-            status: value > target ? "complete" : "continue"
-          };
-        default:
-          return {
-            status: "continue"
-          };
-      }
-    };
-    const res = this.loop(applyOperator, condition, fallbackStep, "while", variables);
-    this.#lastBuilderType = "while";
-    return res;
-  }
-  until(condition, fallbackStep, variables) {
-    const applyOperator = (operator, value, target) => {
-      switch (operator) {
-        case "$eq":
-          return {
-            status: value === target ? "complete" : "continue"
-          };
-        case "$ne":
-          return {
-            status: value !== target ? "complete" : "continue"
-          };
-        case "$gt":
-          return {
-            status: value > target ? "complete" : "continue"
-          };
-        case "$gte":
-          return {
-            status: value >= target ? "complete" : "continue"
-          };
-        case "$lt":
-          return {
-            status: value < target ? "complete" : "continue"
-          };
-        case "$lte":
-          return {
-            status: value <= target ? "complete" : "continue"
-          };
-        default:
-          return {
-            status: "continue"
-          };
-      }
-    };
-    const res = this.loop(applyOperator, condition, fallbackStep, "until", variables);
-    this.#lastBuilderType = "until";
-    return res;
-  }
-  if(condition, ifStep, elseStep) {
-    this.#ifCount++;
-    const lastStep = this.#getLastStep({
-      if_else_check: this.#lastBuilderType !== "else"
-    });
-    if (!lastStep) {
-      throw new Error("Condition requires a step to be executed after");
-    }
-    this.after(lastStep.step);
-    if (ifStep) {
-      const _ifStep = isWorkflow(ifStep) ? workflowToStep(ifStep, {
-        mastra: this.#mastra
-      }) : ifStep;
-      this.step(_ifStep, {
-        id: _ifStep.id,
-        when: condition
-      });
-      if (elseStep) {
-        const _elseStep = isWorkflow(elseStep) ? workflowToStep(elseStep, {
-          mastra: this.#mastra
-        }) : elseStep;
-        this.step(_elseStep, {
-          id: _elseStep.id,
-          when: typeof condition === "function" ? async payload => {
-            const result = await condition(payload);
-            return !result;
-          } : {
-            not: condition
-          }
-        });
-        this.after([_ifStep, _elseStep]);
-      } else {
-        this.after(_ifStep);
-      }
-      this.step(new LegacyStep({
-        id: `${lastStep.id}_if_else`,
-        execute: async () => {
-          return {
-            executed: true
-          };
-        }
-      }));
-      return this;
-    }
-    const ifStepKey = `__${lastStep.id}_if_${this.#ifCount}`;
-    this.step({
-      id: ifStepKey,
-      execute: async () => {
-        return {
-          executed: true
-        };
-      }
-    }, {
-      id: ifStepKey,
-      when: condition
-    });
-    const elseStepKey = `__${lastStep.id}_else_${this.#ifCount}`;
-    this.#ifStack.push({
-      condition,
-      elseStepKey,
-      condStep: lastStep.step
-    });
-    this.#lastBuilderType = "if";
-    return this;
-  }
-  else() {
-    const activeCondition = this.#ifStack.pop();
-    if (!activeCondition) {
-      throw new Error("No active condition found");
-    }
-    this.after(activeCondition.condStep).step({
-      id: activeCondition.elseStepKey,
-      execute: async () => {
-        return {
-          executed: true
-        };
-      }
-    }, {
-      id: activeCondition.elseStepKey,
-      when: typeof activeCondition.condition === "function" ? async payload => {
-        const result = await activeCondition.condition(payload);
-        return !result;
-      } : {
-        not: activeCondition.condition
-      }
-    });
-    this.#lastBuilderType = "else";
-    return this;
-  }
-  after(steps) {
-    const stepsArray = Array.isArray(steps) ? steps : [steps];
-    const stepKeys = stepsArray.map(step => this.#makeStepKey(step));
-    const compoundKey = stepKeys.join("&&");
-    this.#afterStepStack.push(compoundKey);
-    if (!this.#stepSubscriberGraph[compoundKey]) {
-      this.#stepSubscriberGraph[compoundKey] = {
-        initial: []
-      };
-      this.#serializedStepSubscriberGraph[compoundKey] = {
-        initial: []
-      };
-    }
-    this.#lastBuilderType = "after";
-    return this;
-  }
-  afterEvent(eventName) {
-    const event = this.events?.[eventName];
-    if (!event) {
-      throw new Error(`Event ${eventName} not found`);
-    }
-    const lastStep = this.#steps[this.#lastStepStack[this.#lastStepStack.length - 1] ?? ""];
-    if (!lastStep) {
-      throw new Error("Condition requires a step to be executed after");
-    }
-    const eventStepKey = `__${eventName}_event`;
-    const eventStep = new LegacyStep({
-      id: eventStepKey,
-      execute: async ({
-        context,
-        suspend
-      }) => {
-        if (context.inputData?.resumedEvent) {
-          return {
-            executed: true,
-            resumedEvent: context.inputData?.resumedEvent
-          };
-        }
-        await suspend();
-        return {
-          executed: false
-        };
-      }
-    });
-    this.after(lastStep.step).step(eventStep).after(eventStep);
-    this.#lastBuilderType = "afterEvent";
-    return this;
-  }
-  /**
-   * Executes the workflow with the given trigger data
-   * @param triggerData - Initial data to start the workflow with
-   * @returns Promise resolving to workflow results or rejecting with error
-   * @throws Error if trigger schema validation fails
-   */
-  createRun({
-    runId,
-    events
-  } = {}) {
-    const run = new WorkflowInstance({
-      logger: this.logger,
-      name: this.name,
-      mastra: this.#mastra,
-      retryConfig: this.#retryConfig,
-      steps: this.#steps,
-      runId,
-      stepGraph: this.#stepGraph,
-      stepSubscriberGraph: this.#stepSubscriberGraph,
-      onStepTransition: this.#onStepTransition,
-      resultMapping: this.resultMapping,
-      onFinish: () => {
-        this.#runs.delete(run.runId);
-      },
-      events
-    });
-    this.#runs.set(run.runId, run);
-    return {
-      start: run.start.bind(run),
-      runId: run.runId,
-      watch: run.watch.bind(run),
-      resume: run.resume.bind(run),
-      resumeWithEvent: run.resumeWithEvent.bind(run)
-    };
-  }
-  /**
-   * Gets a workflow run instance by ID
-   * @param runId - ID of the run to retrieve
-   * @returns The workflow run instance if found, undefined otherwise
-   */
-  async getRun(runId) {
-    const inMemoryRun = this.#runs.get(runId);
-    if (inMemoryRun) {
-      return inMemoryRun;
-    }
-    const storage = this.#mastra?.getStorage();
-    if (!storage) {
-      this.logger.debug("Cannot get workflow run. Mastra engine is not initialized");
-      return null;
-    }
-    return await storage.getWorkflowRunById({
-      runId,
-      workflowName: this.name
-    });
-  }
-  /**
-   * Gets a workflow run instance by ID, from memory
-   * @param runId - ID of the run to retrieve
-   * @returns The workflow run instance if found, undefined otherwise
-   */
-  getMemoryRun(runId) {
-    return this.#runs.get(runId);
-  }
-  /**
-   * Rebuilds the machine with the current steps configuration and validates the workflow
-   *
-   * This is the last step of a workflow builder method chain
-   * @throws Error if validation fails
-   *
-   * @returns this instance for method chaining
-   */
-  commit() {
-    return this;
-  }
-  // record all object paths that leads to a suspended state
-  #getSuspendedPaths({
-    value,
-    path,
-    suspendedPaths
-  }) {
-    if (typeof value === "string") {
-      if (value === "suspended") {
-        suspendedPaths.add(path);
-      }
-    } else {
-      Object.keys(value).forEach(key => this.#getSuspendedPaths({
-        value: value[key],
-        path: path ? `${path}.${key}` : key,
-        suspendedPaths
-      }));
-    }
-  }
-  async getWorkflowRuns(args) {
-    const storage = this.#mastra?.getStorage();
-    if (!storage) {
-      this.logger.debug("Cannot get workflow runs. Mastra engine is not initialized");
-      return {
-        runs: [],
-        total: 0
-      };
-    }
-    return storage.getWorkflowRuns({
-      workflowName: this.name,
-      ...(args ?? {})
-    });
-  }
-  getExecutionSpan(runId) {
-    return this.#runs.get(runId)?.executionSpan;
-  }
-  #getParentStepKey({
-    loop_check = false,
-    if_else_check = false
-  } = {}) {
-    for (let i = this.#afterStepStack.length - 1; i >= 0; i--) {
-      const stepKey = this.#afterStepStack[i];
-      if (!stepKey) continue;
-      const isValidStep = this.#stepSubscriberGraph[stepKey] && (!loop_check || !stepKey.includes("loop_check")) && (!if_else_check || !isConditionalKey(stepKey));
-      if (isValidStep) {
-        return stepKey;
-      }
-    }
-    return void 0;
-  }
-  #getLastStep({
-    if_else_check
-  }) {
-    for (let i = this.#lastStepStack.length - 1; i >= 0; i--) {
-      const stepKey = this.#lastStepStack[i];
-      if (!stepKey) continue;
-      const step = this.#steps[stepKey];
-      const isInvalidStep = !step || if_else_check && isConditionalKey(stepKey);
-      if (isInvalidStep) continue;
-      return step;
-    }
-    return void 0;
-  }
-  #makeStepDef(stepId) {
-    const executeStep = (handler2, spanName, attributes) => {
-      return async data => {
-        return await context.with(trace.setSpan(context.active(), this.getExecutionSpan(attributes?.runId ?? data?.runId)), async () => {
-          if (this?.telemetry) {
-            return this.telemetry.traceMethod(handler2, {
-              spanName,
-              attributes
-            })(data);
-          } else {
-            return handler2(data);
-          }
-        });
-      };
-    };
-    const handler = async ({
-      context,
-      ...rest
-    }) => {
-      const targetStep = this.#steps[stepId];
-      if (!targetStep) throw new Error(`Step not found`);
-      const {
-        payload = {},
-        execute = async () => {}
-      } = targetStep.step;
-      const finalAction = this.telemetry ? executeStep(execute, `workflow.${this.name}.action.${stepId}`, {
-        componentName: this.name,
-        runId: rest.runId
-      }) : execute;
-      return finalAction ? await finalAction({
-        context: {
-          ...context,
-          inputData: {
-            ...(context?.inputData || {}),
-            ...payload
-          }
-        },
-        ...rest
-      }) : {};
-    };
-    const finalHandler = ({
-      context,
-      ...rest
-    }) => {
-      if (this.getExecutionSpan(rest?.runId)) {
-        return executeStep(handler, `workflow.${this.name}.step.${stepId}`, {
-          componentName: this.name,
-          runId: rest?.runId
-        })({
-          context,
-          ...rest
-        });
-      }
-      return handler({
-        context,
-        ...rest
-      });
-    };
-    return {
-      handler: finalHandler,
-      data: {}
-    };
-  }
-  #getActivePathsAndStatus(value) {
-    const paths = [];
-    const traverse = (current, path = []) => {
-      for (const [key, value2] of Object.entries(current)) {
-        const currentPath = [...path, key];
-        if (typeof value2 === "string") {
-          paths.push({
-            stepPath: currentPath,
-            stepId: key,
-            status: value2
-          });
-        } else if (typeof value2 === "object" && value2 !== null) {
-          traverse(value2, currentPath);
-        }
-      }
-    };
-    traverse(value);
-    return paths;
-  }
-  async getState(runId) {
-    const run = this.#runs.get(runId);
-    if (run) {
-      return run.getState();
-    }
-    const storage = this.#mastra?.getStorage();
-    const storedSnapshot = await storage?.loadWorkflowSnapshot({
-      runId,
-      workflowName: this.name
-    });
-    if (storedSnapshot) {
-      const parsed = storedSnapshot;
-      const m = this.#getActivePathsAndStatus(parsed.value);
-      return {
-        runId,
-        value: parsed.value,
-        context: parsed.context,
-        activePaths: m,
-        timestamp: Date.now()
-      };
-    }
-    return null;
-  }
-  async resume({
-    runId,
-    stepId,
-    context: resumeContext,
-    runtimeContext = new RuntimeContext()
-  }) {
-    this.logger.warn(`Please use 'resume' on the 'createRun' call instead, resume is deprecated`);
-    const activeRun = this.#runs.get(runId);
-    if (activeRun) {
-      return activeRun.resume({
-        stepId,
-        context: resumeContext,
-        runtimeContext
-      });
-    }
-    const run = this.createRun({
-      runId
-    });
-    return run.resume({
-      stepId,
-      context: resumeContext,
-      runtimeContext
-    });
-  }
-  watch(onTransition) {
-    this.logger.warn(`Please use 'watch' on the 'createRun' call instead, watch is deprecated`);
-    this.#onStepTransition.add(onTransition);
-    return () => {
-      this.#onStepTransition.delete(onTransition);
-    };
-  }
-  async resumeWithEvent(runId, eventName, data) {
-    this.logger.warn(`Please use 'resumeWithEvent' on the 'createRun' call instead, resumeWithEvent is deprecated`);
-    const event = this.events?.[eventName];
-    if (!event) {
-      throw new Error(`Event ${eventName} not found`);
-    }
-    const results = await this.resume({
-      runId,
-      stepId: `__${eventName}_event`,
-      context: {
-        resumedEvent: data
-      },
-      runtimeContext: new RuntimeContext()
-    });
-    return results;
-  }
-  __registerMastra(mastra) {
-    this.#mastra = mastra;
-  }
-  __registerPrimitives(p) {
-    if (p.telemetry) {
-      this.__setTelemetry(p.telemetry);
-    }
-    if (p.logger) {
-      this.__setLogger(p.logger);
-    }
-  }
-  get stepGraph() {
-    return this.#stepGraph;
-  }
-  get stepSubscriberGraph() {
-    return this.#stepSubscriberGraph;
-  }
-  get serializedStepGraph() {
-    return this.#serializedStepGraph;
-  }
-  get serializedStepSubscriberGraph() {
-    return this.#serializedStepSubscriberGraph;
-  }
-  get steps() {
-    return Object.entries(this.#steps).reduce((acc, [key, step]) => {
-      acc[key] = step.step;
-      return acc;
-    }, {});
-  }
-  setNested(isNested) {
-    this.isNested = isNested;
-  }
-  toStep() {
-    const x = workflowToStep(this, {
-      mastra: this.#mastra
-    });
-    return new LegacyStep(x);
-  }
-};
-
-export { Agent, LegacyStep, LegacyWorkflow, WhenConditionReturnValue, agentToStep, getActivePathsAndStatus, getResultActivePaths, getStepResult, getSuspendedPaths, isAgent, isConditionalKey, isErrorEvent, isFinalState, isLimboState, isTransitionEvent, isVariableReference, isWorkflow, mergeChildValue, recursivelyCheckForFinalState, resolveVariables, updateStepInHierarchy, workflowToStep };