@mastra/inngest 1.0.0-beta.11 → 1.0.0-beta.13

package/dist/index.cjs

@@ -1,6 +1,9 @@
 'use strict';
 
 var agent = require('@mastra/core/agent');
+var error = require('@mastra/core/error');
+var observability = require('@mastra/core/observability');
+var processors = require('@mastra/core/processors');
 var tools = require('@mastra/core/tools');
 var workflows = require('@mastra/core/workflows');
 var _constants = require('@mastra/core/workflows/_constants');
@@ -8,7 +11,6 @@ var zod = require('zod');
 var crypto$1 = require('crypto');
 var di = require('@mastra/core/di');
 var inngest = require('inngest');
-var error = require('@mastra/core/error');
 var realtime = require('@inngest/realtime');
 var events = require('@mastra/core/events');
 var web = require('stream/web');
@@ -116,15 +118,32 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
   }
   /**
    * Wrap durable operations in Inngest step.run() for durability.
-   * If retryConfig is provided, throws RetryAfterError INSIDE step.run() to trigger
-   * Inngest's step-level retry mechanism (not function-level retry).
+   *
+   * IMPORTANT: Errors are wrapped with a cause structure before throwing.
+   * This is necessary because Inngest's error serialization (serialize-error-cjs)
+   * only captures standard Error properties (message, name, stack, code, cause).
+   * Custom properties like statusCode, responseHeaders from AI SDK errors would
+   * be lost. By putting our serialized error (via getErrorFromUnknown with toJSON())
+   * in the cause property, we ensure custom properties survive serialization.
+   * The cause property is in serialize-error-cjs's allowlist, and when the cause
+   * object is finally JSON.stringify'd, our error's toJSON() is called.
    */
   async wrapDurableOperation(operationId, operationFn) {
     return this.inngestStep.run(operationId, async () => {
       try {
         return await operationFn();
       } catch (e) {
-        throw e;
+        const errorInstance = error.getErrorFromUnknown(e, {
+          serializeStack: false,
+          fallbackMessage: "Unknown step execution error"
+        });
+        throw new Error(errorInstance.message, {
+          cause: {
+            status: "failed",
+            error: errorInstance,
+            endedAt: Date.now()
+          }
+        });
       }
     });
   }
@@ -146,6 +165,96 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
   async invokeLifecycleCallbacksInternal(result) {
     return super.invokeLifecycleCallbacks(result);
   }
+  // =============================================================================
+  // Durable Span Lifecycle Hooks
+  // =============================================================================
+  /**
+   * Create a step span durably - on first execution, creates and exports span.
+   * On replay, returns cached span data without re-creating.
+   */
+  async createStepSpan(params) {
+    const { executionContext, operationId, options, parentSpan } = params;
+    const parentSpanId = parentSpan?.id ?? executionContext.tracingIds?.workflowSpanId;
+    const exportedSpan = await this.wrapDurableOperation(operationId, async () => {
+      const observability = this.mastra?.observability?.getSelectedInstance({});
+      if (!observability) return void 0;
+      const span = observability.startSpan({
+        ...options,
+        entityType: options.entityType,
+        traceId: executionContext.tracingIds?.traceId,
+        parentSpanId
+      });
+      return span?.exportSpan();
+    });
+    if (exportedSpan) {
+      const observability = this.mastra?.observability?.getSelectedInstance({});
+      return observability?.rebuildSpan(exportedSpan);
+    }
+    return void 0;
+  }
+  /**
+   * End a step span durably.
+   */
+  async endStepSpan(params) {
+    const { span, operationId, endOptions } = params;
+    if (!span) return;
+    await this.wrapDurableOperation(operationId, async () => {
+      span.end(endOptions);
+    });
+  }
+  /**
+   * Record error on step span durably.
+   */
+  async errorStepSpan(params) {
+    const { span, operationId, errorOptions } = params;
+    if (!span) return;
+    await this.wrapDurableOperation(operationId, async () => {
+      span.error(errorOptions);
+    });
+  }
+  /**
+   * Create a generic child span durably (for control-flow operations).
+   * On first execution, creates and exports span. On replay, returns cached span data.
+   */
+  async createChildSpan(params) {
+    const { executionContext, operationId, options, parentSpan } = params;
+    const parentSpanId = parentSpan?.id ?? executionContext.tracingIds?.workflowSpanId;
+    const exportedSpan = await this.wrapDurableOperation(operationId, async () => {
+      const observability = this.mastra?.observability?.getSelectedInstance({});
+      if (!observability) return void 0;
+      const span = observability.startSpan({
+        ...options,
+        traceId: executionContext.tracingIds?.traceId,
+        parentSpanId
+      });
+      return span?.exportSpan();
+    });
+    if (exportedSpan) {
+      const observability = this.mastra?.observability?.getSelectedInstance({});
+      return observability?.rebuildSpan(exportedSpan);
+    }
+    return void 0;
+  }
+  /**
+   * End a generic child span durably (for control-flow operations).
+   */
+  async endChildSpan(params) {
+    const { span, operationId, endOptions } = params;
+    if (!span) return;
+    await this.wrapDurableOperation(operationId, async () => {
+      span.end(endOptions);
+    });
+  }
+  /**
+   * Record error on a generic child span durably (for control-flow operations).
+   */
+  async errorChildSpan(params) {
+    const { span, operationId, errorOptions } = params;
+    if (!span) return;
+    await this.wrapDurableOperation(operationId, async () => {
+      span.error(errorOptions);
+    });
+  }
   /**
    * Execute nested InngestWorkflow using inngestStep.invoke() for durability.
    * This MUST be called directly (not inside step.run()) due to Inngest constraints.
@@ -164,8 +273,13 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
       inputData,
       pubsub,
       startedAt,
-      perStep
+      perStep,
+      stepSpan
     } = params;
+    const nestedTracingContext = executionContext.tracingIds?.traceId ? {
+      traceId: executionContext.tracingIds.traceId,
+      parentSpanId: stepSpan?.id
+    } : void 0;
     const isResume = !!resume?.steps?.length;
     let result;
     let runId;
@@ -192,7 +306,8 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
               resumePath: resume.steps?.[1] ? snapshot?.suspendedPaths?.[resume.steps?.[1]] : void 0
             },
             outputOptions: { includeState: true },
-            perStep
+            perStep,
+            tracingOptions: nestedTracingContext
           }
         });
         result = invokeResp.result;
@@ -220,7 +335,8 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
             initialState: executionContext.state ?? {},
             runId: executionContext.runId,
             outputOptions: { includeState: true },
-            perStep
+            perStep,
+            tracingOptions: nestedTracingContext
           }
         });
         result = invokeResp.result;
@@ -233,7 +349,8 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
             inputData,
             initialState: executionContext.state ?? {},
             outputOptions: { includeState: true },
-            perStep
+            perStep,
+            tracingOptions: nestedTracingContext
           }
         });
         result = invokeResp.result;
@@ -630,8 +747,8 @@ var InngestRun = class extends workflows.Run {
       });
     }
   }
-  async start(params) {
-    return this._start(params);
+  async start(args) {
+    return this._start(args);
   }
   /**
    * Starts the workflow execution without waiting for completion (fire-and-forget).
@@ -639,7 +756,7 @@ var InngestRun = class extends workflows.Run {
    * The workflow executes independently in Inngest.
    * Use this when you don't need to wait for the result or want to avoid polling failures.
    */
-  async startAsync(params) {
+  async startAsync(args) {
     const workflowsStore = await this.#mastra.getStorage()?.getStore("workflows");
     await workflowsStore?.persistWorkflowSnapshot({
       workflowName: this.workflowId,
@@ -659,8 +776,8 @@ var InngestRun = class extends workflows.Run {
         timestamp: Date.now()
       }
     });
-    const inputDataToUse = await this._validateInput(params.inputData);
-    const initialStateToUse = await this._validateInitialState(params.initialState ?? {});
+    const inputDataToUse = await this._validateInput(args.inputData);
+    const initialStateToUse = await this._validateInitialState(args.initialState ?? {});
     const eventOutput = await this.inngest.send({
       name: `workflow.${this.workflowId}`,
       data: {
@@ -668,10 +785,10 @@ var InngestRun = class extends workflows.Run {
         initialState: initialStateToUse,
         runId: this.runId,
         resourceId: this.resourceId,
-        outputOptions: params.outputOptions,
-        tracingOptions: params.tracingOptions,
-        requestContext: params.requestContext ? Object.fromEntries(params.requestContext.entries()) : {},
-        perStep: params.perStep
+        outputOptions: args.outputOptions,
+        tracingOptions: args.tracingOptions,
+        requestContext: args.requestContext ? Object.fromEntries(args.requestContext.entries()) : {},
+        perStep: args.perStep
       }
     });
     const eventId = eventOutput.ids[0];
@@ -1043,6 +1160,7 @@ var InngestRun = class extends workflows.Run {
     context,
     nestedStepsContext,
     requestContext,
+    // tracingContext,
     tracingOptions,
     outputOptions,
     perStep
@@ -1175,7 +1293,8 @@ var InngestWorkflow = class _InngestWorkflow extends workflows.Workflow {
   }
   async createRun(options) {
     const runIdToUse = options?.runId || crypto$1.randomUUID();
-    const run = this.runs.get(runIdToUse) ?? new InngestRun(
+    const existingInMemoryRun = this.runs.get(runIdToUse);
+    const newRun = new InngestRun(
       {
         workflowId: this.id,
         runId: runIdToUse,
@@ -1192,15 +1311,16 @@ var InngestWorkflow = class _InngestWorkflow extends workflows.Workflow {
       },
       this.inngest
     );
+    const run = existingInMemoryRun ?? newRun;
     this.runs.set(runIdToUse, run);
     const shouldPersistSnapshot = this.options.shouldPersistSnapshot({
       workflowStatus: run.workflowRunStatus,
       stepResults: {}
     });
-    const existingRun = await this.getWorkflowRunById(runIdToUse, {
+    const existingStoredRun = await this.getWorkflowRunById(runIdToUse, {
       withNestedWorkflows: false
     });
-    const existsInStorage = existingRun && !existingRun.isFromInMemory;
+    const existsInStorage = existingStoredRun && !existingStoredRun.isFromInMemory;
     if (!existsInStorage && shouldPersistSnapshot) {
       const workflowsStore = await this.mastra?.getStorage()?.getStore("workflows");
       await workflowsStore?.persistWorkflowSnapshot({
@@ -1264,47 +1384,120 @@ var InngestWorkflow = class _InngestWorkflow extends workflows.Workflow {
       },
       { event: `workflow.${this.id}` },
       async ({ event, step, attempt, publish }) => {
-        let { inputData, initialState, runId, resourceId, resume, outputOptions, format, timeTravel, perStep } = event.data;
+        let {
+          inputData,
+          initialState,
+          runId,
+          resourceId,
+          resume,
+          outputOptions,
+          format,
+          timeTravel,
+          perStep,
+          tracingOptions
+        } = event.data;
         if (!runId) {
           runId = await step.run(`workflow.${this.id}.runIdGen`, async () => {
             return crypto$1.randomUUID();
           });
         }
         const pubsub = new InngestPubSub(this.inngest, this.id, publish);
+        const requestContext = new di.RequestContext(Object.entries(event.data.requestContext ?? {}));
+        const mastra = this.#mastra;
+        const tracingPolicy = this.options.tracingPolicy;
+        const workflowSpanData = await step.run(`workflow.${this.id}.span.start`, async () => {
+          const observability$1 = mastra?.observability?.getSelectedInstance({ requestContext });
+          if (!observability$1) return void 0;
+          const span = observability$1.startSpan({
+            type: observability.SpanType.WORKFLOW_RUN,
+            name: `workflow run: '${this.id}'`,
+            entityType: observability.EntityType.WORKFLOW_RUN,
+            entityId: this.id,
+            input: inputData,
+            metadata: {
+              resourceId,
+              runId
+            },
+            tracingPolicy,
+            tracingOptions,
+            requestContext
+          });
+          return span?.exportSpan();
+        });
         const engine = new InngestExecutionEngine(this.#mastra, step, attempt, this.options);
-        const result = await engine.execute({
-          workflowId: this.id,
-          runId,
-          resourceId,
-          graph: this.executionGraph,
-          serializedStepGraph: this.serializedStepGraph,
-          input: inputData,
-          initialState,
-          pubsub,
-          retryConfig: this.retryConfig,
-          requestContext: new di.RequestContext(Object.entries(event.data.requestContext ?? {})),
-          resume,
-          timeTravel,
-          perStep,
-          format,
-          abortController: new AbortController(),
-          // currentSpan: undefined, // TODO: Pass actual parent Span from workflow execution context
-          outputOptions,
-          outputWriter: async (chunk) => {
-            try {
-              await pubsub.publish(`workflow.events.v2.${runId}`, {
-                type: "watch",
-                runId,
-                data: chunk
-              });
-            } catch (err) {
-              this.logger.debug?.("Failed to publish watch event:", err);
+        let result;
+        try {
+          result = await engine.execute({
+            workflowId: this.id,
+            runId,
+            resourceId,
+            graph: this.executionGraph,
+            serializedStepGraph: this.serializedStepGraph,
+            input: inputData,
+            initialState,
+            pubsub,
+            retryConfig: this.retryConfig,
+            requestContext,
+            resume,
+            timeTravel,
+            perStep,
+            format,
+            abortController: new AbortController(),
+            // For Inngest, we don't pass workflowSpan - step spans use tracingIds instead
+            workflowSpan: void 0,
+            // Pass tracing IDs for durable span operations
+            tracingIds: workflowSpanData ? {
+              traceId: workflowSpanData.traceId,
+              workflowSpanId: workflowSpanData.id
+            } : void 0,
+            outputOptions,
+            outputWriter: async (chunk) => {
+              try {
+                await pubsub.publish(`workflow.events.v2.${runId}`, {
+                  type: "watch",
+                  runId,
+                  data: chunk
+                });
+              } catch (err) {
+                this.logger.debug?.("Failed to publish watch event:", err);
+              }
             }
-          }
-        });
+          });
+        } catch (error) {
+          throw error;
+        }
         await step.run(`workflow.${this.id}.finalize`, async () => {
           if (result.status !== "paused") {
-            await engine.invokeLifecycleCallbacksInternal(result);
+            await engine.invokeLifecycleCallbacksInternal({
+              status: result.status,
+              result: "result" in result ? result.result : void 0,
+              error: "error" in result ? result.error : void 0,
+              steps: result.steps,
+              tripwire: "tripwire" in result ? result.tripwire : void 0,
+              runId,
+              workflowId: this.id,
+              resourceId,
+              input: inputData,
+              requestContext,
+              state: result.state ?? initialState ?? {}
+            });
+          }
+          if (workflowSpanData) {
+            const observability = mastra?.observability?.getSelectedInstance({ requestContext });
+            if (observability) {
+              const workflowSpan = observability.rebuildSpan(workflowSpanData);
+              if (result.status === "failed") {
+                workflowSpan.error({
+                  error: result.error instanceof Error ? result.error : new Error(String(result.error)),
+                  attributes: { status: "failed" }
+                });
+              } else {
+                workflowSpan.end({
+                  output: result.status === "success" ? result.result : void 0,
+                  attributes: { status: result.status }
+                });
+              }
+            }
           }
           if (result.status === "failed") {
             throw new inngest.NonRetriableError(`Workflow failed`, {
@@ -1339,12 +1532,7 @@ var InngestWorkflow = class _InngestWorkflow extends workflows.Workflow {
     ];
   }
 };
-function serve({
-  mastra,
-  inngest,
-  functions: userFunctions = [],
-  registerOptions
-}) {
+function prepareServeOptions({ mastra, inngest, functions: userFunctions = [], registerOptions }) {
   const wfs = mastra.listWorkflows();
   const workflowFunctions = Array.from(
     new Set(
@@ -1357,175 +1545,181 @@ function serve({
       })
     )
   );
-  return hono.serve({
+  return {
     ...registerOptions,
     client: inngest,
     functions: [...workflowFunctions, ...userFunctions]
-  });
+  };
+}
+function createServe(adapter) {
+  return (options) => {
+    const serveOptions = prepareServeOptions(options);
+    return adapter(serveOptions);
+  };
 }
+var serve = createServe(hono.serve);
 
 // src/types.ts
 var _compatibilityCheck = true;
 
 // src/index.ts
+function isInngestWorkflow(input) {
+  return input instanceof InngestWorkflow;
+}
+function isAgent(input) {
+  return input instanceof agent.Agent;
+}
+function isToolStep(input) {
+  return input instanceof tools.Tool;
+}
+function isStepParams(input) {
+  return input !== null && typeof input === "object" && "id" in input && "execute" in input && !(input instanceof agent.Agent) && !(input instanceof tools.Tool) && !(input instanceof InngestWorkflow);
+}
+function isProcessor(obj) {
+  return obj !== null && typeof obj === "object" && "id" in obj && typeof obj.id === "string" && !(obj instanceof agent.Agent) && !(obj instanceof tools.Tool) && !(obj instanceof InngestWorkflow) && (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 InngestWorkflow) {
+  if (isInngestWorkflow(params)) {
     return params;
   }
-  if (params instanceof agent.Agent) {
-    const options = agentOrToolOptions;
-    const outputSchema = options?.structuredOutput?.schema ?? zod.z.object({ text: zod.z.string() });
-    const { retries, scorers, ...agentOptions } = options ?? {};
-    return {
-      id: params.name,
-      description: params.getDescription(),
-      inputSchema: zod.z.object({
-        prompt: zod.z.string()
-        // resourceId: z.string().optional(),
-        // threadId: z.string().optional(),
-      }),
-      outputSchema,
-      retries,
-      scorers,
-      execute: async ({
-        inputData,
-        runId,
-        [_constants.PUBSUB_SYMBOL]: pubsub,
-        [_constants.STREAM_FORMAT_SYMBOL]: streamFormat,
-        requestContext,
-        tracingContext,
-        abortSignal,
-        abort,
-        writer
-      }) => {
-        let streamPromise = {};
-        streamPromise.promise = new Promise((resolve, reject) => {
-          streamPromise.resolve = resolve;
-          streamPromise.reject = reject;
+  if (isAgent(params)) {
+    return createStepFromAgent(params, agentOrToolOptions);
+  }
+  if (isToolStep(params)) {
+    return createStepFromTool(params, agentOrToolOptions);
+  }
+  if (isStepParams(params)) {
+    return createStepFromParams(params);
+  }
+  if (isProcessor(params)) {
+    return createStepFromProcessor(params);
+  }
+  throw new Error("Invalid input: expected StepParams, Agent, ToolStep, Processor, or InngestWorkflow");
+}
+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 ?? zod.z.object({ text: zod.z.string() });
+  const { retries, scorers, ...agentOptions } = options ?? {};
+  return {
+    id: params.name,
+    description: params.getDescription(),
+    inputSchema: zod.z.object({
+      prompt: zod.z.string()
+    }),
+    outputSchema,
+    retries,
+    scorers,
+    execute: async ({
+      inputData,
+      runId,
+      [_constants.PUBSUB_SYMBOL]: pubsub,
+      [_constants.STREAM_FORMAT_SYMBOL]: streamFormat,
+      requestContext,
+      tracingContext,
+      abortSignal,
+      abort,
+      writer
+    }) => {
+      let streamPromise = {};
+      streamPromise.promise = new Promise((resolve, reject) => {
+        streamPromise.resolve = resolve;
+        streamPromise.reject = reject;
+      });
+      let structuredResult = null;
+      const toolData = {
+        name: params.name,
+        args: inputData
+      };
+      let stream;
+      if ((await params.getModel()).specificationVersion === "v1") {
+        const { fullStream } = await params.streamLegacy(inputData.prompt, {
+          ...agentOptions ?? {},
+          requestContext,
+          tracingContext,
+          onFinish: (result) => {
+            const resultWithObject = result;
+            if (agentOptions?.structuredOutput?.schema && resultWithObject.object) {
+              structuredResult = resultWithObject.object;
+            }
+            streamPromise.resolve(result.text);
+            void agentOptions?.onFinish?.(result);
+          },
+          abortSignal
         });
-        let structuredResult = null;
-        const toolData = {
-          name: params.name,
-          args: inputData
-        };
-        let stream;
-        if ((await params.getModel()).specificationVersion === "v1") {
-          const { fullStream } = await params.streamLegacy(inputData.prompt, {
-            ...agentOptions ?? {},
-            // resourceId: inputData.resourceId,
-            // threadId: inputData.threadId,
-            requestContext,
-            tracingContext,
-            onFinish: (result) => {
-              const resultWithObject = result;
-              if (agentOptions?.structuredOutput?.schema && resultWithObject.object) {
-                structuredResult = resultWithObject.object;
-              }
-              streamPromise.resolve(result.text);
-              void agentOptions?.onFinish?.(result);
-            },
-            abortSignal
-          });
-          stream = fullStream;
-        } else {
-          const modelOutput = await params.stream(inputData.prompt, {
-            ...agentOptions ?? {},
-            requestContext,
-            tracingContext,
-            onFinish: (result) => {
-              const resultWithObject = result;
-              if (agentOptions?.structuredOutput?.schema && resultWithObject.object) {
-                structuredResult = resultWithObject.object;
-              }
-              streamPromise.resolve(result.text);
-              void agentOptions?.onFinish?.(result);
-            },
-            abortSignal
-          });
-          stream = modelOutput.fullStream;
-        }
-        if (streamFormat === "legacy") {
-          await pubsub.publish(`workflow.events.v2.${runId}`, {
-            type: "watch",
-            runId,
-            data: { type: "tool-call-streaming-start", ...toolData ?? {} }
-          });
-          for await (const chunk of stream) {
-            if (chunk.type === "text-delta") {
-              await pubsub.publish(`workflow.events.v2.${runId}`, {
-                type: "watch",
-                runId,
-                data: { type: "tool-call-delta", ...toolData ?? {}, argsTextDelta: chunk.textDelta }
-              });
+        stream = fullStream;
+      } else {
+        const modelOutput = await params.stream(inputData.prompt, {
+          ...agentOptions ?? {},
+          requestContext,
+          tracingContext,
+          onFinish: (result) => {
+            const resultWithObject = result;
+            if (agentOptions?.structuredOutput?.schema && resultWithObject.object) {
+              structuredResult = resultWithObject.object;
             }
-          }
-          await pubsub.publish(`workflow.events.v2.${runId}`, {
-            type: "watch",
-            runId,
-            data: { type: "tool-call-streaming-finish", ...toolData ?? {} }
-          });
-        } else {
-          for await (const chunk of stream) {
-            await writer.write(chunk);
+            streamPromise.resolve(result.text);
+            void agentOptions?.onFinish?.(result);
+          },
+          abortSignal
+        });
+        stream = modelOutput.fullStream;
+      }
+      if (streamFormat === "legacy") {
+        await pubsub.publish(`workflow.events.v2.${runId}`, {
+          type: "watch",
+          runId,
+          data: { type: "tool-call-streaming-start", ...toolData ?? {} }
+        });
+        for await (const chunk of stream) {
+          if (chunk.type === "text-delta") {
+            await pubsub.publish(`workflow.events.v2.${runId}`, {
+              type: "watch",
+              runId,
+              data: { type: "tool-call-delta", ...toolData ?? {}, argsTextDelta: chunk.textDelta }
+            });
           }
         }
-        if (abortSignal.aborted) {
-          return abort();
-        }
-        if (structuredResult !== null) {
-          return structuredResult;
+        await pubsub.publish(`workflow.events.v2.${runId}`, {
+          type: "watch",
+          runId,
+          data: { type: "tool-call-streaming-finish", ...toolData ?? {} }
+        });
+      } else {
+        for await (const chunk of stream) {
+          await writer.write(chunk);
         }
-        return {
-          text: await streamPromise.promise
-        };
-      },
-      component: params.component
-    };
-  }
-  if (params instanceof tools.Tool) {
-    const toolOpts = agentOrToolOptions;
-    if (!params.inputSchema || !params.outputSchema) {
-      throw new Error("Tool must have input and output schemas defined");
-    }
-    return {
-      // TODO: tool probably should have strong id type
-      id: params.id,
-      description: params.description,
-      inputSchema: params.inputSchema,
-      outputSchema: params.outputSchema,
-      suspendSchema: params.suspendSchema,
-      resumeSchema: params.resumeSchema,
-      retries: toolOpts?.retries,
-      scorers: toolOpts?.scorers,
-      execute: async ({
-        inputData,
-        mastra,
-        requestContext,
-        tracingContext,
-        suspend,
-        resumeData,
-        runId,
-        workflowId,
-        state,
-        setState
-      }) => {
-        const toolContext = {
-          mastra,
-          requestContext,
-          tracingContext,
-          workflow: {
-            runId,
-            resumeData,
-            suspend,
-            workflowId,
-            state,
-            setState
-          }
-        };
-        return params.execute(inputData, toolContext);
-      },
-      component: "TOOL"
-    };
+      }
+      if (abortSignal.aborted) {
+        return abort();
+      }
+      if (structuredResult !== null) {
+        return structuredResult;
+      }
+      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,
@@ -1534,9 +1728,480 @@ function createStep(params, agentOrToolOptions) {
     outputSchema: params.outputSchema,
     resumeSchema: params.resumeSchema,
     suspendSchema: params.suspendSchema,
-    retries: params.retries,
-    scorers: params.scorers,
-    execute: params.execute
+    retries: toolOpts?.retries,
+    scorers: toolOpts?.scorers,
+    execute: async ({
+      inputData,
+      mastra,
+      requestContext,
+      tracingContext,
+      suspend,
+      resumeData,
+      runId,
+      workflowId,
+      state,
+      setState
+    }) => {
+      const toolContext = {
+        mastra,
+        requestContext,
+        tracingContext,
+        workflow: {
+          runId,
+          resumeData,
+          suspend,
+          workflowId,
+          state,
+          setState
+        }
+      };
+      return params.execute(inputData, toolContext);
+    },
+    component: "TOOL"
+  };
+}
+function createStepFromProcessor(processor) {
+  const getProcessorEntityType = (phase) => {
+    switch (phase) {
+      case "input":
+        return observability.EntityType.INPUT_PROCESSOR;
+      case "inputStep":
+        return observability.EntityType.INPUT_STEP_PROCESSOR;
+      case "outputStream":
+      case "outputResult":
+        return observability.EntityType.OUTPUT_PROCESSOR;
+      case "outputStep":
+        return observability.EntityType.OUTPUT_STEP_PROCESSOR;
+      default:
+        return observability.EntityType.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: processors.ProcessorStepSchema,
+    outputSchema: processors.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 agent.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(observability.SpanType.MODEL_STEP) || currentSpan : currentSpan?.findParent(observability.SpanType.AGENT_RUN) || currentSpan;
+      const processorSpan = phase !== "outputStream" ? parentSpan?.createChildSpan({
+        type: observability.SpanType.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 agent.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 agent.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 error.MastraError({
+                  category: error.ErrorCategory.USER,
+                  domain: error.ErrorDomain.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 agent.MessageList) {
+                if (result !== passThrough.messageList) {
+                  throw new error.MastraError({
+                    category: error.ErrorCategory.USER,
+                    domain: error.ErrorDomain.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)) {
+                processors.ProcessorRunner.applyMessagesToMessageList(
+                  result,
+                  passThrough.messageList,
+                  idsBeforeProcessing,
+                  check,
+                  "input"
+                );
+                return { ...passThrough, messages: result };
+              } else if (result && "messages" in result && "systemMessages" in result) {
+                const typedResult = result;
+                processors.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 error.MastraError({
+                  category: error.ErrorCategory.USER,
+                  domain: error.ErrorDomain.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 processors.ProcessorRunner.validateAndFormatProcessInputStepResult(result, {
+                messageList: passThrough.messageList,
+                processor,
+                stepNumber: stepNumber ?? 0
+              });
+              if (validatedResult.messages) {
+                processors.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: observability.SpanType.PROCESSOR_RUN,
+                  name: `output stream processor: ${processor.id}`,
+                  entityType: observability.EntityType.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 agent.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 error.MastraError({
+                  category: error.ErrorCategory.USER,
+                  domain: error.ErrorDomain.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 agent.MessageList) {
+                if (result !== passThrough.messageList) {
+                  throw new error.MastraError({
+                    category: error.ErrorCategory.USER,
+                    domain: error.ErrorDomain.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)) {
+                processors.ProcessorRunner.applyMessagesToMessageList(
+                  result,
+                  passThrough.messageList,
+                  idsBeforeProcessing,
+                  check,
+                  "response"
+                );
+                return { ...passThrough, messages: result };
+              } else if (result && "messages" in result && "systemMessages" in result) {
+                const typedResult = result;
+                processors.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 error.MastraError({
+                  category: error.ErrorCategory.USER,
+                  domain: error.ErrorDomain.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 agent.MessageList) {
+                if (result !== passThrough.messageList) {
+                  throw new error.MastraError({
+                    category: error.ErrorCategory.USER,
+                    domain: error.ErrorDomain.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)) {
+                processors.ProcessorRunner.applyMessagesToMessageList(
+                  result,
+                  passThrough.messageList,
+                  idsBeforeProcessing,
+                  check,
+                  "response"
+                );
+                return { ...passThrough, messages: result };
+              } else if (result && "messages" in result && "systemMessages" in result) {
+                const typedResult = result;
+                processors.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 init(inngest) {
@@ -1584,6 +2249,7 @@ exports.InngestPubSub = InngestPubSub;
 exports.InngestRun = InngestRun;
 exports.InngestWorkflow = InngestWorkflow;
 exports._compatibilityCheck = _compatibilityCheck;
+exports.createServe = createServe;
 exports.createStep = createStep;
 exports.init = init;
 exports.serve = serve;