@oomol-lab/open-flow 0.1.0-beta.64 → 0.1.0-beta.66

package/dist/common/scheduler.js

@@ -9504,6 +9504,7 @@ var port = object({
 	nullable: boolean(),
 	handle: text
 });
+var workflowInputDefs = array(port.strict());
 var input = port.extend({ value: json.optional() });
 var group = object({
 	collapsed: boolean().optional(),
@@ -9661,6 +9662,11 @@ var managedFields = object({
 				messageHandle: text,
 				inputs: record$1(text, agentValue)
 			}).optional()
+		}),
+		strictObject({
+			kind: literal("workflow"),
+			flowId: text,
+			revisionId: text
 		})
 	])
 });
@@ -9769,6 +9775,12 @@ var base = {
 	timeoutMs: number().optional()
 };
 var node = union([
+	strictObject({
+		...base,
+		kind: literal("outputs"),
+		outputDefs: array(port.strict()),
+		outputMappings: inputs
+	}).omit({ inputs: true }),
 	object({
 		...base,
 		inputs: record$1(text, never()),
@@ -9801,6 +9813,11 @@ var node = union([
 		...trigger,
 		kind: literal("manual")
 	}),
+	strictObject({
+		...trigger,
+		kind: literal("start"),
+		inputDefs: workflowInputDefs
+	}),
 	strictObject({
 		...trigger,
 		kind: literal("error"),
@@ -9865,7 +9882,7 @@ var module = object({
 	imports: strings,
 	source: text
 });
-var document = preprocess(rejectRetiredDefinitions, object({
+var document = preprocess(normalizeDocument, object({
 	bindings: record$1(text, binding),
 	graph
 }));
@@ -9874,7 +9891,9 @@ object({
 		literal(2),
 		literal(4),
 		literal(5),
-		literal(6)
+		literal(6),
+		literal(7),
+		literal(8)
 	]),
 	document,
 	modules: record$1(text, module)
@@ -9882,13 +9901,19 @@ object({
 	kind: literal("open-flow-flow-revision"),
 	version: literal(1)
 });
-function rejectRetiredDefinitions(value) {
+function normalizeDocument(value) {
 	const candidate = record(value);
 	if (candidate.tasks !== void 0 && (candidate.tasks === null || typeof candidate.tasks !== "object" || Array.isArray(candidate.tasks) || Object.keys(candidate.tasks).length > 0)) throw new TypeError("Independent Task definitions are no longer supported.");
 	if (Object.values(record(record(candidate.graph).nodes)).some((candidateNode) => Object.hasOwn(record(candidateNode), "taskId"))) throw new TypeError("Task references are no longer supported.");
 	const subflows = candidate.subflows;
 	if (subflows !== void 0 && (subflows === null || typeof subflows !== "object" || Array.isArray(subflows) || Object.keys(subflows).length > 0)) throw new TypeError("Subflows are no longer supported.");
 	if (Object.values(record(record(candidate.graph).nodes)).some((candidateNode) => record(candidateNode).kind === "subflow")) throw new TypeError("Subflow nodes are no longer supported.");
+	if ([
+		"inputDefs",
+		"outputDefs",
+		"outputMappings"
+	].some((field) => Object.hasOwn(candidate, field))) throw new TypeError("Workflow interface configuration must belong to Start and Outputs nodes.");
+	if (Object.values(record(record(candidate.graph).nodes)).some((candidateNode) => record(candidateNode).kind == "start" && Object.hasOwn(record(candidateNode), "parameters"))) throw new TypeError("Legacy Start.parameters is unsupported; configure node.inputDefs.");
 	return value;
 }
 function record(value) {
@@ -10088,6 +10113,7 @@ function conditionOperands(node) {
 	}] : []])));
 }
 function nodeInputMappings(node) {
+	if (node.kind == "outputs") return node.outputMappings;
 	if (node.kind != "condition") return "inputs" in node ? node.inputs : {};
 	return Object.fromEntries(conditionOperands(node).flatMap(({ handle, operand }) => operand.kind == "source" ? [[handle, {
 		kind: "sources",
@@ -10243,6 +10269,17 @@ function selectConditionBranches(node, values) {
 function portsByHandle(ports) {
 	return Object.fromEntries(ports.flatMap((port) => "handle" in port ? [[port.handle, port]] : []));
 }
+function isTriggerNode(node) {
+	return [
+		"manual",
+		"start",
+		"error",
+		"webhook",
+		"cron",
+		"poll",
+		"integration"
+	].includes(node.kind);
+}
 //#endregion
 //#region src/flow/common/agent.ts
 var schema = lazy(() => union([boolean(), strictObject({
@@ -10515,6 +10552,7 @@ function triggerOutputDefinitions(trigger) {
 	switch (trigger.kind) {
 		case "error": return errorOutputs;
 		case "manual": return [];
+		case "start": return trigger.inputDefs;
 		case "cron": return cronOutputs;
 		case "poll":
 		case "integration": return trigger.definition.outputs;
@@ -10534,11 +10572,37 @@ function matchesTriggerOutputs(trigger, outputs) {
 	const ports = triggerOutputDefinitions(trigger);
 	return new Set(ports.map((port) => port.handle)).size === ports.length && Object.keys(outputs).length === ports.length && ports.every((port) => Object.hasOwn(outputs, port.handle) && (outputs[port.handle] === null && port.nullable || matchesSchema(outputs[port.handle], port.jsonSchema)));
 }
+/** Resolve caller-supplied Start parameters into the complete output snapshot used by execution. */
+function normalizeTriggerOutputs(trigger, outputs) {
+	if (!isJsonObject(outputs)) return;
+	const normalized = trigger.kind == "start" ? {
+		...outputs,
+		...Object.fromEntries(trigger.inputDefs.filter((port) => port.nullable && !Object.hasOwn(outputs, port.handle)).map((port) => [port.handle, null]))
+	} : outputs;
+	return matchesTriggerOutputs(trigger, normalized) ? normalized : void 0;
+}
 //#endregion
 //#region src/flow/common/graph.ts
 function isResolutionNode(node) {
 	return node?.kind == "approval" || node?.kind == "wait";
 }
+function nodeInputPorts(node) {
+	switch (node.kind) {
+		case "outputs": return portsByHandle(node.outputDefs);
+		case "condition": return conditionInputPorts(node);
+		case "value": return {};
+		case "task": return portsByHandle([...node.task.inputs, ...node.additionalInputs ?? []]);
+		case "approval":
+		case "wait": return portsByHandle(node.inputDefinitions);
+		case "cron":
+		case "integration":
+		case "poll":
+		case "error":
+		case "manual":
+		case "start":
+		case "webhook": return {};
+	}
+}
 function resolutionActions(node) {
 	return node.kind == "wait" ? ["continue"] : ["approve", "reject"];
 }
@@ -10563,6 +10627,12 @@ function resolutionOutputPorts(node) {
 		pending: objectPort({
 			inputs,
 			prompt: { type: "string" },
+			pageUrl: { type: "string" },
+			message: {
+				type: "string",
+				minLength: 1,
+				pattern: "\\S"
+			},
 			...Object.fromEntries(actions.map((action) => [`${action}Url`, { type: "string" }])),
 			expiresAt: { type: "string" }
 		}),
@@ -10576,6 +10646,7 @@ function resolutionOutputPorts(node) {
 }
 function nodeOutputPorts(node) {
 	switch (node.kind) {
+		case "outputs":
 		case "condition": return {};
 		case "value": return portsByHandle(node.values);
 		case "task": return portsByHandle(node.task.outputs);
@@ -10586,6 +10657,7 @@ function nodeOutputPorts(node) {
 		case "poll":
 		case "error":
 		case "manual":
+		case "start":
 		case "webhook": return triggerOutputPorts(node);
 	}
 }
@@ -10652,7 +10724,7 @@ var Dependencies = class {
 			stack.delete(id);
 		};
 		const ids = Object.keys(graph.nodes).toSorted();
-		for (const triggerId of ids.filter((id) => !("inputs" in graph.nodes[id]))) visit(triggerId);
+		for (const triggerId of ids.filter((id) => isTriggerNode(graph.nodes[id]))) visit(triggerId);
 		for (const id of ids) visit(id);
 		for (const edge of this.forward) {
 			const edges = this.incoming.get(edge.target) ?? [];
@@ -10727,7 +10799,7 @@ var Dependencies = class {
 	}
 	start(nodeId, outputs) {
 		for (const [id, node] of Object.entries(this.graph.nodes)) {
-			if ("inputs" in node) continue;
+			if (!isTriggerNode(node)) continue;
 			const state = this.state.nodes[id];
 			state.status = id == nodeId ? "completed" : "skipped";
 			if (id == nodeId) {
@@ -10875,12 +10947,28 @@ var waitCommentSchema = string().trim().refine((value) => [...value].length <= 2
 function normalizeWaitComment$1(value) {
 	return waitCommentSchema.parse(value) || null;
 }
+function withWaitNotificationMessage$1(value) {
+	const source = schemaObject(value);
+	if (source == null || source.pageUrl !== void 0 && source.message !== void 0) return value;
+	const pageUrl = source.pageUrl === void 0 ? source.continueUrl ?? source.approveUrl : source.pageUrl;
+	if (typeof pageUrl != "string" || typeof source.prompt != "string" || typeof source.expiresAt != "string") return value;
+	return {
+		...source,
+		pageUrl,
+		message: source.message === void 0 ? [
+			source.prompt,
+			`Expires at: ${source.expiresAt}`,
+			`Review request: ${pageUrl}`
+		].join("\n\n") : source.message
+	};
+}
 //#endregion
 //#region src/execution/common/scheduler.ts
+var withWaitNotificationMessage = withWaitNotificationMessage$1;
 var normalizeWaitComment = normalizeWaitComment$1;
 var PortValidationError = class extends Error {};
 function usesPending(graph, nodeId) {
-	return graph.edges.some((edge) => edge.source == nodeId && edge.sourceHandle == "pending") || Object.values(graph.nodes).some((node) => "inputs" in node && Object.values(node.inputs).some((mapping) => mapping.kind == "sources" && mapping.sources.some((source) => source.kind == "node" && source.nodeId == nodeId && source.output == "pending")));
+	return graph.edges.some((edge) => edge.source == nodeId && edge.sourceHandle == "pending") || Object.values(graph.nodes).some((node) => !isTriggerNode(node) && Object.values(nodeInputMappings(node)).some((mapping) => mapping.kind == "sources" && mapping.sources.some((source) => source.kind == "node" && source.nodeId == nodeId && source.output == "pending")));
 }
 var waitRetentionMs = 12e4;
 function nodeFailure(error, project) {
@@ -10889,19 +10977,11 @@ function nodeFailure(error, project) {
 		message: error instanceof Error ? error.message : String(error)
 	};
 }
-function nodePorts(node) {
-	switch (node.kind) {
-		case "condition": return conditionInputPorts(node);
-		case "value": return {};
-		case "task": return portsByHandle([...node.task.inputs, ...node.additionalInputs ?? []]);
-		case "approval":
-		case "wait": return portsByHandle(node.inputDefinitions);
-	}
-}
 function nodeTitle(node) {
 	if (node.name != null) return node.name;
 	switch (node.kind) {
 		case "condition": return;
+		case "outputs": return "Workflow Outputs";
 		case "value": return "Fixed Values";
 		case "task": return node.task.name;
 		case "approval": return "Approval";
@@ -10957,7 +11037,8 @@ function decodeFlowRunCheckpoint(input) {
 		"inputs",
 		"results",
 		"version",
-		"waits"
+		"waits",
+		...source.calls === void 0 ? [] : ["calls"]
 	], "Flow Run checkpoint");
 	if (source.version != 5) throw new Error("Flow Run checkpoint version is unsupported.");
 	const bindingValues = Object.fromEntries(Object.entries(checkpointRecord(source.bindingValues, "Checkpoint bindings")).map(([id, value]) => {
@@ -10981,7 +11062,14 @@ function decodeFlowRunCheckpoint(input) {
 		value: json$1(),
 		waitId: string().min(1),
 		pending: json$1().optional()
-	})).min(1).parse(source.waits);
+	})).parse(source.waits);
+	const calls = array(strictObject({
+		jobId: string().min(1),
+		nodeId: string().min(1),
+		childRunId: string().min(1),
+		input: record$1(string(), json$1())
+	})).parse(source.calls ?? []);
+	if (pendingWaits.length + calls.length == 0) throw new Error("Checkpoint has no pending execution.");
 	const agents = record$1(string(), strictObject({
 		invocationId: string().min(1),
 		input: record$1(string(), json$1()),
@@ -10995,6 +11083,10 @@ function decodeFlowRunCheckpoint(input) {
 		jobs.add(pending.jobId);
 		waits.add(pending.waitId);
 	}
+	for (const call of calls) {
+		if (jobs.has(call.jobId) || dependencies.nodes[call.nodeId]?.status != "running" || dependencies.nodes[call.nodeId]?.jobId != call.jobId || Object.values(results).some((result) => result.jobId == call.jobId)) throw new Error("Checkpoint call execution conflicts.");
+		jobs.add(call.jobId);
+	}
 	if (Object.values(dependencies.nodes).some((state) => state.status == "running" && !jobs.has(state.jobId))) throw new Error("Checkpoint dependency has no waiting execution.");
 	if (Object.keys(agents).some((id) => !jobs.has(id))) throw new Error("Checkpoint Agent has no waiting execution.");
 	return {
@@ -11005,7 +11097,8 @@ function decodeFlowRunCheckpoint(input) {
 		inputs,
 		results,
 		version: 5,
-		waits: pendingWaits
+		waits: pendingWaits,
+		...source.calls === void 0 ? {} : { calls }
 	};
 }
 function jsonEqual(left, right) {
@@ -11057,14 +11150,14 @@ function agentApproval(config, checkpoint, inputs) {
 }
 function validateOutputs(nodeId, node, value) {
 	const raw = outputRecord(value, nodeId);
-	const discardUndeclared = node.kind == "task" && "executor" in node.task && node.task.executor.kind == "connector";
-	const ports = isResolutionNode(node) ? resolutionOutputPorts(node) : node.kind == "task" ? portsByHandle(node.task.outputs) : node.kind == "value" ? portsByHandle(node.values) : {};
+	const discardUndeclared = node.kind == "task" && "executor" in node.task && (node.task.executor.kind == "connector" || node.task.executor.kind == "workflow");
+	const ports = node.kind == "outputs" ? nodeInputPorts(node) : isResolutionNode(node) ? resolutionOutputPorts(node) : node.kind == "task" ? portsByHandle(node.task.outputs) : node.kind == "value" ? portsByHandle(node.values) : {};
 	const outputs = outputRecord(checkpointJson(Object.fromEntries(Object.entries(raw).map(([handle, item]) => [handle, Object.hasOwn(ports, handle) && item === void 0 ? null : item])), `Node "${nodeId}" outputs`), nodeId);
 	const complete = node.kind == "condition" || isResolutionNode(node) ? outputs : {
 		...Object.fromEntries(Object.keys(ports).map((handle) => [handle, null])),
 		...outputs
 	};
-	const validated = {};
+	const validated = [];
 	for (const [handle, output] of Object.entries(complete)) {
 		const port = ports[handle];
 		if (port == null) {
@@ -11072,9 +11165,9 @@ function validateOutputs(nodeId, node, value) {
 			throw new PortValidationError(`Node "${nodeId}" output "${handle}" does not match its declaration.`);
 		}
 		if (!(output === null && port.nullable) && !matchesSchema(output, port.jsonSchema)) throw new PortValidationError(`Node "${nodeId}" output "${handle}" does not match its declaration.`);
-		validated[handle] = output;
+		validated.push([handle, output]);
 	}
-	return validated;
+	return Object.fromEntries(validated);
 }
 function validateCheckpoint(target, checkpoint, resolveInputs) {
 	const launch = checkpoint.inputs;
@@ -11085,14 +11178,14 @@ function validateCheckpoint(target, checkpoint, resolveInputs) {
 		if (graph == null) throw new Error("Checkpoint execution counts reference an unknown graph.");
 		for (const [id, count] of Object.entries(counts)) {
 			const node = graph.nodes[id];
-			if (node == null || !("inputs" in node) || count > (node.maxExecutions ?? 1e3)) throw new Error("Checkpoint execution count is invalid.");
+			if (node == null || isTriggerNode(node) || count > (node.maxExecutions ?? 1e3)) throw new Error("Checkpoint execution count is invalid.");
 		}
 	}
 	const validateResults = (results, frame = false) => {
 		for (const [id, outputs] of Object.entries(results)) {
 			const node = target.graph.nodes[id];
 			if (node == null) throw new Error("Checkpoint result node is missing.");
-			if (!("inputs" in node)) {
+			if (isTriggerNode(node)) {
 				if (!matchesTriggerOutputs(node, outputs)) throw new Error("Checkpoint Trigger output is invalid.");
 			} else {
 				if (checkpoint.counts[""]?.[id] == null) throw new Error("Checkpoint execution count is missing.");
@@ -11103,20 +11196,20 @@ function validateCheckpoint(target, checkpoint, resolveInputs) {
 		}
 	};
 	validateResults(Object.fromEntries(Object.entries(checkpoint.results).map(([id, result]) => [id, result.outputs])));
-	const triggerIds = Object.keys(checkpoint.results).filter((id) => !("inputs" in target.graph.nodes[id]));
+	const triggerIds = Object.keys(checkpoint.results).filter((id) => isTriggerNode(target.graph.nodes[id]));
 	if (triggerIds.length != 1) throw new Error("Checkpoint must contain exactly one selected Trigger.");
 	const pendingCounts = /* @__PURE__ */ new Map();
-	for (const waiting of checkpoint.waits) pendingCounts.set(waiting.nodeId, (pendingCounts.get(waiting.nodeId) ?? 0) + 1);
+	for (const waiting of [...checkpoint.waits, ...checkpoint.calls ?? []]) pendingCounts.set(waiting.nodeId, (pendingCounts.get(waiting.nodeId) ?? 0) + 1);
 	for (const [id, count] of pendingCounts) if ((checkpoint.counts[""]?.[id] ?? 0) < count + (checkpoint.results[id] == null ? 0 : 1)) throw new Error("Checkpoint waiting execution count is incomplete.");
 	for (const [id, values] of Object.entries(launch)) {
 		const node = target.graph.nodes[id];
-		if (!("inputs" in node) || Object.keys(values).some((handle) => nodePorts(node)[handle] == null)) throw new Error("Checkpoint launch inputs do not match the prepared graph.");
+		if (isTriggerNode(node) || Object.keys(values).some((handle) => nodeInputPorts(node)[handle] == null)) throw new Error("Checkpoint launch inputs do not match the prepared graph.");
 	}
 	for (const [nodeId, state] of Object.entries(checkpoint.dependencies.nodes)) {
 		const frame = dependencyValues(state.input);
 		validateResults(frame, true);
-		if ("inputs" in target.graph.nodes[nodeId] && (state.status == "running" || state.status == "completed")) {
-			const triggers = Object.keys(frame).filter((id) => !("inputs" in target.graph.nodes[id]));
+		if (!isTriggerNode(target.graph.nodes[nodeId]) && (state.status == "running" || state.status == "completed")) {
+			const triggers = Object.keys(frame).filter((id) => isTriggerNode(target.graph.nodes[id]));
 			if (triggers.length != 1 || triggers[0] != triggerIds[0] || !jsonEqual(frame[triggers[0]], checkpoint.results[triggers[0]].outputs)) throw new Error("Checkpoint input Trigger does not match the Run.");
 		}
 		if (state.output != null) validateResults({ [nodeId]: state.output }, state.status == "running");
@@ -11125,9 +11218,13 @@ function validateCheckpoint(target, checkpoint, resolveInputs) {
 			if (result == null || state.jobId != null && state.jobId != result.jobId || !jsonEqual(state.output, result.outputs)) throw new Error("Checkpoint completed dependency conflicts with its result.");
 		}
 	}
+	for (const call of checkpoint.calls ?? []) {
+		const node = target.graph.nodes[call.nodeId];
+		if (node?.kind != "task" || !("executor" in node.task) || node.task.executor.kind != "workflow" || !jsonEqual(resolveInputs(call.nodeId, node), call.input) || checkpoint.agents[call.jobId] != null || checkpoint.dependencies.nodes[call.nodeId]?.output != null) throw new Error("Checkpoint workflow call does not match its node.");
+	}
 	for (const waiting of checkpoint.waits) {
 		const node = target.graph.nodes[waiting.nodeId];
-		if (node == null || !("inputs" in node)) throw new Error("Checkpoint waiting node is missing.");
+		if (node == null || isTriggerNode(node)) throw new Error("Checkpoint waiting node is missing.");
 		const state = checkpoint.dependencies.nodes[waiting.nodeId];
 		const expectedOutput = waiting.pending == null ? void 0 : { pending: waiting.pending };
 		if (state.output == null != (expectedOutput == null) || state.output != null && !jsonEqual(state.output, expectedOutput)) throw new Error("Checkpoint waiting dependency output is inconsistent.");
@@ -11156,7 +11253,7 @@ function runGraph(context, target, runId, launchInputs = {}, trigger, resume) {
 			runId,
 			type: "run.started"
 		});
-		const order = Object.keys(target.graph.nodes).filter((id) => "inputs" in target.graph.nodes[id]);
+		const order = Object.keys(target.graph.nodes).filter((id) => !isTriggerNode(target.graph.nodes[id]));
 		const outgoing = /* @__PURE__ */ new Map();
 		for (const edge of target.graph.edges) {
 			const targets = outgoing.get(edge.source) ?? [];
@@ -11171,10 +11268,10 @@ function runGraph(context, target, runId, launchInputs = {}, trigger, resume) {
 		if (resume == null) {
 			if (trigger != null) {
 				const node = target.graph.nodes[trigger.nodeId];
-				if (node == null || "inputs" in node || !matchesTriggerOutputs(node, trigger.outputs)) throw new Error("Trigger outputs are invalid.");
+				if (node == null || !isTriggerNode(node) || !matchesTriggerOutputs(node, trigger.outputs)) throw new Error("Trigger outputs are invalid.");
 			}
 			for (const [id, node] of Object.entries(target.graph.nodes)) {
-				if ("inputs" in node) continue;
+				if (!isTriggerNode(node)) continue;
 				if (trigger?.nodeId == id) completed.set(id, {
 					jobId: id,
 					outputs: trigger.outputs
@@ -11185,6 +11282,7 @@ function runGraph(context, target, runId, launchInputs = {}, trigger, resume) {
 		const runNode = yield* FiberSet.runtime(active)();
 		let firstCause;
 		let firstFailure;
+		const pendingCalls = new Map((resume?.checkpoint.calls ?? []).map((call) => [call.jobId, call]));
 		const pendingWaits = new Map((resume?.checkpoint.waits ?? []).map((wait) => [wait.jobId, wait]));
 		const changes = yield* Queue.unbounded();
 		let remainingMs = context.remainingMs;
@@ -11214,7 +11312,7 @@ function runGraph(context, target, runId, launchInputs = {}, trigger, resume) {
 		const resolveInputs = (nodeId, node) => {
 			const mappings = nodeInputMappings(node);
 			const frame = dependencies.inputValues(nodeId);
-			return Object.fromEntries(Object.entries(nodePorts(node)).map(([handle, port]) => [handle, resolveInput(mappings[handle], port, launch[nodeId]?.[handle], `Node "${nodeId}" input "${handle}"`, frame, node.kind == "condition")]));
+			return Object.fromEntries(Object.entries(nodeInputPorts(node)).map(([handle, port]) => [handle, resolveInput(mappings[handle], port, launch[nodeId]?.[handle], `Node "${nodeId}" input "${handle}"`, frame, node.kind == "condition")]));
 		};
 		const commit = (nodeId, jobId, outputs, releasedHandles = Object.keys(outputs)) => Effect.uninterruptible(Effect.gen(function* () {
 			yield* context.emit({
@@ -11243,7 +11341,7 @@ function runGraph(context, target, runId, launchInputs = {}, trigger, resume) {
 					const mapping = nodeInputMappings(node)[handle];
 					return mapping?.kind != "sources" || mapping.sources.every((source) => source.kind != "binding");
 				}));
-				if (resolution == null) yield* context.emit({
+				if (resolution == null && !pendingCalls.has(jobId)) yield* context.emit({
 					inputs: projectedInputs,
 					jobId,
 					nodeId,
@@ -11254,6 +11352,9 @@ function runGraph(context, target, runId, launchInputs = {}, trigger, resume) {
 				});
 				let outputs;
 				switch (node.kind) {
+					case "outputs":
+						outputs = nodeInputs;
+						break;
 					case "condition": return {
 						kind: "completed",
 						outputs: {},
@@ -11267,6 +11368,7 @@ function runGraph(context, target, runId, launchInputs = {}, trigger, resume) {
 						const previousIds = dependencies.state.nodes[nodeId].previous;
 						const additional = new Set((node.additionalInputs ?? []).map((port) => port.handle));
 						const result = yield* context.invokeTask({
+							...pendingCalls.has(jobId) ? { workflowRunId: pendingCalls.get(jobId).childRunId } : {},
 							additionalInputs: Object.fromEntries(Object.entries(nodeInputs).filter(([handle]) => additional.has(handle))),
 							blockId: "moduleId" in node.task ? node.task.moduleId : nodeId,
 							flowId: target.flowId,
@@ -11293,7 +11395,7 @@ function runGraph(context, target, runId, launchInputs = {}, trigger, resume) {
 										const previous = target.graph.nodes[previousId];
 										return {
 											id: previousId,
-											name: previous.name ?? ("inputs" in previous ? nodeTitle(previous) : void 0) ?? previousId,
+											name: previous.name ?? (!isTriggerNode(previous) ? nodeTitle(previous) : void 0) ?? previousId,
 											outputs: frame[previousId],
 											outputDefs: Object.entries(nodeOutputPorts(previous)).map(([handle, definition]) => Object.assign({
 												handle,
@@ -11305,7 +11407,21 @@ function runGraph(context, target, runId, launchInputs = {}, trigger, resume) {
 								}
 							} : { kind: "managed" }
 						});
-						if (config != null) {
+						if ("executor" in node.task && node.task.executor.kind == "workflow") {
+							const response = discriminatedUnion("kind", [strictObject({
+								kind: literal("calling"),
+								childRunId: string().min(1)
+							}), strictObject({
+								kind: literal("completed"),
+								outputs: record$1(string(), json$1())
+							})]).parse(result);
+							if (response.kind == "calling") return {
+								kind: "calling",
+								childRunId: response.childRunId,
+								input: nodeInputs
+							};
+							outputs = response.outputs;
+						} else if (config != null) {
 							const response = agentResultSchema.parse(result);
 							if (response.kind == "suspended") {
 								const checkpoint = response.checkpoint;
@@ -11349,7 +11465,7 @@ function runGraph(context, target, runId, launchInputs = {}, trigger, resume) {
 			const node = target.graph.nodes[nodeId];
 			const waitId = nanoid$1();
 			const notify = isResolutionNode(node) && usesPending(target.graph, nodeId);
-			const pending = yield* context.waits.create({
+			const notification = yield* context.waits.create({
 				jobId,
 				nodeId,
 				value,
@@ -11359,6 +11475,7 @@ function runGraph(context, target, runId, launchInputs = {}, trigger, resume) {
 				prompt: isResolutionNode(node) ? node.prompt : JSON.stringify(value, null, 2),
 				...isResolutionNode(node) ? {} : { notification: agentNotice(node, agents[jobId].input) }
 			});
+			const pending = notification == null ? notification : withWaitNotificationMessage(notification);
 			if (notify) {
 				validateOutputs(nodeId, node, { pending });
 				dependencies.release(nodeId, { pending }, ["pending"], false);
@@ -11373,6 +11490,16 @@ function runGraph(context, target, runId, launchInputs = {}, trigger, resume) {
 			yield* Queue.offer(changes, void 0);
 		});
 		const settleNode = (nodeId, jobId, result) => {
+			if (result.kind == "calling") {
+				pendingCalls.set(jobId, {
+					jobId,
+					nodeId,
+					childRunId: result.childRunId,
+					input: result.input
+				});
+				return Effect.void;
+			}
+			pendingCalls.delete(jobId);
 			if (result.kind == "completed") {
 				delete agents[jobId];
 				return commit(nodeId, jobId, result.outputs, result.releasedHandles);
@@ -11400,7 +11527,7 @@ function runGraph(context, target, runId, launchInputs = {}, trigger, resume) {
 		const executeReady = (nodeId) => {
 			if (firstCause != null) return;
 			const node = target.graph.nodes[nodeId];
-			if (!("inputs" in node)) return;
+			if (isTriggerNode(node)) return;
 			const jobId = context.createId();
 			const count = counts[nodeId] ?? 0;
 			const limit = node.maxExecutions ?? 1e3;
@@ -11488,18 +11615,22 @@ function runGraph(context, target, runId, launchInputs = {}, trigger, resume) {
 				return yield* Effect.failCause(firstCause);
 			}
 			if (pendingWaits.size > 0 && context.waits != null) applyResolutions(yield* context.waits.resolutions([...pendingWaits.values()].map((wait) => wait.waitId), false), now);
+			for (const call of pendingCalls.values()) yield* observe(call.nodeId, call.jobId, Effect.gen(function* () {
+				const result = yield* executeNode(call.nodeId, target.graph.nodes[call.nodeId], call.jobId, call.input);
+				yield* settleNode(call.nodeId, call.jobId, result);
+			})).pipe(Effect.catch(() => Effect.void));
 			const ready = dependencies.ready();
 			for (const nodeId of ready) executeReady(nodeId);
 			const running = yield* FiberSet.size(active);
 			if (firstCause != null) continue;
-			if (running == 0 && pendingWaits.size == 0 && ready.length == 0) {
+			if (running == 0 && pendingWaits.size == 0 && pendingCalls.size == 0 && ready.length == 0) {
 				if (dependencies.incomplete) return yield* Effect.fail(/* @__PURE__ */ new Error("Execution graph contains unresolved dependencies."));
 				break;
 			}
 			if (running > 0 || ready.length > 0) idleSince = void 0;
 			else idleSince ??= now;
 			const left = idleSince == null ? remainingMs : waitRetentionMs - (now - idleSince);
-			if (idleSince != null && left <= 0) {
+			if (idleSince != null && (left <= 0 || pendingCalls.size > 0)) {
 				const checkpoint = {
 					bindingValues: context.bindingValues,
 					inputs: launch,
@@ -11508,7 +11639,8 @@ function runGraph(context, target, runId, launchInputs = {}, trigger, resume) {
 					dependencies: dependencies.state,
 					version: 5,
 					agents,
-					waits: [...pendingWaits.values()]
+					waits: [...pendingWaits.values()],
+					...pendingCalls.size == 0 ? {} : { calls: [...pendingCalls.values()] }
 				};
 				const encoded = JSON.stringify(checkpoint);
 				if (new TextEncoder().encode(encoded).byteLength > 16777216) return yield* Effect.fail(/* @__PURE__ */ new Error("Flow Run checkpoint exceeds 16 MiB."));
@@ -11521,6 +11653,7 @@ function runGraph(context, target, runId, launchInputs = {}, trigger, resume) {
 			const activity = Queue.take(changes).pipe(Effect.as({}));
 			const decision = pendingWaits.size == 0 || context.waits == null ? Effect.never : context.waits.resolutions([...pendingWaits.values()].map((wait) => wait.waitId), true);
 			let next = Effect.raceFirst(activity, decision);
+			if (pendingCalls.size > 0) next = Effect.raceFirst(next, Effect.sleep(1e3).pipe(Effect.as({})));
 			if (left != null) next = Effect.raceFirst(next, Effect.sleep(Math.max(0, left)).pipe(Effect.as({})));
 			applyResolutions(yield* next, yield* Clock.currentTimeMillis);
 		}
@@ -11529,8 +11662,11 @@ function runGraph(context, target, runId, launchInputs = {}, trigger, resume) {
 			runId,
 			type: "run.progress"
 		});
+		const outputNodeId = order.find((nodeId) => target.graph.nodes[nodeId]?.kind == "outputs");
+		const businessOutputs = outputNodeId == null ? void 0 : completed.get(outputNodeId)?.outputs;
 		const result = {
 			kind: "node-results",
+			...businessOutputs == null ? {} : { outputs: businessOutputs },
 			nodes: resultNodes.flatMap((nodeId) => {
 				const saved = completed.get(nodeId);
 				return saved == null ? [] : [{
@@ -11553,11 +11689,40 @@ function runFlow(prepared, options) {
 	const emit = options.emit ?? (() => Effect.void);
 	return Effect.gen(function* () {
 		if (options.resume != null && (options.inputs != null || options.trigger != null || options.bindingValues != null)) return yield* Effect.fail(/* @__PURE__ */ new Error("A resumed Flow Run cannot accept launch inputs, binding values, or a Trigger seed."));
-		const checkpoint = options.resume == null ? void 0 : decodeFlowRunCheckpoint(options.resume.checkpoint);
+		const decoded = options.resume == null ? void 0 : decodeFlowRunCheckpoint(options.resume.checkpoint);
+		const outputs = (nodeId, value) => isResolutionNode(prepared.graph.nodes[nodeId]) && value.pending != null ? {
+			...value,
+			pending: withWaitNotificationMessage(value.pending)
+		} : value;
+		const checkpoint = decoded == null ? void 0 : {
+			...decoded,
+			results: Object.fromEntries(Object.entries(decoded.results).map(([id, result]) => [id, {
+				...result,
+				outputs: outputs(id, result.outputs)
+			}])),
+			dependencies: {
+				...decoded.dependencies,
+				nodes: Object.fromEntries(Object.entries(decoded.dependencies.nodes).map(([id, state]) => [id, {
+					...state,
+					...state.output == null ? {} : { output: outputs(id, state.output) },
+					input: Object.fromEntries(Object.entries(state.input).map(([source, result]) => [source, {
+						...result,
+						outputs: outputs(source, result.outputs)
+					}]))
+				}]))
+			},
+			waits: decoded.waits.map((wait) => wait.pending == null ? wait : Object.assign({}, wait, { pending: withWaitNotificationMessage(wait.pending) }))
+		};
 		if (checkpoint != null && new TextEncoder().encode(JSON.stringify(checkpoint)).byteLength > 16777216) return yield* Effect.fail(/* @__PURE__ */ new Error("Flow Run checkpoint exceeds 16 MiB."));
 		if (checkpoint == null && options.trigger == null) return yield* Effect.fail(/* @__PURE__ */ new Error("A Flow Run requires a Trigger seed."));
 		const triggerNode = options.trigger == null ? void 0 : prepared.graph.nodes[options.trigger.nodeId];
-		if (options.trigger != null && (triggerNode == null || "inputs" in triggerNode)) return yield* Effect.fail(/* @__PURE__ */ new Error(`Node "${options.trigger.nodeId}" is not a TriggerNode in Flow "${options.flowId}".`));
+		if (options.trigger != null && (triggerNode == null || !isTriggerNode(triggerNode))) return yield* Effect.fail(/* @__PURE__ */ new Error(`Node "${options.trigger.nodeId}" is not a TriggerNode in Flow "${options.flowId}".`));
+		const triggerOutputs = triggerNode == null || !isTriggerNode(triggerNode) ? void 0 : normalizeTriggerOutputs(triggerNode, options.trigger.outputs);
+		if (options.trigger != null && triggerOutputs == null) return yield* Effect.fail(/* @__PURE__ */ new Error("Trigger outputs are invalid."));
+		const trigger = options.trigger == null ? void 0 : {
+			nodeId: options.trigger.nodeId,
+			outputs: triggerOutputs
+		};
 		return yield* runGraph({
 			failures: /* @__PURE__ */ new WeakMap(),
 			counts: Object.fromEntries(Object.entries(checkpoint?.counts ?? {}).map(([scope, counts]) => [scope, { ...counts }])),
@@ -11571,9 +11736,12 @@ function runFlow(prepared, options) {
 			remainingMs: options.remainingMs
 		}, {
 			flowId: options.flowId,
-			graph: prepared.graph
-		}, options.runId, options.inputs, options.trigger, checkpoint == null ? void 0 : { checkpoint });
+			graph: prepared.graph,
+			inputDefs: prepared.inputDefs,
+			outputDefs: prepared.outputDefs,
+			outputMappings: prepared.outputMappings
+		}, options.runId, options.inputs, trigger, checkpoint == null ? void 0 : { checkpoint });
 	});
 }
 //#endregion
-export { PortValidationError, decodeFlowRunCheckpoint, normalizeWaitComment, runFlow, waitRetentionMs };
+export { PortValidationError, decodeFlowRunCheckpoint, normalizeWaitComment, runFlow, waitRetentionMs, withWaitNotificationMessage };

package/dist/common/trigger-contract.d.ts

@@ -7,3 +7,5 @@ export declare const webhookOutputs: readonly Port[];
 export declare function triggerOutputDefinitions(trigger: TriggerNode): readonly Port[];
 export declare function triggerOutputPorts(trigger: TriggerNode): Readonly<Record<string, PortDefinition>>;
 export declare function matchesTriggerOutputs(trigger: TriggerNode, outputs: unknown): outputs is Readonly<Record<string, JsonValue>>;
+/** Resolve caller-supplied Start parameters into the complete output snapshot used by execution. */
+export declare function normalizeTriggerOutputs(trigger: TriggerNode, outputs: unknown): Readonly<Record<string, JsonValue>> | undefined;