@mastra/inngest 1.9.1 → 1.9.2-alpha.0

package/dist/index.cjs

@@ -1,1434 +1,15 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_connect = require("./connect-B5ShyCfq.cjs");
-let _mastra_core_agent = require("@mastra/core/agent");
-let _mastra_core_error = require("@mastra/core/error");
-let _mastra_core_observability = require("@mastra/core/observability");
-let _mastra_core_processors = require("@mastra/core/processors");
-let _mastra_core_schema = require("@mastra/core/schema");
-let _mastra_core_tools = require("@mastra/core/tools");
-let _mastra_core_workflows = require("@mastra/core/workflows");
-let _mastra_core_agent_durable = require("@mastra/core/agent/durable");
-let inngest = require("inngest");
-let _mastra_core_events = require("@mastra/core/events");
-let inngest_hono = require("inngest/hono");
-let _mastra_core_cache = require("@mastra/core/cache");
-let _mastra_core_workflows__constants = require("@mastra/core/workflows/_constants");
-let zod = require("zod");
-//#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: require_connect.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 = createServe(inngest_hono.serve);
-//#endregion
-//#region src/types.ts
-const _compatibilityCheck = true;
-//#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 = 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: _mastra_core_agent_durable.modelConfigSchema,
-	options: zod.z.any(),
-	state: zod.z.any(),
-	messageId: zod.z.string(),
-	requestContextEntries: zod.z.record(zod.z.string(), zod.z.any()).optional(),
-	agentSpanData: zod.z.any().optional(),
-	modelSpanData: zod.z.any().optional(),
-	stepIndex: zod.z.number().optional()
-});
-/**
-* Iteration state schema - extends base with observability fields.
-*/
-const iterationStateSchema = _mastra_core_agent_durable.baseIterationStateSchema.extend({
-	agentSpanData: zod.z.any().optional(),
-	modelSpanData: zod.z.any().optional(),
-	stepIndex: zod.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}:${_mastra_core_agent_durable.DurableStepIds.AGENTIC_EXECUTION}`,
-	AGENTIC_LOOP: `${INNGEST_ENGINE_PREFIX}:${_mastra_core_agent_durable.DurableStepIds.AGENTIC_LOOP}`
-};
-function createInngestDurableAgenticWorkflow(options) {
-	const { inngest, maxSteps = _mastra_core_agent_durable.DurableAgentDefaults.MAX_STEPS, retries } = options;
-	const { createWorkflow } = init(inngest);
-	const llmExecutionStep = (0, _mastra_core_agent_durable.createDurableLLMExecutionStep)();
-	const toolCallStep = (0, _mastra_core_agent_durable.createDurableToolCallStep)();
-	const llmMappingStep = (0, _mastra_core_agent_durable.createDurableLLMMappingStep)();
-	const backgroundTaskCheckStep = (0, _mastra_core_agent_durable.createDurableBackgroundTaskCheckStep)();
-	const singleIterationWorkflow = createWorkflow({
-		id: InngestDurableStepIds.AGENTIC_EXECUTION,
-		retries,
-		inputSchema: iterationStateSchema,
-		outputSchema: iterationStateSchema,
-		options: {
-			tracingPolicy: { internal: _mastra_core_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,
-			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 (0, _mastra_core_agent_durable.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 {
-			...(0, _mastra_core_agent_durable.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: _mastra_core_agent_durable.durableAgenticOutputSchema,
-		options: {
-			tracingPolicy: { internal: _mastra_core_observability.InternalSpans.WORKFLOW },
-			shouldPersistSnapshot: ({ workflowStatus }) => workflowStatus === "suspended",
-			validateInputs: 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[_mastra_core_workflows__constants.PUBSUB_SYMBOL];
-		const lastStep = state.accumulatedSteps[state.accumulatedSteps.length - 1];
-		let finalText = lastStep?.text;
-		const finishResult = await (0, _mastra_core_agent_durable.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 (0, _mastra_core_agent_durable.emitFinishEvent)(pubsub, state.runId, {
-			output: finalOutput.output,
-			stepResult: finalOutput.stepResult
-		});
-		return finalOutput;
-	}, { id: "map-final-output" }).map(async ({ inputData, getInitData, mastra, requestContext, tracingContext }) => {
-		(0, _mastra_core_agent_durable.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 _mastra_core_events.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");
-/**
-* 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: inngest$1, 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: inngest$1,
-		retries
-	});
-	let _customCache = cache;
-	let innerPubsub = customPubsub ?? new require_connect.InngestPubSub(inngest$1, InngestDurableStepIds.AGENTIC_LOOP);
-	let _cachingPubsub = null;
-	function resolveCache() {
-		const resolved = _customCache ?? mastra?.serverCache ?? new _mastra_core_cache.InMemoryServerCache();
-		_customCache = resolved;
-		return resolved;
-	}
-	function getPubsub() {
-		if (!_cachingPubsub) if (innerPubsub instanceof _mastra_core_events.CachingPubSub) {
-			_cachingPubsub = innerPubsub;
-			_customCache = _customCache ?? mastra?.serverCache;
-		} else _cachingPubsub = new _mastra_core_events.CachingPubSub(innerPubsub, resolveCache());
-		return _cachingPubsub;
-	}
-	workflow.__setPubsubFactory((defaultPubsub) => {
-		if (defaultPubsub instanceof _mastra_core_events.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$1.send({
-			name: eventName,
-			data: require_connect.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 (0, _mastra_core_agent_durable.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 (0, _mastra_core_agent_durable.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$1;
-		},
-		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 (0, _mastra_core_agent_durable.runDurableStreamUntilIdle)(proxyRef, messages, {
-					...rest,
-					maxIdleMs
-				}, {
-					activeStreams: activeStreamUntilIdle,
-					bgManager: mastra?.backgroundTaskManager
-				});
-			}
-			const { runId, messageId, workflowInput, registryEntry, threadId, resourceId } = await (0, _mastra_core_agent_durable.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;
-			_mastra_core_agent_durable.globalRunRegistry.set(runId, registryEntry);
-			workflowInput.stepIndex = 0;
-			let cleanedUp = false;
-			const finalizeGlobalRegistry = () => {
-				if (cleanedUp) return;
-				cleanedUp = true;
-				_mastra_core_agent_durable.globalRunRegistry.delete(runId);
-			};
-			const { output, cleanup: streamCleanup, ready } = (0, _mastra_core_agent_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 (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 = _mastra_core_agent_durable.globalRunRegistry.get(runId);
-			if (trackedEntry) trackedEntry.workflowExecution = workflowExecution;
-			await _mastra_core_agent_durable.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 (0, _mastra_core_agent_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 = _mastra_core_agent_durable.globalRunRegistry.get(runId);
-			if (!existingEntry) {
-				existingEntry = {
-					isPlaceholder: true,
-					tools: {},
-					model: void 0
-				};
-				_mastra_core_agent_durable.globalRunRegistry.set(runId, existingEntry);
-			}
-			existingEntry.abortController = abortController;
-			existingEntry.abortSignal = abortController.signal;
-			let resumeCleanedUp = false;
-			const finalizeResumeRegistry = () => {
-				if (resumeCleanedUp) return;
-				resumeCleanedUp = true;
-				_mastra_core_agent_durable.globalRunRegistry.delete(runId);
-			};
-			const { output, cleanup: streamCleanup, ready } = (0, _mastra_core_agent_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 (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}`;
-			const dispatch = ready.then(async () => {
-				const snapshot = await (await mastra?.getStorage()?.getStore("workflows"))?.loadWorkflowSnapshot({
-					workflowName: InngestDurableStepIds.AGENTIC_LOOP,
-					runId
-				});
-				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 inngest.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 inngest.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 = require_connect.mergeResumeRequestContext(snapshot?.requestContext, resumeOptions?.requestContext);
-				const tracingOptions = snapshot?.tracingContext ? {
-					traceId: snapshot.tracingContext.traceId,
-					parentSpanId: snapshot.tracingContext.spanId
-				} : void 0;
-				await inngest$1.send({
-					name: eventName,
-					data: require_connect.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) => {
-				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 (0, _mastra_core_agent_durable.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 } = (0, _mastra_core_agent_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 = 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 _mastra_core_agent_durable.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 _mastra_core_agent_durable.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/index.ts
-function isInngestWorkflow(input) {
-	return input instanceof require_connect.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 _mastra_core_tools.Tool;
-}
-function isStepParams(input) {
-	return input !== null && typeof input === "object" && "id" in input && "execute" in input && !(input instanceof _mastra_core_agent.Agent) && !(input instanceof _mastra_core_tools.Tool) && !(input instanceof require_connect.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 _mastra_core_agent.Agent) && !(obj instanceof _mastra_core_tools.Tool) && !(obj instanceof require_connect.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: (0, _mastra_core_schema.toStandardSchema)(params.inputSchema),
-		stateSchema: params.stateSchema ? (0, _mastra_core_schema.toStandardSchema)(params.stateSchema) : void 0,
-		outputSchema: (0, _mastra_core_schema.toStandardSchema)(params.outputSchema),
-		resumeSchema: params.resumeSchema ? (0, _mastra_core_schema.toStandardSchema)(params.resumeSchema) : void 0,
-		suspendSchema: params.suspendSchema ? (0, _mastra_core_schema.toStandardSchema)(params.suspendSchema) : void 0,
-		scorers: params.scorers,
-		retries: params.retries,
-		metadata: params.metadata,
-		execute: params.execute.bind(params)
-	};
-}
-function createStepFromAgent(params, agentOrToolOptions) {
-	return (0, _mastra_core_workflows.createStepFromAgent)(params, agentOrToolOptions);
-}
-function createStepFromTool(params, agentOrToolOptions) {
-	return (0, _mastra_core_workflows.createStepFromTool)(params, agentOrToolOptions);
-}
-function createStepFromProcessor(processor) {
-	const getProcessorEntityType = (phase) => {
-		switch (phase) {
-			case "input": return _mastra_core_observability.EntityType.INPUT_PROCESSOR;
-			case "inputStep": return _mastra_core_observability.EntityType.INPUT_STEP_PROCESSOR;
-			case "outputStream":
-			case "outputResult": return _mastra_core_observability.EntityType.OUTPUT_PROCESSOR;
-			case "outputStep": return _mastra_core_observability.EntityType.OUTPUT_STEP_PROCESSOR;
-			default: return _mastra_core_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: _mastra_core_processors.ProcessorStepSchema,
-		outputSchema: _mastra_core_processors.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 _mastra_core_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(_mastra_core_observability.SpanType.MODEL_STEP) || currentSpan : currentSpan?.findParent(_mastra_core_observability.SpanType.AGENT_RUN) || currentSpan;
-			const processorSpan = phase !== "outputStream" ? parentSpan?.createChildSpan({
-				type: _mastra_core_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",
-					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 _mastra_core_processors.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 _mastra_core_agent.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 _mastra_core_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 _mastra_core_error.MastraError({
-								category: _mastra_core_error.ErrorCategory.USER,
-								domain: _mastra_core_error.ErrorDomain.MASTRA_WORKFLOW,
-								id: "PROCESSOR_MISSING_MESSAGE_LIST",
-								text: `Processor ${processor.id} requires messageList or messages for processInput phase`
-							});
-							const idsBeforeProcessing = messages.map((m) => m.id);
-							const check = passThrough.messageList.makeMessageSourceChecker();
-							const result = await processor.processInput({
-								...baseContext,
-								messages,
-								messageList: passThrough.messageList,
-								systemMessages: systemMessages ?? [],
-								state: processorState
-							});
-							if (result instanceof _mastra_core_agent.MessageList) {
-								if (result !== passThrough.messageList) throw new _mastra_core_error.MastraError({
-									category: _mastra_core_error.ErrorCategory.USER,
-									domain: _mastra_core_error.ErrorDomain.MASTRA_WORKFLOW,
-									id: "PROCESSOR_RETURNED_EXTERNAL_MESSAGE_LIST",
-									text: `Processor ${processor.id} returned a MessageList instance other than the one passed in. Use the messageList argument instead.`
-								});
-								return {
-									...passThrough,
-									messages: result.get.all.db(),
-									systemMessages: result.getSystemMessages()
-								};
-							} else if (Array.isArray(result)) {
-								_mastra_core_processors.ProcessorRunner.applyMessagesToMessageList(result, passThrough.messageList, idsBeforeProcessing, check, "input");
-								return {
-									...passThrough,
-									messages: result
-								};
-							} else if (result && "messages" in result && "systemMessages" in result) {
-								const typedResult = result;
-								_mastra_core_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 _mastra_core_error.MastraError({
-								category: _mastra_core_error.ErrorCategory.USER,
-								domain: _mastra_core_error.ErrorDomain.MASTRA_WORKFLOW,
-								id: "PROCESSOR_MISSING_MESSAGE_LIST",
-								text: `Processor ${processor.id} requires messageList or messages for processInputStep phase`
-							});
-							const idsBeforeProcessing = messages.map((m) => m.id);
-							const check = passThrough.messageList.makeMessageSourceChecker();
-							const result = await processor.processInputStep({
-								...baseContext,
-								messages,
-								messageList: passThrough.messageList,
-								stepNumber: stepNumber ?? 0,
-								systemMessages: systemMessages ?? [],
-								model,
-								tools,
-								toolChoice,
-								activeTools,
-								providerOptions,
-								modelSettings,
-								structuredOutput,
-								steps: steps ?? [],
-								state: processorState
-							});
-							const validatedResult = await _mastra_core_processors.ProcessorRunner.validateAndFormatProcessInputStepResult(result, {
-								messageList: passThrough.messageList,
-								processor,
-								stepNumber: stepNumber ?? 0
-							});
-							if (validatedResult.messages) _mastra_core_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 = processorState;
-							let processorSpan = mutableState[spanKey];
-							if (!processorSpan && parentSpan) {
-								processorSpan = parentSpan.createChildSpan({
-									type: _mastra_core_observability.SpanType.PROCESSOR_RUN,
-									name: `output stream processor: ${processor.id}`,
-									entityType: _mastra_core_observability.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 _mastra_core_agent.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 _mastra_core_error.MastraError({
-								category: _mastra_core_error.ErrorCategory.USER,
-								domain: _mastra_core_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: processorState,
-								result: outputResult
-							});
-							if (processResult instanceof _mastra_core_agent.MessageList) {
-								if (processResult !== passThrough.messageList) throw new _mastra_core_error.MastraError({
-									category: _mastra_core_error.ErrorCategory.USER,
-									domain: _mastra_core_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)) {
-								_mastra_core_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;
-								_mastra_core_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 _mastra_core_error.MastraError({
-								category: _mastra_core_error.ErrorCategory.USER,
-								domain: _mastra_core_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 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 _mastra_core_agent.MessageList) {
-								if (result !== passThrough.messageList) throw new _mastra_core_error.MastraError({
-									category: _mastra_core_error.ErrorCategory.USER,
-									domain: _mastra_core_error.ErrorDomain.MASTRA_WORKFLOW,
-									id: "PROCESSOR_RETURNED_EXTERNAL_MESSAGE_LIST",
-									text: `Processor ${processor.id} returned a MessageList instance other than the one passed in. Use the messageList argument instead.`
-								});
-								return {
-									...passThrough,
-									messages: result.get.all.db(),
-									systemMessages: result.getSystemMessages()
-								};
-							} else if (Array.isArray(result)) {
-								_mastra_core_processors.ProcessorRunner.applyMessagesToMessageList(result, passThrough.messageList, idsBeforeProcessing, check, "response");
-								return {
-									...passThrough,
-									messages: result
-								};
-							} else if (result && "messages" in result && "systemMessages" in result) {
-								const typedResult = result;
-								_mastra_core_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: _mastra_core_tools.createTool,
-		createWorkflow(params) {
-			return new require_connect.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 _mastra_core_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;
-		}
-	};
-}
-//#endregion
-exports.InngestExecutionEngine = require_connect.InngestExecutionEngine;
-exports.InngestPubSub = require_connect.InngestPubSub;
-exports.InngestRun = require_connect.InngestRun;
-exports.InngestWorkflow = require_connect.InngestWorkflow;
-exports._compatibilityCheck = _compatibilityCheck;
-exports.connect = require_connect.connect;
-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
+const require_src = require("./src-EDtPitm-.cjs");
+exports.InngestExecutionEngine = require_src.InngestExecutionEngine;
+exports.InngestPubSub = require_src.InngestPubSub;
+exports.InngestRun = require_src.InngestRun;
+exports.InngestWorkflow = require_src.InngestWorkflow;
+exports._compatibilityCheck = require_src._compatibilityCheck;
+exports.connect = require_src.connect;
+exports.createInngestAgent = require_src.createInngestAgent;
+exports.createInngestDurableAgenticWorkflow = require_src.createInngestDurableAgenticWorkflow;
+exports.createServe = require_src.createServe;
+exports.createStep = require_src.createStep;
+exports.init = require_src.init;
+exports.isInngestAgent = require_src.isInngestAgent;
+exports.serve = require_src.serve;