@mastra/core 1.0.0-beta.2 → 1.0.0-beta.3

package/dist/{chunk-YCVEJ3UN.cjs → chunk-OWX2PUFH.cjs}

@@ -2,15 +2,15 @@
 
 var chunkQUKUN6NR_cjs = require('./chunk-QUKUN6NR.cjs');
 var chunkABJOUEVA_cjs = require('./chunk-ABJOUEVA.cjs');
-var chunkECFXGXWO_cjs = require('./chunk-ECFXGXWO.cjs');
-var chunk2ZVKF4HP_cjs = require('./chunk-2ZVKF4HP.cjs');
-var chunkVOY2RXOC_cjs = require('./chunk-VOY2RXOC.cjs');
+var chunkG36A2JRR_cjs = require('./chunk-G36A2JRR.cjs');
+var chunkN4SJ4YX7_cjs = require('./chunk-N4SJ4YX7.cjs');
+var chunkO6NA3Z43_cjs = require('./chunk-O6NA3Z43.cjs');
 var chunkMR7ZWBL6_cjs = require('./chunk-MR7ZWBL6.cjs');
-var chunkWM6CK2F3_cjs = require('./chunk-WM6CK2F3.cjs');
+var chunkHBJPYQRN_cjs = require('./chunk-HBJPYQRN.cjs');
 var chunkE7K4FTLN_cjs = require('./chunk-E7K4FTLN.cjs');
 var chunkTWH4PTDG_cjs = require('./chunk-TWH4PTDG.cjs');
 var chunkLRSB62Z6_cjs = require('./chunk-LRSB62Z6.cjs');
-var chunkET6UOTTU_cjs = require('./chunk-ET6UOTTU.cjs');
+var chunk4IKJAKCD_cjs = require('./chunk-4IKJAKCD.cjs');
 var chunkJ7O6WENZ_cjs = require('./chunk-J7O6WENZ.cjs');
 var chunk4WQYXT2I_cjs = require('./chunk-4WQYXT2I.cjs');
 var chunkKEXGB7FK_cjs = require('./chunk-KEXGB7FK.cjs');
@@ -543,6 +543,11 @@ function runScorer({
   chunkMR7ZWBL6_cjs.executeHook("onScorerRun" /* ON_SCORER_RUN */, payload);
 }
 
+// src/llm/model/is-v2-model.ts
+function isV2Model(model) {
+  return model.specificationVersion === "v2";
+}
+
 // src/stream/base/consume-stream.ts
 async function consumeStream2({
   stream,
@@ -599,7 +604,7 @@ var WorkflowRunOutput = class {
     this.workflowId = workflowId;
     this.#baseStream = stream;
     stream.pipeTo(
-      new WritableStream({
+      new web.WritableStream({
         start() {
           const chunk = {
             type: "workflow-start",
@@ -727,7 +732,7 @@ var WorkflowRunOutput = class {
     };
     const self = this;
     stream.pipeTo(
-      new WritableStream({
+      new web.WritableStream({
         start() {
           const chunk = {
             type: "workflow-start",
@@ -962,6 +967,24 @@ async function validateStepInput({
   }
   return { inputData, validationError };
 }
+async function validateStepResumeData({ resumeData, step }) {
+  if (!resumeData) {
+    return { resumeData: void 0, validationError: void 0 };
+  }
+  let validationError;
+  const resumeSchema = step.resumeSchema;
+  if (resumeSchema) {
+    const validatedResumeData = await resumeSchema.safeParseAsync(resumeData);
+    if (!validatedResumeData.success) {
+      const errors = getZodErrors(validatedResumeData.error);
+      const errorMessages = errors.map((e) => `- ${e.path?.join(".")}: ${e.message}`).join("\n");
+      validationError = new Error("Step resume data validation failed: \n" + errorMessages);
+    } else {
+      resumeData = validatedResumeData.data;
+    }
+  }
+  return { resumeData, validationError };
+}
 function getResumeLabelsByStepId(resumeLabels, stepId) {
   return Object.entries(resumeLabels).filter(([_, value]) => value.stepId === stepId).reduce(
     (acc, [key, value]) => {
@@ -992,6 +1015,111 @@ function createDeprecationProxy(params, {
     }
   });
 }
+var getStepIds = (entry) => {
+  if (entry.type === "step" || entry.type === "foreach" || entry.type === "loop") {
+    return [entry.step.id];
+  }
+  if (entry.type === "parallel" || entry.type === "conditional") {
+    return entry.steps.map((s) => s.step.id);
+  }
+  if (entry.type === "sleep" || entry.type === "sleepUntil") {
+    return [entry.id];
+  }
+  return [];
+};
+var createTimeTravelExecutionParams = (params) => {
+  const { steps, inputData, resumeData, context, nestedStepsContext, snapshot, initialState, graph } = params;
+  const firstStepId = steps[0];
+  let executionPath = [];
+  const stepResults = {};
+  const snapshotContext = snapshot.context;
+  for (const [index, entry] of graph.steps.entries()) {
+    const currentExecPathLength = executionPath.length;
+    if (currentExecPathLength > 0 && !resumeData) {
+      break;
+    }
+    const stepIds = getStepIds(entry);
+    if (stepIds.includes(firstStepId)) {
+      const innerExecutionPath = stepIds?.length > 1 ? [stepIds?.findIndex((s) => s === firstStepId)] : [];
+      executionPath = [index, ...innerExecutionPath];
+    }
+    const prevStep = graph.steps[index - 1];
+    let stepPayload = void 0;
+    if (prevStep) {
+      const prevStepIds = getStepIds(prevStep);
+      if (prevStepIds.length > 0) {
+        if (prevStepIds.length === 1) {
+          stepPayload = stepResults?.[prevStepIds[0]]?.output ?? {};
+        } else {
+          stepPayload = prevStepIds.reduce(
+            (acc, stepId) => {
+              acc[stepId] = stepResults?.[stepId]?.output ?? {};
+              return acc;
+            },
+            {}
+          );
+        }
+      }
+    }
+    if (index === 0 && stepIds.includes(firstStepId)) {
+      stepResults.input = context?.[firstStepId]?.payload ?? inputData ?? snapshotContext?.input;
+    } else if (index === 0) {
+      stepResults.input = stepIds?.reduce((acc, stepId) => {
+        if (acc) return acc;
+        return context?.[stepId]?.payload ?? snapshotContext?.[stepId]?.payload;
+      }, null) ?? snapshotContext?.input ?? {};
+    }
+    let stepOutput = void 0;
+    const nextStep = graph.steps[index + 1];
+    if (nextStep) {
+      const nextStepIds = getStepIds(nextStep);
+      if (nextStepIds.length > 0 && inputData && nextStepIds.includes(firstStepId) && steps.length === 1) {
+        stepOutput = inputData;
+      }
+    }
+    stepIds.forEach((stepId) => {
+      let result;
+      const stepContext = context?.[stepId] ?? snapshotContext[stepId];
+      const defaultStepStatus = steps?.includes(stepId) ? "running" : "success";
+      const status = ["failed", "canceled"].includes(stepContext?.status) ? defaultStepStatus : stepContext?.status ?? defaultStepStatus;
+      const isCompleteStatus = ["success", "failed", "canceled"].includes(status);
+      result = {
+        status,
+        payload: context?.[stepId]?.payload ?? stepPayload ?? snapshotContext[stepId]?.payload ?? {},
+        output: isCompleteStatus ? context?.[stepId]?.output ?? stepOutput ?? snapshotContext[stepId]?.output ?? {} : void 0,
+        resumePayload: stepContext?.resumePayload,
+        suspendPayload: stepContext?.suspendPayload,
+        suspendOutput: stepContext?.suspendOutput,
+        startedAt: stepContext?.startedAt ?? Date.now(),
+        endedAt: isCompleteStatus ? stepContext?.endedAt ?? Date.now() : void 0,
+        suspendedAt: stepContext?.suspendedAt,
+        resumedAt: stepContext?.resumedAt
+      };
+      if (currentExecPathLength > 0 && (!snapshotContext[stepId] || snapshotContext[stepId] && snapshotContext[stepId].status !== "suspended")) {
+        result = void 0;
+      }
+      if (result) {
+        const formattedResult = chunkHBJPYQRN_cjs.removeUndefinedValues(result);
+        stepResults[stepId] = formattedResult;
+      }
+    });
+  }
+  if (!executionPath.length) {
+    throw new Error(
+      `Time travel target step not found in execution graph: '${steps?.join(".")}'. Verify the step id/path.`
+    );
+  }
+  const timeTravelData = {
+    inputData,
+    executionPath,
+    steps,
+    stepResults,
+    nestedStepResults: nestedStepsContext,
+    state: initialState ?? snapshot.value ?? {},
+    resumeData
+  };
+  return timeTravelData;
+};
 
 // src/workflows/default.ts
 var DefaultExecutionEngine = class extends ExecutionEngine {
@@ -1078,7 +1206,9 @@ var DefaultExecutionEngine = class extends ExecutionEngine {
       resume,
       retryConfig,
       workflowSpan,
-      disableScorers
+      disableScorers,
+      restart,
+      timeTravel
     } = params;
     const { attempts = 0, delay: delay2 = 0 } = retryConfig ?? {};
     const steps = graph.steps;
@@ -1094,19 +1224,26 @@ var DefaultExecutionEngine = class extends ExecutionEngine {
       throw empty_graph_error;
     }
     let startIdx = 0;
-    if (resume?.resumePath) {
+    if (timeTravel) {
+      startIdx = timeTravel.executionPath[0];
+      timeTravel.executionPath.shift();
+    } else if (restart) {
+      startIdx = restart.activePaths[0];
+      restart.activePaths.shift();
+    } else if (resume?.resumePath) {
       startIdx = resume.resumePath[0];
       resume.resumePath.shift();
     }
-    const stepResults = resume?.stepResults || { input };
+    const stepResults = timeTravel?.stepResults || restart?.stepResults || resume?.stepResults || { input };
     let lastOutput;
-    let lastState = initialState ?? {};
+    let lastState = timeTravel?.state ?? restart?.state ?? initialState ?? {};
     for (let i = startIdx; i < steps.length; i++) {
       const entry = steps[i];
       const executionContext = {
         workflowId,
         runId,
         executionPath: [i],
+        activeStepsPath: {},
         suspendedPaths: {},
         resumeLabels: {},
         retryConfig: { attempts, delay: delay2 },
@@ -1124,6 +1261,8 @@ var DefaultExecutionEngine = class extends ExecutionEngine {
           prevStep: steps[i - 1],
           stepResults,
           resume,
+          timeTravel,
+          restart,
           tracingContext: {
             currentSpan: workflowSpan
           },
@@ -1413,7 +1552,9 @@ var DefaultExecutionEngine = class extends ExecutionEngine {
     step,
     stepResults,
     executionContext,
+    restart,
     resume,
+    timeTravel,
     prevOutput,
     emitter,
     abortController,
@@ -1425,22 +1566,38 @@ var DefaultExecutionEngine = class extends ExecutionEngine {
     tracingContext,
     iterationCount
   }) {
-    const startTime = resume?.steps[0] === step.id ? void 0 : Date.now();
-    const resumeTime = resume?.steps[0] === step.id ? Date.now() : void 0;
     const stepCallId = crypto2.randomUUID();
     const { inputData, validationError } = await validateStepInput({
       prevOutput,
       step,
-      validateInputs: this.options?.validateInputs ?? false
+      validateInputs: this.options?.validateInputs ?? true
     });
+    const { resumeData: timeTravelResumeData, validationError: timeTravelResumeValidationError } = await validateStepResumeData({
+      resumeData: timeTravel?.stepResults[step.id]?.status === "suspended" ? timeTravel?.resumeData : void 0,
+      step
+    });
+    let resumeDataToUse;
+    if (timeTravelResumeData && !timeTravelResumeValidationError) {
+      resumeDataToUse = timeTravelResumeData;
+    } else if (timeTravelResumeData && timeTravelResumeValidationError) {
+      this.logger.warn("Time travel resume data validation failed", {
+        stepId: step.id,
+        error: timeTravelResumeValidationError.message
+      });
+    } else if (resume?.steps[0] === step.id) {
+      resumeDataToUse = resume?.resumePayload;
+    }
+    const startTime = resumeDataToUse ? void 0 : Date.now();
+    const resumeTime = resumeDataToUse ? Date.now() : void 0;
     const stepInfo = {
       ...stepResults[step.id],
-      ...resume?.steps[0] === step.id ? { resumePayload: resume?.resumePayload } : { payload: inputData },
+      ...resumeDataToUse ? { resumePayload: resumeDataToUse } : { payload: inputData },
       ...startTime ? { startedAt: startTime } : {},
       ...resumeTime ? { resumedAt: resumeTime } : {},
       status: "running",
       ...iterationCount ? { metadata: { iterationCount } } : {}
     };
+    executionContext.activeStepsPath[step.id] = executionContext.executionPath;
     const stepSpan = tracingContext.currentSpan?.createChildSpan({
       name: `workflow step: '${step.id}'`,
       type: "workflow_step" /* WORKFLOW_STEP */,
@@ -1495,6 +1652,10 @@ var DefaultExecutionEngine = class extends ExecutionEngine {
           throw validationError;
         }
         const retryCount = this.getOrGenerateRetryCount(step.id);
+        let timeTravelSteps = [];
+        if (timeTravel && timeTravel.steps.length > 0) {
+          timeTravelSteps = timeTravel.steps[0] === step.id ? timeTravel.steps.slice(1) : [];
+        }
         const result = await runStep({
           runId,
           resourceId,
@@ -1507,7 +1668,7 @@ var DefaultExecutionEngine = class extends ExecutionEngine {
             executionContext.state = state;
           },
           retryCount,
-          resumeData: resume?.steps[0] === step.id ? resume?.resumePayload : void 0,
+          resumeData: resumeDataToUse,
           tracingContext: { currentSpan: stepSpan },
           getInitData: () => stepResults?.input,
           getStepResult: getStepResult.bind(this, stepResults),
@@ -1540,6 +1701,15 @@ var DefaultExecutionEngine = class extends ExecutionEngine {
             label: resume?.label,
             forEachIndex: resume?.forEachIndex
           } : void 0,
+          // Only pass restart data if this step is part of activeStepsPath
+          // This prevents pending nested workflows from trying to restart instead of start
+          restart: !!restart?.activeStepsPath?.[step.id],
+          timeTravel: timeTravelSteps.length > 0 ? {
+            inputData: timeTravel?.inputData,
+            steps: timeTravelSteps,
+            nestedStepResults: timeTravel?.nestedStepResults,
+            resumeData: timeTravel?.resumeData
+          } : void 0,
           [chunkABJOUEVA_cjs.EMITTER_SYMBOL]: emitter,
           [chunkABJOUEVA_cjs.STREAM_FORMAT_SYMBOL]: executionContext.format,
           engine: {},
@@ -1611,6 +1781,7 @@ var DefaultExecutionEngine = class extends ExecutionEngine {
         };
       }
     }
+    delete executionContext.activeStepsPath[step.id];
     if (!skipEmits) {
       if (execResults.status === "suspended") {
         await emitter.emit("watch", {
@@ -1714,6 +1885,8 @@ var DefaultExecutionEngine = class extends ExecutionEngine {
     serializedStepGraph,
     stepResults,
     resume,
+    restart,
+    timeTravel,
     executionContext,
     tracingContext,
     emitter,
@@ -1733,22 +1906,38 @@ var DefaultExecutionEngine = class extends ExecutionEngine {
       tracingPolicy: this.options?.tracingPolicy
     });
     const prevOutput = this.getStepOutput(stepResults, prevStep);
-    for (const step of entry.steps) {
-      if (step.type === "step") {
-        const startTime = resume?.steps[0] === step.step.id ? void 0 : Date.now();
-        const resumeTime = resume?.steps[0] === step.step.id ? Date.now() : void 0;
-        stepResults[step.step.id] = {
-          ...stepResults[step.step.id],
-          status: "running",
-          ...resumeTime ? { resumePayload: resume?.resumePayload } : { payload: prevOutput },
-          ...startTime ? { startedAt: startTime } : {},
-          ...resumeTime ? { resumedAt: resumeTime } : {}
-        };
+    for (const [stepIndex, step] of entry.steps.entries()) {
+      let makeStepRunning = true;
+      if (restart) {
+        makeStepRunning = !!restart.activeStepsPath[step.step.id];
+      }
+      if (timeTravel && timeTravel.executionPath.length > 0) {
+        makeStepRunning = timeTravel.steps[0] === step.step.id;
       }
+      if (!makeStepRunning) {
+        continue;
+      }
+      const startTime = resume?.steps[0] === step.step.id ? void 0 : Date.now();
+      const resumeTime = resume?.steps[0] === step.step.id ? Date.now() : void 0;
+      stepResults[step.step.id] = {
+        ...stepResults[step.step.id],
+        status: "running",
+        ...resumeTime ? { resumePayload: resume?.resumePayload } : { payload: prevOutput },
+        ...startTime ? { startedAt: startTime } : {},
+        ...resumeTime ? { resumedAt: resumeTime } : {}
+      };
+      executionContext.activeStepsPath[step.step.id] = [...executionContext.executionPath, stepIndex];
+    }
+    if (timeTravel && timeTravel.executionPath.length > 0) {
+      timeTravel.executionPath.shift();
     }
     let execResults;
     const results = await Promise.all(
       entry.steps.map(async (step, i) => {
+        const currStepResult = stepResults[step.step.id];
+        if (currStepResult && currStepResult.status !== "running") {
+          return currStepResult;
+        }
         const result = await this.executeStep({
           workflowId,
           runId,
@@ -1757,8 +1946,11 @@ var DefaultExecutionEngine = class extends ExecutionEngine {
           prevOutput,
           stepResults,
           serializedStepGraph,
+          restart,
+          timeTravel,
           resume,
           executionContext: {
+            activeStepsPath: executionContext.activeStepsPath,
             workflowId,
             runId,
             executionPath: [...executionContext.executionPath, i],
@@ -1823,6 +2015,8 @@ var DefaultExecutionEngine = class extends ExecutionEngine {
     serializedStepGraph,
     stepResults,
     resume,
+    restart,
+    timeTravel,
     executionContext,
     tracingContext,
     emitter,
@@ -1938,7 +2132,13 @@ var DefaultExecutionEngine = class extends ExecutionEngine {
     const results = await Promise.all(
       stepsToRun.map(async (step, index) => {
         const currStepResult = stepResults[step.step.id];
-        if (currStepResult && currStepResult.status === "success") {
+        const isRestartStep = restart ? !!restart.activeStepsPath[step.step.id] : void 0;
+        if (currStepResult && timeTravel && timeTravel.executionPath.length > 0) {
+          if (timeTravel.steps[0] !== step.step.id) {
+            return currStepResult;
+          }
+        }
+        if (currStepResult && ["success", "failed"].includes(currStepResult.status) && isRestartStep === void 0) {
           return currStepResult;
         }
         const result = await this.executeStep({
@@ -1950,10 +2150,13 @@ var DefaultExecutionEngine = class extends ExecutionEngine {
           stepResults,
           serializedStepGraph,
           resume,
+          restart,
+          timeTravel,
           executionContext: {
             workflowId,
             runId,
             executionPath: [...executionContext.executionPath, index],
+            activeStepsPath: executionContext.activeStepsPath,
             suspendedPaths: executionContext.suspendedPaths,
             resumeLabels: executionContext.resumeLabels,
             retryConfig: executionContext.retryConfig,
@@ -2015,6 +2218,8 @@ var DefaultExecutionEngine = class extends ExecutionEngine {
     prevOutput,
     stepResults,
     resume,
+    restart,
+    timeTravel,
     executionContext,
     tracingContext,
     emitter,
@@ -2040,6 +2245,8 @@ var DefaultExecutionEngine = class extends ExecutionEngine {
     const prevPayload = stepResults[step.id]?.payload;
     let result = { status: "success", output: prevPayload ?? prevOutput };
     let currentResume = resume;
+    let currentRestart = restart;
+    let currentTimeTravel = timeTravel;
     do {
       result = await this.executeStep({
         workflowId,
@@ -2048,7 +2255,9 @@ var DefaultExecutionEngine = class extends ExecutionEngine {
         step,
         stepResults,
         executionContext,
+        restart: currentRestart,
         resume: currentResume,
+        timeTravel: currentTimeTravel,
         prevOutput: result.output,
         tracingContext: {
           currentSpan: loopSpan
@@ -2061,6 +2270,8 @@ var DefaultExecutionEngine = class extends ExecutionEngine {
         serializedStepGraph,
         iterationCount: iteration + 1
       });
+      currentRestart = void 0;
+      currentTimeTravel = void 0;
       if (currentResume && result.status !== "suspended") {
         currentResume = void 0;
       }
@@ -2075,7 +2286,7 @@ var DefaultExecutionEngine = class extends ExecutionEngine {
       const evalSpan = loopSpan?.createChildSpan({
         type: "workflow_conditional_eval" /* WORKFLOW_CONDITIONAL_EVAL */,
         name: `condition: '${entry.loopType}'`,
-        input: chunkWM6CK2F3_cjs.selectFields(result.output, ["stepResult", "output.text", "output.object", "messages"]),
+        input: chunkHBJPYQRN_cjs.selectFields(result.output, ["stepResult", "output.text", "output.object", "messages"]),
         attributes: {
           conditionIndex: iteration
         },
@@ -2148,7 +2359,9 @@ var DefaultExecutionEngine = class extends ExecutionEngine {
     entry,
     prevOutput,
     stepResults,
+    restart,
     resume,
+    timeTravel,
     executionContext,
     tracingContext,
     emitter,
@@ -2217,6 +2430,8 @@ var DefaultExecutionEngine = class extends ExecutionEngine {
             resourceId,
             step,
             stepResults,
+            restart,
+            timeTravel,
             executionContext: { ...executionContext, foreachIndex: k },
             resume: resumeToUse,
             prevOutput: item,
@@ -2350,7 +2565,8 @@ var DefaultExecutionEngine = class extends ExecutionEngine {
         status: workflowStatus,
         value: executionContext.state,
         context: stepResults,
-        activePaths: [],
+        activePaths: executionContext.executionPath,
+        activeStepsPath: executionContext.activeStepsPath,
         serializedStepGraph,
         suspendedPaths: executionContext.suspendedPaths,
         waitingPaths: {},
@@ -2371,6 +2587,8 @@ var DefaultExecutionEngine = class extends ExecutionEngine {
     prevStep,
     serializedStepGraph,
     stepResults,
+    restart,
+    timeTravel,
     resume,
     executionContext,
     tracingContext,
@@ -2391,6 +2609,8 @@ var DefaultExecutionEngine = class extends ExecutionEngine {
         step,
         stepResults,
         executionContext,
+        timeTravel,
+        restart,
         resume,
         prevOutput,
         tracingContext,
@@ -2419,6 +2639,7 @@ var DefaultExecutionEngine = class extends ExecutionEngine {
           suspendedPaths: executionContext.suspendedPaths,
           resumeLabels: executionContext.resumeLabels,
           retryConfig: executionContext.retryConfig,
+          activeStepsPath: executionContext.activeStepsPath,
           state: executionContext.state
         },
         tracingContext,
@@ -2498,6 +2719,8 @@ var DefaultExecutionEngine = class extends ExecutionEngine {
         prevStep,
         stepResults,
         serializedStepGraph,
+        timeTravel,
+        restart,
         resume,
         executionContext,
         tracingContext,
@@ -2515,6 +2738,8 @@ var DefaultExecutionEngine = class extends ExecutionEngine {
         prevOutput,
         stepResults,
         serializedStepGraph,
+        timeTravel,
+        restart,
         resume,
         executionContext,
         tracingContext,
@@ -2532,6 +2757,8 @@ var DefaultExecutionEngine = class extends ExecutionEngine {
         prevStep,
         prevOutput,
         stepResults,
+        timeTravel,
+        restart,
         resume,
         executionContext,
         tracingContext,
@@ -2550,6 +2777,8 @@ var DefaultExecutionEngine = class extends ExecutionEngine {
         prevStep,
         prevOutput,
         stepResults,
+        timeTravel,
+        restart,
         resume,
         executionContext,
         tracingContext,
@@ -2571,6 +2800,12 @@ var DefaultExecutionEngine = class extends ExecutionEngine {
           status: "waiting"
         }
       });
+      stepResults[entry.id] = {
+        status: "waiting",
+        payload: prevOutput,
+        startedAt
+      };
+      executionContext.activeStepsPath[entry.id] = executionContext.executionPath;
       await this.persistStepUpdate({
         workflowId,
         runId,
@@ -2597,6 +2832,7 @@ var DefaultExecutionEngine = class extends ExecutionEngine {
         requestContext,
         writableStream
       });
+      delete executionContext.activeStepsPath[entry.id];
       await this.persistStepUpdate({
         workflowId,
         runId,
@@ -2642,6 +2878,12 @@ var DefaultExecutionEngine = class extends ExecutionEngine {
           status: "waiting"
         }
       });
+      stepResults[entry.id] = {
+        status: "waiting",
+        payload: prevOutput,
+        startedAt
+      };
+      executionContext.activeStepsPath[entry.id] = executionContext.executionPath;
       await this.persistStepUpdate({
         workflowId,
         runId,
@@ -2668,6 +2910,7 @@ var DefaultExecutionEngine = class extends ExecutionEngine {
         requestContext,
         writableStream
       });
+      delete executionContext.activeStepsPath[entry.id];
       await this.persistStepUpdate({
         workflowId,
         runId,
@@ -2828,7 +3071,7 @@ function createStep(params, agentOptions) {
       component: params.component
     };
   }
-  if (params instanceof chunkET6UOTTU_cjs.Tool) {
+  if (params instanceof chunk4IKJAKCD_cjs.Tool) {
     if (!params.inputSchema || !params.outputSchema) {
       throw new Error("Tool must have input and output schemas defined");
     }
@@ -2888,8 +3131,12 @@ function cloneStep(step, opts) {
     description: step.description,
     inputSchema: step.inputSchema,
     outputSchema: step.outputSchema,
+    suspendSchema: step.suspendSchema,
+    resumeSchema: step.resumeSchema,
+    stateSchema: step.stateSchema,
     execute: step.execute,
     retries: step.retries,
+    scorers: step.scorers,
     component: step.component
   };
 }
@@ -2902,7 +3149,8 @@ function cloneWorkflow(workflow, opts) {
     inputSchema: workflow.inputSchema,
     outputSchema: workflow.outputSchema,
     steps: workflow.stepDefs,
-    mastra: workflow.mastra
+    mastra: workflow.mastra,
+    options: workflow.options
   });
   wf.setStepFlow(workflow.stepGraph);
   wf.commit();
@@ -2916,6 +3164,8 @@ var Workflow = class extends chunkKEXGB7FK_cjs.MastraBase {
   stateSchema;
   steps;
   stepDefs;
+  engineType = "default";
+  #nestedWorkflowInput;
   committed = false;
   stepFlow;
   serializedStepFlow;
@@ -2951,7 +3201,7 @@ var Workflow = class extends chunkKEXGB7FK_cjs.MastraBase {
     this.steps = {};
     this.stepDefs = steps;
     this.#options = {
-      validateInputs: options.validateInputs ?? false,
+      validateInputs: options.validateInputs ?? true,
       shouldPersistSnapshot: options.shouldPersistSnapshot ?? (() => true),
       tracingPolicy: options.tracingPolicy
     };
@@ -2963,6 +3213,7 @@ var Workflow = class extends chunkKEXGB7FK_cjs.MastraBase {
     } else {
       this.executionEngine = executionEngine;
     }
+    this.engineType = "default";
     this.#runs = /* @__PURE__ */ new Map();
   }
   get runs() {
@@ -3322,7 +3573,8 @@ var Workflow = class extends chunkKEXGB7FK_cjs.MastraBase {
       cleanup: () => this.#runs.delete(runIdToUse),
       tracingPolicy: this.#options?.tracingPolicy,
       workflowSteps: this.steps,
-      validateInputs: this.#options?.validateInputs
+      validateInputs: this.#options?.validateInputs,
+      workflowEngineType: this.engineType
     });
     this.#runs.set(runIdToUse, run);
     const shouldPersistSnapshot = this.#options.shouldPersistSnapshot({
@@ -3339,8 +3591,9 @@ var Workflow = class extends chunkKEXGB7FK_cjs.MastraBase {
           runId: runIdToUse,
           status: "pending",
           value: {},
-          context: {},
+          context: this.#nestedWorkflowInput ? { input: this.#nestedWorkflowInput } : {},
           activePaths: [],
+          activeStepsPath: {},
           serializedStepGraph: this.serializedStepGraph,
           suspendedPaths: {},
           resumeLabels: {},
@@ -3384,7 +3637,9 @@ var Workflow = class extends chunkKEXGB7FK_cjs.MastraBase {
     state,
     setState,
     suspend,
+    restart,
     resume,
+    timeTravel,
     [chunkABJOUEVA_cjs.EMITTER_SYMBOL]: emitter,
     mastra,
     requestContext,
@@ -3396,17 +3651,20 @@ var Workflow = class extends chunkKEXGB7FK_cjs.MastraBase {
     validateInputs
   }) {
     this.__registerMastra(mastra);
-    if (validateInputs) {
-      this.#options = {
-        ...this.#options || {},
-        validateInputs
-      };
-    }
+    const effectiveValidateInputs = validateInputs ?? this.#options.validateInputs ?? true;
+    this.#options = {
+      ...this.#options || {},
+      validateInputs: effectiveValidateInputs
+    };
     this.executionEngine.options = {
       ...this.executionEngine.options || {},
-      validateInputs: validateInputs ?? false
+      validateInputs: effectiveValidateInputs
     };
     const isResume = !!(resume?.steps && resume.steps.length > 0) || !!resume?.label || !!(resume?.steps && resume.steps.length === 0 && (!retryCount || retryCount === 0));
+    if (!restart && !isResume) {
+      this.#nestedWorkflowInput = inputData;
+    }
+    const isTimeTravel = !!(timeTravel && timeTravel.steps.length > 0);
     const run = isResume ? await this.createRun({ runId: resume.runId }) : await this.createRun({ runId });
     const nestedAbortCb = () => {
       abort();
@@ -3422,21 +3680,41 @@ var Workflow = class extends chunkKEXGB7FK_cjs.MastraBase {
     if (retryCount && retryCount > 0 && isResume && requestContext) {
       requestContext.set("__mastraWorflowInputData", inputData);
     }
-    const res = isResume ? await run.resume({
-      resumeData,
-      step: resume.steps?.length > 0 ? resume.steps : void 0,
-      requestContext,
-      tracingContext,
-      outputOptions: { includeState: true, includeResumeLabels: true },
-      label: resume.label
-    }) : await run.start({
-      inputData,
-      requestContext,
-      tracingContext,
-      writableStream: writer,
-      initialState: state,
-      outputOptions: { includeState: true, includeResumeLabels: true }
-    });
+    let res;
+    if (isTimeTravel) {
+      res = await run.timeTravel({
+        inputData: timeTravel?.inputData,
+        resumeData: timeTravel?.resumeData,
+        initialState: state,
+        step: timeTravel?.steps,
+        context: timeTravel?.nestedStepResults?.[this.id] ?? {},
+        nestedStepsContext: timeTravel?.nestedStepResults,
+        requestContext,
+        tracingContext,
+        writableStream: writer,
+        outputOptions: { includeState: true, includeResumeLabels: true }
+      });
+    } else if (restart) {
+      res = await run.restart({ requestContext, tracingContext, writableStream: writer });
+    } else if (isResume) {
+      res = await run.resume({
+        resumeData,
+        step: resume.steps?.length > 0 ? resume.steps : void 0,
+        requestContext,
+        tracingContext,
+        outputOptions: { includeState: true, includeResumeLabels: true },
+        label: resume.label
+      });
+    } else {
+      res = await run.start({
+        inputData,
+        requestContext,
+        tracingContext,
+        writableStream: writer,
+        initialState: state,
+        outputOptions: { includeState: true, includeResumeLabels: true }
+      });
+    }
     unwatch();
     const suspendedSteps = Object.entries(res.steps).filter(([_stepName, stepResult]) => {
       const stepRes = stepResult;
@@ -3472,6 +3750,35 @@ var Workflow = class extends chunkKEXGB7FK_cjs.MastraBase {
     }
     return storage.listWorkflowRuns({ workflowName: this.id, ...args ?? {} });
   }
+  async listActiveWorkflowRuns() {
+    const runningRuns = await this.listWorkflowRuns({ status: "running" });
+    const waitingRuns = await this.listWorkflowRuns({ status: "waiting" });
+    return {
+      runs: [...runningRuns.runs, ...waitingRuns.runs],
+      total: runningRuns.total + waitingRuns.total
+    };
+  }
+  async restartAllActiveWorkflowRuns() {
+    if (this.engineType !== "default") {
+      this.logger.debug(`Cannot restart active workflow runs for ${this.engineType} engine`);
+      return;
+    }
+    const activeRuns = await this.listActiveWorkflowRuns();
+    if (activeRuns.runs.length > 0) {
+      this.logger.debug(
+        `Restarting ${activeRuns.runs.length} active workflow run${activeRuns.runs.length > 1 ? "s" : ""}`
+      );
+    }
+    for (const runSnapshot of activeRuns.runs) {
+      try {
+        const run = await this.createRun({ runId: runSnapshot.runId });
+        await run.restart();
+        this.logger.debug(`Restarted ${this.id} workflow run ${runSnapshot.runId}`);
+      } catch (error) {
+        this.logger.error(`Failed to restart ${this.id} workflow run ${runSnapshot.runId}: ${error}`);
+      }
+    }
+  }
   async getWorkflowRunById(runId) {
     const storage = this.#mastra?.getStorage();
     if (!storage) {
@@ -3547,7 +3854,9 @@ var Workflow = class extends chunkKEXGB7FK_cjs.MastraBase {
       result: snapshot.result,
       error: snapshot.error,
       payload: snapshot.context?.input,
-      steps: fullSteps
+      steps: fullSteps,
+      activeStepsPath: snapshot.activeStepsPath,
+      serializedStepGraph: snapshot.serializedStepGraph
     };
   }
 };
@@ -3599,6 +3908,7 @@ var Run = class {
    */
   workflowSteps;
   workflowRunStatus;
+  workflowEngineType;
   /**
    * The storage for this run
    */
@@ -3630,6 +3940,7 @@ var Run = class {
     this.validateInputs = params.validateInputs;
     this.stateSchema = params.stateSchema;
     this.workflowRunStatus = "pending";
+    this.workflowEngineType = params.workflowEngineType;
   }
   get abortController() {
     if (!this.#abortController) {
@@ -3702,6 +4013,20 @@ var Run = class {
     }
     return resumeDataToUse;
   }
+  async _validateTimetravelInputData(inputData, step) {
+    let inputDataToUse = inputData;
+    if (step && step.inputSchema && this.validateInputs) {
+      const inputSchema = step.inputSchema;
+      const validatedInputData = await inputSchema.safeParseAsync(inputData);
+      if (!validatedInputData.success) {
+        const errors = getZodErrors(validatedInputData.error);
+        const errorMessages = errors.map((e) => `- ${e.path?.join(".")}: ${e.message}`).join("\n");
+        throw new Error("Invalid inputData: \n" + errorMessages);
+      }
+      inputDataToUse = validatedInputData.data;
+    }
+    return inputDataToUse;
+  }
   async _start({
     inputData,
     initialState,
@@ -4127,6 +4452,13 @@ var Run = class {
   async resume(params) {
     return this._resume(params);
   }
+  /**
+   * Restarts the workflow execution that was previously active
+   * @returns A promise that resolves to the workflow output
+   */
+  async restart(args = {}) {
+    return this._restart(args);
+  }
   async _resume(params) {
     const snapshot = await this.#mastra?.getStorage()?.loadWorkflowSnapshot({
       workflowName: this.workflowId,
@@ -4194,7 +4526,7 @@ var Run = class {
       params.requestContext.delete("__mastraWorflowInputData");
     }
     const stepResults = { ...snapshot?.context ?? {}, input: requestContextInput ?? snapshot?.context?.input };
-    let requestContextToUse = params.requestContext ?? new chunkJ7O6WENZ_cjs.RequestContext();
+    const requestContextToUse = params.requestContext ?? new chunkJ7O6WENZ_cjs.RequestContext();
     Object.entries(snapshot?.requestContext ?? {}).forEach(([key, value]) => {
       if (!requestContextToUse.has(key)) {
         requestContextToUse.set(key, value);
@@ -4270,6 +4602,298 @@ var Run = class {
       return result;
     });
   }
+  async _restart({
+    requestContext,
+    writableStream,
+    tracingContext,
+    tracingOptions
+  }) {
+    if (this.workflowEngineType !== "default") {
+      throw new Error(`restart() is not supported on ${this.workflowEngineType} workflows`);
+    }
+    const snapshot = await this.#mastra?.getStorage()?.loadWorkflowSnapshot({
+      workflowName: this.workflowId,
+      runId: this.runId
+    });
+    let nestedWorkflowPending = false;
+    if (!snapshot) {
+      throw new Error(`Snapshot not found for run ${this.runId}`);
+    }
+    if (snapshot.status !== "running" && snapshot.status !== "waiting") {
+      if (snapshot.status === "pending" && !!snapshot.context.input) {
+        nestedWorkflowPending = true;
+      } else {
+        throw new Error("This workflow run was not active");
+      }
+    }
+    let nestedWorkflowActiveStepsPath = {};
+    const firstEntry = this.executionGraph.steps[0];
+    if (firstEntry.type === "step" || firstEntry.type === "foreach" || firstEntry.type === "loop") {
+      nestedWorkflowActiveStepsPath = {
+        [firstEntry.step.id]: [0]
+      };
+    } else if (firstEntry.type === "sleep" || firstEntry.type === "sleepUntil") {
+      nestedWorkflowActiveStepsPath = {
+        [firstEntry.id]: [0]
+      };
+    } else if (firstEntry.type === "conditional" || firstEntry.type === "parallel") {
+      nestedWorkflowActiveStepsPath = firstEntry.steps.reduce(
+        (acc, step) => {
+          acc[step.step.id] = [0];
+          return acc;
+        },
+        {}
+      );
+    }
+    const restartData = {
+      activePaths: nestedWorkflowPending ? [0] : snapshot.activePaths,
+      activeStepsPath: nestedWorkflowPending ? nestedWorkflowActiveStepsPath : snapshot.activeStepsPath,
+      stepResults: snapshot.context,
+      state: snapshot.value
+    };
+    const requestContextToUse = requestContext ?? new chunkJ7O6WENZ_cjs.RequestContext();
+    for (const [key, value] of Object.entries(snapshot.requestContext ?? {})) {
+      if (!requestContextToUse.has(key)) {
+        requestContextToUse.set(key, value);
+      }
+    }
+    const workflowSpan = chunkE7K4FTLN_cjs.getOrCreateSpan({
+      type: "workflow_run" /* WORKFLOW_RUN */,
+      name: `workflow run: '${this.workflowId}'`,
+      attributes: {
+        workflowId: this.workflowId
+      },
+      metadata: {
+        resourceId: this.resourceId,
+        runId: this.runId
+      },
+      tracingPolicy: this.tracingPolicy,
+      tracingOptions,
+      tracingContext,
+      requestContext: requestContextToUse,
+      mastra: this.#mastra
+    });
+    const traceId = workflowSpan?.externalTraceId;
+    const result = await this.executionEngine.execute({
+      workflowId: this.workflowId,
+      runId: this.runId,
+      resourceId: this.resourceId,
+      disableScorers: this.disableScorers,
+      graph: this.executionGraph,
+      serializedStepGraph: this.serializedStepGraph,
+      restart: restartData,
+      emitter: {
+        emit: async (event, data) => {
+          this.emitter.emit(event, data);
+        },
+        on: (event, callback) => {
+          this.emitter.on(event, callback);
+        },
+        off: (event, callback) => {
+          this.emitter.off(event, callback);
+        },
+        once: (event, callback) => {
+          this.emitter.once(event, callback);
+        }
+      },
+      retryConfig: this.retryConfig,
+      requestContext: requestContextToUse,
+      abortController: this.abortController,
+      writableStream,
+      workflowSpan
+    });
+    if (result.status !== "suspended") {
+      this.cleanup?.();
+    }
+    result.traceId = traceId;
+    return result;
+  }
+  async _timeTravel({
+    inputData,
+    resumeData,
+    initialState,
+    step: stepParam,
+    context,
+    nestedStepsContext,
+    requestContext,
+    writableStream,
+    tracingContext,
+    tracingOptions,
+    outputOptions
+  }) {
+    if (!stepParam || Array.isArray(stepParam) && stepParam.length === 0) {
+      throw new Error("Step is required and must be a valid step or array of steps");
+    }
+    const snapshot = await this.#mastra?.getStorage()?.loadWorkflowSnapshot({
+      workflowName: this.workflowId,
+      runId: this.runId
+    });
+    if (!snapshot) {
+      throw new Error(`Snapshot not found for run ${this.runId}`);
+    }
+    if (snapshot.status === "running") {
+      throw new Error("This workflow run is still running, cannot time travel");
+    }
+    let steps;
+    let newStepParam = stepParam;
+    if (typeof stepParam === "string") {
+      newStepParam = stepParam.split(".");
+    }
+    steps = (Array.isArray(newStepParam) ? newStepParam : [newStepParam]).map(
+      (step) => typeof step === "string" ? step : step?.id
+    );
+    let inputDataToUse = inputData;
+    if (inputDataToUse && steps.length === 1) {
+      inputDataToUse = await this._validateTimetravelInputData(inputData, this.workflowSteps[steps[0]]);
+    }
+    const timeTravelData = createTimeTravelExecutionParams({
+      steps,
+      inputData: inputDataToUse,
+      resumeData,
+      context,
+      nestedStepsContext,
+      snapshot,
+      initialState,
+      graph: this.executionGraph
+    });
+    const requestContextToUse = requestContext ?? new chunkJ7O6WENZ_cjs.RequestContext();
+    for (const [key, value] of Object.entries(snapshot.requestContext ?? {})) {
+      if (!requestContextToUse.has(key)) {
+        requestContextToUse.set(key, value);
+      }
+    }
+    const workflowSpan = chunkE7K4FTLN_cjs.getOrCreateSpan({
+      type: "workflow_run" /* WORKFLOW_RUN */,
+      name: `workflow run: '${this.workflowId}'`,
+      input: inputData,
+      attributes: {
+        workflowId: this.workflowId
+      },
+      metadata: {
+        resourceId: this.resourceId,
+        runId: this.runId
+      },
+      tracingPolicy: this.tracingPolicy,
+      tracingOptions,
+      tracingContext,
+      requestContext: requestContextToUse,
+      mastra: this.#mastra
+    });
+    const traceId = workflowSpan?.externalTraceId;
+    const result = await this.executionEngine.execute({
+      workflowId: this.workflowId,
+      runId: this.runId,
+      resourceId: this.resourceId,
+      disableScorers: this.disableScorers,
+      graph: this.executionGraph,
+      timeTravel: timeTravelData,
+      serializedStepGraph: this.serializedStepGraph,
+      emitter: {
+        emit: async (event, data) => {
+          this.emitter.emit(event, data);
+        },
+        on: (event, callback) => {
+          this.emitter.on(event, callback);
+        },
+        off: (event, callback) => {
+          this.emitter.off(event, callback);
+        },
+        once: (event, callback) => {
+          this.emitter.once(event, callback);
+        }
+      },
+      retryConfig: this.retryConfig,
+      requestContext: requestContextToUse,
+      abortController: this.abortController,
+      writableStream,
+      workflowSpan,
+      outputOptions
+    });
+    if (result.status !== "suspended") {
+      this.cleanup?.();
+    }
+    result.traceId = traceId;
+    return result;
+  }
+  async timeTravel(args) {
+    return this._timeTravel(args);
+  }
+  timeTravelStream({
+    inputData,
+    resumeData,
+    initialState,
+    step,
+    context,
+    nestedStepsContext,
+    requestContext,
+    tracingContext,
+    tracingOptions,
+    outputOptions
+  }) {
+    this.closeStreamAction = async () => {
+    };
+    const self = this;
+    const stream = new web.ReadableStream({
+      async start(controller) {
+        const unwatch = self.watch(async ({ type, from = "WORKFLOW" /* WORKFLOW */, payload }) => {
+          controller.enqueue({
+            type,
+            runId: self.runId,
+            from,
+            payload: {
+              stepName: payload.id,
+              ...payload
+            }
+          });
+        });
+        self.closeStreamAction = async () => {
+          unwatch();
+          try {
+            await controller.close();
+          } catch (err) {
+            console.error("Error closing stream:", err);
+          }
+        };
+        const executionResultsPromise = self._timeTravel({
+          inputData,
+          step,
+          context,
+          nestedStepsContext,
+          resumeData,
+          initialState,
+          requestContext,
+          tracingContext,
+          tracingOptions,
+          writableStream: new web.WritableStream({
+            write(chunk) {
+              controller.enqueue(chunk);
+            }
+          }),
+          outputOptions
+        });
+        self.executionResults = executionResultsPromise;
+        let executionResults;
+        try {
+          executionResults = await executionResultsPromise;
+          self.closeStreamAction?.().catch(() => {
+          });
+          if (self.streamOutput) {
+            self.streamOutput.updateResults(executionResults);
+          }
+        } catch (err) {
+          self.streamOutput?.rejectResults(err);
+          self.closeStreamAction?.().catch(() => {
+          });
+        }
+      }
+    });
+    this.streamOutput = new WorkflowRunOutput({
+      runId: this.runId,
+      workflowId: this.workflowId,
+      stream
+    });
+    return this.streamOutput;
+  }
   /**
    * @access private
    * @returns The execution results of the workflow run
@@ -4732,7 +5356,7 @@ function convertMastraChunkToAISDKv5({
       if (mode === "generate") {
         return {
           type: "file",
-          file: new chunkECFXGXWO_cjs.DefaultGeneratedFile({
+          file: new chunkG36A2JRR_cjs.DefaultGeneratedFile({
             data: chunk.payload.data,
             mediaType: chunk.payload.mimeType
           })
@@ -4740,7 +5364,7 @@ function convertMastraChunkToAISDKv5({
       }
       return {
         type: "file",
-        file: new chunkECFXGXWO_cjs.DefaultGeneratedFileWithType({
+        file: new chunkG36A2JRR_cjs.DefaultGeneratedFileWithType({
           data: chunk.payload.data,
           mediaType: chunk.payload.mimeType
         })
@@ -4895,7 +5519,8 @@ function execute({
   modelSettings,
   structuredOutput,
   headers,
-  shouldThrowError
+  shouldThrowError,
+  methodType
 }) {
   const v5 = new AISDKV5InputStream({
     component: "LLM",
@@ -4943,7 +5568,8 @@ You don't need to format your response as JSON unless the user asks you to. Just
         const pRetry = await import('p-retry');
         return await pRetry.default(
           async () => {
-            const streamResult = await model.doStream({
+            const fn = (methodType === "stream" ? model.doStream : model.doGenerate).bind(model);
+            const streamResult = await fn({
               ...toolsAndToolChoice,
               prompt,
               providerOptions: providerOptionsToUse,
@@ -4967,10 +5593,6 @@ You don't need to format your response as JSON unless the user asks you to. Just
           }
         );
       } catch (error) {
-        const abortSignal = options?.abortSignal;
-        if (providerUtilsV5.isAbortError(error) && abortSignal?.aborted) {
-          console.error("Abort error", error);
-        }
         if (shouldThrowError) {
           throw error;
         }
@@ -5442,7 +6064,8 @@ function createLLMExecutionStep({
   headers,
   downloadRetries,
   downloadConcurrency,
-  processorStates
+  processorStates,
+  methodType
 }) {
   return createStep({
     id: "llm-execution",
@@ -5492,7 +6115,7 @@ function createLLMExecutionStep({
                   }
                   if (prepareStepResult.messages) {
                     const newMessages = prepareStepResult.messages;
-                    const newMessageList = new chunkECFXGXWO_cjs.MessageList();
+                    const newMessageList = new chunkG36A2JRR_cjs.MessageList();
                     for (const message of newMessages) {
                       if (message.role === "system") {
                         newMessageList.addSystem(message);
@@ -5521,6 +6144,7 @@ function createLLMExecutionStep({
               includeRawChunks,
               structuredOutput,
               headers,
+              methodType,
               onResult: ({
                 warnings: warningsFromStream,
                 request: requestFromStream,
@@ -5981,7 +6605,8 @@ function createAgenticExecutionWorkflow({ models, _internal, ...rest }) {
         // VNext execution as internal
         internal: 1 /* WORKFLOW */
       },
-      shouldPersistSnapshot: ({ workflowStatus }) => workflowStatus === "suspended"
+      shouldPersistSnapshot: ({ workflowStatus }) => workflowStatus === "suspended",
+      validateInputs: false
     }
   }).then(llmExecutionStep).map(
     async ({ inputData }) => {
@@ -6021,7 +6646,8 @@ function createAgenticLoopWorkflow(params) {
       },
       shouldPersistSnapshot: (params2) => {
         return params2.workflowStatus === "suspended";
-      }
+      },
+      validateInputs: false
     }
   }).dowhile(agenticExecutionWorkflow, async ({ inputData }) => {
     const typedInputData = inputData;
@@ -6112,7 +6738,7 @@ function workflowLoopStream({
 }) {
   return new web.ReadableStream({
     start: async (controller) => {
-      const writer = new WritableStream({
+      const writer = new web.WritableStream({
         write: (chunk) => {
           controller.enqueue(chunk);
         }
@@ -6431,7 +7057,8 @@ var MastraLLMVNext = class extends chunkKEXGB7FK_cjs.MastraBase {
     requireToolApproval,
     _internal,
     agentId,
-    toolCallId
+    toolCallId,
+    methodType
   }) {
     let stopWhenToUse;
     if (maxSteps && typeof maxSteps === "number") {
@@ -6488,6 +7115,7 @@ var MastraLLMVNext = class extends chunkKEXGB7FK_cjs.MastraBase {
         modelSpanTracker,
         requireToolApproval,
         agentId,
+        methodType,
         options: {
           ...options,
           onStepFinish: async (props) => {
@@ -6527,7 +7155,7 @@ var MastraLLMVNext = class extends chunkKEXGB7FK_cjs.MastraBase {
             });
             if (props?.response?.headers?.["x-ratelimit-remaining-tokens"] && parseInt(props?.response?.headers?.["x-ratelimit-remaining-tokens"], 10) < 2e3) {
               this.logger.warn("Rate limit approaching, waiting 10 seconds", { runId });
-              await chunkWM6CK2F3_cjs.delay(10 * 1e3);
+              await chunkHBJPYQRN_cjs.delay(10 * 1e3);
             }
           },
           onFinish: async (props) => {
@@ -6831,7 +7459,7 @@ async function prepareMemoryStep({
       );
     }
   } else {
-    const messageList = new chunkECFXGXWO_cjs.MessageList({
+    const messageList = new chunkG36A2JRR_cjs.MessageList({
       threadId: thread?.id,
       resourceId: thread?.resourceId
     });
@@ -7596,7 +8224,8 @@ ${completionResult?.object?.finalResult}` : ""}
       isOneOff: z5__default.default.boolean()
     }),
     options: {
-      shouldPersistSnapshot: ({ workflowStatus }) => workflowStatus === "suspended"
+      shouldPersistSnapshot: ({ workflowStatus }) => workflowStatus === "suspended",
+      validateInputs: false
     }
   });
   networkWorkflow.then(routingStep).branch([
@@ -7723,7 +8352,8 @@ async function networkLoop({
       iteration: z5__default.default.number()
     }),
     options: {
-      shouldPersistSnapshot: ({ workflowStatus }) => workflowStatus === "suspended"
+      shouldPersistSnapshot: ({ workflowStatus }) => workflowStatus === "suspended",
+      validateInputs: false
     }
   }).dountil(networkWorkflow, async ({ inputData }) => {
     return inputData.isComplete || inputData.iteration >= maxIterations;
@@ -8281,7 +8911,7 @@ var AgentLegacyHandler = class {
           writableStream,
           methodType: methodType === "generate" ? "generateLegacy" : "streamLegacy"
         });
-        const messageList = new chunkECFXGXWO_cjs.MessageList({
+        const messageList = new chunkG36A2JRR_cjs.MessageList({
           threadId,
           resourceId,
           generateMessageId: this.capabilities.mastra?.generateId?.bind(this.capabilities.mastra),
@@ -8362,7 +8992,7 @@ var AgentLegacyHandler = class {
           existingThread || hasResourceScopeSemanticRecall ? this.capabilities.getMemoryMessages({
             resourceId,
             threadId: threadObject.id,
-            vectorMessageSearch: new chunkECFXGXWO_cjs.MessageList().add(messages, `user`).getLatestUserContent() || "",
+            vectorMessageSearch: new chunkG36A2JRR_cjs.MessageList().add(messages, `user`).getLatestUserContent() || "",
             memoryConfig,
             requestContext
           }) : { messages: [] },
@@ -8384,7 +9014,7 @@ The following messages were remembered from a different conversation:
 <remembered_from_other_conversation>
 ${(() => {
             let result = ``;
-            const messages2 = new chunkECFXGXWO_cjs.MessageList().add(resultsFromOtherThreads, "memory").get.all.v1();
+            const messages2 = new chunkG36A2JRR_cjs.MessageList().add(resultsFromOtherThreads, "memory").get.all.v1();
             let lastYmd = null;
             for (const msg of messages2) {
               const date = msg.createdAt;
@@ -8435,7 +9065,7 @@ the following messages are from ${ymd}
           systemMessage,
           memorySystemMessage: memorySystemMessage || void 0
         });
-        const processedList = new chunkECFXGXWO_cjs.MessageList({
+        const processedList = new chunkG36A2JRR_cjs.MessageList({
           threadId: threadObject.id,
           resourceId,
           generateMessageId: this.capabilities.mastra?.generateId?.bind(this.capabilities.mastra),
@@ -8491,7 +9121,7 @@ the following messages are from ${ymd}
           result: resToLog,
           threadId
         });
-        const messageListResponses = new chunkECFXGXWO_cjs.MessageList({
+        const messageListResponses = new chunkG36A2JRR_cjs.MessageList({
           threadId,
           resourceId,
           generateMessageId: this.capabilities.mastra?.generateId?.bind(this.capabilities.mastra),
@@ -8851,7 +9481,7 @@ the following messages are from ${ymd}
         requestContext: mergedGenerateOptions.requestContext || new chunkJ7O6WENZ_cjs.RequestContext(),
         tracingContext,
         outputProcessorOverrides: finalOutputProcessors,
-        messageList: new chunkECFXGXWO_cjs.MessageList({
+        messageList: new chunkG36A2JRR_cjs.MessageList({
           threadId: llmOptions.threadId || "",
           resourceId: llmOptions.resourceId || ""
         }).add(
@@ -8941,7 +9571,7 @@ the following messages are from ${ymd}
     const outputProcessorResult = await this.capabilities.__runOutputProcessors({
       requestContext: mergedGenerateOptions.requestContext || new chunkJ7O6WENZ_cjs.RequestContext(),
       tracingContext,
-      messageList: new chunkECFXGXWO_cjs.MessageList({
+      messageList: new chunkG36A2JRR_cjs.MessageList({
         threadId: llmOptions.threadId || "",
         resourceId: llmOptions.resourceId || ""
       }).add(
@@ -9151,6 +9781,21 @@ the following messages are from ${ymd}
   }
 };
 
+// src/llm/model/model-method-from-agent.ts
+function getModelMethodFromAgentMethod(methodType) {
+  if (methodType === "generate" || methodType === "generateLegacy") {
+    return "generate";
+  } else if (methodType === "stream" || methodType === "streamLegacy") {
+    return "stream";
+  } else {
+    throw new chunkTWH4PTDG_cjs.MastraError({
+      id: "INVALID_METHOD_TYPE",
+      domain: "AGENT" /* AGENT */,
+      category: "USER" /* USER */
+    });
+  }
+}
+
 // src/processors/processors/unicode-normalizer.ts
 var UnicodeNormalizer = class {
   id = "unicode-normalizer";
@@ -11149,7 +11794,8 @@ function createMapResultsStep({
   memoryConfig,
   saveQueueManager,
   agentSpan,
-  agentId
+  agentId,
+  methodType
 }) {
   return async ({
     inputData,
@@ -11214,7 +11860,9 @@ function createMapResultsStep({
       effectiveOutputProcessors = effectiveOutputProcessors ? [...effectiveOutputProcessors, structuredProcessor] : [structuredProcessor];
     }
     const messageList = memoryData.messageList;
+    const modelMethodType = getModelMethodFromAgentMethod(methodType);
     const loopOptions = {
+      methodType: modelMethodType,
       agentId,
       requestContext: result.requestContext,
       tracingContext: { currentSpan: agentSpan },
@@ -11318,7 +11966,7 @@ var prepareToolsStepOutputSchema = z5.z.object({
 var prepareMemoryStepOutputSchema = z5.z.object({
   threadExists: z5.z.boolean(),
   thread: storageThreadSchema.optional(),
-  messageList: z5.z.instanceof(chunkECFXGXWO_cjs.MessageList),
+  messageList: z5.z.instanceof(chunkG36A2JRR_cjs.MessageList),
   tripwire: z5.z.boolean().optional(),
   tripwireReason: z5.z.string().optional()
 });
@@ -11351,7 +11999,7 @@ function createPrepareMemoryStep({
     outputSchema: prepareMemoryStepOutputSchema,
     execute: async ({ tracingContext }) => {
       const thread = threadFromArgs;
-      const messageList = new chunkECFXGXWO_cjs.MessageList({
+      const messageList = new chunkG36A2JRR_cjs.MessageList({
         threadId: thread?.id,
         resourceId,
         generateMessageId: capabilities.generateMessageId,
@@ -11432,7 +12080,7 @@ function createPrepareMemoryStep({
         existingThread || hasResourceScopeSemanticRecall ? capabilities.getMemoryMessages({
           resourceId,
           threadId: threadObject.id,
-          vectorMessageSearch: new chunkECFXGXWO_cjs.MessageList().add(options.messages, `user`).getLatestUserContent() || "",
+          vectorMessageSearch: new chunkG36A2JRR_cjs.MessageList().add(options.messages, `user`).getLatestUserContent() || "",
           memoryConfig,
           requestContext
         }) : { messages: [] },
@@ -11458,7 +12106,7 @@ The following messages were remembered from a different conversation:
 <remembered_from_other_conversation>
 ${(() => {
           let result = ``;
-          const messages = new chunkECFXGXWO_cjs.MessageList().add(resultsFromOtherThreads, "memory").get.all.v1();
+          const messages = new chunkG36A2JRR_cjs.MessageList().add(resultsFromOtherThreads, "memory").get.all.v1();
           let lastYmd = null;
           for (const msg of messages) {
             const date = msg.createdAt;
@@ -11505,7 +12153,7 @@ the following messages are from ${ymd}
         systemMessage,
         memorySystemMessage: memorySystemMessage || void 0
       });
-      const processedList = new chunkECFXGXWO_cjs.MessageList({
+      const processedList = new chunkG36A2JRR_cjs.MessageList({
         threadId: threadObject.id,
         resourceId,
         generateMessageId: capabilities.generateMessageId,
@@ -11580,7 +12228,8 @@ function createStreamStep({
   requireToolApproval,
   resumeContext,
   agentId,
-  toolCallId
+  toolCallId,
+  methodType
 }) {
   return createStep({
     id: "stream-text-step",
@@ -11598,6 +12247,7 @@ function createStreamStep({
       const processors = validatedInputData.outputProcessors || (capabilities.outputProcessors ? typeof capabilities.outputProcessors === "function" ? await capabilities.outputProcessors({
         requestContext: validatedInputData.requestContext || new chunkJ7O6WENZ_cjs.RequestContext()
       }) : capabilities.outputProcessors : []);
+      const modelMethodType = getModelMethodFromAgentMethod(methodType);
       const streamResult = capabilities.llm.stream({
         ...validatedInputData,
         outputProcessors: processors,
@@ -11609,7 +12259,8 @@ function createStreamStep({
           generateId: capabilities.generateMessageId
         },
         agentId,
-        toolCallId
+        toolCallId,
+        methodType: modelMethodType
       });
       return streamResult;
     }
@@ -11665,7 +12316,8 @@ function createPrepareStreamWorkflow({
     requireToolApproval,
     resumeContext,
     agentId,
-    toolCallId
+    toolCallId,
+    methodType
   });
   const mapResultsStep = createMapResultsStep({
     capabilities,
@@ -11677,7 +12329,8 @@ function createPrepareStreamWorkflow({
     memoryConfig,
     saveQueueManager,
     agentSpan,
-    agentId
+    agentId,
+    methodType
   });
   return createWorkflow({
     id: "execution-workflow",
@@ -11690,7 +12343,8 @@ function createPrepareStreamWorkflow({
     options: {
       tracingPolicy: {
         internal: 1 /* WORKFLOW */
-      }
+      },
+      validateInputs: false
     }
   }).parallel([prepareToolsStep, prepareMemoryStep2]).map(mapResultsStep).then(streamStep).commit();
 }
@@ -12288,7 +12942,7 @@ var Agent = class extends chunkKEXGB7FK_cjs.MastraBase {
    */
   listTools({ requestContext = new chunkJ7O6WENZ_cjs.RequestContext() } = {}) {
     if (typeof this.#tools !== "function") {
-      return chunkWM6CK2F3_cjs.ensureToolProperties(this.#tools);
+      return chunkHBJPYQRN_cjs.ensureToolProperties(this.#tools);
     }
     const result = this.#tools({ requestContext, mastra: this.#mastra });
     return resolveMaybePromise(result, (tools) => {
@@ -12306,7 +12960,7 @@ var Agent = class extends chunkKEXGB7FK_cjs.MastraBase {
         this.logger.error(mastraError.toString());
         throw mastraError;
       }
-      return chunkWM6CK2F3_cjs.ensureToolProperties(tools);
+      return chunkHBJPYQRN_cjs.ensureToolProperties(tools);
     });
   }
   /**
@@ -12338,7 +12992,7 @@ var Agent = class extends chunkKEXGB7FK_cjs.MastraBase {
           });
         });
       } else {
-        llm = new chunkVOY2RXOC_cjs.MastraLLMV1({
+        llm = new chunkO6NA3Z43_cjs.MastraLLMV1({
           model: resolvedModel,
           mastra: this.#mastra,
           options: { tracingPolicy: this.#options?.tracingPolicy }
@@ -12363,7 +13017,7 @@ var Agent = class extends chunkKEXGB7FK_cjs.MastraBase {
    */
   async resolveModelConfig(modelConfig, requestContext) {
     try {
-      return await chunk2ZVKF4HP_cjs.resolveModelConfig(modelConfig, requestContext, this.#mastra);
+      return await chunkN4SJ4YX7_cjs.resolveModelConfig(modelConfig, requestContext, this.#mastra);
     } catch (error) {
       const mastraError = new chunkTWH4PTDG_cjs.MastraError({
         id: "AGENT_GET_MODEL_MISSING_MODEL_INSTANCE",
@@ -12569,7 +13223,7 @@ var Agent = class extends chunkKEXGB7FK_cjs.MastraBase {
     instructions
   }) {
     const llm = await this.getLLM({ requestContext, model });
-    const normMessage = new chunkECFXGXWO_cjs.MessageList().add(message, "user").get.all.ui().at(-1);
+    const normMessage = new chunkG36A2JRR_cjs.MessageList().add(message, "user").get.all.ui().at(-1);
     if (!normMessage) {
       throw new Error(`Could not generate title from input ${JSON.stringify(message)}`);
     }
@@ -12592,7 +13246,7 @@ var Agent = class extends chunkKEXGB7FK_cjs.MastraBase {
     const systemInstructions = await this.resolveTitleInstructions(requestContext, instructions);
     let text = "";
     if (llm.getModel().specificationVersion === "v2") {
-      const messageList = new chunkECFXGXWO_cjs.MessageList().add(
+      const messageList = new chunkG36A2JRR_cjs.MessageList().add(
         [
           {
             role: "system",
@@ -12610,6 +13264,7 @@ var Agent = class extends chunkKEXGB7FK_cjs.MastraBase {
         "input"
       );
       const result = llm.stream({
+        methodType: "generate",
         requestContext,
         tracingContext,
         messageList,
@@ -12643,7 +13298,7 @@ var Agent = class extends chunkKEXGB7FK_cjs.MastraBase {
   async genTitle(userMessage, requestContext, tracingContext, model, instructions) {
     try {
       if (userMessage) {
-        const normMessage = new chunkECFXGXWO_cjs.MessageList().add(userMessage, "user").get.all.ui().at(-1);
+        const normMessage = new chunkG36A2JRR_cjs.MessageList().add(userMessage, "user").get.all.ui().at(-1);
         if (normMessage) {
           return await this.generateTitleFromUserMessage({
             message: normMessage,
@@ -12705,7 +13360,7 @@ var Agent = class extends chunkKEXGB7FK_cjs.MastraBase {
           model: await this.getModel({ requestContext }),
           tracingPolicy: this.#options?.tracingPolicy
         };
-        const convertedToCoreTool = chunkWM6CK2F3_cjs.makeCoreTool(toolObj, options);
+        const convertedToCoreTool = chunkHBJPYQRN_cjs.makeCoreTool(toolObj, options);
         convertedMemoryTools[toolName] = convertedToCoreTool;
       }
     }
@@ -12855,7 +13510,7 @@ var Agent = class extends chunkKEXGB7FK_cjs.MastraBase {
           tracingPolicy: this.#options?.tracingPolicy,
           requireApproval: tool.requireApproval
         };
-        return [k, chunkWM6CK2F3_cjs.makeCoreTool(tool, options)];
+        return [k, chunkHBJPYQRN_cjs.makeCoreTool(tool, options)];
       })
     );
     const assignedToolEntriesConverted = Object.fromEntries(
@@ -12903,7 +13558,7 @@ var Agent = class extends chunkKEXGB7FK_cjs.MastraBase {
             model: await this.getModel({ requestContext }),
             tracingPolicy: this.#options?.tracingPolicy
           };
-          const convertedToCoreTool = chunkWM6CK2F3_cjs.makeCoreTool(toolObj, options, "toolset");
+          const convertedToCoreTool = chunkHBJPYQRN_cjs.makeCoreTool(toolObj, options, "toolset");
           toolsForRequest[toolName] = convertedToCoreTool;
         }
       }
@@ -12946,7 +13601,7 @@ var Agent = class extends chunkKEXGB7FK_cjs.MastraBase {
           model: await this.getModel({ requestContext }),
           tracingPolicy: this.#options?.tracingPolicy
         };
-        const convertedToCoreTool = chunkWM6CK2F3_cjs.makeCoreTool(rest, options, "client-tool");
+        const convertedToCoreTool = chunkHBJPYQRN_cjs.makeCoreTool(rest, options, "client-tool");
         toolsForRequest[toolName] = convertedToCoreTool;
       }
     }
@@ -12977,7 +13632,7 @@ var Agent = class extends chunkKEXGB7FK_cjs.MastraBase {
           subAgentResourceId: z5.z.string().describe("The resource ID of the agent").optional()
         });
         const modelVersion = (await agent.getModel()).specificationVersion;
-        const toolObj = chunkET6UOTTU_cjs.createTool({
+        const toolObj = chunk4IKJAKCD_cjs.createTool({
           id: `agent-${agentName}`,
           description: `Agent: ${agentName}`,
           inputSchema: agentInputSchema,
@@ -12997,12 +13652,24 @@ var Agent = class extends chunkKEXGB7FK_cjs.MastraBase {
               });
               let result;
               if ((methodType === "generate" || methodType === "generateLegacy") && modelVersion === "v2") {
+                if (!agent.hasOwnMemory() && this.#memory) {
+                  agent.__setMemory(this.#memory);
+                }
+                const subAgentThreadId = crypto2.randomUUID();
+                const slugify = await import('@sindresorhus/slugify');
+                const subAgentResourceId = `${slugify.default(this.id)}-${agentName}`;
                 const generateResult = await agent.generate(inputData.prompt, {
                   requestContext,
-                  tracingContext: context?.tracingContext
+                  tracingContext: context?.tracingContext,
+                  ...resourceId && threadId ? {
+                    memory: {
+                      resource: subAgentResourceId,
+                      thread: subAgentThreadId
+                    }
+                  } : {}
                 });
-                result = { text: generateResult.text };
-              } else if ((methodType === "generate" || methodType === "generateLegacy") && modelVersion === "v1") {
+                result = { text: generateResult.text, subAgentThreadId, subAgentResourceId };
+              } else if (methodType === "generate" && modelVersion === "v1") {
                 const generateResult = await agent.generateLegacy(inputData.prompt, {
                   requestContext,
                   tracingContext: context?.tracingContext
@@ -13089,7 +13756,7 @@ var Agent = class extends chunkKEXGB7FK_cjs.MastraBase {
           tracingContext,
           tracingPolicy: this.#options?.tracingPolicy
         };
-        convertedAgentTools[`agent-${agentName}`] = chunkWM6CK2F3_cjs.makeCoreTool(toolObj, options);
+        convertedAgentTools[`agent-${agentName}`] = chunkHBJPYQRN_cjs.makeCoreTool(toolObj, options);
       }
     }
     return convertedAgentTools;
@@ -13110,11 +13777,11 @@ var Agent = class extends chunkKEXGB7FK_cjs.MastraBase {
     const workflows = await this.listWorkflows({ requestContext });
     if (Object.keys(workflows).length > 0) {
       for (const [workflowName, workflow] of Object.entries(workflows)) {
-        const toolObj = chunkET6UOTTU_cjs.createTool({
+        const toolObj = chunk4IKJAKCD_cjs.createTool({
           id: `workflow-${workflowName}`,
           description: workflow.description || `Workflow: ${workflowName}`,
           inputSchema: workflow.inputSchema,
-          outputSchema: workflow.outputSchema,
+          outputSchema: z5.z.object({ result: workflow.outputSchema, runId: z5.z.string() }),
           mastra: this.#mastra,
           // BREAKING CHANGE v1.0: New tool signature - first param is inputData, second is context
           // manually wrap workflow tools with tracing, so that we can pass the
@@ -13161,7 +13828,8 @@ var Agent = class extends chunkKEXGB7FK_cjs.MastraBase {
                 }
                 result = await streamResult.result;
               }
-              return { result, runId: run.runId };
+              const workflowOutput = result?.result || result;
+              return { result: workflowOutput, runId: run.runId };
             } catch (err) {
               const mastraError = new chunkTWH4PTDG_cjs.MastraError(
                 {
@@ -13198,7 +13866,7 @@ var Agent = class extends chunkKEXGB7FK_cjs.MastraBase {
           tracingContext,
           tracingPolicy: this.#options?.tracingPolicy
         };
-        convertedWorkflowTools[`workflow-${workflowName}`] = chunkWM6CK2F3_cjs.makeCoreTool(toolObj, options);
+        convertedWorkflowTools[`workflow-${workflowName}`] = chunkHBJPYQRN_cjs.makeCoreTool(toolObj, options);
       }
     }
     return convertedWorkflowTools;
@@ -13221,7 +13889,7 @@ var Agent = class extends chunkKEXGB7FK_cjs.MastraBase {
     let mastraProxy = void 0;
     const logger = this.logger;
     if (this.#mastra) {
-      mastraProxy = chunkWM6CK2F3_cjs.createMastraProxy({ mastra: this.#mastra, logger });
+      mastraProxy = chunkHBJPYQRN_cjs.createMastraProxy({ mastra: this.#mastra, logger });
     }
     const assignedTools = await this.listAssignedTools({
       runId,
@@ -13441,7 +14109,7 @@ var Agent = class extends chunkKEXGB7FK_cjs.MastraBase {
     if (model || !Array.isArray(this.model)) {
       const modelToUse = model ?? this.model;
       const resolvedModel = typeof modelToUse === "function" ? await modelToUse({ requestContext, mastra: this.#mastra }) : modelToUse;
-      if (resolvedModel.specificationVersion !== "v2") {
+      if (resolvedModel?.specificationVersion !== "v2") {
         const mastraError = new chunkTWH4PTDG_cjs.MastraError({
           id: "AGENT_PREPARE_MODELS_INCOMPATIBLE_WITH_MODEL_ARRAY_V1",
           domain: "AGENT" /* AGENT */,
@@ -13458,6 +14126,7 @@ var Agent = class extends chunkKEXGB7FK_cjs.MastraBase {
       return [
         {
           id: "main",
+          // TODO fix type check
           model: resolvedModel,
           maxRetries: this.maxRetries ?? 0,
           enabled: true
@@ -13467,7 +14136,7 @@ var Agent = class extends chunkKEXGB7FK_cjs.MastraBase {
     const models = await Promise.all(
       this.model.map(async (modelConfig) => {
         const model2 = await this.resolveModelConfig(modelConfig.model, requestContext);
-        if (model2.specificationVersion !== "v2") {
+        if (!isV2Model(model2)) {
           const mastraError = new chunkTWH4PTDG_cjs.MastraError({
             id: "AGENT_PREPARE_MODELS_INCOMPATIBLE_WITH_MODEL_ARRAY_V1",
             domain: "AGENT" /* AGENT */,
@@ -13814,8 +14483,59 @@ var Agent = class extends chunkKEXGB7FK_cjs.MastraBase {
     });
   }
   async generate(messages, options) {
-    const result = await this.stream(messages, options);
-    const fullOutput = await result.getFullOutput();
+    const defaultOptions = await this.getDefaultOptions({
+      requestContext: options?.requestContext
+    });
+    const mergedOptions = {
+      ...defaultOptions,
+      ...options ?? {}
+    };
+    const llm = await this.getLLM({
+      requestContext: mergedOptions.requestContext
+    });
+    const modelInfo = llm.getModel();
+    if (modelInfo.specificationVersion !== "v2") {
+      const modelId = modelInfo.modelId || "unknown";
+      const provider = modelInfo.provider || "unknown";
+      throw new chunkTWH4PTDG_cjs.MastraError({
+        id: "AGENT_GENERATE_V1_MODEL_NOT_SUPPORTED",
+        domain: "AGENT" /* AGENT */,
+        category: "USER" /* USER */,
+        text: `Agent "${this.name}" is using AI SDK v4 model (${provider}:${modelId}) which is not compatible with generate(). Please use AI SDK v5 models or call the generateLegacy() method instead. See https://mastra.ai/en/docs/streaming/overview for more information.`,
+        details: {
+          agentName: this.name,
+          modelId,
+          provider,
+          specificationVersion: modelInfo.specificationVersion
+        }
+      });
+    }
+    const executeOptions = {
+      ...mergedOptions,
+      messages,
+      methodType: "generate"
+    };
+    const result = await this.#execute(executeOptions);
+    if (result.status !== "success") {
+      if (result.status === "failed") {
+        throw new chunkTWH4PTDG_cjs.MastraError(
+          {
+            id: "AGENT_GENERATE_FAILED",
+            domain: "AGENT" /* AGENT */,
+            category: "USER" /* USER */
+          },
+          // pass original error to preserve stack trace
+          result.error
+        );
+      }
+      throw new chunkTWH4PTDG_cjs.MastraError({
+        id: "AGENT_GENERATE_UNKNOWN_ERROR",
+        domain: "AGENT" /* AGENT */,
+        category: "USER" /* USER */,
+        text: "An unknown error occurred while streaming"
+      });
+    }
+    const fullOutput = await result.result.getFullOutput();
     const error = fullOutput.error;
     if (fullOutput.finishReason === "error" && error) {
       throw error;
@@ -15204,7 +15924,7 @@ var MastraModelOutput = class extends chunkKEXGB7FK_cjs.MastraBase {
                     self.messageList,
                     options.tracingContext
                   );
-                  const outputText = self.messageList.get.response.aiV4.core().map((m) => chunkECFXGXWO_cjs.MessageList.coreContentToString(m.content)).join("\n");
+                  const outputText = self.messageList.get.response.aiV4.core().map((m) => chunkG36A2JRR_cjs.MessageList.coreContentToString(m.content)).join("\n");
                   self.#delayedPromises.text.resolve(outputText);
                   self.#delayedPromises.finishReason.resolve(self.#finishReason);
                   if (chunk.payload.metadata) {
@@ -15827,8 +16547,10 @@ exports.convertFullStreamChunkToUIMessageStream = convertFullStreamChunkToUIMess
 exports.convertMastraChunkToAISDKv5 = convertMastraChunkToAISDKv5;
 exports.createDeprecationProxy = createDeprecationProxy;
 exports.createStep = createStep;
+exports.createTimeTravelExecutionParams = createTimeTravelExecutionParams;
 exports.createWorkflow = createWorkflow;
 exports.getResumeLabelsByStepId = getResumeLabelsByStepId;
+exports.getStepIds = getStepIds;
 exports.getStepResult = getStepResult;
 exports.getZodErrors = getZodErrors;
 exports.loop = loop;
@@ -15838,5 +16560,6 @@ exports.runCountDeprecationMessage = runCountDeprecationMessage;
 exports.tryGenerateWithJsonFallback = tryGenerateWithJsonFallback;
 exports.tryStreamWithJsonFallback = tryStreamWithJsonFallback;
 exports.validateStepInput = validateStepInput;
-//# sourceMappingURL=chunk-YCVEJ3UN.cjs.map
-//# sourceMappingURL=chunk-YCVEJ3UN.cjs.map
+exports.validateStepResumeData = validateStepResumeData;
+//# sourceMappingURL=chunk-OWX2PUFH.cjs.map
+//# sourceMappingURL=chunk-OWX2PUFH.cjs.map