@mastra/inngest 0.0.0-fix-local-pkg-cwd-20251224015404 → 0.0.0-fix-agent-network-schema-20260119184437

package/dist/index.js

@@ -1,11 +1,14 @@
+import { MessageList, Agent, TripWire } from '@mastra/core/agent';
+import { getErrorFromUnknown, MastraError, ErrorDomain, ErrorCategory } from '@mastra/core/error';
+import { EntityType, SpanType } from '@mastra/core/observability';
+import { ProcessorStepOutputSchema, ProcessorStepSchema, ProcessorRunner } from '@mastra/core/processors';
 import { Tool } from '@mastra/core/tools';
 import { DefaultExecutionEngine, createTimeTravelExecutionParams, Run, hydrateSerializedStepErrors, Workflow } from '@mastra/core/workflows';
 import { PUBSUB_SYMBOL, STREAM_FORMAT_SYMBOL } from '@mastra/core/workflows/_constants';
 import { z } from 'zod';
 import { randomUUID } from 'crypto';
 import { RequestContext } from '@mastra/core/di';
-import { RetryAfterError, NonRetriableError } from 'inngest';
-import { getErrorFromUnknown } from '@mastra/core/error';
+import { NonRetriableError } from 'inngest';
 import { subscribe } from '@inngest/realtime';
 import { PubSub } from '@mastra/core/events';
 import { ReadableStream } from 'stream/web';
@@ -58,38 +61,46 @@ var InngestExecutionEngine = class extends DefaultExecutionEngine {
    * After retries exhausted, error propagates here and we return a failed result.
    */
   async executeStepWithRetry(stepId, runStep, params) {
-    try {
-      const result = await this.wrapDurableOperation(stepId, runStep, { delay: params.delay });
-      return { ok: true, result };
-    } catch (e) {
-      const cause = e?.cause;
-      if (cause?.status === "failed") {
-        params.stepSpan?.error({
-          error: e,
-          attributes: { status: "failed" }
-        });
-        if (cause.error && !(cause.error instanceof Error)) {
-          cause.error = getErrorFromUnknown(cause.error, { serializeStack: false });
-        }
-        return { ok: false, error: cause };
+    for (let i = 0; i < params.retries + 1; i++) {
+      if (i > 0 && params.delay) {
+        await new Promise((resolve) => setTimeout(resolve, params.delay));
       }
-      const errorInstance = getErrorFromUnknown(e, {
-        serializeStack: false,
-        fallbackMessage: "Unknown step execution error"
-      });
-      params.stepSpan?.error({
-        error: errorInstance,
-        attributes: { status: "failed" }
-      });
-      return {
-        ok: false,
-        error: {
-          status: "failed",
-          error: errorInstance,
-          endedAt: Date.now()
+      try {
+        const result = await this.wrapDurableOperation(stepId, runStep);
+        return { ok: true, result };
+      } catch (e) {
+        if (i === params.retries) {
+          const cause = e?.cause;
+          if (cause?.status === "failed") {
+            params.stepSpan?.error({
+              error: e,
+              attributes: { status: "failed" }
+            });
+            if (cause.error && !(cause.error instanceof Error)) {
+              cause.error = getErrorFromUnknown(cause.error, { serializeStack: false });
+            }
+            return { ok: false, error: cause };
+          }
+          const errorInstance = getErrorFromUnknown(e, {
+            serializeStack: false,
+            fallbackMessage: "Unknown step execution error"
+          });
+          params.stepSpan?.error({
+            error: errorInstance,
+            attributes: { status: "failed" }
+          });
+          return {
+            ok: false,
+            error: {
+              status: "failed",
+              error: errorInstance,
+              endedAt: Date.now()
+            }
+          };
         }
-      };
+      }
     }
+    return { ok: false, error: { status: "failed", error: new Error("Unknown error"), endedAt: Date.now() } };
   }
   /**
    * Use Inngest's sleep primitive for durability
@@ -105,28 +116,32 @@ var InngestExecutionEngine = class extends 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, retryConfig) {
+  async wrapDurableOperation(operationId, operationFn) {
     return this.inngestStep.run(operationId, async () => {
       try {
         return await operationFn();
       } catch (e) {
-        if (retryConfig) {
-          const errorInstance = getErrorFromUnknown(e, {
-            serializeStack: false,
-            fallbackMessage: "Unknown step execution error"
-          });
-          throw new RetryAfterError(errorInstance.message, retryConfig.delay, {
-            cause: {
-              status: "failed",
-              error: errorInstance,
-              endedAt: Date.now()
-            }
-          });
-        }
-        throw e;
+        const errorInstance = getErrorFromUnknown(e, {
+          serializeStack: false,
+          fallbackMessage: "Unknown step execution error"
+        });
+        throw new Error(errorInstance.message, {
+          cause: {
+            status: "failed",
+            error: errorInstance,
+            endedAt: Date.now()
+          }
+        });
       }
     });
   }
@@ -148,6 +163,96 @@ var InngestExecutionEngine = class extends 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.
@@ -166,8 +271,13 @@ var InngestExecutionEngine = class extends 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;
@@ -194,7 +304,8 @@ var InngestExecutionEngine = class extends DefaultExecutionEngine {
               resumePath: resume.steps?.[1] ? snapshot?.suspendedPaths?.[resume.steps?.[1]] : void 0
             },
             outputOptions: { includeState: true },
-            perStep
+            perStep,
+            tracingOptions: nestedTracingContext
           }
         });
         result = invokeResp.result;
@@ -222,7 +333,8 @@ var InngestExecutionEngine = class extends DefaultExecutionEngine {
             initialState: executionContext.state ?? {},
             runId: executionContext.runId,
             outputOptions: { includeState: true },
-            perStep
+            perStep,
+            tracingOptions: nestedTracingContext
           }
         });
         result = invokeResp.result;
@@ -235,7 +347,8 @@ var InngestExecutionEngine = class extends DefaultExecutionEngine {
             inputData,
             initialState: executionContext.state ?? {},
             outputOptions: { includeState: true },
-            perStep
+            perStep,
+            tracingOptions: nestedTracingContext
           }
         });
         result = invokeResp.result;
@@ -632,8 +745,8 @@ var InngestRun = class extends 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).
@@ -641,7 +754,7 @@ var InngestRun = class extends 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,
@@ -661,8 +774,8 @@ var InngestRun = class extends 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: {
@@ -670,10 +783,10 @@ var InngestRun = class extends 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];
@@ -1037,9 +1150,6 @@ var InngestRun = class extends Run {
     });
     return this.streamOutput;
   }
-  streamVNext(args = {}) {
-    return this.stream(args);
-  }
   timeTravelStream({
     inputData,
     resumeData,
@@ -1048,6 +1158,7 @@ var InngestRun = class extends Run {
     context,
     nestedStepsContext,
     requestContext,
+    // tracingContext,
     tracingOptions,
     outputOptions,
     perStep
@@ -1130,9 +1241,11 @@ var InngestWorkflow = class _InngestWorkflow extends Workflow {
   #mastra;
   inngest;
   function;
+  cronFunction;
   flowControlConfig;
+  cronConfig;
   constructor(params, inngest) {
-    const { concurrency, rateLimit, throttle, debounce, priority, ...workflowParams } = params;
+    const { concurrency, rateLimit, throttle, debounce, priority, cron, inputData, initialState, ...workflowParams } = params;
     super(workflowParams);
     this.engineType = "inngest";
     const flowControlEntries = Object.entries({ concurrency, rateLimit, throttle, debounce, priority }).filter(
@@ -1141,6 +1254,9 @@ var InngestWorkflow = class _InngestWorkflow extends Workflow {
     this.flowControlConfig = flowControlEntries.length > 0 ? Object.fromEntries(flowControlEntries) : void 0;
     this.#mastra = params.mastra;
     this.inngest = inngest;
+    if (cron) {
+      this.cronConfig = { cron, inputData, initialState };
+    }
   }
   async listWorkflowRuns(args) {
     const storage = this.#mastra?.getStorage();
@@ -1154,19 +1270,6 @@ var InngestWorkflow = class _InngestWorkflow extends Workflow {
     }
     return workflowsStore.listWorkflowRuns({ workflowName: this.id, ...args ?? {} });
   }
-  async getWorkflowRunById(runId) {
-    const storage = this.#mastra?.getStorage();
-    if (!storage) {
-      this.logger.debug("Cannot get workflow runs. Mastra engine is not initialized");
-      return this.runs.get(runId) ? { ...this.runs.get(runId), workflowName: this.id } : null;
-    }
-    const workflowsStore = await storage.getStore("workflows");
-    if (!workflowsStore) {
-      return this.runs.get(runId) ? { ...this.runs.get(runId), workflowName: this.id } : null;
-    }
-    const run = await workflowsStore.getWorkflowRunById({ runId, workflowName: this.id });
-    return run ?? (this.runs.get(runId) ? { ...this.runs.get(runId), workflowName: this.id } : null);
-  }
   __registerMastra(mastra) {
     super.__registerMastra(mastra);
     this.#mastra = mastra;
@@ -1188,7 +1291,8 @@ var InngestWorkflow = class _InngestWorkflow extends Workflow {
   }
   async createRun(options) {
     const runIdToUse = options?.runId || randomUUID();
-    const run = this.runs.get(runIdToUse) ?? new InngestRun(
+    const existingInMemoryRun = this.runs.get(runIdToUse);
+    const newRun = new InngestRun(
       {
         workflowId: this.id,
         runId: runIdToUse,
@@ -1205,15 +1309,17 @@ var InngestWorkflow = class _InngestWorkflow extends Workflow {
       },
       this.inngest
     );
+    const run = existingInMemoryRun ?? newRun;
     this.runs.set(runIdToUse, run);
     const shouldPersistSnapshot = this.options.shouldPersistSnapshot({
       workflowStatus: run.workflowRunStatus,
       stepResults: {}
     });
-    const workflowSnapshotInStorage = await this.getWorkflowRunExecutionResult(runIdToUse, {
+    const existingStoredRun = await this.getWorkflowRunById(runIdToUse, {
       withNestedWorkflows: false
     });
-    if (!workflowSnapshotInStorage && shouldPersistSnapshot) {
+    const existsInStorage = existingStoredRun && !existingStoredRun.isFromInMemory;
+    if (!existsInStorage && shouldPersistSnapshot) {
       const workflowsStore = await this.mastra?.getStorage()?.getStore("workflows");
       await workflowsStore?.persistWorkflowSnapshot({
         workflowName: this.id,
@@ -1238,6 +1344,30 @@ var InngestWorkflow = class _InngestWorkflow extends Workflow {
     }
     return run;
   }
+  //createCronFunction is only called if cronConfig.cron is defined.
+  createCronFunction() {
+    if (this.cronFunction) {
+      return this.cronFunction;
+    }
+    this.cronFunction = this.inngest.createFunction(
+      {
+        id: `workflow.${this.id}.cron`,
+        retries: 0,
+        cancelOn: [{ event: `cancel.workflow.${this.id}` }],
+        ...this.flowControlConfig
+      },
+      { cron: this.cronConfig?.cron ?? "" },
+      async () => {
+        const run = await this.createRun();
+        const result = await run.start({
+          inputData: this.cronConfig?.inputData,
+          initialState: this.cronConfig?.initialState
+        });
+        return { result, runId: run.runId };
+      }
+    );
+    return this.cronFunction;
+  }
   getFunction() {
     if (this.function) {
       return this.function;
@@ -1245,54 +1375,127 @@ var InngestWorkflow = class _InngestWorkflow extends Workflow {
     this.function = this.inngest.createFunction(
       {
         id: `workflow.${this.id}`,
-        retries: Math.min(this.retryConfig?.attempts ?? 0, 20),
+        retries: 0,
         cancelOn: [{ event: `cancel.workflow.${this.id}` }],
         // Spread flow control configuration
         ...this.flowControlConfig
       },
       { 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 randomUUID();
           });
         }
         const pubsub = new InngestPubSub(this.inngest, this.id, publish);
+        const requestContext = new 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 = mastra?.observability?.getSelectedInstance({ requestContext });
+          if (!observability) return void 0;
+          const span = observability.startSpan({
+            type: SpanType.WORKFLOW_RUN,
+            name: `workflow run: '${this.id}'`,
+            entityType: 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 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 NonRetriableError(`Workflow failed`, {
@@ -1320,15 +1523,14 @@ var InngestWorkflow = class _InngestWorkflow extends Workflow {
     });
   }
   getFunctions() {
-    return [this.getFunction(), ...this.getNestedFunctions(this.executionGraph.steps)];
+    return [
+      this.getFunction(),
+      ...this.cronConfig?.cron ? [this.createCronFunction()] : [],
+      ...this.getNestedFunctions(this.executionGraph.steps)
+    ];
   }
 };
-function serve({
-  mastra,
-  inngest,
-  functions: userFunctions = [],
-  registerOptions
-}) {
+function prepareServeOptions({ mastra, inngest, functions: userFunctions = [], registerOptions }) {
   const wfs = mastra.listWorkflows();
   const workflowFunctions = Array.from(
     new Set(
@@ -1341,177 +1543,181 @@ function serve({
       })
     )
   );
-  return serve$1({
+  return {
     ...registerOptions,
     client: inngest,
     functions: [...workflowFunctions, ...userFunctions]
-  });
+  };
 }
+function createServe(adapter) {
+  return (options) => {
+    const serveOptions = prepareServeOptions(options);
+    return adapter(serveOptions);
+  };
+}
+var serve = createServe(serve$1);
 
 // src/types.ts
 var _compatibilityCheck = true;
 
 // src/index.ts
-function isAgent(params) {
-  return params?.component === "AGENT";
+function isInngestWorkflow(input) {
+  return input instanceof InngestWorkflow;
+}
+function isAgent(input) {
+  return input instanceof Agent;
+}
+function isToolStep(input) {
+  return input instanceof Tool;
 }
-function isTool(params) {
-  return params instanceof Tool;
+function isStepParams(input) {
+  return input !== null && typeof input === "object" && "id" in input && "execute" in input && !(input instanceof Agent) && !(input instanceof Tool) && !(input instanceof InngestWorkflow);
 }
-function isInngestWorkflow(params) {
-  return params instanceof InngestWorkflow;
+function isProcessor(obj) {
+  return obj !== null && typeof obj === "object" && "id" in obj && typeof obj.id === "string" && !(obj instanceof Agent) && !(obj instanceof 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, agentOptions) {
+function createStep(params, agentOrToolOptions) {
   if (isInngestWorkflow(params)) {
     return params;
   }
   if (isAgent(params)) {
-    const outputSchema = agentOptions?.structuredOutput?.schema ?? z.object({ text: z.string() });
-    return {
-      id: params.name,
-      description: params.getDescription(),
-      inputSchema: z.object({
-        prompt: z.string()
-        // resourceId: z.string().optional(),
-        // threadId: z.string().optional(),
-      }),
-      outputSchema,
-      execute: async ({
-        inputData,
-        runId,
-        [PUBSUB_SYMBOL]: pubsub,
-        [STREAM_FORMAT_SYMBOL]: streamFormat,
-        requestContext,
-        tracingContext,
-        abortSignal,
-        abort,
-        writer
-      }) => {
-        let streamPromise = {};
-        streamPromise.promise = new Promise((resolve, reject) => {
-          streamPromise.resolve = resolve;
-          streamPromise.reject = reject;
+    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 ?? z.object({ text: z.string() });
+  const { retries, scorers, ...agentOptions } = options ?? {};
+  return {
+    id: params.name,
+    description: params.getDescription(),
+    inputSchema: z.object({
+      prompt: z.string()
+    }),
+    outputSchema,
+    retries,
+    scorers,
+    execute: async ({
+      inputData,
+      runId,
+      [PUBSUB_SYMBOL]: pubsub,
+      [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 (isTool(params)) {
-    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,
-      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,
@@ -1520,7 +1726,480 @@ function createStep(params, agentOptions) {
     outputSchema: params.outputSchema,
     resumeSchema: params.resumeSchema,
     suspendSchema: params.suspendSchema,
-    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 EntityType.INPUT_PROCESSOR;
+      case "inputStep":
+        return EntityType.INPUT_STEP_PROCESSOR;
+      case "outputStream":
+      case "outputResult":
+        return EntityType.OUTPUT_PROCESSOR;
+      case "outputStep":
+        return EntityType.OUTPUT_STEP_PROCESSOR;
+      default:
+        return 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: 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(SpanType.MODEL_STEP) || currentSpan : currentSpan?.findParent(SpanType.AGENT_RUN) || currentSpan;
+      const processorSpan = phase !== "outputStream" ? parentSpan?.createChildSpan({
+        type: 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 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: ErrorCategory.USER,
+                  domain: 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 MessageList) {
+                if (result !== passThrough.messageList) {
+                  throw new MastraError({
+                    category: ErrorCategory.USER,
+                    domain: 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)) {
+                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: ErrorCategory.USER,
+                  domain: 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 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: SpanType.PROCESSOR_RUN,
+                  name: `output stream processor: ${processor.id}`,
+                  entityType: 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 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: ErrorCategory.USER,
+                  domain: 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 MessageList) {
+                if (result !== passThrough.messageList) {
+                  throw new MastraError({
+                    category: ErrorCategory.USER,
+                    domain: 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)) {
+                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: ErrorCategory.USER,
+                  domain: 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 MessageList) {
+                if (result !== passThrough.messageList) {
+                  throw new MastraError({
+                    category: ErrorCategory.USER,
+                    domain: 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)) {
+                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 init(inngest) {
@@ -1563,6 +2242,6 @@ function init(inngest) {
   };
 }
 
-export { InngestExecutionEngine, InngestPubSub, InngestRun, InngestWorkflow, _compatibilityCheck, createStep, init, serve };
+export { InngestExecutionEngine, InngestPubSub, InngestRun, InngestWorkflow, _compatibilityCheck, createServe, createStep, init, serve };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map