@mastra/core 1.0.0-beta.21 → 1.0.0-beta.22

package/dist/{chunk-O4H44CMA.js → chunk-N7TDP7ZE.js}

@@ -1,13 +1,14 @@
-import { validateStepInput, createDeprecationProxy, EventEmitterPubSub, getStepResult, validateStepSuspendData, runCountDeprecationMessage, createTimeTravelExecutionParams, validateStepResumeData, Workflow, Agent, Run, ExecutionEngine, hydrateSerializedStepErrors } from './chunk-IC2MIQBW.js';
+import { validateStepInput, createDeprecationProxy, EventEmitterPubSub, getStepResult, validateStepSuspendData, runCountDeprecationMessage, createTimeTravelExecutionParams, validateStepResumeData, Workflow, ProcessorStepOutputSchema, ProcessorStepSchema, Run, ExecutionEngine, hydrateSerializedStepErrors, Agent, TripWire, ProcessorRunner } from './chunk-UVOQLIWL.js';
 import { STREAM_FORMAT_SYMBOL, PUBSUB_SYMBOL } from './chunk-YEQB4VUA.js';
+import { MessageList } from './chunk-PSIJ6OSV.js';
 import { getErrorFromUnknown, MastraError } from './chunk-FJEVLHJT.js';
-import { Tool } from './chunk-KGE3KAM7.js';
-import { RequestContext } from './chunk-6TBWJV35.js';
+import { Tool } from './chunk-N3PAHTKU.js';
+import { RequestContext } from './chunk-Y22QMA7S.js';
 import { MastraBase } from './chunk-LSHPJWM5.js';
 import { RegisteredLogger } from './chunk-NRUZYMHE.js';
 import EventEmitter from 'events';
 import { randomUUID } from 'crypto';
-import z from 'zod';
+import { z } from 'zod/v3';
 
 var StepExecutor = class extends MastraBase {
   mastra;
@@ -2245,116 +2246,120 @@ function cloneStep(step, opts) {
     component: step.component
   };
 }
+function isAgent(input) {
+  return input instanceof Agent;
+}
+function isToolStep(input) {
+  return input instanceof Tool;
+}
+function isStepParams(input) {
+  return input !== null && typeof input === "object" && "id" in input && "execute" in input && !(input instanceof Agent) && !(input instanceof Tool);
+}
+function isProcessor(obj) {
+  return obj !== null && typeof obj === "object" && "id" in obj && typeof obj.id === "string" && !(obj instanceof Agent) && !(obj instanceof Tool) && (typeof obj.processInput === "function" || typeof obj.processInputStep === "function" || typeof obj.processOutputStream === "function" || typeof obj.processOutputResult === "function" || typeof obj.processOutputStep === "function");
+}
 function createStep(params, agentOrToolOptions) {
-  if (params instanceof Agent) {
-    return {
-      id: params.id,
-      description: params.getDescription(),
-      // @ts-ignore
-      inputSchema: z.object({
-        prompt: z.string()
-        // resourceId: z.string().optional(),
-        // threadId: z.string().optional(),
-      }),
-      // @ts-ignore
-      outputSchema: z.object({
-        text: z.string()
-      }),
-      retries: agentOrToolOptions?.retries,
-      scorers: agentOrToolOptions?.scorers,
-      execute: async ({ inputData, runId, [PUBSUB_SYMBOL]: pubsub, requestContext, abortSignal, abort }) => {
-        let streamPromise = {};
-        streamPromise.promise = new Promise((resolve, reject) => {
-          streamPromise.resolve = resolve;
-          streamPromise.reject = reject;
-        });
-        const { fullStream } = await params.streamLegacy(inputData.prompt, {
-          // resourceId: inputData.resourceId,
-          // threadId: inputData.threadId,
-          requestContext,
-          onFinish: (result) => {
-            streamPromise.resolve(result.text);
-          },
-          abortSignal
-        });
-        if (abortSignal.aborted) {
-          return abort();
-        }
-        const toolData = {
-          name: params.name,
-          args: inputData
-        };
-        await pubsub.publish(`workflow.events.v2.${runId}`, {
-          type: "watch",
-          runId,
-          data: { type: "tool-call-streaming-start", ...toolData ?? {} }
-        });
-        for await (const chunk of fullStream) {
-          if (chunk.type === "text-delta") {
-            await pubsub.publish(`workflow.events.v2.${runId}`, {
-              type: "watch",
-              runId,
-              data: { type: "tool-call-delta", ...toolData ?? {}, argsTextDelta: chunk.textDelta }
-            });
-          }
-        }
-        await pubsub.publish(`workflow.events.v2.${runId}`, {
-          type: "watch",
-          runId,
-          data: { type: "tool-call-streaming-finish", ...toolData ?? {} }
-        });
-        return {
-          text: await streamPromise.promise
-        };
-      },
-      component: params.component
-    };
+  if (isAgent(params)) {
+    return createStepFromAgent(params, agentOrToolOptions);
   }
-  if (params instanceof Tool) {
-    if (!params.inputSchema || !params.outputSchema) {
-      throw new Error("Tool must have input and output schemas defined");
-    }
-    return {
-      id: params.id,
-      description: params.description,
-      inputSchema: params.inputSchema,
-      outputSchema: params.outputSchema,
-      suspendSchema: params.suspendSchema,
-      resumeSchema: params.resumeSchema,
-      retries: agentOrToolOptions?.retries,
-      scorers: agentOrToolOptions?.scorers,
-      execute: async ({
-        inputData,
-        mastra,
+  if (isToolStep(params)) {
+    return createStepFromTool(params, agentOrToolOptions);
+  }
+  if (isProcessor(params)) {
+    return createStepFromProcessor(params);
+  }
+  if (isStepParams(params)) {
+    return createStepFromParams(params);
+  }
+  throw new Error("Invalid input: expected StepParams, Agent, ToolStep, or Processor");
+}
+function createStepFromParams(params) {
+  return {
+    id: params.id,
+    description: params.description,
+    inputSchema: params.inputSchema,
+    stateSchema: params.stateSchema,
+    outputSchema: params.outputSchema,
+    resumeSchema: params.resumeSchema,
+    suspendSchema: params.suspendSchema,
+    scorers: params.scorers,
+    retries: params.retries,
+    execute: params.execute.bind(params)
+  };
+}
+function createStepFromAgent(params, agentOrToolOptions) {
+  const options = agentOrToolOptions ?? {};
+  const outputSchema = options?.structuredOutput?.schema ?? z.object({ text: z.string() });
+  const { retries, scorers, ...agentOptions } = options ?? {};
+  return {
+    id: params.id,
+    description: params.getDescription(),
+    inputSchema: z.object({
+      prompt: z.string()
+    }),
+    outputSchema,
+    retries,
+    scorers,
+    execute: async ({
+      inputData,
+      runId,
+      [PUBSUB_SYMBOL]: pubsub,
+      requestContext,
+      tracingContext,
+      abortSignal,
+      abort
+    }) => {
+      let streamPromise = {};
+      streamPromise.promise = new Promise((resolve, reject) => {
+        streamPromise.resolve = resolve;
+        streamPromise.reject = reject;
+      });
+      const { fullStream } = await params.streamLegacy(inputData.prompt, {
+        ...agentOptions ?? {},
+        tracingContext,
         requestContext,
-        suspend,
-        resumeData,
+        onFinish: (result) => {
+          streamPromise.resolve(result.text);
+        },
+        abortSignal
+      });
+      if (abortSignal.aborted) {
+        return abort();
+      }
+      const toolData = {
+        name: params.name,
+        args: inputData
+      };
+      await pubsub.publish(`workflow.events.v2.${runId}`, {
+        type: "watch",
         runId,
-        workflowId,
-        state,
-        setState
-      }) => {
-        if (!params.execute) {
-          throw new Error(`Tool ${params.id} does not have an execute function`);
-        }
-        const context = {
-          mastra,
-          requestContext,
-          tracingContext: { currentSpan: void 0 },
-          // TODO: Pass proper tracing context when evented workflows support tracing
-          workflow: {
+        data: { type: "tool-call-streaming-start", ...toolData ?? {} }
+      });
+      for await (const chunk of fullStream) {
+        if (chunk.type === "text-delta") {
+          await pubsub.publish(`workflow.events.v2.${runId}`, {
+            type: "watch",
             runId,
-            workflowId,
-            state,
-            setState,
-            suspend,
-            resumeData
-          }
-        };
-        return params.execute(inputData, context);
-      },
-      component: "TOOL"
-    };
+            data: { type: "tool-call-delta", ...toolData ?? {}, argsTextDelta: chunk.textDelta }
+          });
+        }
+      }
+      await pubsub.publish(`workflow.events.v2.${runId}`, {
+        type: "watch",
+        runId,
+        data: { type: "tool-call-streaming-finish", ...toolData ?? {} }
+      });
+      return {
+        text: await streamPromise.promise
+      };
+    },
+    component: params.component
+  };
+}
+function createStepFromTool(params, agentOrToolOptions) {
+  const toolOpts = agentOrToolOptions;
+  if (!params.inputSchema || !params.outputSchema) {
+    throw new Error("Tool must have input and output schemas defined");
   }
   return {
     id: params.id,
@@ -2363,9 +2368,473 @@ function createStep(params, agentOrToolOptions) {
     outputSchema: params.outputSchema,
     resumeSchema: params.resumeSchema,
     suspendSchema: params.suspendSchema,
-    execute: params.execute,
-    retries: params?.retries,
-    scorers: params.scorers
+    retries: toolOpts?.retries,
+    scorers: toolOpts?.scorers,
+    execute: async ({ inputData, mastra, requestContext, suspend, resumeData, runId, workflowId, state, setState }) => {
+      if (!params.execute) {
+        throw new Error(`Tool ${params.id} does not have an execute function`);
+      }
+      const context = {
+        mastra,
+        requestContext,
+        tracingContext: { currentSpan: void 0 },
+        // TODO: Pass proper tracing context when evented workflows support tracing
+        workflow: {
+          runId,
+          workflowId,
+          state,
+          setState,
+          suspend,
+          resumeData
+        }
+      };
+      return params.execute(inputData, context);
+    },
+    component: "TOOL"
+  };
+}
+function createStepFromProcessor(processor) {
+  const getProcessorEntityType = (phase) => {
+    switch (phase) {
+      case "input":
+        return "input_processor" /* INPUT_PROCESSOR */;
+      case "inputStep":
+        return "input_step_processor" /* INPUT_STEP_PROCESSOR */;
+      case "outputStream":
+      case "outputResult":
+        return "output_processor" /* OUTPUT_PROCESSOR */;
+      case "outputStep":
+        return "output_step_processor" /* OUTPUT_STEP_PROCESSOR */;
+      default:
+        return "output_processor" /* OUTPUT_PROCESSOR */;
+    }
+  };
+  const getSpanNamePrefix = (phase) => {
+    switch (phase) {
+      case "input":
+        return "input processor";
+      case "inputStep":
+        return "input step processor";
+      case "outputStream":
+        return "output stream processor";
+      case "outputResult":
+        return "output processor";
+      case "outputStep":
+        return "output step processor";
+      default:
+        return "processor";
+    }
+  };
+  const hasPhaseMethod = (phase) => {
+    switch (phase) {
+      case "input":
+        return !!processor.processInput;
+      case "inputStep":
+        return !!processor.processInputStep;
+      case "outputStream":
+        return !!processor.processOutputStream;
+      case "outputResult":
+        return !!processor.processOutputResult;
+      case "outputStep":
+        return !!processor.processOutputStep;
+      default:
+        return false;
+    }
+  };
+  return {
+    id: `processor:${processor.id}`,
+    description: processor.name ?? `Processor ${processor.id}`,
+    inputSchema: ProcessorStepSchema,
+    outputSchema: ProcessorStepOutputSchema,
+    execute: async ({ inputData, requestContext, tracingContext }) => {
+      const input = inputData;
+      const {
+        phase,
+        messages,
+        messageList,
+        stepNumber,
+        systemMessages,
+        part,
+        streamParts,
+        state,
+        finishReason,
+        toolCalls,
+        text,
+        retryCount,
+        // inputStep phase fields for model/tools configuration
+        model,
+        tools,
+        toolChoice,
+        activeTools,
+        providerOptions,
+        modelSettings,
+        structuredOutput,
+        steps
+      } = input;
+      const abort = (reason, options) => {
+        throw new TripWire(reason || `Tripwire triggered by ${processor.id}`, options, processor.id);
+      };
+      if (!hasPhaseMethod(phase)) {
+        return input;
+      }
+      const currentSpan = tracingContext?.currentSpan;
+      const parentSpan = phase === "inputStep" || phase === "outputStep" ? currentSpan?.findParent("model_step" /* MODEL_STEP */) || currentSpan : currentSpan?.findParent("agent_run" /* AGENT_RUN */) || currentSpan;
+      const processorSpan = phase !== "outputStream" ? parentSpan?.createChildSpan({
+        type: "processor_run" /* PROCESSOR_RUN */,
+        name: `${getSpanNamePrefix(phase)}: ${processor.id}`,
+        entityType: getProcessorEntityType(phase),
+        entityId: processor.id,
+        entityName: processor.name ?? processor.id,
+        input: { phase, messageCount: messages?.length },
+        attributes: {
+          processorExecutor: "workflow",
+          // Read processorIndex from processor (set in combineProcessorsIntoWorkflow)
+          processorIndex: processor.processorIndex
+        }
+      }) : void 0;
+      const processorTracingContext = processorSpan ? { currentSpan: processorSpan } : tracingContext;
+      const baseContext = {
+        abort,
+        retryCount: retryCount ?? 0,
+        requestContext,
+        tracingContext: processorTracingContext
+      };
+      const passThrough = {
+        phase,
+        // Auto-create MessageList from messages if not provided
+        // This enables running processor workflows from the UI where messageList can't be serialized
+        messageList: messageList ?? (Array.isArray(messages) ? new MessageList().add(messages, "input").addSystem(systemMessages ?? []) : void 0),
+        stepNumber,
+        systemMessages,
+        streamParts,
+        state,
+        finishReason,
+        toolCalls,
+        text,
+        retryCount,
+        // inputStep phase fields for model/tools configuration
+        model,
+        tools,
+        toolChoice,
+        activeTools,
+        providerOptions,
+        modelSettings,
+        structuredOutput,
+        steps
+      };
+      const executePhaseWithSpan = async (fn) => {
+        try {
+          const result = await fn();
+          processorSpan?.end({ output: result });
+          return result;
+        } catch (error) {
+          if (error instanceof TripWire) {
+            processorSpan?.end({ output: { tripwire: error.message } });
+          } else {
+            processorSpan?.error({ error, endSpan: true });
+          }
+          throw error;
+        }
+      };
+      return executePhaseWithSpan(async () => {
+        switch (phase) {
+          case "input": {
+            if (processor.processInput) {
+              if (!passThrough.messageList) {
+                throw new MastraError({
+                  category: "USER" /* USER */,
+                  domain: "MASTRA_WORKFLOW" /* MASTRA_WORKFLOW */,
+                  id: "PROCESSOR_MISSING_MESSAGE_LIST",
+                  text: `Processor ${processor.id} requires messageList or messages for processInput phase`
+                });
+              }
+              const idsBeforeProcessing = messages.map((m) => m.id);
+              const check = passThrough.messageList.makeMessageSourceChecker();
+              const result = await processor.processInput({
+                ...baseContext,
+                messages,
+                messageList: passThrough.messageList,
+                systemMessages: systemMessages ?? []
+              });
+              if (result instanceof MessageList) {
+                if (result !== passThrough.messageList) {
+                  throw new MastraError({
+                    category: "USER" /* USER */,
+                    domain: "MASTRA_WORKFLOW" /* MASTRA_WORKFLOW */,
+                    id: "PROCESSOR_RETURNED_EXTERNAL_MESSAGE_LIST",
+                    text: `Processor ${processor.id} returned a MessageList instance other than the one passed in. Use the messageList argument instead.`
+                  });
+                }
+                return {
+                  ...passThrough,
+                  messages: result.get.all.db(),
+                  systemMessages: result.getAllSystemMessages()
+                };
+              } else if (Array.isArray(result)) {
+                ProcessorRunner.applyMessagesToMessageList(
+                  result,
+                  passThrough.messageList,
+                  idsBeforeProcessing,
+                  check,
+                  "input"
+                );
+                return { ...passThrough, messages: result };
+              } else if (result && "messages" in result && "systemMessages" in result) {
+                const typedResult = result;
+                ProcessorRunner.applyMessagesToMessageList(
+                  typedResult.messages,
+                  passThrough.messageList,
+                  idsBeforeProcessing,
+                  check,
+                  "input"
+                );
+                passThrough.messageList.replaceAllSystemMessages(typedResult.systemMessages);
+                return {
+                  ...passThrough,
+                  messages: typedResult.messages,
+                  systemMessages: typedResult.systemMessages
+                };
+              }
+              return { ...passThrough, messages };
+            }
+            return { ...passThrough, messages };
+          }
+          case "inputStep": {
+            if (processor.processInputStep) {
+              if (!passThrough.messageList) {
+                throw new MastraError({
+                  category: "USER" /* USER */,
+                  domain: "MASTRA_WORKFLOW" /* MASTRA_WORKFLOW */,
+                  id: "PROCESSOR_MISSING_MESSAGE_LIST",
+                  text: `Processor ${processor.id} requires messageList or messages for processInputStep phase`
+                });
+              }
+              const idsBeforeProcessing = messages.map((m) => m.id);
+              const check = passThrough.messageList.makeMessageSourceChecker();
+              const result = await processor.processInputStep({
+                ...baseContext,
+                messages,
+                messageList: passThrough.messageList,
+                stepNumber: stepNumber ?? 0,
+                systemMessages: systemMessages ?? [],
+                // Pass model/tools configuration fields - types match ProcessInputStepArgs
+                model,
+                tools,
+                toolChoice,
+                activeTools,
+                providerOptions,
+                modelSettings,
+                structuredOutput,
+                steps: steps ?? []
+              });
+              const validatedResult = await ProcessorRunner.validateAndFormatProcessInputStepResult(result, {
+                messageList: passThrough.messageList,
+                processor,
+                stepNumber: stepNumber ?? 0
+              });
+              if (validatedResult.messages) {
+                ProcessorRunner.applyMessagesToMessageList(
+                  validatedResult.messages,
+                  passThrough.messageList,
+                  idsBeforeProcessing,
+                  check
+                );
+              }
+              if (validatedResult.systemMessages) {
+                passThrough.messageList.replaceAllSystemMessages(validatedResult.systemMessages);
+              }
+              return { ...passThrough, messages, ...validatedResult };
+            }
+            return { ...passThrough, messages };
+          }
+          case "outputStream": {
+            if (processor.processOutputStream) {
+              const spanKey = `__outputStreamSpan_${processor.id}`;
+              const mutableState = state ?? {};
+              let processorSpan2 = mutableState[spanKey];
+              if (!processorSpan2 && parentSpan) {
+                processorSpan2 = parentSpan.createChildSpan({
+                  type: "processor_run" /* PROCESSOR_RUN */,
+                  name: `output stream processor: ${processor.id}`,
+                  entityType: "output_processor" /* OUTPUT_PROCESSOR */,
+                  entityId: processor.id,
+                  entityName: processor.name ?? processor.id,
+                  input: { phase, streamParts: [] },
+                  attributes: {
+                    processorExecutor: "workflow",
+                    processorIndex: processor.processorIndex
+                  }
+                });
+                mutableState[spanKey] = processorSpan2;
+              }
+              if (processorSpan2) {
+                processorSpan2.input = {
+                  phase,
+                  streamParts: streamParts ?? [],
+                  totalChunks: (streamParts ?? []).length
+                };
+              }
+              const processorTracingContext2 = processorSpan2 ? { currentSpan: processorSpan2 } : baseContext.tracingContext;
+              let result;
+              try {
+                result = await processor.processOutputStream({
+                  ...baseContext,
+                  tracingContext: processorTracingContext2,
+                  part,
+                  streamParts: streamParts ?? [],
+                  state: mutableState,
+                  messageList: passThrough.messageList
+                  // Optional for stream processing
+                });
+                if (part && part.type === "finish") {
+                  processorSpan2?.end({ output: result });
+                  delete mutableState[spanKey];
+                }
+              } catch (error) {
+                if (error instanceof TripWire) {
+                  processorSpan2?.end({ output: { tripwire: error.message } });
+                } else {
+                  processorSpan2?.error({ error, endSpan: true });
+                }
+                delete mutableState[spanKey];
+                throw error;
+              }
+              return { ...passThrough, state: mutableState, part: result };
+            }
+            return { ...passThrough, part };
+          }
+          case "outputResult": {
+            if (processor.processOutputResult) {
+              if (!passThrough.messageList) {
+                throw new MastraError({
+                  category: "USER" /* USER */,
+                  domain: "MASTRA_WORKFLOW" /* MASTRA_WORKFLOW */,
+                  id: "PROCESSOR_MISSING_MESSAGE_LIST",
+                  text: `Processor ${processor.id} requires messageList or messages for processOutputResult phase`
+                });
+              }
+              const idsBeforeProcessing = messages.map((m) => m.id);
+              const check = passThrough.messageList.makeMessageSourceChecker();
+              const result = await processor.processOutputResult({
+                ...baseContext,
+                messages,
+                messageList: passThrough.messageList
+              });
+              if (result instanceof MessageList) {
+                if (result !== passThrough.messageList) {
+                  throw new MastraError({
+                    category: "USER" /* USER */,
+                    domain: "MASTRA_WORKFLOW" /* MASTRA_WORKFLOW */,
+                    id: "PROCESSOR_RETURNED_EXTERNAL_MESSAGE_LIST",
+                    text: `Processor ${processor.id} returned a MessageList instance other than the one passed in. Use the messageList argument instead.`
+                  });
+                }
+                return {
+                  ...passThrough,
+                  messages: result.get.all.db(),
+                  systemMessages: result.getAllSystemMessages()
+                };
+              } else if (Array.isArray(result)) {
+                ProcessorRunner.applyMessagesToMessageList(
+                  result,
+                  passThrough.messageList,
+                  idsBeforeProcessing,
+                  check,
+                  "response"
+                );
+                return { ...passThrough, messages: result };
+              } else if (result && "messages" in result && "systemMessages" in result) {
+                const typedResult = result;
+                ProcessorRunner.applyMessagesToMessageList(
+                  typedResult.messages,
+                  passThrough.messageList,
+                  idsBeforeProcessing,
+                  check,
+                  "response"
+                );
+                passThrough.messageList.replaceAllSystemMessages(typedResult.systemMessages);
+                return {
+                  ...passThrough,
+                  messages: typedResult.messages,
+                  systemMessages: typedResult.systemMessages
+                };
+              }
+              return { ...passThrough, messages };
+            }
+            return { ...passThrough, messages };
+          }
+          case "outputStep": {
+            if (processor.processOutputStep) {
+              if (!passThrough.messageList) {
+                throw new MastraError({
+                  category: "USER" /* USER */,
+                  domain: "MASTRA_WORKFLOW" /* MASTRA_WORKFLOW */,
+                  id: "PROCESSOR_MISSING_MESSAGE_LIST",
+                  text: `Processor ${processor.id} requires messageList or messages for processOutputStep phase`
+                });
+              }
+              const idsBeforeProcessing = messages.map((m) => m.id);
+              const check = passThrough.messageList.makeMessageSourceChecker();
+              const result = await processor.processOutputStep({
+                ...baseContext,
+                messages,
+                messageList: passThrough.messageList,
+                stepNumber: stepNumber ?? 0,
+                finishReason,
+                toolCalls,
+                text,
+                systemMessages: systemMessages ?? [],
+                steps: steps ?? []
+              });
+              if (result instanceof MessageList) {
+                if (result !== passThrough.messageList) {
+                  throw new MastraError({
+                    category: "USER" /* USER */,
+                    domain: "MASTRA_WORKFLOW" /* MASTRA_WORKFLOW */,
+                    id: "PROCESSOR_RETURNED_EXTERNAL_MESSAGE_LIST",
+                    text: `Processor ${processor.id} returned a MessageList instance other than the one passed in. Use the messageList argument instead.`
+                  });
+                }
+                return {
+                  ...passThrough,
+                  messages: result.get.all.db(),
+                  systemMessages: result.getAllSystemMessages()
+                };
+              } else if (Array.isArray(result)) {
+                ProcessorRunner.applyMessagesToMessageList(
+                  result,
+                  passThrough.messageList,
+                  idsBeforeProcessing,
+                  check,
+                  "response"
+                );
+                return { ...passThrough, messages: result };
+              } else if (result && "messages" in result && "systemMessages" in result) {
+                const typedResult = result;
+                ProcessorRunner.applyMessagesToMessageList(
+                  typedResult.messages,
+                  passThrough.messageList,
+                  idsBeforeProcessing,
+                  check,
+                  "response"
+                );
+                passThrough.messageList.replaceAllSystemMessages(typedResult.systemMessages);
+                return {
+                  ...passThrough,
+                  messages: typedResult.messages,
+                  systemMessages: typedResult.systemMessages
+                };
+              }
+              return { ...passThrough, messages };
+            }
+            return { ...passThrough, messages };
+          }
+          default:
+            return { ...passThrough, messages };
+        }
+      });
+    },
+    component: "PROCESSOR"
   };
 }
 function createWorkflow(params) {
@@ -2506,7 +2975,7 @@ var EventedRun = class extends Run {
         timestamp: Date.now()
       }
     });
-    const inputDataToUse = await this._validateInput(inputData);
+    const inputDataToUse = await this._validateInput(inputData ?? {});
     const initialStateToUse = await this._validateInitialState(initialState ?? {});
     if (!this.mastra?.pubsub) {
       throw new Error("Mastra instance with pubsub is required for workflow execution");
@@ -2570,7 +3039,7 @@ var EventedRun = class extends Run {
         timestamp: Date.now()
       }
     });
-    const inputDataToUse = await this._validateInput(inputData);
+    const inputDataToUse = await this._validateInput(inputData ?? {});
     const initialStateToUse = await this._validateInitialState(initialState ?? {});
     if (!this.mastra?.pubsub) {
       throw new Error("Mastra instance with pubsub is required for workflow execution");
@@ -2644,7 +3113,7 @@ var EventedRun = class extends Run {
       runId: this.runId,
       graph: this.executionGraph,
       serializedStepGraph: this.serializedStepGraph,
-      input: resumeDataToUse,
+      input: snapshot?.context?.input,
       resume: {
         steps,
         stepResults: snapshot?.context,
@@ -2909,5 +3378,5 @@ var EventedExecutionEngine = class extends ExecutionEngine {
 };
 
 export { EventedExecutionEngine, EventedRun, EventedWorkflow, StepExecutor, WorkflowEventProcessor, cloneStep, cloneWorkflow, createStep, createWorkflow };
-//# sourceMappingURL=chunk-O4H44CMA.js.map
-//# sourceMappingURL=chunk-O4H44CMA.js.map
+//# sourceMappingURL=chunk-N7TDP7ZE.js.map
+//# sourceMappingURL=chunk-N7TDP7ZE.js.map