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

package/dist/{chunk-7CBEP2ZQ.js → chunk-XXBWX7DT.js}

@@ -1,21 +1,21 @@
-import { DefaultVoice } from './chunk-UIZSWUKP.js';
+import { DefaultVoice } from './chunk-NZAXAFI3.js';
 import { STREAM_FORMAT_SYMBOL, EMITTER_SYMBOL } from './chunk-NLNKQD2T.js';
-import { MessageList, DefaultGeneratedFile, DefaultGeneratedFileWithType } from './chunk-JV2KH24V.js';
-import { resolveModelConfig } from './chunk-W7UH2PWL.js';
-import { MastraLLMV1 } from './chunk-XEVG546F.js';
+import { MessageList, DefaultGeneratedFile, DefaultGeneratedFileWithType } from './chunk-W3DD3XP5.js';
+import { resolveModelConfig } from './chunk-FVNT7VTO.js';
+import { MastraLLMV1 } from './chunk-JXESKY4A.js';
 import { executeHook } from './chunk-L54GIUCB.js';
-import { selectFields, ensureToolProperties, makeCoreTool, createMastraProxy, delay } from './chunk-4CDL2QJT.js';
+import { removeUndefinedValues, selectFields, ensureToolProperties, makeCoreTool, createMastraProxy, delay } from './chunk-D6EDHNGV.js';
 import { wrapMastra, getOrCreateSpan } from './chunk-KIZIOFZC.js';
 import { MastraError, getErrorFromUnknown } from './chunk-JJ5O45LH.js';
 import { ToolStream } from './chunk-HGNRQ3OG.js';
-import { Tool, createTool } from './chunk-7AHYOMHJ.js';
+import { Tool, createTool } from './chunk-KEURQGCQ.js';
 import { RequestContext } from './chunk-GRBGQ2GE.js';
 import { zodToJsonSchema } from './chunk-PJKCPRYF.js';
 import { MastraBase } from './chunk-S6URFGCZ.js';
 import { RegisteredLogger, ConsoleLogger } from './chunk-KJ2SW6VA.js';
 import { __commonJS, __toESM } from './chunk-5WRI5ZAA.js';
 import EventEmitter, { EventEmitter as EventEmitter$1 } from 'events';
-import { ReadableStream as ReadableStream$1, TransformStream, WritableStream as WritableStream$1 } from 'stream/web';
+import { WritableStream as WritableStream$1, ReadableStream as ReadableStream$1, TransformStream } from 'stream/web';
 import * as crypto2 from 'crypto';
 import { randomUUID } from 'crypto';
 import { getErrorMessage, TypeValidationError } from '@ai-sdk/provider-v5';
@@ -422,14 +422,22 @@ function prepareToolsAndToolChoice({
               inputSchema: asSchema(sdkTool.inputSchema).jsonSchema,
               providerOptions: sdkTool.providerOptions
             };
-          case "provider-defined":
+          case "provider-defined": {
+            const providerId = sdkTool.id;
+            let providerToolName = name;
+            if (providerId && providerId.includes(".")) {
+              providerToolName = providerId.split(".").slice(1).join(".");
+            } else if (providerId) {
+              providerToolName = providerId;
+            }
             return {
               type: "provider-defined",
-              name,
+              name: providerToolName,
               // TODO: as any seems wrong here. are there cases where we don't have an id?
-              id: sdkTool.id,
+              id: providerId,
               args: sdkTool.args
             };
+          }
           default: {
             const exhaustiveCheck = toolType;
             throw new Error(`Unsupported tool type: ${exhaustiveCheck}`);
@@ -516,6 +524,11 @@ function runScorer({
   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,
@@ -572,7 +585,7 @@ var WorkflowRunOutput = class {
     this.workflowId = workflowId;
     this.#baseStream = stream;
     stream.pipeTo(
-      new WritableStream({
+      new WritableStream$1({
         start() {
           const chunk = {
             type: "workflow-start",
@@ -700,7 +713,7 @@ var WorkflowRunOutput = class {
     };
     const self = this;
     stream.pipeTo(
-      new WritableStream({
+      new WritableStream$1({
         start() {
           const chunk = {
             type: "workflow-start",
@@ -935,6 +948,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]) => {
@@ -965,6 +996,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 = 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 {
@@ -1051,7 +1187,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;
@@ -1067,19 +1205,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 },
@@ -1097,6 +1242,8 @@ var DefaultExecutionEngine = class extends ExecutionEngine {
           prevStep: steps[i - 1],
           stepResults,
           resume,
+          timeTravel,
+          restart,
           tracingContext: {
             currentSpan: workflowSpan
           },
@@ -1386,7 +1533,9 @@ var DefaultExecutionEngine = class extends ExecutionEngine {
     step,
     stepResults,
     executionContext,
+    restart,
     resume,
+    timeTravel,
     prevOutput,
     emitter,
     abortController,
@@ -1398,22 +1547,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 = 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 */,
@@ -1468,6 +1633,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,
@@ -1480,7 +1649,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),
@@ -1513,6 +1682,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,
           [EMITTER_SYMBOL]: emitter,
           [STREAM_FORMAT_SYMBOL]: executionContext.format,
           engine: {},
@@ -1584,6 +1762,7 @@ var DefaultExecutionEngine = class extends ExecutionEngine {
         };
       }
     }
+    delete executionContext.activeStepsPath[step.id];
     if (!skipEmits) {
       if (execResults.status === "suspended") {
         await emitter.emit("watch", {
@@ -1687,6 +1866,8 @@ var DefaultExecutionEngine = class extends ExecutionEngine {
     serializedStepGraph,
     stepResults,
     resume,
+    restart,
+    timeTravel,
     executionContext,
     tracingContext,
     emitter,
@@ -1706,22 +1887,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,
@@ -1730,8 +1927,11 @@ var DefaultExecutionEngine = class extends ExecutionEngine {
           prevOutput,
           stepResults,
           serializedStepGraph,
+          restart,
+          timeTravel,
           resume,
           executionContext: {
+            activeStepsPath: executionContext.activeStepsPath,
             workflowId,
             runId,
             executionPath: [...executionContext.executionPath, i],
@@ -1796,6 +1996,8 @@ var DefaultExecutionEngine = class extends ExecutionEngine {
     serializedStepGraph,
     stepResults,
     resume,
+    restart,
+    timeTravel,
     executionContext,
     tracingContext,
     emitter,
@@ -1911,7 +2113,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({
@@ -1923,10 +2131,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,
@@ -1988,6 +2199,8 @@ var DefaultExecutionEngine = class extends ExecutionEngine {
     prevOutput,
     stepResults,
     resume,
+    restart,
+    timeTravel,
     executionContext,
     tracingContext,
     emitter,
@@ -2013,6 +2226,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,
@@ -2021,7 +2236,9 @@ var DefaultExecutionEngine = class extends ExecutionEngine {
         step,
         stepResults,
         executionContext,
+        restart: currentRestart,
         resume: currentResume,
+        timeTravel: currentTimeTravel,
         prevOutput: result.output,
         tracingContext: {
           currentSpan: loopSpan
@@ -2034,6 +2251,8 @@ var DefaultExecutionEngine = class extends ExecutionEngine {
         serializedStepGraph,
         iterationCount: iteration + 1
       });
+      currentRestart = void 0;
+      currentTimeTravel = void 0;
       if (currentResume && result.status !== "suspended") {
         currentResume = void 0;
       }
@@ -2121,7 +2340,9 @@ var DefaultExecutionEngine = class extends ExecutionEngine {
     entry,
     prevOutput,
     stepResults,
+    restart,
     resume,
+    timeTravel,
     executionContext,
     tracingContext,
     emitter,
@@ -2190,6 +2411,8 @@ var DefaultExecutionEngine = class extends ExecutionEngine {
             resourceId,
             step,
             stepResults,
+            restart,
+            timeTravel,
             executionContext: { ...executionContext, foreachIndex: k },
             resume: resumeToUse,
             prevOutput: item,
@@ -2323,7 +2546,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: {},
@@ -2344,6 +2568,8 @@ var DefaultExecutionEngine = class extends ExecutionEngine {
     prevStep,
     serializedStepGraph,
     stepResults,
+    restart,
+    timeTravel,
     resume,
     executionContext,
     tracingContext,
@@ -2364,6 +2590,8 @@ var DefaultExecutionEngine = class extends ExecutionEngine {
         step,
         stepResults,
         executionContext,
+        timeTravel,
+        restart,
         resume,
         prevOutput,
         tracingContext,
@@ -2392,6 +2620,7 @@ var DefaultExecutionEngine = class extends ExecutionEngine {
           suspendedPaths: executionContext.suspendedPaths,
           resumeLabels: executionContext.resumeLabels,
           retryConfig: executionContext.retryConfig,
+          activeStepsPath: executionContext.activeStepsPath,
           state: executionContext.state
         },
         tracingContext,
@@ -2471,6 +2700,8 @@ var DefaultExecutionEngine = class extends ExecutionEngine {
         prevStep,
         stepResults,
         serializedStepGraph,
+        timeTravel,
+        restart,
         resume,
         executionContext,
         tracingContext,
@@ -2488,6 +2719,8 @@ var DefaultExecutionEngine = class extends ExecutionEngine {
         prevOutput,
         stepResults,
         serializedStepGraph,
+        timeTravel,
+        restart,
         resume,
         executionContext,
         tracingContext,
@@ -2505,6 +2738,8 @@ var DefaultExecutionEngine = class extends ExecutionEngine {
         prevStep,
         prevOutput,
         stepResults,
+        timeTravel,
+        restart,
         resume,
         executionContext,
         tracingContext,
@@ -2523,6 +2758,8 @@ var DefaultExecutionEngine = class extends ExecutionEngine {
         prevStep,
         prevOutput,
         stepResults,
+        timeTravel,
+        restart,
         resume,
         executionContext,
         tracingContext,
@@ -2544,6 +2781,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,
@@ -2570,6 +2813,7 @@ var DefaultExecutionEngine = class extends ExecutionEngine {
         requestContext,
         writableStream
       });
+      delete executionContext.activeStepsPath[entry.id];
       await this.persistStepUpdate({
         workflowId,
         runId,
@@ -2615,6 +2859,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,
@@ -2641,6 +2891,7 @@ var DefaultExecutionEngine = class extends ExecutionEngine {
         requestContext,
         writableStream
       });
+      delete executionContext.activeStepsPath[entry.id];
       await this.persistStepUpdate({
         workflowId,
         runId,
@@ -2861,8 +3112,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
   };
 }
@@ -2875,7 +3130,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();
@@ -2889,6 +3145,8 @@ var Workflow = class extends MastraBase {
   stateSchema;
   steps;
   stepDefs;
+  engineType = "default";
+  #nestedWorkflowInput;
   committed = false;
   stepFlow;
   serializedStepFlow;
@@ -2924,7 +3182,7 @@ var Workflow = class extends MastraBase {
     this.steps = {};
     this.stepDefs = steps;
     this.#options = {
-      validateInputs: options.validateInputs ?? false,
+      validateInputs: options.validateInputs ?? true,
       shouldPersistSnapshot: options.shouldPersistSnapshot ?? (() => true),
       tracingPolicy: options.tracingPolicy
     };
@@ -2936,6 +3194,7 @@ var Workflow = class extends MastraBase {
     } else {
       this.executionEngine = executionEngine;
     }
+    this.engineType = "default";
     this.#runs = /* @__PURE__ */ new Map();
   }
   get runs() {
@@ -3295,7 +3554,8 @@ var Workflow = class extends 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({
@@ -3312,8 +3572,9 @@ var Workflow = class extends MastraBase {
           runId: runIdToUse,
           status: "pending",
           value: {},
-          context: {},
+          context: this.#nestedWorkflowInput ? { input: this.#nestedWorkflowInput } : {},
           activePaths: [],
+          activeStepsPath: {},
           serializedStepGraph: this.serializedStepGraph,
           suspendedPaths: {},
           resumeLabels: {},
@@ -3357,7 +3618,9 @@ var Workflow = class extends MastraBase {
     state,
     setState,
     suspend,
+    restart,
     resume,
+    timeTravel,
     [EMITTER_SYMBOL]: emitter,
     mastra,
     requestContext,
@@ -3369,17 +3632,20 @@ var Workflow = class extends 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();
@@ -3395,21 +3661,41 @@ var Workflow = class extends 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;
@@ -3445,6 +3731,35 @@ var Workflow = class extends 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) {
@@ -3520,7 +3835,9 @@ var Workflow = class extends MastraBase {
       result: snapshot.result,
       error: snapshot.error,
       payload: snapshot.context?.input,
-      steps: fullSteps
+      steps: fullSteps,
+      activeStepsPath: snapshot.activeStepsPath,
+      serializedStepGraph: snapshot.serializedStepGraph
     };
   }
 };
@@ -3572,6 +3889,7 @@ var Run = class {
    */
   workflowSteps;
   workflowRunStatus;
+  workflowEngineType;
   /**
    * The storage for this run
    */
@@ -3603,6 +3921,7 @@ var Run = class {
     this.validateInputs = params.validateInputs;
     this.stateSchema = params.stateSchema;
     this.workflowRunStatus = "pending";
+    this.workflowEngineType = params.workflowEngineType;
   }
   get abortController() {
     if (!this.#abortController) {
@@ -3675,6 +3994,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,
@@ -4100,6 +4433,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,
@@ -4167,7 +4507,7 @@ var Run = class {
       params.requestContext.delete("__mastraWorflowInputData");
     }
     const stepResults = { ...snapshot?.context ?? {}, input: requestContextInput ?? snapshot?.context?.input };
-    let requestContextToUse = params.requestContext ?? new RequestContext();
+    const requestContextToUse = params.requestContext ?? new RequestContext();
     Object.entries(snapshot?.requestContext ?? {}).forEach(([key, value]) => {
       if (!requestContextToUse.has(key)) {
         requestContextToUse.set(key, value);
@@ -4234,14 +4574,306 @@ var Run = class {
         this.closeStreamAction?.().catch(() => {
         });
       }
-      result.traceId = traceId;
-      return result;
+      result.traceId = traceId;
+      return result;
+    });
+    this.executionResults = executionResultPromise;
+    return executionResultPromise.then((result) => {
+      this.streamOutput?.updateResults(result);
+      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 RequestContext();
+    for (const [key, value] of Object.entries(snapshot.requestContext ?? {})) {
+      if (!requestContextToUse.has(key)) {
+        requestContextToUse.set(key, value);
+      }
+    }
+    const workflowSpan = 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 RequestContext();
+    for (const [key, value] of Object.entries(snapshot.requestContext ?? {})) {
+      if (!requestContextToUse.has(key)) {
+        requestContextToUse.set(key, value);
+      }
+    }
+    const workflowSpan = 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 ReadableStream$1({
+      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 WritableStream$1({
+            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.executionResults = executionResultPromise;
-    return executionResultPromise.then((result) => {
-      this.streamOutput?.updateResults(result);
-      return result;
+    this.streamOutput = new WorkflowRunOutput({
+      runId: this.runId,
+      workflowId: this.workflowId,
+      stream
     });
+    return this.streamOutput;
   }
   /**
    * @access private
@@ -4868,7 +5500,8 @@ function execute({
   modelSettings,
   structuredOutput,
   headers,
-  shouldThrowError
+  shouldThrowError,
+  methodType
 }) {
   const v5 = new AISDKV5InputStream({
     component: "LLM",
@@ -4916,7 +5549,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,
@@ -4940,10 +5574,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 (isAbortError(error) && abortSignal?.aborted) {
-          console.error("Abort error", error);
-        }
         if (shouldThrowError) {
           throw error;
         }
@@ -5099,23 +5729,22 @@ async function processOutputStream({
       if (runState.state.textDeltas.length) {
         const textStartPayload = chunk.payload;
         const providerMetadata = textStartPayload.providerMetadata ?? runState.state.providerOptions;
-        messageList.add(
-          {
-            id: messageId,
-            role: "assistant",
-            content: [
-              providerMetadata ? {
+        const message = {
+          id: messageId,
+          role: "assistant",
+          content: {
+            format: 2,
+            parts: [
+              {
                 type: "text",
                 text: runState.state.textDeltas.join(""),
-                providerOptions: providerMetadata
-              } : {
-                type: "text",
-                text: runState.state.textDeltas.join("")
+                ...providerMetadata ? { providerMetadata } : {}
               }
             ]
           },
-          "response"
-        );
+          createdAt: /* @__PURE__ */ new Date()
+        };
+        messageList.add(message, "response");
       }
       runState.setState({
         isStreaming: false,
@@ -5195,20 +5824,23 @@ async function processOutputStream({
           providerOptions: chunk.payload.providerMetadata ?? runState.state.providerOptions
         });
         if (Object.values(chunk.payload.providerMetadata || {}).find((v) => v?.redactedData)) {
-          messageList.add(
-            {
-              id: messageId,
-              role: "assistant",
-              content: [
+          const message = {
+            id: messageId,
+            role: "assistant",
+            content: {
+              format: 2,
+              parts: [
                 {
                   type: "reasoning",
-                  text: "",
-                  providerOptions: chunk.payload.providerMetadata ?? runState.state.providerOptions
+                  reasoning: "",
+                  details: [{ type: "redacted", data: "" }],
+                  providerMetadata: chunk.payload.providerMetadata ?? runState.state.providerOptions
                 }
               ]
             },
-            "response"
-          );
+            createdAt: /* @__PURE__ */ new Date()
+          };
+          messageList.add(message, "response");
           if (isControllerOpen(controller)) {
             controller.enqueue(chunk);
           }
@@ -5234,20 +5866,23 @@ async function processOutputStream({
       }
       case "reasoning-end": {
         if (runState.state.reasoningDeltas.length > 0) {
-          messageList.add(
-            {
-              id: messageId,
-              role: "assistant",
-              content: [
+          const message = {
+            id: messageId,
+            role: "assistant",
+            content: {
+              format: 2,
+              parts: [
                 {
                   type: "reasoning",
-                  text: runState.state.reasoningDeltas.join(""),
-                  providerOptions: chunk.payload.providerMetadata ?? runState.state.providerOptions
+                  reasoning: "",
+                  details: [{ type: "text", text: runState.state.reasoningDeltas.join("") }],
+                  providerMetadata: chunk.payload.providerMetadata ?? runState.state.providerOptions
                 }
               ]
             },
-            "response"
-          );
+            createdAt: /* @__PURE__ */ new Date()
+          };
+          messageList.add(message, "response");
         }
         runState.setState({
           isReasoning: false,
@@ -5259,25 +5894,31 @@ async function processOutputStream({
         break;
       }
       case "file":
-        messageList.add(
-          {
+        {
+          const message = {
             id: messageId,
             role: "assistant",
-            content: [
-              {
-                type: "file",
-                data: chunk.payload.data,
-                mimeType: chunk.payload.mimeType
-              }
-            ]
-          },
-          "response"
-        );
-        controller.enqueue(chunk);
+            content: {
+              format: 2,
+              parts: [
+                {
+                  type: "file",
+                  // @ts-expect-error
+                  data: chunk.payload.data,
+                  // TODO: incorrect string type
+                  mimeType: chunk.payload.mimeType
+                }
+              ]
+            },
+            createdAt: /* @__PURE__ */ new Date()
+          };
+          messageList.add(message, "response");
+          controller.enqueue(chunk);
+        }
         break;
       case "source":
-        messageList.add(
-          {
+        {
+          const message = {
             id: messageId,
             role: "assistant",
             content: {
@@ -5296,10 +5937,10 @@ async function processOutputStream({
               ]
             },
             createdAt: /* @__PURE__ */ new Date()
-          },
-          "response"
-        );
-        controller.enqueue(chunk);
+          };
+          messageList.add(message, "response");
+          controller.enqueue(chunk);
+        }
         break;
       case "finish":
         runState.setState({
@@ -5415,7 +6056,8 @@ function createLLMExecutionStep({
   headers,
   downloadRetries,
   downloadConcurrency,
-  processorStates
+  processorStates,
+  methodType
 }) {
   return createStep({
     id: "llm-execution",
@@ -5494,6 +6136,7 @@ function createLLMExecutionStep({
               includeRawChunks,
               structuredOutput,
               headers,
+              methodType,
               onResult: ({
                 warnings: warningsFromStream,
                 request: requestFromStream,
@@ -5636,24 +6279,27 @@ function createLLMExecutionStep({
         return chunk.payload;
       });
       if (toolCalls.length > 0) {
-        const assistantContent = [
-          ...toolCalls.map((toolCall) => {
-            return {
-              type: "tool-call",
-              toolCallId: toolCall.toolCallId,
-              toolName: toolCall.toolName,
-              args: toolCall.args
-            };
-          })
-        ];
-        messageList.add(
-          {
-            id: messageId,
-            role: "assistant",
-            content: assistantContent
+        const message = {
+          id: messageId,
+          role: "assistant",
+          content: {
+            format: 2,
+            parts: toolCalls.map((toolCall) => {
+              return {
+                type: "tool-invocation",
+                toolInvocation: {
+                  state: "call",
+                  toolCallId: toolCall.toolCallId,
+                  toolName: toolCall.toolName,
+                  args: toolCall.args
+                },
+                ...toolCall.providerMetadata ? { providerMetadata: toolCall.providerMetadata } : {}
+              };
+            })
           },
-          "response"
-        );
+          createdAt: /* @__PURE__ */ new Date()
+        };
+        messageList.add(message, "response");
       }
       const finishReason = runState?.state?.stepResult?.reason ?? outputStream._getImmediateFinishReason();
       const hasErrored = runState.state.hasErrored;
@@ -5735,24 +6381,28 @@ function createLLMMappingStep({ models, _internal, ...rest }, llmExecutionStep)
             };
             rest.controller.enqueue(chunk);
           });
-          rest.messageList.add(
-            {
-              id: toolResultMessageId,
-              role: "tool",
-              content: errorResults.map((toolCall) => {
+          const msg = {
+            id: toolResultMessageId || "",
+            role: "assistant",
+            content: {
+              format: 2,
+              parts: errorResults.map((toolCallErrorResult) => {
                 return {
-                  type: "tool-result",
-                  args: toolCall.args,
-                  toolCallId: toolCall.toolCallId,
-                  toolName: toolCall.toolName,
-                  result: {
-                    tool_execution_error: toolCall.error?.message ?? toolCall.error
-                  }
+                  type: "tool-invocation",
+                  toolInvocation: {
+                    state: "result",
+                    toolCallId: toolCallErrorResult.toolCallId,
+                    toolName: toolCallErrorResult.toolName,
+                    args: toolCallErrorResult.args,
+                    result: toolCallErrorResult.error?.message ?? toolCallErrorResult.error
+                  },
+                  ...toolCallErrorResult.providerMetadata ? { providerMetadata: toolCallErrorResult.providerMetadata } : {}
                 };
               })
             },
-            "response"
-          );
+            createdAt: /* @__PURE__ */ new Date()
+          };
+          rest.messageList.add(msg, "response");
         }
         initialResult.stepResult.isContinued = false;
         return bail(initialResult);
@@ -5780,24 +6430,30 @@ function createLLMMappingStep({ models, _internal, ...rest }, llmExecutionStep)
               })
             });
           }
-          const toolResultMessageId = rest.experimental_generateMessageId?.() || _internal?.generateId?.();
-          rest.messageList.add(
-            {
-              id: toolResultMessageId,
-              role: "tool",
-              content: inputData.map((toolCall2) => {
-                return {
-                  type: "tool-result",
-                  args: toolCall2.args,
-                  toolCallId: toolCall2.toolCallId,
-                  toolName: toolCall2.toolName,
-                  result: toolCall2.result
-                };
-              })
-            },
-            "response"
-          );
         }
+        const toolResultMessageId = rest.experimental_generateMessageId?.() || _internal?.generateId?.();
+        const toolResultMessage = {
+          id: toolResultMessageId || "",
+          role: "assistant",
+          content: {
+            format: 2,
+            parts: inputData.map((toolCall) => {
+              return {
+                type: "tool-invocation",
+                toolInvocation: {
+                  state: "result",
+                  toolCallId: toolCall.toolCallId,
+                  toolName: toolCall.toolName,
+                  args: toolCall.args,
+                  result: toolCall.result
+                },
+                ...toolCall.providerMetadata ? { providerMetadata: toolCall.providerMetadata } : {}
+              };
+            })
+          },
+          createdAt: /* @__PURE__ */ new Date()
+        };
+        rest.messageList.add(toolResultMessage, "response");
         return {
           ...initialResult,
           messages: {
@@ -5954,7 +6610,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 }) => {
@@ -5994,7 +6651,8 @@ function createAgenticLoopWorkflow(params) {
       },
       shouldPersistSnapshot: (params2) => {
         return params2.workflowStatus === "suspended";
-      }
+      },
+      validateInputs: false
     }
   }).dowhile(agenticExecutionWorkflow, async ({ inputData }) => {
     const typedInputData = inputData;
@@ -6085,7 +6743,7 @@ function workflowLoopStream({
 }) {
   return new ReadableStream$1({
     start: async (controller) => {
-      const writer = new WritableStream({
+      const writer = new WritableStream$1({
         write: (chunk) => {
           controller.enqueue(chunk);
         }
@@ -6404,7 +7062,8 @@ var MastraLLMVNext = class extends MastraBase {
     requireToolApproval,
     _internal,
     agentId,
-    toolCallId
+    toolCallId,
+    methodType
   }) {
     let stopWhenToUse;
     if (maxSteps && typeof maxSteps === "number") {
@@ -6461,6 +7120,7 @@ var MastraLLMVNext = class extends MastraBase {
         modelSpanTracker,
         requireToolApproval,
         agentId,
+        methodType,
         options: {
           ...options,
           onStepFinish: async (props) => {
@@ -7299,7 +7959,7 @@ ${completionResult?.object?.finalResult}` : ""}
         requestContext
       });
       let chunks = [];
-      for await (const chunk of stream) {
+      for await (const chunk of stream.fullStream) {
         chunks.push(chunk);
         await writer?.write({
           type: `workflow-execution-event-${chunk.type}`,
@@ -7569,7 +8229,8 @@ ${completionResult?.object?.finalResult}` : ""}
       isOneOff: z5.boolean()
     }),
     options: {
-      shouldPersistSnapshot: ({ workflowStatus }) => workflowStatus === "suspended"
+      shouldPersistSnapshot: ({ workflowStatus }) => workflowStatus === "suspended",
+      validateInputs: false
     }
   });
   networkWorkflow.then(routingStep).branch([
@@ -7696,7 +8357,8 @@ async function networkLoop({
       iteration: z5.number()
     }),
     options: {
-      shouldPersistSnapshot: ({ workflowStatus }) => workflowStatus === "suspended"
+      shouldPersistSnapshot: ({ workflowStatus }) => workflowStatus === "suspended",
+      validateInputs: false
     }
   }).dountil(networkWorkflow, async ({ inputData }) => {
     return inputData.isComplete || inputData.iteration >= maxIterations;
@@ -9124,6 +9786,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 MastraError({
+      id: "INVALID_METHOD_TYPE",
+      domain: "AGENT" /* AGENT */,
+      category: "USER" /* USER */
+    });
+  }
+}
+
 // src/processors/processors/unicode-normalizer.ts
 var UnicodeNormalizer = class {
   id = "unicode-normalizer";
@@ -11122,7 +11799,8 @@ function createMapResultsStep({
   memoryConfig,
   saveQueueManager,
   agentSpan,
-  agentId
+  agentId,
+  methodType
 }) {
   return async ({
     inputData,
@@ -11187,7 +11865,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 },
@@ -11553,7 +12233,8 @@ function createStreamStep({
   requireToolApproval,
   resumeContext,
   agentId,
-  toolCallId
+  toolCallId,
+  methodType
 }) {
   return createStep({
     id: "stream-text-step",
@@ -11571,6 +12252,7 @@ function createStreamStep({
       const processors = validatedInputData.outputProcessors || (capabilities.outputProcessors ? typeof capabilities.outputProcessors === "function" ? await capabilities.outputProcessors({
         requestContext: validatedInputData.requestContext || new RequestContext()
       }) : capabilities.outputProcessors : []);
+      const modelMethodType = getModelMethodFromAgentMethod(methodType);
       const streamResult = capabilities.llm.stream({
         ...validatedInputData,
         outputProcessors: processors,
@@ -11582,7 +12264,8 @@ function createStreamStep({
           generateId: capabilities.generateMessageId
         },
         agentId,
-        toolCallId
+        toolCallId,
+        methodType: modelMethodType
       });
       return streamResult;
     }
@@ -11638,7 +12321,8 @@ function createPrepareStreamWorkflow({
     requireToolApproval,
     resumeContext,
     agentId,
-    toolCallId
+    toolCallId,
+    methodType
   });
   const mapResultsStep = createMapResultsStep({
     capabilities,
@@ -11650,7 +12334,8 @@ function createPrepareStreamWorkflow({
     memoryConfig,
     saveQueueManager,
     agentSpan,
-    agentId
+    agentId,
+    methodType
   });
   return createWorkflow({
     id: "execution-workflow",
@@ -11663,7 +12348,8 @@ function createPrepareStreamWorkflow({
     options: {
       tracingPolicy: {
         internal: 1 /* WORKFLOW */
-      }
+      },
+      validateInputs: false
     }
   }).parallel([prepareToolsStep, prepareMemoryStep2]).map(mapResultsStep).then(streamStep).commit();
 }
@@ -12583,6 +13269,7 @@ var Agent = class extends MastraBase {
         "input"
       );
       const result = llm.stream({
+        methodType: "generate",
         requestContext,
         tracingContext,
         messageList,
@@ -12970,12 +13657,24 @@ var Agent = class extends MastraBase {
               });
               let result;
               if ((methodType === "generate" || methodType === "generateLegacy") && modelVersion === "v2") {
+                if (!agent.hasOwnMemory() && this.#memory) {
+                  agent.__setMemory(this.#memory);
+                }
+                const subAgentThreadId = 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
@@ -13087,7 +13786,7 @@ var Agent = class extends MastraBase {
           id: `workflow-${workflowName}`,
           description: workflow.description || `Workflow: ${workflowName}`,
           inputSchema: workflow.inputSchema,
-          outputSchema: workflow.outputSchema,
+          outputSchema: z.object({ result: workflow.outputSchema, runId: 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
@@ -13134,7 +13833,8 @@ var Agent = class extends 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 MastraError(
                 {
@@ -13414,7 +14114,7 @@ var Agent = class extends 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 MastraError({
           id: "AGENT_PREPARE_MODELS_INCOMPATIBLE_WITH_MODEL_ARRAY_V1",
           domain: "AGENT" /* AGENT */,
@@ -13431,6 +14131,7 @@ var Agent = class extends MastraBase {
       return [
         {
           id: "main",
+          // TODO fix type check
           model: resolvedModel,
           maxRetries: this.maxRetries ?? 0,
           enabled: true
@@ -13440,7 +14141,7 @@ var Agent = class extends 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 MastraError({
             id: "AGENT_PREPARE_MODELS_INCOMPATIBLE_WITH_MODEL_ARRAY_V1",
             domain: "AGENT" /* AGENT */,
@@ -13787,8 +14488,59 @@ var Agent = class extends 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 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 MastraError(
+          {
+            id: "AGENT_GENERATE_FAILED",
+            domain: "AGENT" /* AGENT */,
+            category: "USER" /* USER */
+          },
+          // pass original error to preserve stack trace
+          result.error
+        );
+      }
+      throw new 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;
@@ -15773,6 +16525,6 @@ var MastraModelOutput = class extends MastraBase {
   }
 };
 
-export { AISDKV5OutputStream, Agent, BatchPartsProcessor, ChunkFrom, DefaultExecutionEngine, ExecutionEngine, LanguageDetector, MastraAgentNetworkStream, MastraModelOutput, ModerationProcessor, PIIDetector, ProcessorState, PromptInjectionDetector, Run, StructuredOutputProcessor, SystemPromptScrubber, TokenLimiterProcessor, TripWire, UnicodeNormalizer, Workflow, WorkflowRunOutput, cloneStep, cloneWorkflow, convertFullStreamChunkToUIMessageStream, convertMastraChunkToAISDKv5, createDeprecationProxy, createStep, createWorkflow, getResumeLabelsByStepId, getStepResult, getZodErrors, loop, mapVariable, resolveThreadIdFromArgs, runCountDeprecationMessage, tryGenerateWithJsonFallback, tryStreamWithJsonFallback, validateStepInput };
-//# sourceMappingURL=chunk-7CBEP2ZQ.js.map
-//# sourceMappingURL=chunk-7CBEP2ZQ.js.map
+export { AISDKV5OutputStream, Agent, BatchPartsProcessor, ChunkFrom, DefaultExecutionEngine, ExecutionEngine, LanguageDetector, MastraAgentNetworkStream, MastraModelOutput, ModerationProcessor, PIIDetector, ProcessorState, PromptInjectionDetector, Run, StructuredOutputProcessor, SystemPromptScrubber, TokenLimiterProcessor, TripWire, UnicodeNormalizer, Workflow, WorkflowRunOutput, cloneStep, cloneWorkflow, convertFullStreamChunkToUIMessageStream, convertMastraChunkToAISDKv5, createDeprecationProxy, createStep, createTimeTravelExecutionParams, createWorkflow, getResumeLabelsByStepId, getStepIds, getStepResult, getZodErrors, loop, mapVariable, resolveThreadIdFromArgs, runCountDeprecationMessage, tryGenerateWithJsonFallback, tryStreamWithJsonFallback, validateStepInput, validateStepResumeData };
+//# sourceMappingURL=chunk-XXBWX7DT.js.map
+//# sourceMappingURL=chunk-XXBWX7DT.js.map