@mastra/inngest 1.9.1 → 1.9.2-alpha.1

package/dist/{connect-DbsoIp0h.js → src-CVg0ITpU.js}

@@ -1,16 +1,24 @@
-import { MastraNonRetryableError, getErrorFromUnknown } from "@mastra/core/error";
-import { EntityType, SpanType } from "@mastra/core/observability";
-import { DefaultExecutionEngine, Run, Workflow, createTimeTravelExecutionParams, getEntryWorkflow, hydrateSerializedStepErrors, isSingleStepEntry } from "@mastra/core/workflows";
+import { Agent, MessageList, TripWire } from "@mastra/core/agent";
+import { ErrorCategory, ErrorDomain, MastraError, MastraNonRetryableError, getErrorFromUnknown } from "@mastra/core/error";
+import { EntityType, InternalSpans, SpanType } from "@mastra/core/observability";
+import { ProcessorRunner, ProcessorState, ProcessorStepOutputSchema, ProcessorStepSchema } from "@mastra/core/processors";
+import { toStandardSchema } from "@mastra/core/schema";
+import { Tool, createTool } from "@mastra/core/tools";
+import { DefaultExecutionEngine, Run, Workflow, createStepFromAgent, createStepFromTool, createTimeTravelExecutionParams, getEntryWorkflow, hydrateSerializedStepErrors, isSingleStepEntry } from "@mastra/core/workflows";
 import { randomUUID } from "crypto";
-import { emitErrorEvent } from "@mastra/core/agent/durable";
+import { AGENT_STREAM_TOPIC, DurableAgentDefaults, DurableStepIds, agentThreadStreamRuntime, baseIterationStateSchema, createBaseIterationStateUpdate, createDurableAgentStream, createDurableBackgroundTaskCheckStep, createDurableLLMExecutionStep, createDurableLLMMappingStep, createDurableToolCallStep, durableAgenticOutputSchema, emitErrorEvent, emitFinishEvent, executeDurableAgentScorers, globalRunRegistry, modelConfigSchema, prepareForDurableExecution, publishAbortRequest, resolveDurableToolCallConcurrency, runDurableFinishSideEffects, runDurableStreamUntilIdle, runResumeDurableStreamUntilIdle } from "@mastra/core/agent/durable";
 import { RequestContext } from "@mastra/core/di";
 import { NonRetriableError } from "inngest";
 import { AsyncLocalStorage } from "async_hooks";
-import { PubSub } from "@mastra/core/events";
+import { CachingPubSub, PubSub } from "@mastra/core/events";
 import { subscribe } from "inngest/realtime";
 import { ReadableStream } from "stream/web";
 import { ChunkFrom, WorkflowRunOutput } from "@mastra/core/stream";
 import { MASTRA_AUTH_TOKEN_KEY } from "@mastra/core/request-context";
+import { serve } from "inngest/hono";
+import { InMemoryServerCache } from "@mastra/core/cache";
+import { PUBSUB_SYMBOL } from "@mastra/core/workflows/_constants";
+import { z } from "zod";
 //#region src/nested-workflow-output.ts
 const NESTED_WORKFLOW_OUTPUT_MODE = {
 	DEFAULT: "default",
@@ -77,6 +85,15 @@ function isNonRetryableStepFailure(error) {
 	return false;
 }
 const retryCountStorage = new AsyncLocalStorage();
+const BUILTIN_ERROR_TYPES = [
+	TypeError,
+	RangeError,
+	ReferenceError,
+	SyntaxError,
+	EvalError,
+	URIError,
+	AggregateError
+];
 var InngestExecutionEngine = class extends DefaultExecutionEngine {
 	parentStream;
 	inngestStep;
@@ -120,8 +137,9 @@ var InngestExecutionEngine = class extends DefaultExecutionEngine {
 	}
 	/**
 	* Execute a step with retry logic for Inngest.
-	* Retries are handled via step-level retry (RetryAfterError thrown INSIDE step.run()).
-	* After retries exhausted, error propagates here and we return a failed result.
+	* Each attempt is its own step.run() that fails as NonRetriableError, so Inngest never
+	* retries step code; this loop owns the retries. After retries are exhausted we return
+	* a failed result instead of rethrowing.
 	*/
 	async executeStepWithRetry(stepId, runStep, params) {
 		for (let i = 0; i < params.retries + 1; i++) {
@@ -129,12 +147,12 @@ var InngestExecutionEngine = class extends DefaultExecutionEngine {
 			try {
 				return {
 					ok: true,
-					result: await retryCountStorage.run(i, () => this.wrapDurableOperation(stepId, runStep))
+					result: await retryCountStorage.run(i, () => this.runDurably(stepId, runStep, NonRetriableError))
 				};
 			} catch (e) {
-				const isNonRetryable = isNonRetryableStepFailure(e);
+				const cause = e?.cause;
+				const isNonRetryable = isNonRetryableStepFailure(cause?.status === "failed" ? cause : e);
 				if (isNonRetryable || i === params.retries) {
-					const cause = e?.cause;
 					if (cause?.status === "failed") {
 						params.stepSpan?.error({
 							error: e,
@@ -201,23 +219,39 @@ var InngestExecutionEngine = class extends DefaultExecutionEngine {
 	* 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.
+	*
+	* Failures here stay retriable, so a non-zero function-level `retries` covers
+	* transient errors in these operations (spans, event publishing, conditions).
 	*/
 	async wrapDurableOperation(operationId, operationFn) {
+		return this.runDurably(operationId, operationFn, Error);
+	}
+	/**
+	* Runs `operationFn` in step.run() and throws failures as `ErrorType` with the
+	* serialized failure in the cause. Step code passes NonRetriableError because Inngest
+	* applies the function-level `retries` to every step.run() that throws, and step
+	* retries are already handled by executeStepWithRetry.
+	*/
+	async runDurably(operationId, operationFn, ErrorType) {
 		return await this.inngestStep.run(operationId, async () => {
 			try {
 				return await operationFn();
 			} catch (e) {
 				const errorInstance = getErrorFromUnknown(e, {
-					serializeStack: false,
+					serializeStack: true,
 					fallbackMessage: "Unknown step execution error"
 				});
 				const isNonRetryable = isNonRetryableStepFailure(e);
-				throw new Error(errorInstance.message, { cause: {
+				const wrapped = new ErrorType(errorInstance.message, { cause: {
 					status: "failed",
 					error: errorInstance,
 					endedAt: Date.now(),
 					...isNonRetryable && { nonRetryable: true }
 				} });
+				if (errorInstance.stack) wrapped.stack = errorInstance.stack;
+				const builtinErrorType = e instanceof Error ? BUILTIN_ERROR_TYPES.find((BuiltinType) => Object.getPrototypeOf(e) === BuiltinType.prototype) : void 0;
+				if (builtinErrorType) Object.setPrototypeOf(wrapped, builtinErrorType.prototype);
+				throw wrapped;
 			}
 		});
 	}
@@ -245,6 +279,7 @@ var InngestExecutionEngine = class extends DefaultExecutionEngine {
 	async createStepSpan(params) {
 		const { executionContext, operationId, options, parentSpan } = params;
 		const parentSpanId = parentSpan?.id ?? executionContext.tracingIds?.workflowSpanId;
+		if (!this.mastra?.observability?.getSelectedInstance({})) return void 0;
 		const exportedSpan = await this.wrapDurableOperation(operationId, async () => {
 			const observability = this.mastra?.observability?.getSelectedInstance({});
 			if (!observability) return void 0;
@@ -284,6 +319,7 @@ var InngestExecutionEngine = class extends DefaultExecutionEngine {
 	async createChildSpan(params) {
 		const { executionContext, operationId, options, parentSpan } = params;
 		const parentSpanId = parentSpan?.id ?? executionContext.tracingIds?.workflowSpanId;
+		if (!this.mastra?.observability?.getSelectedInstance({})) return void 0;
 		const exportedSpan = await this.wrapDurableOperation(operationId, async () => {
 			const observability = this.mastra?.observability?.getSelectedInstance({});
 			if (!observability) return void 0;
@@ -1962,18 +1998,947 @@ function toSnapshotResult(output) {
 	return output;
 }
 //#endregion
+//#region src/durable-agent/create-inngest-agentic-workflow.ts
+/**
+* Input schema for the durable agentic workflow.
+* Extends base with observability fields for Inngest.
+*/
+const durableAgenticInputSchema = z.object({
+	runId: z.string(),
+	agentId: z.string(),
+	agentName: z.string().optional(),
+	messageListState: z.any(),
+	toolsMetadata: z.array(z.any()),
+	modelConfig: modelConfigSchema,
+	options: z.any(),
+	state: z.any(),
+	messageId: z.string(),
+	requestContextEntries: z.record(z.string(), z.any()).optional(),
+	agentSpanData: z.any().optional(),
+	modelSpanData: z.any().optional(),
+	stepIndex: z.number().optional()
+});
+/**
+* Iteration state schema - extends base with observability fields.
+*/
+const iterationStateSchema = baseIterationStateSchema.extend({
+	agentSpanData: z.any().optional(),
+	modelSpanData: z.any().optional(),
+	stepIndex: z.number()
+});
+/**
+* Create a durable agentic workflow using Inngest.
+*
+* This workflow implements the agentic loop pattern in a durable way using
+* Inngest's execution engine:
+*
+* 1. LLM Execution Step - Calls the LLM and gets response/tool calls
+* 2. Tool Call Steps (foreach) - Executes each tool call individually with suspend support
+* 3. LLM Mapping Step - Merges tool results back into state
+* 4. Loop - Continues if more tool calls are needed (dowhile)
+*
+* All state flows through workflow input/output, making it durable across
+* process restarts and execution engine replays.
+*
+* @param options - Configuration options
+* @returns An InngestWorkflow instance that implements the agentic loop
+*/
+/** Prefix for Inngest engine workflow IDs to avoid collision with other engines */
+const INNGEST_ENGINE_PREFIX = "inngest";
+/** Inngest-prefixed workflow IDs */
+const InngestDurableStepIds = {
+	AGENTIC_EXECUTION: `${INNGEST_ENGINE_PREFIX}:${DurableStepIds.AGENTIC_EXECUTION}`,
+	AGENTIC_LOOP: `${INNGEST_ENGINE_PREFIX}:${DurableStepIds.AGENTIC_LOOP}`
+};
+function createInngestDurableAgenticWorkflow(options) {
+	const { inngest, maxSteps = DurableAgentDefaults.MAX_STEPS, retries } = options;
+	const { createWorkflow } = init(inngest);
+	const llmExecutionStep = createDurableLLMExecutionStep();
+	const toolCallStep = createDurableToolCallStep();
+	const llmMappingStep = createDurableLLMMappingStep();
+	const backgroundTaskCheckStep = createDurableBackgroundTaskCheckStep();
+	const singleIterationWorkflow = createWorkflow({
+		id: InngestDurableStepIds.AGENTIC_EXECUTION,
+		retries,
+		inputSchema: iterationStateSchema,
+		outputSchema: iterationStateSchema,
+		options: {
+			tracingPolicy: { internal: InternalSpans.WORKFLOW },
+			shouldPersistSnapshot: ({ workflowStatus }) => workflowStatus === "suspended",
+			evaluatePersistencePredicateBeforeDurableOperation: true,
+			validateInputs: false,
+			emitStepEvents: 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,
+			requestContextEntries: state.requestContextEntries,
+			agentSpanData: state.agentSpanData,
+			modelSpanData: state.modelSpanData,
+			stepIndex: state.stepIndex
+		};
+	}, { id: "map-to-llm-input" }).then(llmExecutionStep).map(async ({ inputData }) => {
+		const llmOutput = inputData;
+		return (llmOutput.toolCalls ?? []).map((toolCall) => ({
+			...toolCall,
+			stepSpanData: llmOutput.stepSpanData
+		}));
+	}, { id: "extract-tool-calls" }).foreach(toolCallStep, { concurrency: ({ inputData, getInitData }) => {
+		const state = getInitData();
+		return resolveDurableToolCallConcurrency({
+			options: state?.options,
+			toolsMetadata: state?.toolsMetadata,
+			toolCalls: inputData
+		});
+	} }).map(async ({ inputData, getStepResult, getInitData }) => {
+		const toolResults = inputData;
+		const llmOutput = getStepResult(llmExecutionStep.id);
+		const initData = getInitData();
+		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();
+		return {
+			...createBaseIterationStateUpdate({
+				currentState: initData,
+				executionOutput
+			}),
+			agentSpanData: initData.agentSpanData,
+			modelSpanData: initData.modelSpanData,
+			stepIndex: initData.stepIndex + 1
+		};
+	}, { id: "update-iteration-state" }).commit();
+	return createWorkflow({
+		id: InngestDurableStepIds.AGENTIC_LOOP,
+		retries,
+		inputSchema: durableAgenticInputSchema,
+		outputSchema: durableAgenticOutputSchema,
+		options: {
+			tracingPolicy: { internal: InternalSpans.WORKFLOW },
+			shouldPersistSnapshot: ({ workflowStatus }) => workflowStatus === "suspended",
+			evaluatePersistencePredicateBeforeDurableOperation: true,
+			validateInputs: false,
+			emitStepEvents: false
+		},
+		steps: []
+	}).map(async ({ inputData }) => {
+		const input = inputData;
+		const agentSpanData = input.agentSpanData;
+		const modelSpanData = input.modelSpanData;
+		return {
+			...input,
+			iterationCount: 0,
+			accumulatedSteps: [],
+			accumulatedUsage: {
+				inputTokens: 0,
+				outputTokens: 0,
+				totalTokens: 0
+			},
+			lastStepResult: void 0,
+			agentSpanData,
+			modelSpanData,
+			stepIndex: input.stepIndex ?? 0
+		};
+	}, { 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, requestContext, tracingContext } = params;
+		const state = inputData;
+		const initData = params.getInitData();
+		const pubsub = params[PUBSUB_SYMBOL];
+		const lastStep = state.accumulatedSteps[state.accumulatedSteps.length - 1];
+		let finalText = lastStep?.text;
+		const finishResult = await runDurableFinishSideEffects({
+			runId: state.runId,
+			initData,
+			messageListState: state.messageListState,
+			mastra,
+			requestContext,
+			tracingContext,
+			logger: mastra?.getLogger?.(),
+			outputResult: {
+				text: finalText ?? "",
+				usage: state.accumulatedUsage,
+				finishReason: state.lastStepResult?.reason ?? "unknown",
+				steps: state.accumulatedSteps
+			}
+		});
+		if (lastStep && finishResult.outputText && finishResult.outputText !== (finalText ?? "")) {
+			lastStep.text = finishResult.outputText;
+			finalText = finishResult.outputText;
+		}
+		const finalOutput = {
+			messageListState: finishResult.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) (observability?.rebuildSpan(state.modelSpanData))?.createTracker()?.endGeneration({
+			output: { text: finalText },
+			attributes: { finishReason: state.lastStepResult?.reason || "stop" },
+			usage: state.accumulatedUsage
+		});
+		if (state.agentSpanData) (observability?.rebuildSpan(state.agentSpanData))?.end({ output: { text: finalText } });
+		if (pubsub) await emitFinishEvent(pubsub, state.runId, {
+			output: finalOutput.output,
+			stepResult: finalOutput.stepResult
+		});
+		return finalOutput;
+	}, { id: "map-final-output" }).map(async ({ inputData, getInitData, mastra, requestContext, tracingContext }) => {
+		executeDurableAgentScorers({
+			initData: getInitData(),
+			finalOutput: inputData,
+			mastra,
+			requestContext,
+			tracingContext
+		});
+		return inputData;
+	}, { id: "execute-scorers" }).commit();
+}
+//#endregion
+//#region src/durable-agent/create-inngest-agent.ts
+var InngestWorkflowCachingPubSub = class extends CachingPubSub {
+	publish(topic, event, options) {
+		if (topic.startsWith("workflow.events.v2.")) return super.publish(topic, event, {
+			...options,
+			localOnly: true
+		});
+		return super.publish(topic, event, options);
+	}
+};
+/**
+* Internal sentinel used by {@link InngestAgent.generate} and
+* {@link InngestAgent.resumeGenerate} to ask the underlying `stream()` /
+* `resume()` implementation to close the consumer stream on a SUSPENDED
+* event, so `getFullOutput()` resolves promptly with `finishReason:
+* 'suspended'` instead of waiting for FINISH/ERROR.
+*
+* Modelled on `CLOSE_ON_SUSPEND` in core `DurableAgent`.
+*/
+const CLOSE_ON_SUSPEND = Symbol("mastra.durable.inngest.closeOnSuspend");
+/**
+* Internal symbol used by `generate()` / `resumeGenerate()` to tear down the
+* pubsub subscription on suspend without removing the run-registry entry.
+* The public `cleanup()` does both; this lets the generate wrappers keep the
+* registry alive across `suspend` → `resumeGenerate()` while still releasing
+* the local stream subscription.
+*/
+const STREAM_CLEANUP = Symbol("mastra.durable.inngest.streamCleanup");
+const RESUME_SNAPSHOT_WAIT_MS = 1e4;
+const RESUME_SNAPSHOT_POLL_MS = 100;
+/**
+* Create an Inngest-powered durable agent from a Mastra Agent.
+*
+* This factory function wraps a regular Mastra Agent with Inngest's durable
+* execution capabilities. The returned InngestAgent can be registered with
+* Mastra, and the required workflow will be automatically registered.
+*
+* @param options - Configuration options
+* @returns An InngestAgent that can be registered with Mastra
+*
+* @example
+* ```typescript
+* const agent = new Agent({
+*   id: 'my-agent',
+*   instructions: 'You are helpful',
+*   model: openai('gpt-4'),
+* });
+*
+* const durableAgent = createInngestAgent({ agent, inngest });
+*
+* const mastra = new Mastra({
+*   agents: { myAgent: durableAgent },
+* });
+* ```
+*/
+function createInngestAgent(options) {
+	const { agent, inngest, id: idOverride, name: nameOverride, pubsub: customPubsub, cache, mastra: mastraOption, shouldPersistSnapshot, retries } = options;
+	if (shouldPersistSnapshot) console.warn(`InngestAgent '${idOverride ?? agent.id}': ignoring the shouldPersistSnapshot option. Inngest's step memoization/replay owns durability, so InngestAgent always persists 'suspended' snapshots only (for human-in-the-loop resume).`);
+	const agentId = idOverride ?? agent.id;
+	const agentName = nameOverride ?? agent.name;
+	let mastra = mastraOption;
+	const activeStreamUntilIdle = /* @__PURE__ */ new Map();
+	let proxyRef;
+	const workflow = createInngestDurableAgenticWorkflow({
+		inngest,
+		retries
+	});
+	let _customCache = cache;
+	let innerPubsub = customPubsub ?? new InngestPubSub(inngest, InngestDurableStepIds.AGENTIC_LOOP);
+	let _cachingPubsub = null;
+	function resolveCache() {
+		const resolved = _customCache ?? mastra?.serverCache ?? new InMemoryServerCache();
+		_customCache = resolved;
+		return resolved;
+	}
+	function getPubsub() {
+		if (!_cachingPubsub) if (innerPubsub instanceof CachingPubSub) {
+			_cachingPubsub = innerPubsub;
+			_customCache = _customCache ?? mastra?.serverCache;
+		} else _cachingPubsub = new CachingPubSub(innerPubsub, resolveCache());
+		return _cachingPubsub;
+	}
+	async function getPubsubOffset(runId) {
+		return (await getPubsub().getHistory(AGENT_STREAM_TOPIC(runId))).length;
+	}
+	workflow.__setPubsubFactory((defaultPubsub) => {
+		if (defaultPubsub instanceof CachingPubSub) return defaultPubsub;
+		getPubsub();
+		return new InngestWorkflowCachingPubSub(defaultPubsub, resolveCache());
+	});
+	function getCache() {
+		getPubsub();
+		return _customCache;
+	}
+	/**
+	* Trigger the workflow via Inngest event
+	*/
+	async function triggerWorkflow(runId, workflowInput, tracingOptions, actor) {
+		const eventName = `workflow.${InngestDurableStepIds.AGENTIC_LOOP}`;
+		await inngest.send({
+			name: eventName,
+			data: buildDurableTriggerEventData({
+				inputData: workflowInput,
+				runId,
+				resourceId: workflowInput.state?.resourceId,
+				requestContext: workflowInput.requestContextEntries ?? {},
+				tracingOptions,
+				actor
+			})
+		});
+	}
+	/**
+	* Emit an error event to pubsub.
+	*
+	* Best-effort: callers fire-and-forget this on paths that are already
+	* failing, so an unreachable pubsub must not turn error reporting into an
+	* unhandled rejection.
+	*/
+	async function emitError(runId, error) {
+		try {
+			await emitErrorEvent(getPubsub(), runId, error);
+		} catch (publishError) {
+			mastra?.getLogger?.()?.warn?.("Failed to publish Inngest durable agent error event", {
+				agentId,
+				runId,
+				error: publishError instanceof Error ? publishError.message : String(publishError)
+			});
+		}
+	}
+	/**
+	* Stop a run in whichever worker is executing it.
+	*
+	* An Inngest agent's steps run on Inngest's infrastructure, essentially never
+	* in the process that called `stream()`. The local `AbortController` is
+	* therefore invisible to the step worker, and on its own `abort()` cannot
+	* stop anything. Publishing an abort request lets the worker flip its own
+	* controller and unwind the run gracefully, emitting the terminal stream
+	* event consumers wait on — which a hard workflow cancel would skip.
+	*
+	* Best-effort: the local abort has already happened, and a caller asking to
+	* stop a run should not get a rejection because the publish failed.
+	*/
+	async function requestRemoteAbort(runId) {
+		try {
+			await publishAbortRequest(getPubsub(), runId);
+		} catch (error) {
+			mastra?.getLogger?.()?.warn?.("Failed to publish Inngest durable agent abort request", {
+				agentId,
+				runId,
+				error: error instanceof Error ? error.message : String(error)
+			});
+		}
+	}
+	const result = new Proxy({
+		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 runDurableStreamUntilIdle(proxyRef, messages, {
+					...rest,
+					maxIdleMs
+				}, {
+					activeStreams: activeStreamUntilIdle,
+					bgManager: mastra?.backgroundTaskManager
+				});
+			}
+			const { runId, messageId, workflowInput, registryEntry, threadId, resourceId } = await prepareForDurableExecution({
+				agent,
+				messages,
+				options: streamOptions,
+				runId: streamOptions?.runId,
+				requestContext: streamOptions?.requestContext,
+				methodType: streamOptions?.__methodType ?? "stream",
+				mastra,
+				durableAgentId: agentId,
+				durableAgentName: agentName
+			});
+			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;
+			globalRunRegistry.set(runId, registryEntry);
+			workflowInput.stepIndex = 0;
+			let cleanedUp = false;
+			const finalizeGlobalRegistry = () => {
+				if (cleanedUp) return;
+				cleanedUp = true;
+				globalRunRegistry.delete(runId);
+			};
+			const { output, cleanup: streamCleanup, ready } = 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 (result) => {
+					try {
+						await streamOptions?.onFinish?.(result);
+					} 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 agentSpanData = workflowInput.agentSpanData;
+			const tracingOptions = agentSpanData?.traceId && agentSpanData?.id ? {
+				traceId: agentSpanData.traceId,
+				parentSpanId: agentSpanData.id
+			} : void 0;
+			const workflowExecution = ready.then(() => triggerWorkflow(runId, workflowInput, tracingOptions, streamOptions?.actor)).catch((error) => {
+				emitError(runId, error);
+			});
+			const trackedEntry = globalRunRegistry.get(runId);
+			if (trackedEntry) trackedEntry.workflowExecution = workflowExecution;
+			await agentThreadStreamRuntime.registerRun(proxyRef, output, streamOptions ?? {}, agent.getPubSub());
+			const cleanup = () => {
+				streamCleanup();
+				finalizeGlobalRegistry();
+			};
+			const abort = async (reason) => {
+				if (!abortController.signal.aborted) abortController.abort(reason);
+				await requestRemoteAbort(runId);
+			};
+			return {
+				output,
+				runId,
+				threadId,
+				resourceId,
+				cleanup,
+				abort,
+				get fullStream() {
+					return output.fullStream;
+				},
+				[STREAM_CLEANUP]: streamCleanup
+			};
+		},
+		async resume(runId, resumeData, resumeOptions) {
+			if (resumeOptions?.untilIdle) {
+				const { untilIdle, ...rest } = resumeOptions;
+				const maxIdleMs = typeof untilIdle === "object" ? untilIdle.maxIdleMs : void 0;
+				return runResumeDurableStreamUntilIdle(proxyRef, runId, resumeData, {
+					...rest,
+					maxIdleMs
+				}, {
+					activeStreams: activeStreamUntilIdle,
+					bgManager: mastra?.backgroundTaskManager
+				});
+			}
+			const existingRegistryEntry = globalRunRegistry.get(runId);
+			await (existingRegistryEntry?.workflowExecution)?.catch(() => {});
+			const resumeOffset = await getPubsubOffset(runId);
+			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 = existingRegistryEntry;
+			if (!existingEntry) {
+				existingEntry = {
+					isPlaceholder: true,
+					tools: {},
+					model: void 0
+				};
+				globalRunRegistry.set(runId, existingEntry);
+			}
+			existingEntry.abortController = abortController;
+			existingEntry.abortSignal = abortController.signal;
+			let resumeCleanedUp = false;
+			const finalizeResumeRegistry = () => {
+				if (resumeCleanedUp) return;
+				resumeCleanedUp = true;
+				globalRunRegistry.delete(runId);
+			};
+			const { output, cleanup: streamCleanup, ready } = createDurableAgentStream({
+				pubsub: getPubsub(),
+				runId,
+				offset: resumeOffset,
+				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 (result) => {
+					try {
+						await resumeOptions?.onFinish?.(result);
+					} 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}`;
+			let notResumable = false;
+			const dispatch = ready.then(async () => {
+				const workflowsStore = await mastra?.getStorage()?.getStore("workflows");
+				const loadSnapshot = async () => workflowsStore?.loadWorkflowSnapshot({
+					workflowName: InngestDurableStepIds.AGENTIC_LOOP,
+					runId
+				});
+				let snapshot = await loadSnapshot();
+				const deadline = Date.now() + RESUME_SNAPSHOT_WAIT_MS;
+				while (workflowsStore && snapshot?.status !== "suspended" && Date.now() < deadline) {
+					await new Promise((resolve) => setTimeout(resolve, RESUME_SNAPSHOT_POLL_MS));
+					snapshot = await loadSnapshot();
+				}
+				if (workflowsStore && snapshot?.status !== "suspended") {
+					notResumable = true;
+					throw new NonRetriableError(`Cannot resume run ${runId}: it is not suspended` + (snapshot?.status ? ` (status: ${snapshot.status}).` : " (no snapshot found)."));
+				}
+				const suspendedStepIds = snapshot?.suspendedPaths ? Object.keys(snapshot.suspendedPaths) : [];
+				const resumeLabels = snapshot?.resumeLabels ?? {};
+				const toolCallId = resumeOptions?.toolCallId;
+				const expandToLeafPath = (stepId) => {
+					const nestedPath = (snapshot?.context ?? {})[stepId]?.suspendPayload?.__workflow_meta?.path;
+					return Array.isArray(nestedPath) ? [stepId, ...nestedPath] : [stepId];
+				};
+				let steps;
+				if (toolCallId) {
+					const targetStepId = resumeLabels[toolCallId]?.stepId;
+					if (!targetStepId) {
+						const available = Object.keys(resumeLabels);
+						throw new NonRetriableError(`Cannot resume run ${runId}: no suspended tool call with id "${toolCallId}". ` + (available.length > 0 ? `Suspended tool call ids: ${available.join(", ")}.` : `No tool calls are currently suspended.`));
+					}
+					steps = expandToLeafPath(targetStepId);
+				} else {
+					const available = Object.keys(resumeLabels);
+					if (suspendedStepIds.length > 1 || available.length > 1) throw new NonRetriableError(`Cannot resume run ${runId}: more than one suspension is parked. Pass "toolCallId" to choose which suspended tool call to resume.` + (available.length > 0 ? ` Suspended tool call ids: ${available.join(", ")}.` : ""));
+					steps = suspendedStepIds[0] ? expandToLeafPath(suspendedStepIds[0]) : [];
+				}
+				const requestContext = mergeResumeRequestContext(snapshot?.requestContext, resumeOptions?.requestContext);
+				const tracingOptions = snapshot?.tracingContext ? {
+					traceId: snapshot.tracingContext.traceId,
+					parentSpanId: snapshot.tracingContext.spanId
+				} : void 0;
+				await inngest.send({
+					name: eventName,
+					data: buildDurableResumeEventData({
+						inputData: resumeData,
+						runId,
+						resourceId: resumeOptions?.resourceId,
+						requestContext,
+						tracingOptions,
+						actor: resumeOptions?.actor,
+						resume: {
+							steps,
+							resumePayload: resumeData,
+							resumePath: steps[0] ? snapshot?.suspendedPaths?.[steps[0]] : void 0
+						}
+					})
+				});
+			});
+			const workflowExecution = dispatch.catch((error) => {
+				if (!notResumable) emitError(runId, error);
+			});
+			existingEntry.workflowExecution = workflowExecution;
+			try {
+				await dispatch;
+			} catch (error) {
+				streamCleanup();
+				finalizeResumeRegistry();
+				throw error;
+			}
+			const abort = async (reason) => {
+				if (!abortController.signal.aborted) abortController.abort(reason);
+				await requestRemoteAbort(runId);
+			};
+			const cleanup = () => {
+				streamCleanup();
+				finalizeResumeRegistry();
+			};
+			return {
+				output,
+				get fullStream() {
+					return output.fullStream;
+				},
+				runId,
+				threadId: resumeOptions?.threadId,
+				resourceId: resumeOptions?.resourceId,
+				cleanup,
+				abort,
+				[STREAM_CLEANUP]: streamCleanup
+			};
+		},
+		async prepare(messages, prepareOptions) {
+			const preparation = await prepareForDurableExecution({
+				agent,
+				messages,
+				options: prepareOptions,
+				requestContext: prepareOptions?.requestContext,
+				mastra,
+				durableAgentId: agentId,
+				durableAgentName: agentName
+			});
+			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 } = 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 = async (_reason) => {
+				streamCleanup();
+				await requestRemoteAbort(runId);
+			};
+			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 result = await proxyRef.stream(messages, streamOpts);
+			let suspended = false;
+			try {
+				const fullOutput = await result.output.getFullOutput();
+				if (fullOutput.error) throw fullOutput.error;
+				suspended = fullOutput.finishReason === "suspended";
+				if (suspended) await globalRunRegistry.get(result.runId)?.workflowExecution;
+				if (!fullOutput.runId) fullOutput.runId = result.runId;
+				return fullOutput;
+			} finally {
+				if (suspended) {
+					const streamOnlyCleanup = result[STREAM_CLEANUP];
+					streamOnlyCleanup?.();
+				} else result.cleanup();
+			}
+		},
+		async resumeGenerate(runId, resumeData, resumeOptions) {
+			const { untilIdle, ...rest } = resumeOptions ?? {};
+			const result = await proxyRef.resume(runId, resumeData, {
+				...rest,
+				[CLOSE_ON_SUSPEND]: true
+			});
+			let suspended = false;
+			try {
+				const fullOutput = await result.output.getFullOutput();
+				if (fullOutput.error) throw fullOutput.error;
+				suspended = fullOutput.finishReason === "suspended";
+				if (suspended) await globalRunRegistry.get(result.runId)?.workflowExecution;
+				if (!fullOutput.runId) fullOutput.runId = result.runId;
+				return fullOutput;
+			} finally {
+				if (suspended) {
+					const streamOnlyCleanup = result[STREAM_CLEANUP];
+					streamOnlyCleanup?.();
+				} else result.cleanup();
+			}
+		},
+		async resumeStream(resumeData, streamOptions) {
+			const runId = streamOptions?.runId;
+			if (!runId) throw new Error("resumeStream() on InngestAgent requires a runId in streamOptions.");
+			const { runId: _runId, ...resumeOptions } = streamOptions;
+			return (await proxyRef.resume(runId, resumeData, {
+				...resumeOptions,
+				[CLOSE_ON_SUSPEND]: true
+			})).output;
+		},
+		async approveToolCall(options) {
+			return proxyRef.resumeStream({ approved: true }, options);
+		},
+		async declineToolCall(options) {
+			const { reason, ...resumeOptions } = options;
+			return proxyRef.resumeStream({
+				approved: false,
+				...reason !== void 0 ? { reason } : {}
+			}, resumeOptions);
+		},
+		async approveToolCallGenerate(options) {
+			const { runId, ...resumeOptions } = options;
+			if (!runId) throw new Error("approveToolCallGenerate() on InngestAgent requires a runId.");
+			return proxyRef.resumeGenerate(runId, { approved: true }, resumeOptions);
+		},
+		async declineToolCallGenerate(options) {
+			const { runId, reason, ...resumeOptions } = options;
+			if (!runId) throw new Error("declineToolCallGenerate() on InngestAgent requires a runId.");
+			return proxyRef.resumeGenerate(runId, {
+				approved: false,
+				...reason !== void 0 ? { reason } : {}
+			}, resumeOptions);
+		},
+		__fork() {
+			const { shouldPersistSnapshot: _ignored, ...forkOptions } = options;
+			return createInngestAgent({
+				...forkOptions,
+				agent: agent.__fork(),
+				pubsub: innerPubsub,
+				cache: _customCache,
+				mastra
+			});
+		},
+		getDurableWorkflows() {
+			return [workflow];
+		},
+		__setMastra(mastraInstance) {
+			mastra = mastraInstance;
+		}
+	}, {
+		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;
+	agent.__setThreadRuntimeAgent(result);
+	return result;
+}
+/**
+* Check if an object is an InngestAgent
+*/
+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";
+}
+//#endregion
 //#region src/functions.ts
 function collectInngestFunctions({ mastra, functions: userFunctions = [] }) {
-	const workflows = mastra.listWorkflows();
-	return [...Array.from(new Set(Object.values(workflows).flatMap((workflow) => {
-		if (workflow instanceof InngestWorkflow) {
-			workflow.__registerMastra(mastra);
-			return workflow.getFunctions();
+	/**
+	* Inngest agents share the same logical durable workflow IDs and resolve the
+	* concrete agent from the workflow input, so only the first registered
+	* agent's workflow needs to be served.
+	*/
+	const durableAgent = Object.values(mastra.listAgents()).find((agent) => isInngestAgent(agent));
+	const workflows = [...Object.values(mastra.listWorkflows()), ...durableAgent?.getDurableWorkflows() ?? []];
+	const workflowFunctions = /* @__PURE__ */ new Map();
+	for (const workflow of workflows) {
+		if (!(workflow instanceof InngestWorkflow)) continue;
+		workflow.__registerMastra(mastra);
+		for (const fn of workflow.getFunctions()) {
+			const functionId = fn.id();
+			if (!workflowFunctions.has(functionId)) workflowFunctions.set(functionId, fn);
 		}
-		return [];
-	}))), ...userFunctions];
+	}
+	return [...workflowFunctions.values(), ...userFunctions];
 }
 //#endregion
+//#region src/serve.ts
+/**
+* Collects workflow functions from Mastra and prepares serve options for inngest.
+*/
+function prepareServeOptions({ mastra, inngest, functions: userFunctions = [], registerOptions }) {
+	return {
+		...registerOptions,
+		client: inngest,
+		functions: collectInngestFunctions({
+			mastra,
+			functions: userFunctions
+		})
+	};
+}
+/**
+* Factory function to create a serve function with any inngest adapter.
+* Use this to integrate Mastra workflows with any framework supported by inngest.
+*
+* @example Express
+* ```ts
+* import { createServe } from '@mastra/inngest';
+* import { serve } from 'inngest/express';
+*
+* const serveExpress = createServe(serve);
+* app.use('/inngest/api', serveExpress({ mastra, inngest }));
+* ```
+*
+* @example Fastify
+* ```ts
+* import { createServe } from '@mastra/inngest';
+* import { serve } from 'inngest/fastify';
+*
+* const serveFastify = createServe(serve);
+* fastify.route({
+*   method: ['GET', 'POST', 'PUT'],
+*   handler: serveFastify({ mastra, inngest }),
+*   url: '/inngest/api',
+* });
+* ```
+*
+* @example Next.js
+* ```ts
+* // app/inngest/api/route.ts — file path determines the route URL
+* import { createServe } from '@mastra/inngest';
+* import { serve } from 'inngest/next';
+*
+* const serveNext = createServe(serve);
+* export const { GET, POST, PUT } = serveNext({ mastra, inngest });
+* ```
+*/
+function createServe(adapter) {
+	return (options) => {
+		return adapter(prepareServeOptions(options));
+	};
+}
+/**
+* Serve Mastra workflows with Hono (default).
+*
+* For other frameworks, use `createServe` with the appropriate inngest adapter.
+*
+* @example
+* ```ts
+* import { serve } from '@mastra/inngest';
+*
+* app.use('/inngest/api', async (c) => {
+*   return serve({ mastra, inngest })(c);
+* });
+* ```
+*/
+const serve$1 = createServe(serve);
+//#endregion
 //#region src/connect.ts
 /**
 * Connect Mastra workflows to Inngest using an outbound worker connection.
@@ -2013,6 +2978,514 @@ async function connect(options) {
 	});
 }
 //#endregion
-export { buildDurableResumeEventData as a, InngestPubSub as c, InngestRun as i, InngestExecutionEngine as l, collectInngestFunctions as n, buildDurableTriggerEventData as o, InngestWorkflow as r, mergeResumeRequestContext as s, connect as t };
+//#region src/types.ts
+const _compatibilityCheck = true;
+//#endregion
+//#region src/index.ts
+function isInngestWorkflow(input) {
+	return input instanceof InngestWorkflow;
+}
+/**
+* copied from @mastra/core/agent/subagent.ts for compatible
+*/
+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 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);
+}
+/**
+* Type guard to check if an object is a Processor.
+* A Processor must have an 'id' property and at least one processor method.
+*/
+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, agentOrToolOptions) {
+	if (isInngestWorkflow(params)) return params;
+	if (isAgentCompatible(params)) return createStepFromAgent$1(params, agentOrToolOptions);
+	if (isToolStep(params)) return createStepFromTool$1(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: toStandardSchema(params.inputSchema),
+		stateSchema: params.stateSchema ? toStandardSchema(params.stateSchema) : void 0,
+		outputSchema: toStandardSchema(params.outputSchema),
+		resumeSchema: params.resumeSchema ? toStandardSchema(params.resumeSchema) : void 0,
+		suspendSchema: params.suspendSchema ? toStandardSchema(params.suspendSchema) : void 0,
+		scorers: params.scorers,
+		retries: params.retries,
+		metadata: params.metadata,
+		execute: params.execute.bind(params)
+	};
+}
+function createStepFromAgent$1(params, agentOrToolOptions) {
+	return createStepFromAgent(params, agentOrToolOptions);
+}
+function createStepFromTool$1(params, agentOrToolOptions) {
+	return createStepFromTool(params, agentOrToolOptions);
+}
+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, processorStates, result, finishReason, toolCalls, text, retryCount, model, tools, toolChoice, activeTools, providerOptions, modelSettings, structuredOutput, steps, usage } = 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",
+					processorIndex: processor.processorIndex
+				}
+			}) : void 0;
+			const processorTracingContext = processorSpan ? { currentSpan: processorSpan } : tracingContext;
+			let processorState = {};
+			if (processorStates) {
+				let ps = processorStates.get(processor.id);
+				if (!ps) {
+					ps = new ProcessorState(processor.id);
+					processorStates.set(processor.id, ps);
+				}
+				processorState = ps.customState;
+			}
+			const baseContext = {
+				abort,
+				retryCount: retryCount ?? 0,
+				requestContext,
+				tracingContext: processorTracingContext
+			};
+			const passThrough = {
+				phase,
+				messageList: messageList ?? (Array.isArray(messages) ? new MessageList().add(messages, "input").addSystem(systemMessages ?? []) : void 0),
+				stepNumber,
+				systemMessages,
+				streamParts,
+				state: processorState,
+				processorStates,
+				result,
+				finishReason,
+				toolCalls,
+				text,
+				retryCount,
+				model,
+				tools,
+				toolChoice,
+				activeTools,
+				providerOptions,
+				modelSettings,
+				structuredOutput,
+				steps,
+				usage
+			};
+			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 ?? [],
+								state: processorState
+							});
+							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.getSystemMessages()
+								};
+							} 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: passThrough.messageList.getSystemMessages()
+								};
+							}
+							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 ?? [],
+								model,
+								tools,
+								toolChoice,
+								activeTools,
+								providerOptions,
+								modelSettings,
+								structuredOutput,
+								steps: steps ?? [],
+								state: processorState
+							});
+							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,
+								systemMessages: passThrough.messageList.getSystemMessages()
+							};
+						}
+						return {
+							...passThrough,
+							messages
+						};
+					case "outputStream":
+						if (processor.processOutputStream) {
+							const spanKey = `__outputStreamSpan_${processor.id}`;
+							const mutableState = processorState;
+							let processorSpan = mutableState[spanKey];
+							if (!processorSpan && parentSpan) {
+								processorSpan = 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] = processorSpan;
+							}
+							if (processorSpan) processorSpan.input = {
+								phase,
+								streamParts: streamParts ?? [],
+								totalChunks: (streamParts ?? []).length
+							};
+							const processorTracingContext = processorSpan ? { currentSpan: processorSpan } : baseContext.tracingContext;
+							let result;
+							try {
+								result = await processor.processOutputStream({
+									...baseContext,
+									tracingContext: processorTracingContext,
+									part,
+									streamParts: streamParts ?? [],
+									state: mutableState,
+									messageList: passThrough.messageList
+								});
+								if (part && part.type === "finish") {
+									processorSpan?.end({ output: result });
+									delete mutableState[spanKey];
+								}
+							} catch (error) {
+								if (error instanceof TripWire) processorSpan?.end({ output: { tripwire: error.message } });
+								else processorSpan?.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 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: processorState,
+								result: outputResult
+							});
+							if (processResult instanceof MessageList) {
+								if (processResult !== 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: processResult.get.all.db(),
+									systemMessages: processResult.getSystemMessages()
+								};
+							} else if (Array.isArray(processResult)) {
+								ProcessorRunner.applyMessagesToMessageList(processResult, passThrough.messageList, idsBeforeProcessing, check, "response");
+								return {
+									...passThrough,
+									messages: processResult
+								};
+							} else if (processResult && "messages" in processResult && "systemMessages" in processResult) {
+								const typedResult = processResult;
+								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 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 defaultUsage = {
+								inputTokens: void 0,
+								outputTokens: void 0,
+								totalTokens: void 0
+							};
+							const result = await processor.processOutputStep({
+								...baseContext,
+								messages,
+								messageList: passThrough.messageList,
+								stepNumber: stepNumber ?? 0,
+								finishReason,
+								toolCalls,
+								text,
+								usage: usage ?? defaultUsage,
+								systemMessages: systemMessages ?? [],
+								steps: steps ?? [],
+								state: processorState
+							});
+							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.getSystemMessages()
+								};
+							} 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: passThrough.messageList.getSystemMessages()
+								};
+							}
+							return {
+								...passThrough,
+								messages
+							};
+						}
+						return {
+							...passThrough,
+							messages
+						};
+					default: return {
+						...passThrough,
+						messages
+					};
+				}
+			});
+		},
+		component: "PROCESSOR"
+	};
+}
+function init(inngest) {
+	return {
+		createTool,
+		createWorkflow(params) {
+			return new 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 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;
+		}
+	};
+}
+//#endregion
+export { createServe as a, isInngestAgent as c, InngestRun as d, InngestPubSub as f, connect as i, createInngestDurableAgenticWorkflow as l, init as n, serve$1 as o, InngestExecutionEngine as p, _compatibilityCheck as r, createInngestAgent as s, createStep as t, InngestWorkflow as u };
 
-//# sourceMappingURL=connect-DbsoIp0h.js.map
+//# sourceMappingURL=src-CVg0ITpU.js.map