@mastra/inngest 1.10.2-alpha.0 → 1.10.2

package/dist/{src-Cc6OY9_U.js → src-D3sbOdZM.js}

@@ -16,6 +16,7 @@ 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 { deepMerge } from "@mastra/core/utils";
 import { PUBSUB_SYMBOL } from "@mastra/core/workflows/_constants";
 import { z } from "zod";
 //#region src/nested-workflow-output.ts
@@ -488,7 +489,10 @@ var InngestExecutionEngine = class extends DefaultExecutionEngine {
 				runId = globalThis.crypto.randomUUID();
 				result = {
 					status: "failed",
-					error: e instanceof Error ? e : new Error(String(e))
+					error: getErrorFromUnknown(e, {
+						serializeStack: true,
+						fallbackMessage: "Nested workflow failed"
+					})
 				};
 			}
 		}
@@ -1284,8 +1288,7 @@ var InngestRun = class extends Run {
 			snapshotForRollback = pendingSnapshot;
 		}
 		if (snapshot?.status === "running") throw new Error("This workflow run is still running, cannot time travel");
-		let inputDataToUse = params.inputData;
-		if (inputDataToUse && steps.length === 1) inputDataToUse = await this._validateTimetravelInputData(params.inputData, this.workflowSteps[steps[0]]);
+		const inputDataToUse = await this._resolveTimetravelInputData(params.inputData, steps);
 		const timeTravelData = createTimeTravelExecutionParams({
 			steps,
 			inputData: inputDataToUse,
@@ -2934,6 +2937,82 @@ function createInngestAgent(options) {
 				...reason !== void 0 ? { reason } : {}
 			}, resumeOptions);
 		},
+		async sendToolApproval(options) {
+			const { threadId, resourceId, approved, resumeData: customResumeData, declineContext, messages, streamOptions, ...executionOptions } = options;
+			if (messages && approved) {
+				const continuation = agentThreadStreamRuntime.continueWithMessages(proxyRef, messages, {
+					resourceId,
+					threadId,
+					runId: executionOptions.runId,
+					streamOptions: deepMerge(streamOptions ?? {}, executionOptions)
+				}, agent.getPubSub());
+				return {
+					accepted: continuation.accepted,
+					runId: continuation.runId,
+					toolCallId: options.toolCallId
+				};
+			}
+			let runId = executionOptions.runId ?? agent.getActiveThreadRunId({
+				threadId,
+				resourceId
+			});
+			if (!runId) {
+				let runs = [];
+				try {
+					({runs} = await agent.listSuspendedRuns({
+						threadId,
+						resourceId
+					}));
+				} catch (error) {
+					if (!(error instanceof MastraError) || error.id !== "AGENT_LIST_SUSPENDED_RUNS_NO_STORAGE") throw error;
+				}
+				const matchingRuns = options.toolCallId ? runs.filter((run) => run.toolCalls.some((toolCall) => toolCall.toolCallId === options.toolCallId)) : runs;
+				if (matchingRuns.length > 1) throw new MastraError({
+					id: "AGENT_SEND_TOOL_APPROVAL_AMBIGUOUS_SUSPENDED_RUNS",
+					domain: ErrorDomain.AGENT,
+					category: ErrorCategory.USER,
+					text: `Agent "${agent.name}" sendToolApproval() found ${matchingRuns.length} suspended runs for thread "${threadId}". Pass a toolCallId to disambiguate, or resume a specific run with approveToolCall()/declineToolCall() and an explicit runId.`,
+					details: {
+						threadId,
+						resourceId,
+						agentName: agent.name,
+						runIds: matchingRuns.map((run) => run.runId).join(", ")
+					}
+				});
+				runId = matchingRuns[0]?.runId;
+			}
+			if (!runId) throw new MastraError({
+				id: "AGENT_SEND_TOOL_APPROVAL_NO_ACTIVE_THREAD_RUN",
+				domain: ErrorDomain.AGENT,
+				category: ErrorCategory.USER,
+				text: `Agent "${agent.name}" sendToolApproval() could not find an active or suspended run for thread "${threadId}". The run may have already completed or been resumed.`,
+				details: {
+					threadId,
+					resourceId,
+					agentName: agent.name
+				}
+			});
+			const resumeData = customResumeData !== void 0 ? customResumeData : approved ? { approved } : {
+				approved,
+				...declineContext ?? {}
+			};
+			const resumeOptions = deepMerge(streamOptions ?? {}, executionOptions);
+			await proxyRef.resumeStream(resumeData, {
+				...resumeOptions,
+				runId,
+				...options.toolCallId ? { toolCallId: options.toolCallId } : {},
+				memory: {
+					...resumeOptions.memory ?? {},
+					thread: resumeOptions.memory?.thread ?? threadId,
+					resource: resumeOptions.memory?.resource ?? resourceId
+				}
+			});
+			return {
+				accepted: true,
+				runId,
+				toolCallId: options.toolCallId
+			};
+		},
 		async approveToolCallGenerate(options) {
 			const { runId, ...resumeOptions } = options;
 			if (!runId) throw new Error("approveToolCallGenerate() on InngestAgent requires a runId.");
@@ -3640,4 +3719,4 @@ function init(inngest) {
 //#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=src-Cc6OY9_U.js.map
+//# sourceMappingURL=src-D3sbOdZM.js.map