@cchevli/inngest 1.8.1-walton.0

package/dist/index.cjs

@@ -0,0 +1,1576 @@
+'use strict';
+
+var chunkMICZJLEE_cjs = require('./chunk-MICZJLEE.cjs');
+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 schema = require('@mastra/core/schema');
+var tools = require('@mastra/core/tools');
+var workflows = require('@mastra/core/workflows');
+var _constants = require('@mastra/core/workflows/_constants');
+var zod = require('zod');
+var hono = require('inngest/hono');
+var durable = require('@mastra/core/agent/durable');
+var cache = require('@mastra/core/cache');
+var events = require('@mastra/core/events');
+
+function prepareServeOptions({ mastra, inngest, functions: userFunctions = [], registerOptions }) {
+  return {
+    ...registerOptions,
+    client: inngest,
+    functions: chunkMICZJLEE_cjs.collectInngestFunctions({ mastra, functions: userFunctions })
+  };
+}
+function createServe(adapter) {
+  return (options) => {
+    const serveOptions = prepareServeOptions(options);
+    return adapter(serveOptions);
+  };
+}
+var serve = createServe(hono.serve);
+
+// src/types.ts
+var _compatibilityCheck = true;
+var durableAgenticInputSchema = zod.z.object({
+  runId: zod.z.string(),
+  agentId: zod.z.string(),
+  agentName: zod.z.string().optional(),
+  messageListState: zod.z.any(),
+  toolsMetadata: zod.z.array(zod.z.any()),
+  modelConfig: durable.modelConfigSchema,
+  options: zod.z.any(),
+  state: zod.z.any(),
+  messageId: zod.z.string(),
+  // Observability fields (Inngest-specific)
+  agentSpanData: zod.z.any().optional(),
+  modelSpanData: zod.z.any().optional(),
+  stepIndex: zod.z.number().optional()
+});
+var iterationStateSchema = durable.baseIterationStateSchema.extend({
+  // Observability - exported span data for agent run
+  agentSpanData: zod.z.any().optional(),
+  // Observability - exported span data for model generation (ONE span for entire run)
+  modelSpanData: zod.z.any().optional(),
+  // Step index for continuation across iterations (maintains step: 0, 1, 2, ...)
+  stepIndex: zod.z.number()
+});
+var INNGEST_ENGINE_PREFIX = "inngest";
+var InngestDurableStepIds = {
+  AGENTIC_EXECUTION: `${INNGEST_ENGINE_PREFIX}:${durable.DurableStepIds.AGENTIC_EXECUTION}`,
+  AGENTIC_LOOP: `${INNGEST_ENGINE_PREFIX}:${durable.DurableStepIds.AGENTIC_LOOP}`
+};
+function createInngestDurableAgenticWorkflow(options) {
+  const { inngest, maxSteps = durable.DurableAgentDefaults.MAX_STEPS } = options;
+  const { createWorkflow } = init(inngest);
+  const llmExecutionStep = durable.createDurableLLMExecutionStep();
+  const toolCallStep = durable.createDurableToolCallStep();
+  const llmMappingStep = durable.createDurableLLMMappingStep();
+  const backgroundTaskCheckStep = durable.createDurableBackgroundTaskCheckStep();
+  const singleIterationWorkflow = createWorkflow({
+    id: InngestDurableStepIds.AGENTIC_EXECUTION,
+    inputSchema: iterationStateSchema,
+    outputSchema: iterationStateSchema,
+    options: {
+      tracingPolicy: {
+        // Mark all workflow spans as internal so they're hidden in traces
+        // This makes the trace structure match regular agents (agent_run -> model_generation -> tool_call)
+        internal: observability.InternalSpans.WORKFLOW
+      },
+      shouldPersistSnapshot: ({ workflowStatus }) => workflowStatus === "suspended",
+      validateInputs: false
+    },
+    steps: []
+  }).map(
+    async ({ inputData }) => {
+      const state = inputData;
+      return {
+        runId: state.runId,
+        agentId: state.agentId,
+        agentName: state.agentName,
+        messageListState: state.messageListState,
+        toolsMetadata: state.toolsMetadata,
+        modelConfig: state.modelConfig,
+        options: state.options,
+        state: state.state,
+        messageId: state.messageId,
+        // Pass agent span data so model spans can use it as parent
+        agentSpanData: state.agentSpanData,
+        // Pass model span data (ONE span for entire agent run)
+        modelSpanData: state.modelSpanData,
+        // Pass step index for continuation (step: 0, 1, 2, ...)
+        stepIndex: state.stepIndex
+      };
+    },
+    { id: "map-to-llm-input" }
+  ).then(llmExecutionStep).map(
+    async ({ inputData }) => {
+      const llmOutput = inputData;
+      return llmOutput.toolCalls ?? [];
+    },
+    { id: "extract-tool-calls" }
+  ).foreach(toolCallStep).map(
+    async ({ inputData, getStepResult, getInitData, mastra }) => {
+      const toolResults = inputData;
+      const llmOutput = getStepResult(llmExecutionStep.id);
+      const initData = getInitData();
+      const observability$1 = mastra?.observability?.getSelectedInstance({});
+      const modelSpanData = llmOutput?.modelSpanData;
+      const stepSpanData = llmOutput?.stepSpanData;
+      const modelSpan = modelSpanData ? observability$1?.rebuildSpan(modelSpanData) : void 0;
+      const stepSpan = stepSpanData ? observability$1?.rebuildSpan(stepSpanData) : void 0;
+      const agentSpan = initData.agentSpanData ? observability$1?.rebuildSpan(initData.agentSpanData) : void 0;
+      const toolParentSpan = stepSpan ?? modelSpan ?? agentSpan;
+      for (const tr of toolResults) {
+        const toolSpan = toolParentSpan?.createChildSpan({
+          type: observability.SpanType.TOOL_CALL,
+          name: `tool: '${tr.toolName}'`,
+          entityType: observability.EntityType.TOOL,
+          entityId: tr.toolName,
+          entityName: tr.toolName,
+          input: tr.args
+        });
+        if (tr.error) {
+          toolSpan?.error({ error: new Error(tr.error.message) });
+        } else {
+          toolSpan?.end({ output: tr.result });
+        }
+        if (!tr.error) {
+          stepSpan?.createEventSpan({
+            type: observability.SpanType.MODEL_CHUNK,
+            name: `chunk: 'tool-result'`,
+            output: {
+              toolCallId: tr.toolCallId,
+              toolName: tr.toolName,
+              result: tr.result
+            }
+          });
+        }
+      }
+      const toolCalls = llmOutput?.toolCalls ?? [];
+      if (stepSpan) {
+        const stepFinishPayload = llmOutput.stepFinishPayload;
+        stepSpan.end({
+          output: {
+            toolCalls: toolCalls.map((tc) => ({
+              toolCallId: tc.toolCallId,
+              toolName: tc.toolName,
+              args: tc.args
+            })),
+            toolResults: toolResults.map((tr) => ({
+              toolCallId: tr.toolCallId,
+              toolName: tr.toolName,
+              result: tr.result,
+              error: tr.error
+            }))
+          },
+          attributes: {
+            usage: stepFinishPayload?.output?.usage,
+            finishReason: stepFinishPayload?.stepResult?.reason,
+            isContinued: stepFinishPayload?.stepResult?.isContinued
+          }
+        });
+      }
+      return {
+        llmOutput,
+        toolResults,
+        runId: initData.runId,
+        agentId: initData.agentId,
+        messageId: initData.messageId,
+        state: llmOutput?.state ?? initData.state
+      };
+    },
+    { id: "collect-tool-results" }
+  ).then(llmMappingStep).then(backgroundTaskCheckStep).map(
+    async ({ inputData, getInitData }) => {
+      const executionOutput = inputData;
+      const initData = getInitData();
+      const baseUpdate = durable.createBaseIterationStateUpdate({
+        currentState: initData,
+        executionOutput
+      });
+      const newIterationState = {
+        ...baseUpdate,
+        // Preserve agent span data for observability
+        agentSpanData: initData.agentSpanData,
+        // Preserve model span data (ONE span for entire agent run)
+        modelSpanData: initData.modelSpanData,
+        // Increment step index for next iteration (step: 0 → 1 → 2 → ...)
+        stepIndex: initData.stepIndex + 1
+      };
+      return newIterationState;
+    },
+    { id: "update-iteration-state" }
+  ).commit();
+  return createWorkflow({
+    id: InngestDurableStepIds.AGENTIC_LOOP,
+    inputSchema: durableAgenticInputSchema,
+    outputSchema: durable.durableAgenticOutputSchema,
+    options: {
+      tracingPolicy: {
+        // Mark all workflow spans as internal so they're hidden in traces
+        // This makes the trace structure match regular agents (agent_run -> model_generation -> tool_call)
+        internal: observability.InternalSpans.WORKFLOW
+      },
+      shouldPersistSnapshot: ({ workflowStatus }) => workflowStatus === "suspended",
+      validateInputs: false
+    },
+    steps: []
+  }).map(
+    async ({ inputData }) => {
+      const input = inputData;
+      const agentSpanData = input.agentSpanData;
+      const modelSpanData = input.modelSpanData;
+      const iterationState = {
+        ...input,
+        iterationCount: 0,
+        accumulatedSteps: [],
+        accumulatedUsage: {
+          inputTokens: 0,
+          outputTokens: 0,
+          totalTokens: 0
+        },
+        lastStepResult: void 0,
+        agentSpanData,
+        modelSpanData,
+        stepIndex: input.stepIndex ?? 0
+      };
+      return iterationState;
+    },
+    { id: "init-iteration-state" }
+  ).dowhile(singleIterationWorkflow, async ({ inputData }) => {
+    const state = inputData;
+    const shouldContinue = state.lastStepResult?.isContinued === true;
+    const effectiveMaxSteps = state.options?.maxSteps ?? maxSteps;
+    const underMaxSteps = state.iterationCount < effectiveMaxSteps;
+    return shouldContinue && underMaxSteps;
+  }).map(
+    async (params) => {
+      const { inputData, mastra } = params;
+      const state = inputData;
+      const pubsub = params[_constants.PUBSUB_SYMBOL];
+      const lastStep = state.accumulatedSteps[state.accumulatedSteps.length - 1];
+      const finalText = lastStep?.text;
+      const finalOutput = {
+        messageListState: state.messageListState,
+        messageId: state.messageId,
+        stepResult: state.lastStepResult || {
+          reason: "stop",
+          warnings: [],
+          isContinued: false
+        },
+        output: {
+          text: finalText,
+          usage: state.accumulatedUsage,
+          steps: state.accumulatedSteps
+        },
+        state: state.state
+      };
+      const observability = mastra?.observability?.getSelectedInstance({});
+      if (state.modelSpanData) {
+        const modelSpan = observability?.rebuildSpan(state.modelSpanData);
+        modelSpan?.end({
+          output: {
+            text: finalText,
+            usage: state.accumulatedUsage
+          },
+          attributes: {
+            finishReason: state.lastStepResult?.reason || "stop"
+          }
+        });
+      }
+      if (state.agentSpanData) {
+        const agentSpan = observability?.rebuildSpan(state.agentSpanData);
+        agentSpan?.end({
+          output: finalOutput.output
+        });
+      }
+      if (pubsub) {
+        await durable.emitFinishEvent(pubsub, state.runId, {
+          output: finalOutput.output,
+          stepResult: finalOutput.stepResult
+        });
+      }
+      return finalOutput;
+    },
+    { id: "map-final-output" }
+  ).commit();
+}
+
+// src/durable-agent/create-inngest-agent.ts
+var CLOSE_ON_SUSPEND = /* @__PURE__ */ Symbol("mastra.durable.inngest.closeOnSuspend");
+var STREAM_CLEANUP = /* @__PURE__ */ Symbol("mastra.durable.inngest.streamCleanup");
+function createInngestAgent(options) {
+  const {
+    agent,
+    inngest,
+    id: idOverride,
+    name: nameOverride,
+    pubsub: customPubsub,
+    cache: cache$1,
+    mastra: mastraOption
+  } = options;
+  const agentId = idOverride ?? agent.id;
+  const agentName = nameOverride ?? agent.name;
+  let mastra = mastraOption;
+  const activeStreamUntilIdle = /* @__PURE__ */ new Map();
+  let proxyRef;
+  const workflow = createInngestDurableAgenticWorkflow({ inngest });
+  let _customCache = cache$1;
+  let innerPubsub = customPubsub ?? new chunkMICZJLEE_cjs.InngestPubSub(inngest, InngestDurableStepIds.AGENTIC_LOOP);
+  let _cachingPubsub = null;
+  function resolveCache() {
+    const resolved = _customCache ?? mastra?.serverCache ?? new cache.InMemoryServerCache();
+    _customCache = resolved;
+    return resolved;
+  }
+  function getPubsub() {
+    if (!_cachingPubsub) {
+      if (innerPubsub instanceof events.CachingPubSub) {
+        _cachingPubsub = innerPubsub;
+        _customCache = _customCache ?? mastra?.serverCache;
+      } else {
+        _cachingPubsub = new events.CachingPubSub(innerPubsub, resolveCache());
+      }
+    }
+    return _cachingPubsub;
+  }
+  workflow.__setPubsubFactory((defaultPubsub) => {
+    if (defaultPubsub instanceof events.CachingPubSub) return defaultPubsub;
+    getPubsub();
+    return new events.CachingPubSub(defaultPubsub, resolveCache());
+  });
+  function getCache() {
+    getPubsub();
+    return _customCache;
+  }
+  async function triggerWorkflow(runId, workflowInput, tracingOptions) {
+    const eventName = `workflow.${InngestDurableStepIds.AGENTIC_LOOP}`;
+    await inngest.send({
+      name: eventName,
+      data: {
+        inputData: workflowInput,
+        runId,
+        resourceId: workflowInput.state?.resourceId,
+        requestContext: workflowInput.requestContextEntries ?? {},
+        tracingOptions
+      }
+    });
+  }
+  async function emitError(runId, error) {
+    await durable.emitErrorEvent(getPubsub(), runId, error);
+  }
+  const inngestAgent = {
+    get id() {
+      return agentId;
+    },
+    get name() {
+      return agentName;
+    },
+    get agent() {
+      return agent;
+    },
+    get inngest() {
+      return inngest;
+    },
+    get cache() {
+      return getCache();
+    },
+    get pubsub() {
+      return getPubsub();
+    },
+    async stream(messages, streamOptions) {
+      if (streamOptions?.untilIdle) {
+        const { untilIdle, ...rest } = streamOptions;
+        const maxIdleMs = typeof untilIdle === "object" ? untilIdle.maxIdleMs : void 0;
+        return durable.runDurableStreamUntilIdle(proxyRef, messages, { ...rest, maxIdleMs }, {
+          activeStreams: activeStreamUntilIdle,
+          bgManager: mastra?.backgroundTaskManager
+        });
+      }
+      const preparation = await durable.prepareForDurableExecution({
+        agent,
+        messages,
+        options: streamOptions,
+        runId: streamOptions?.runId,
+        requestContext: streamOptions?.requestContext,
+        methodType: streamOptions?.__methodType ?? "stream"
+      });
+      const { runId, messageId, workflowInput, registryEntry, threadId, resourceId } = preparation;
+      workflowInput.agentId = agentId;
+      workflowInput.agentName = agentName;
+      const abortController = new AbortController();
+      if (streamOptions?.abortSignal) {
+        const external = streamOptions.abortSignal;
+        if (external.aborted) {
+          abortController.abort(external.reason);
+        } else {
+          external.addEventListener(
+            "abort",
+            () => abortController.abort(external.reason),
+            { once: true }
+          );
+        }
+      }
+      registryEntry.abortController = abortController;
+      registryEntry.abortSignal = abortController.signal;
+      durable.globalRunRegistry.set(runId, registryEntry);
+      const observability$1 = mastra?.observability?.getSelectedInstance({
+        requestContext: streamOptions?.requestContext
+      });
+      const agentSpan = observability$1?.startSpan({
+        type: observability.SpanType.AGENT_RUN,
+        name: `agent run: '${agentId}'`,
+        entityType: observability.EntityType.AGENT,
+        entityId: agentId,
+        entityName: agentName,
+        input: workflowInput.messageListState,
+        metadata: {
+          runId,
+          threadId,
+          resourceId
+        }
+      });
+      const agentSpanData = agentSpan?.exportSpan();
+      const modelSpan = agentSpan?.createChildSpan({
+        type: observability.SpanType.MODEL_GENERATION,
+        name: `llm: '${workflowInput.modelConfig.modelId}'`,
+        input: { messages: workflowInput.messageListState },
+        attributes: {
+          model: workflowInput.modelConfig.modelId,
+          provider: workflowInput.modelConfig.provider,
+          streaming: true,
+          parameters: {
+            temperature: workflowInput.options?.modelSettings?.temperature
+          }
+        }
+      });
+      const modelSpanData = modelSpan?.exportSpan();
+      workflowInput.agentSpanData = agentSpanData;
+      workflowInput.modelSpanData = modelSpanData;
+      workflowInput.stepIndex = 0;
+      let cleanedUp = false;
+      const finalizeGlobalRegistry = () => {
+        if (cleanedUp) return;
+        cleanedUp = true;
+        durable.globalRunRegistry.delete(runId);
+      };
+      const {
+        output,
+        cleanup: streamCleanup,
+        ready
+      } = durable.createDurableAgentStream({
+        pubsub: getPubsub(),
+        runId,
+        messageId,
+        model: {
+          modelId: workflowInput.modelConfig.modelId,
+          provider: workflowInput.modelConfig.provider,
+          version: "v3"
+        },
+        threadId,
+        resourceId,
+        onChunk: streamOptions?.onChunk,
+        onStepFinish: streamOptions?.onStepFinish,
+        onFinish: async (result3) => {
+          try {
+            await streamOptions?.onFinish?.(result3);
+          } finally {
+            finalizeGlobalRegistry();
+          }
+        },
+        onError: async (errorArg) => {
+          try {
+            await streamOptions?.onError?.(errorArg);
+          } finally {
+            finalizeGlobalRegistry();
+          }
+        },
+        onSuspended: streamOptions?.onSuspended,
+        onAbort: async (data) => {
+          try {
+            await streamOptions?.onAbort?.(data);
+          } finally {
+            finalizeGlobalRegistry();
+          }
+        },
+        onIterationComplete: streamOptions?.onIterationComplete ? async (data) => {
+          await streamOptions.onIterationComplete?.(data);
+        } : void 0,
+        closeOnSuspend: streamOptions?.[CLOSE_ON_SUSPEND] === true
+      });
+      const tracingOptions = agentSpanData ? { traceId: agentSpanData.traceId, parentSpanId: agentSpanData.id } : void 0;
+      const workflowExecution = ready.then(() => triggerWorkflow(runId, workflowInput, tracingOptions)).catch((error) => {
+        void emitError(runId, error);
+      });
+      const trackedEntry = durable.globalRunRegistry.get(runId);
+      if (trackedEntry) {
+        trackedEntry.workflowExecution = workflowExecution;
+      }
+      const cleanup = () => {
+        streamCleanup();
+        finalizeGlobalRegistry();
+      };
+      const abort = (reason) => {
+        if (!abortController.signal.aborted) {
+          abortController.abort(reason);
+        }
+      };
+      const result2 = {
+        output,
+        runId,
+        threadId,
+        resourceId,
+        cleanup,
+        abort,
+        // Also expose fullStream directly for server compatibility
+        get fullStream() {
+          return output.fullStream;
+        },
+        // Internal: stream-only cleanup for generate()/resumeGenerate() to
+        // release the subscription on suspend without dropping the registry.
+        [STREAM_CLEANUP]: streamCleanup
+      };
+      return result2;
+    },
+    async resume(runId, resumeData, resumeOptions) {
+      if (resumeOptions?.untilIdle) {
+        const { untilIdle, ...rest } = resumeOptions;
+        const maxIdleMs = typeof untilIdle === "object" ? untilIdle.maxIdleMs : void 0;
+        return durable.runResumeDurableStreamUntilIdle(
+          proxyRef,
+          runId,
+          resumeData,
+          { ...rest, maxIdleMs },
+          {
+            activeStreams: activeStreamUntilIdle,
+            bgManager: mastra?.backgroundTaskManager
+          }
+        );
+      }
+      const abortController = new AbortController();
+      if (resumeOptions?.abortSignal) {
+        const external = resumeOptions.abortSignal;
+        if (external.aborted) {
+          abortController.abort(external.reason);
+        } else {
+          external.addEventListener(
+            "abort",
+            () => abortController.abort(external.reason),
+            { once: true }
+          );
+        }
+      }
+      let existingEntry = durable.globalRunRegistry.get(runId);
+      if (!existingEntry) {
+        existingEntry = {
+          // Minimal placeholder fields. The durable LLM step recreates tools
+          // and model from the workflow input; this slot exists primarily to
+          // carry the abort controller across the resumed segment.
+          tools: {},
+          model: void 0
+        };
+        durable.globalRunRegistry.set(runId, existingEntry);
+      }
+      existingEntry.abortController = abortController;
+      existingEntry.abortSignal = abortController.signal;
+      let resumeCleanedUp = false;
+      const finalizeResumeRegistry = () => {
+        if (resumeCleanedUp) return;
+        resumeCleanedUp = true;
+        durable.globalRunRegistry.delete(runId);
+      };
+      const {
+        output,
+        cleanup: streamCleanup,
+        ready
+      } = durable.createDurableAgentStream({
+        pubsub: getPubsub(),
+        runId,
+        messageId: crypto.randomUUID(),
+        model: {
+          modelId: void 0,
+          provider: void 0,
+          version: "v3"
+        },
+        threadId: resumeOptions?.threadId,
+        resourceId: resumeOptions?.resourceId,
+        onChunk: resumeOptions?.onChunk,
+        onStepFinish: resumeOptions?.onStepFinish,
+        onFinish: async (result2) => {
+          try {
+            await resumeOptions?.onFinish?.(result2);
+          } finally {
+            finalizeResumeRegistry();
+          }
+        },
+        onError: async (errorArg) => {
+          try {
+            await resumeOptions?.onError?.(errorArg);
+          } finally {
+            finalizeResumeRegistry();
+          }
+        },
+        onSuspended: resumeOptions?.onSuspended,
+        onAbort: async (data) => {
+          try {
+            await resumeOptions?.onAbort?.(data);
+          } finally {
+            finalizeResumeRegistry();
+          }
+        },
+        closeOnSuspend: resumeOptions?.[CLOSE_ON_SUSPEND] === true
+      });
+      const eventName = `workflow.${InngestDurableStepIds.AGENTIC_LOOP}`;
+      const workflowExecution = ready.then(async () => {
+        const workflowsStore = await mastra?.getStorage()?.getStore("workflows");
+        const snapshot = await workflowsStore?.loadWorkflowSnapshot({
+          workflowName: InngestDurableStepIds.AGENTIC_LOOP,
+          runId
+        });
+        const suspendedStepIds = snapshot?.suspendedPaths ? Object.keys(snapshot.suspendedPaths) : [];
+        const steps = suspendedStepIds.length > 0 ? suspendedStepIds : [];
+        await inngest.send({
+          name: eventName,
+          data: {
+            inputData: resumeData,
+            initialState: snapshot?.value ?? {},
+            runId,
+            resourceId: resumeOptions?.resourceId,
+            requestContext: snapshot?.requestContext ?? {},
+            stepResults: snapshot?.context,
+            resume: {
+              steps,
+              stepResults: snapshot?.context,
+              resumePayload: resumeData,
+              resumePath: steps[0] ? snapshot?.suspendedPaths?.[steps[0]] : void 0
+            }
+          }
+        });
+      }).catch((error) => {
+        void emitError(runId, error);
+      });
+      existingEntry.workflowExecution = workflowExecution;
+      const abort = (reason) => {
+        if (!abortController.signal.aborted) {
+          abortController.abort(reason);
+        }
+      };
+      const cleanup = () => {
+        streamCleanup();
+        finalizeResumeRegistry();
+      };
+      return {
+        output,
+        get fullStream() {
+          return output.fullStream;
+        },
+        runId,
+        threadId: resumeOptions?.threadId,
+        resourceId: resumeOptions?.resourceId,
+        cleanup,
+        abort,
+        // Internal: stream-only cleanup for resumeGenerate() to release the
+        // subscription on suspend without dropping the resumed registry entry.
+        [STREAM_CLEANUP]: streamCleanup
+      };
+    },
+    async prepare(messages, prepareOptions) {
+      const preparation = await durable.prepareForDurableExecution({
+        agent,
+        messages,
+        options: prepareOptions,
+        requestContext: prepareOptions?.requestContext
+      });
+      preparation.workflowInput.agentId = agentId;
+      preparation.workflowInput.agentName = agentName;
+      return {
+        runId: preparation.runId,
+        messageId: preparation.messageId,
+        workflowInput: preparation.workflowInput,
+        threadId: preparation.threadId,
+        resourceId: preparation.resourceId
+      };
+    },
+    async observe(runId, observeOptions) {
+      const {
+        output,
+        cleanup: streamCleanup,
+        ready
+      } = durable.createDurableAgentStream({
+        pubsub: getPubsub(),
+        runId,
+        messageId: crypto.randomUUID(),
+        model: {
+          modelId: void 0,
+          provider: void 0,
+          version: "v3"
+        },
+        offset: observeOptions?.offset,
+        onChunk: observeOptions?.onChunk,
+        onStepFinish: observeOptions?.onStepFinish,
+        onFinish: observeOptions?.onFinish,
+        onError: observeOptions?.onError,
+        onSuspended: observeOptions?.onSuspended
+      });
+      await ready;
+      const abort = (_reason) => {
+        streamCleanup();
+      };
+      return {
+        output,
+        get fullStream() {
+          return output.fullStream;
+        },
+        runId,
+        cleanup: streamCleanup,
+        abort
+      };
+    },
+    async generate(messages, generateOptions) {
+      const { untilIdle, ...rest } = generateOptions ?? {};
+      const streamOpts = {
+        ...rest,
+        [CLOSE_ON_SUSPEND]: true,
+        __methodType: "generate"
+      };
+      const result2 = await proxyRef.stream(messages, streamOpts);
+      let suspended = false;
+      try {
+        const fullOutput = await result2.output.getFullOutput();
+        if (fullOutput.error) {
+          throw fullOutput.error;
+        }
+        suspended = fullOutput.finishReason === "suspended";
+        if (suspended) {
+          await durable.globalRunRegistry.get(result2.runId)?.workflowExecution;
+        }
+        if (!fullOutput.runId) {
+          fullOutput.runId = result2.runId;
+        }
+        return fullOutput;
+      } finally {
+        if (suspended) {
+          const streamOnlyCleanup = result2[STREAM_CLEANUP];
+          streamOnlyCleanup?.();
+        } else {
+          result2.cleanup();
+        }
+      }
+    },
+    async resumeGenerate(runId, resumeData, resumeOptions) {
+      const { untilIdle, ...rest } = resumeOptions ?? {};
+      const result2 = await proxyRef.resume(runId, resumeData, {
+        ...rest,
+        [CLOSE_ON_SUSPEND]: true
+      });
+      let suspended = false;
+      try {
+        const fullOutput = await result2.output.getFullOutput();
+        if (fullOutput.error) {
+          throw fullOutput.error;
+        }
+        suspended = fullOutput.finishReason === "suspended";
+        if (suspended) {
+          await durable.globalRunRegistry.get(result2.runId)?.workflowExecution;
+        }
+        if (!fullOutput.runId) {
+          fullOutput.runId = result2.runId;
+        }
+        return fullOutput;
+      } finally {
+        if (suspended) {
+          const streamOnlyCleanup = result2[STREAM_CLEANUP];
+          streamOnlyCleanup?.();
+        } else {
+          result2.cleanup();
+        }
+      }
+    },
+    getDurableWorkflows() {
+      return [workflow];
+    },
+    __setMastra(mastraInstance) {
+      mastra = mastraInstance;
+    }
+  };
+  const result = new Proxy(inngestAgent, {
+    get(target, prop, receiver) {
+      if (prop in target) {
+        return Reflect.get(target, prop, receiver);
+      }
+      const agentValue = agent[prop];
+      if (typeof agentValue === "function") {
+        return agentValue.bind(agent);
+      }
+      return agentValue;
+    },
+    has(target, prop) {
+      return prop in target || prop in agent;
+    }
+  });
+  proxyRef = result;
+  return result;
+}
+function isInngestAgent(obj) {
+  if (!obj) return false;
+  return typeof obj.id === "string" && typeof obj.name === "string" && "agent" in obj && "inngest" in obj && typeof obj.stream === "function" && typeof obj.getDurableWorkflows === "function";
+}
+
+// src/index.ts
+function isInngestWorkflow(input) {
+  return input instanceof chunkMICZJLEE_cjs.InngestWorkflow;
+}
+function isAgentCompatible(input) {
+  return typeof input === "object" && input !== null && "generate" in input && typeof input.generate === "function" && "stream" in input && typeof input.stream === "function" && "getDescription" in input && typeof input.getDescription === "function" && "getModel" in input && typeof input.getModel === "function";
+}
+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 chunkMICZJLEE_cjs.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 chunkMICZJLEE_cjs.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 (isInngestWorkflow(params)) {
+    return params;
+  }
+  if (isAgentCompatible(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: schema.toStandardSchema(params.inputSchema),
+    stateSchema: params.stateSchema ? schema.toStandardSchema(params.stateSchema) : void 0,
+    outputSchema: schema.toStandardSchema(params.outputSchema),
+    resumeSchema: params.resumeSchema ? schema.toStandardSchema(params.resumeSchema) : void 0,
+    suspendSchema: params.suspendSchema ? schema.toStandardSchema(params.suspendSchema) : void 0,
+    scorers: params.scorers,
+    retries: params.retries,
+    metadata: params.metadata,
+    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, metadata, ...agentOptions } = options ?? {};
+  return {
+    id: params.id,
+    description: params.getDescription(),
+    inputSchema: schema.toStandardSchema(
+      zod.z.object({
+        prompt: zod.z.string()
+      })
+    ),
+    outputSchema: schema.toStandardSchema(outputSchema),
+    retries,
+    scorers,
+    metadata,
+    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 ?? params.id,
+        args: inputData
+      };
+      let stream;
+      if ((await params.getModel()).specificationVersion === "v1") {
+        if (typeof params.streamLegacy !== "function") {
+          throw new Error(`Agent step ${params.id} returned a v1 model but does not implement streamLegacy`);
+        }
+        const modelOutput = 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
+        });
+        if ("text" in modelOutput) {
+          void modelOutput.text.then(streamPromise.resolve, streamPromise.reject);
+        }
+        stream = modelOutput.fullStream;
+      } else {
+        const { structuredOutput, ...restAgentOptions } = agentOptions ?? {};
+        const baseOptions = {
+          ...restAgentOptions,
+          requestContext,
+          tracingContext,
+          onFinish: (result) => {
+            const resultWithObject = result;
+            if (structuredOutput?.schema && resultWithObject.object) {
+              structuredResult = resultWithObject.object;
+            }
+            streamPromise.resolve(result.text);
+            void agentOptions?.onFinish?.(result);
+          },
+          abortSignal
+        };
+        const modelOutput = structuredOutput ? await params.stream(inputData.prompt, {
+          ...baseOptions,
+          structuredOutput
+        }) : await params.stream(inputData.prompt, baseOptions);
+        stream = modelOutput.fullStream;
+        void modelOutput.text.then(streamPromise.resolve, streamPromise.reject);
+      }
+      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 }
+            });
+          }
+        }
+        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);
+        }
+      }
+      if (abortSignal.aborted) {
+        return abort();
+      }
+      if (structuredResult !== null) {
+        return structuredResult;
+      }
+      return {
+        text: await streamPromise.promise
+      };
+    },
+    component: "AGENT"
+  };
+}
+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,
+    description: params.description,
+    inputSchema: params.inputSchema,
+    outputSchema: params.outputSchema,
+    resumeSchema: params.resumeSchema,
+    suspendSchema: params.suspendSchema,
+    retries: toolOpts?.retries,
+    scorers: toolOpts?.scorers,
+    metadata: toolOpts?.metadata,
+    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,
+        result,
+        finishReason,
+        toolCalls,
+        text,
+        retryCount,
+        // inputStep phase fields for model/tools configuration
+        model,
+        tools,
+        toolChoice,
+        activeTools,
+        providerOptions,
+        modelSettings,
+        structuredOutput,
+        steps,
+        usage
+      } = 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,
+        result,
+        finishReason,
+        toolCalls,
+        text,
+        retryCount,
+        // inputStep phase fields for model/tools configuration
+        model,
+        tools,
+        toolChoice,
+        activeTools,
+        providerOptions,
+        modelSettings,
+        structuredOutput,
+        steps,
+        usage
+      };
+      const executePhaseWithSpan = async (fn) => {
+        try {
+          const result2 = await fn();
+          processorSpan?.end({ output: result2 });
+          return result2;
+        } 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 result2 = await processor.processInput({
+                ...baseContext,
+                messages,
+                messageList: passThrough.messageList,
+                systemMessages: systemMessages ?? [],
+                state: {}
+              });
+              if (result2 instanceof agent.MessageList) {
+                if (result2 !== 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: result2.get.all.db(),
+                  systemMessages: result2.getSystemMessages()
+                };
+              } else if (Array.isArray(result2)) {
+                processors.ProcessorRunner.applyMessagesToMessageList(
+                  result2,
+                  passThrough.messageList,
+                  idsBeforeProcessing,
+                  check,
+                  "input"
+                );
+                return { ...passThrough, messages: result2 };
+              } else if (result2 && "messages" in result2 && "systemMessages" in result2) {
+                const typedResult = result2;
+                processors.ProcessorRunner.applyMessagesToMessageList(
+                  typedResult.messages,
+                  passThrough.messageList,
+                  idsBeforeProcessing,
+                  check,
+                  "input"
+                );
+                passThrough.messageList.replaceAllSystemMessages(typedResult.systemMessages);
+                return {
+                  ...passThrough,
+                  messages: typedResult.messages,
+                  systemMessages: passThrough.messageList.getSystemMessages()
+                };
+              }
+              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 result2 = 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 ?? [],
+                state: {}
+              });
+              const validatedResult = await processors.ProcessorRunner.validateAndFormatProcessInputStepResult(result2, {
+                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,
+                systemMessages: passThrough.messageList.getSystemMessages()
+              };
+            }
+            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 result2;
+              try {
+                result2 = 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: result2 });
+                  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: result2 };
+            }
+            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 outputResult = passThrough.result ?? {
+                text: "",
+                usage: { inputTokens: 0, outputTokens: 0, totalTokens: 0 },
+                finishReason: "unknown",
+                steps: []
+              };
+              const processResult = await processor.processOutputResult({
+                ...baseContext,
+                messages,
+                messageList: passThrough.messageList,
+                state: passThrough.state ?? {},
+                result: outputResult
+              });
+              if (processResult instanceof agent.MessageList) {
+                if (processResult !== 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: processResult.get.all.db(),
+                  systemMessages: processResult.getSystemMessages()
+                };
+              } else if (Array.isArray(processResult)) {
+                processors.ProcessorRunner.applyMessagesToMessageList(
+                  processResult,
+                  passThrough.messageList,
+                  idsBeforeProcessing,
+                  check,
+                  "response"
+                );
+                return { ...passThrough, messages: processResult };
+              } else if (processResult && "messages" in processResult && "systemMessages" in processResult) {
+                const typedResult = processResult;
+                processors.ProcessorRunner.applyMessagesToMessageList(
+                  typedResult.messages,
+                  passThrough.messageList,
+                  idsBeforeProcessing,
+                  check,
+                  "response"
+                );
+                passThrough.messageList.replaceAllSystemMessages(typedResult.systemMessages);
+                return {
+                  ...passThrough,
+                  messages: typedResult.messages,
+                  systemMessages: passThrough.messageList.getSystemMessages()
+                };
+              }
+              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 defaultUsage = {
+                inputTokens: void 0,
+                outputTokens: void 0,
+                totalTokens: void 0
+              };
+              const result2 = await processor.processOutputStep({
+                ...baseContext,
+                messages,
+                messageList: passThrough.messageList,
+                stepNumber: stepNumber ?? 0,
+                finishReason,
+                toolCalls,
+                text,
+                usage: usage ?? defaultUsage,
+                systemMessages: systemMessages ?? [],
+                steps: steps ?? [],
+                state: {}
+              });
+              if (result2 instanceof agent.MessageList) {
+                if (result2 !== 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: result2.get.all.db(),
+                  systemMessages: result2.getSystemMessages()
+                };
+              } else if (Array.isArray(result2)) {
+                processors.ProcessorRunner.applyMessagesToMessageList(
+                  result2,
+                  passThrough.messageList,
+                  idsBeforeProcessing,
+                  check,
+                  "response"
+                );
+                return { ...passThrough, messages: result2 };
+              } else if (result2 && "messages" in result2 && "systemMessages" in result2) {
+                const typedResult = result2;
+                processors.ProcessorRunner.applyMessagesToMessageList(
+                  typedResult.messages,
+                  passThrough.messageList,
+                  idsBeforeProcessing,
+                  check,
+                  "response"
+                );
+                passThrough.messageList.replaceAllSystemMessages(typedResult.systemMessages);
+                return {
+                  ...passThrough,
+                  messages: typedResult.messages,
+                  systemMessages: passThrough.messageList.getSystemMessages()
+                };
+              }
+              return { ...passThrough, messages };
+            }
+            return { ...passThrough, messages };
+          }
+          default:
+            return { ...passThrough, messages };
+        }
+      });
+    },
+    component: "PROCESSOR"
+  };
+}
+function init(inngest) {
+  return {
+    createTool: tools.createTool,
+    createWorkflow(params) {
+      return new chunkMICZJLEE_cjs.InngestWorkflow(
+        params,
+        inngest
+      );
+    },
+    createStep,
+    cloneStep(step, opts) {
+      return {
+        id: opts.id,
+        description: step.description,
+        inputSchema: step.inputSchema,
+        outputSchema: step.outputSchema,
+        resumeSchema: step.resumeSchema,
+        suspendSchema: step.suspendSchema,
+        stateSchema: step.stateSchema,
+        metadata: step.metadata,
+        execute: step.execute,
+        retries: step.retries,
+        scorers: step.scorers,
+        component: step.component
+      };
+    },
+    cloneWorkflow(workflow, opts) {
+      const wf = new workflows.Workflow({
+        id: opts.id,
+        inputSchema: workflow.inputSchema,
+        outputSchema: workflow.outputSchema,
+        steps: workflow.stepDefs,
+        mastra: workflow.mastra,
+        options: workflow.options
+      });
+      wf.setStepFlow(workflow.stepGraph);
+      wf.commit();
+      return wf;
+    }
+  };
+}
+
+Object.defineProperty(exports, "InngestExecutionEngine", {
+  enumerable: true,
+  get: function () { return chunkMICZJLEE_cjs.InngestExecutionEngine; }
+});
+Object.defineProperty(exports, "InngestPubSub", {
+  enumerable: true,
+  get: function () { return chunkMICZJLEE_cjs.InngestPubSub; }
+});
+Object.defineProperty(exports, "InngestRun", {
+  enumerable: true,
+  get: function () { return chunkMICZJLEE_cjs.InngestRun; }
+});
+Object.defineProperty(exports, "InngestWorkflow", {
+  enumerable: true,
+  get: function () { return chunkMICZJLEE_cjs.InngestWorkflow; }
+});
+Object.defineProperty(exports, "connect", {
+  enumerable: true,
+  get: function () { return chunkMICZJLEE_cjs.connect; }
+});
+exports._compatibilityCheck = _compatibilityCheck;
+exports.createInngestAgent = createInngestAgent;
+exports.createInngestDurableAgenticWorkflow = createInngestDurableAgenticWorkflow;
+exports.createServe = createServe;
+exports.createStep = createStep;
+exports.init = init;
+exports.isInngestAgent = isInngestAgent;
+exports.serve = serve;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map