@oomol-lab/open-flow 0.1.0-beta.51 → 0.1.0-beta.52

package/dist/common/flow-semantics.js

@@ -1,196 +1,25 @@
-//#region src/flow/common/promptTemplate.ts
-var promptReferencePattern = /\{\{\s*([^{}\s]+)\s*\}\}/g;
-function renderPrompt(template, input) {
-	return template.replace(promptReferencePattern, (match, name) => {
-		if (!Object.hasOwn(input, name)) return match;
-		const value = input[name];
-		return typeof value == "string" ? value : JSON.stringify(value);
-	});
-}
-//#endregion
-//#region src/flow/common/connectionUsage.ts
-function connectionUsage(document) {
-	const uses = [];
-	const graphs = [{
-		graph: document.graph,
-		target: { kind: "flow" },
-		name: ""
-	}, ...Object.entries(document.subflows).map(([id, subflow]) => ({
-		graph: subflow.graph,
-		target: {
-			kind: "subflow",
-			id
-		},
-		name: subflow.name
-	}))];
-	for (const { graph, target, name: graphName } of graphs) for (const [nodeId, node] of Object.entries(graph.nodes)) {
-		const task = node.kind == "task" && node.taskId != null ? document.tasks[node.taskId] : void 0;
-		const name = [graphName, node.name ?? task?.name ?? nodeId].filter(Boolean).join(" / ");
-		const add = (kind, actionId, connectionId) => {
-			uses.push({
-				kind,
-				providerId: actionId.split(".")[0],
-				actionId,
-				connectionId,
-				nodeId,
-				name,
-				target
-			});
-		};
-		if (node.kind == "poll" || node.kind == "integration") uses.push({
-			kind: "trigger",
-			providerId: node.definition.provider,
-			connectionId: node.connectionId,
-			nodeId,
-			name,
-			target
-		});
-		if (task?.executor.kind == "connector") add("connector", task.executor.action, task.executor.connectionId);
-		if (node.kind == "task" && node.task != null) {
-			for (const capability of node.task.capabilities ?? []) if ("mode" in capability && capability.mode == "independent") for (const action of capability.actions) add("code", action.action, action.connectionId);
-		}
-		if (task?.executor.kind == "agent") {
-			for (const tool of task.executor.tools) add("agent", tool.action, tool.connectionId);
-			const notification = task.executor.notification == null ? void 0 : document.tasks[task.executor.notification.taskId]?.executor;
-			if (notification?.kind == "connector") add("notification", notification.action, notification.connectionId);
-		}
-	}
-	return uses;
-}
-function removeConnectionUsage(content, connectionId) {
-	const document = content.document;
-	return {
-		...content,
-		document: {
-			...document,
-			tasks: Object.fromEntries(Object.entries(document.tasks).map(([id, task]) => {
-				const executor = task.executor;
-				if (executor.kind == "connector" && executor.connectionId == connectionId) {
-					const { connectionId: _, ...next } = executor;
-					return [id, {
-						...task,
-						executor: next
-					}];
-				}
-				if (executor.kind == "agent") return [id, {
-					...task,
-					executor: {
-						...executor,
-						tools: executor.tools.map((tool) => {
-							if (tool.connectionId != connectionId) return tool;
-							const { connectionId: _, ...next } = tool;
-							return next;
-						})
-					}
-				}];
-				return [id, task];
-			})),
-			graph: clearNodeConnections(document.graph, connectionId),
-			subflows: Object.fromEntries(Object.entries(document.subflows).map(([id, subflow]) => [id, {
-				...subflow,
-				graph: clearNodeConnections(subflow.graph, connectionId)
-			}]))
-		}
-	};
-}
-function clearNodeConnections(graph, connectionId) {
-	return {
-		...graph,
-		nodes: Object.fromEntries(Object.entries(graph.nodes).map(([id, node]) => {
-			if ((node.kind == "poll" || node.kind == "integration") && node.connectionId == connectionId) {
-				const { connectionId: _, ...remaining } = node;
-				return [id, remaining];
-			}
-			if (node.kind != "task" || node.task == null) return [id, node];
-			const capabilities = node.task.capabilities?.map((capability) => {
-				if (!("mode" in capability) || capability.mode != "independent") return capability;
-				return {
-					...capability,
-					actions: capability.actions.map((action) => {
-						if (action.connectionId != connectionId) return action;
-						const { connectionId: _, ...remaining } = action;
-						return remaining;
-					})
-				};
-			});
-			return [id, capabilities == null ? node : {
-				...node,
-				task: {
-					...node.task,
-					capabilities
-				}
-			}];
-		}))
-	};
-}
-//#endregion
-//#region src/base/common/json.ts
-function hasJsonShape(root) {
-	if (root === null || typeof root == "boolean" || typeof root == "string") return true;
-	if (typeof root == "number") return Number.isFinite(root);
-	if (typeof root != "object") return false;
-	const ancestors = /* @__PURE__ */ new Set();
-	const pending = [];
-	let value = root;
-	traversal: while (true) {
-		let keys;
-		let arrayLength;
-		if (Array.isArray(value)) {
-			arrayLength = value.length;
-			keys = Reflect.ownKeys(value);
-			if (keys.length != arrayLength + 1) return false;
-		} else {
-			const prototype = Reflect.getPrototypeOf(value);
-			if (prototype != Object.prototype && prototype != null) return false;
-			keys = Reflect.ownKeys(value);
-			arrayLength = void 0;
+//#region ../../node_modules/.bun/dequal@2.0.3/node_modules/dequal/lite/index.mjs
+var has = Object.prototype.hasOwnProperty;
+function dequal(foo, bar) {
+	var ctor, len;
+	if (foo === bar) return true;
+	if (foo && bar && (ctor = foo.constructor) === bar.constructor) {
+		if (ctor === Date) return foo.getTime() === bar.getTime();
+		if (ctor === RegExp) return foo.toString() === bar.toString();
+		if (ctor === Array) {
+			if ((len = foo.length) === bar.length) while (len-- && dequal(foo[len], bar[len]));
+			return len === -1;
 		}
-		ancestors.add(value);
-		let index = 0;
-		while (true) {
-			if (index >= keys.length) {
-				ancestors.delete(value);
-				const parent = pending.pop();
-				if (parent === void 0) return true;
-				value = parent.value;
-				keys = parent.keys;
-				arrayLength = parent.arrayLength;
-				index = parent.index;
-				continue;
-			}
-			const key = keys[index++];
-			if (arrayLength !== void 0) {
-				if (key == "length") continue;
-				if (typeof key != "string") return false;
-				const arrayIndex = Number(key);
-				if (!Number.isSafeInteger(arrayIndex) || arrayIndex < 0 || arrayIndex >= arrayLength || String(arrayIndex) != key) return false;
-			} else if (typeof key != "string") return false;
-			const descriptor = Reflect.getOwnPropertyDescriptor(value, key);
-			if (descriptor?.enumerable != true || !Object.hasOwn(descriptor, "value")) return false;
-			const child = descriptor.value;
-			if (child === null || typeof child == "boolean" || typeof child == "string") continue;
-			if (typeof child == "number") {
-				if (!Number.isFinite(child)) return false;
-				continue;
+		if (!ctor || typeof foo === "object") {
+			len = 0;
+			for (ctor in foo) {
+				if (has.call(foo, ctor) && ++len && !has.call(bar, ctor)) return false;
+				if (!(ctor in bar) || !dequal(foo[ctor], bar[ctor])) return false;
 			}
-			if (typeof child != "object" || ancestors.has(child)) return false;
-			pending.push({
-				value,
-				keys,
-				arrayLength,
-				index
-			});
-			value = child;
-			continue traversal;
+			return Object.keys(bar).length === len;
 		}
 	}
-}
-function isJsonObject(value) {
-	try {
-		return value != null && typeof value == "object" && !Array.isArray(value) && hasJsonShape(value);
-	} catch {
-		return false;
-	}
+	return foo !== foo && bar !== bar;
 }
 //#endregion
 //#region ../../node_modules/.bun/@cfworker+json-schema@4.1.1/node_modules/@cfworker/json-schema/dist/esm/deep-compare-strict.js
@@ -9263,7 +9092,7 @@ var ZodObject = /*@__PURE__*/ $constructor("ZodObject", (inst, def) => {
 		return required(ZodNonOptional, this, args[0]);
 	}
 });
-function object(shape, params) {
+function object$1(shape, params) {
 	return new ZodObject({
 		type: "object",
 		shape: shape ?? {},
@@ -9574,11 +9403,11 @@ function checkJsonDepth(value, depth = 0) {
 }
 //#endregion
 //#region src/flow/common/triggerScheduleSchema.ts
-var triggerScheduleSchema = array(union([object({
+var triggerScheduleSchema = array(union([object$1({
 	type: literal("cron"),
 	expression: string(),
 	timezone: string()
-}), object({
+}), object$1({
 	type: literal("every"),
 	unit: _enum([
 		"day",
@@ -9604,40 +9433,40 @@ function webhookSupportsBody(method) {
 var text = string();
 var json = json$1();
 var strings = array(text);
-var port = object({
+var port = object$1({
 	description: text.optional(),
 	jsonSchema: json,
 	nullable: boolean(),
 	handle: text
 });
 var input = port.extend({ value: json.optional() });
-var group = object({
+var group = object$1({
 	collapsed: boolean().optional(),
 	group: text
 });
-var nodeSource = object({
+var nodeSource = object$1({
 	kind: literal("node"),
 	nodeId: text,
 	output: text,
 	field: text.optional()
 });
-var flowSource = object({
+var flowSource = object$1({
 	kind: literal("flow"),
 	input: text
 });
 var source = union([
 	nodeSource,
 	flowSource,
-	object({
+	object$1({
 		kind: literal("binding"),
 		bindingId: text
 	})
 ]);
-var fixedInput = union([object({ kind: literal("unset") }), object({
+var fixedInput = union([object$1({ kind: literal("unset") }), object$1({
 	kind: literal("value"),
 	value: json
 })]);
-var mapping = union([fixedInput, object({
+var mapping = union([fixedInput, object$1({
 	kind: literal("sources"),
 	sources: array(source)
 })]);
@@ -9678,40 +9507,58 @@ var capability = union([
 		})).optional()
 	})
 ]);
-var inline = object({
+var inline = object$1({
 	...ports,
 	name: text,
 	moduleId: text,
 	capabilities: array(capability).optional()
 });
-var agentValue = union([object({
+var agentValue = union([object$1({
 	kind: literal("value"),
 	value: json
-}), object({
+}), object$1({
 	kind: literal("input"),
 	input: text
 })]);
-var agentInput$1 = union([agentValue, object({ kind: literal("model") })]);
-var managed = object({
+var agentInput$1 = union([agentValue, object$1({ kind: literal("model") })]);
+var managed = object$1({
 	...ports,
 	name: text,
 	executor: union([
-		object({
+		object$1({
 			kind: literal("connector"),
 			action: text,
 			connectionId: text.optional()
 		}),
-		object({
+		object$1({
+			kind: literal("openapi"),
+			sourceUrl: text,
+			method: text,
+			path: text,
+			serverUrl: text,
+			document: json,
+			auth: array(object$1({
+				id: text,
+				type: _enum([
+					"bearer",
+					"basic",
+					"apiKey"
+				]),
+				name: text.optional(),
+				in: _enum(["header", "query"]).optional()
+			}))
+		}),
+		object$1({
 			kind: literal("llm"),
 			mode: _enum(["chat", "json"])
 		}),
-		object({
+		object$1({
 			kind: literal("agent"),
 			code: boolean().optional(),
 			model: text,
 			prompt: text,
 			maxRounds: number(),
-			tools: array(object({
+			tools: array(object$1({
 				id: text,
 				name: text,
 				description: text,
@@ -9720,7 +9567,7 @@ var managed = object({
 				approval: boolean(),
 				inputs: array(input.extend({ source: agentInput$1 }))
 			})),
-			notification: object({
+			notification: object$1({
 				taskId: text,
 				messageHandle: text,
 				inputs: record(text, agentValue)
@@ -9728,20 +9575,20 @@ var managed = object({
 		})
 	])
 });
-var operand = union([object({
+var operand = union([object$1({
 	kind: literal("value"),
 	value: json.optional(),
 	jsonSchema: json.optional()
-}), object({
+}), object$1({
 	kind: literal("source"),
 	source
 })]);
 var condition = {
 	matchMode: _enum(["first", "all"]),
-	cases: array(object({
+	cases: array(object$1({
 		description: text.optional(),
 		output: text,
-		groups: array(object({ expressions: array(object({
+		groups: array(object$1({ expressions: array(object$1({
 			left: operand,
 			operator: _enum([
 				"!=",
@@ -9773,7 +9620,7 @@ var wait = {
 	inputDefinitions: array(input),
 	prompt: text
 };
-var webhookOptions = object({
+var webhookOptions = object$1({
 	allowedMethods: never().optional(),
 	allowedOrigins: strings.optional(),
 	noResponseBody: never().optional(),
@@ -9796,8 +9643,8 @@ var definition = {
 	outputs: array(port).refine((definitions) => new Set(definitions.map((output) => output.handle)).size === definitions.length, "Duplicate Trigger output handle."),
 	provider: text
 };
-var endpoint = object({
-	body: object({
+var endpoint = object$1({
+	body: object$1({
 		allowArray: boolean(),
 		allowEmpty: boolean(),
 		formats: array(_enum([
@@ -9832,30 +9679,30 @@ var base = {
 	timeoutMs: number().optional()
 };
 var node = union([
-	object({
+	object$1({
 		...base,
 		inputs: record(text, never()),
 		kind: literal("condition"),
 		...condition
 	}),
-	object({
+	object$1({
 		...base,
 		inputs: unknown().transform(() => ({})).default({}),
 		kind: literal("value"),
 		values: array(input)
 	}),
-	object({
+	object$1({
 		...base,
 		kind: literal("subflow"),
 		subflowId: text
 	}),
-	object({
+	object$1({
 		...base,
 		kind: literal("task"),
 		task: inline,
 		additionalInputs: array(input).optional()
 	}),
-	object({
+	object$1({
 		...base,
 		kind: literal("task"),
 		taskId: text,
@@ -9871,7 +9718,7 @@ var node = union([
 		kind: literal("wait"),
 		...wait
 	}).omit({ timeoutMs: true }),
-	object({
+	object$1({
 		...trigger,
 		kind: literal("manual")
 	}),
@@ -9880,44 +9727,44 @@ var node = union([
 		kind: literal("error"),
 		sourceFlowIds: sourceFlowIds.optional()
 	}),
-	object({
+	object$1({
 		...trigger,
 		kind: literal("webhook"),
 		...webhook
 	}),
-	object({
+	object$1({
 		...trigger,
 		kind: literal("cron"),
 		cronTimes: triggerScheduleSchema
 	}),
-	object({
+	object$1({
 		...trigger,
 		kind: literal("poll"),
 		connectionId: text.min(1).optional(),
 		config: record(text, fixedInput),
-		definition: object({
+		definition: object$1({
 			...definition,
 			type: literal("poll")
 		}),
 		pollTimes: triggerScheduleSchema
 	}),
-	object({
+	object$1({
 		...trigger,
 		kind: literal("integration"),
 		connectionId: text.min(1).optional(),
 		config: record(text, fixedInput),
-		definition: object({
+		definition: object$1({
 			...definition,
 			type: literal("integration"),
 			endpoint
 		})
 	})
 ]);
-var target = union([object({ kind: literal("flow") }), object({
+var target = union([object$1({ kind: literal("flow") }), object$1({
 	kind: literal("subflow"),
 	id: text
 })]);
-var edge = object({
+var edge = object$1({
 	source: text,
 	target: text,
 	sourceHandle: text.optional()
@@ -9926,31 +9773,31 @@ var at = {
 	nodeId: text,
 	target
 };
-var subflow = object({
+var subflow = object$1({
 	name: text,
 	inputs: array(input),
 	outputs: array(port.extend({ sources: array(union([nodeSource, flowSource])) }))
 });
-var graph = object({
+var graph = object$1({
 	nodes: record(text, node),
 	edges: array(edge).default([])
 });
-var binding = object({
+var binding = object$1({
 	kind: literal("variable"),
 	target: text
 });
-var module = object({
+var module = object$1({
 	name: text,
 	imports: strings,
 	source: text
 });
-var document = object({
+var document = object$1({
 	bindings: record(text, binding),
 	graph,
 	subflows: record(text, subflow.extend({ graph })),
 	tasks: record(text, managed)
 });
-object({
+object$1({
 	modelVersion: union([
 		literal(2),
 		literal(4),
@@ -9992,14 +9839,14 @@ var shapes = {
 	},
 	"graph.node.delete": at,
 	"graph.node.field.set": union([
-		object({
+		object$1({
 			...at,
 			kind: literal("graph.node.field.set"),
 			field: literal("connectionId"),
 			before: text.min(1).optional(),
 			value: text.min(1).optional()
 		}),
-		object({
+		object$1({
 			...at,
 			kind: literal("graph.node.field.set"),
 			field: _enum([
@@ -10010,14 +9857,14 @@ var shapes = {
 			before: text.optional(),
 			value: text.optional()
 		}),
-		object({
+		object$1({
 			...at,
 			kind: literal("graph.node.field.set"),
 			field: literal("maxExecutions"),
 			before: number().int().positive().max(Number.MAX_SAFE_INTEGER).optional(),
 			value: number().int().positive().max(Number.MAX_SAFE_INTEGER).optional()
 		}),
-		object({
+		object$1({
 			...at,
 			kind: literal("graph.node.field.set"),
 			field: literal("timeoutMs"),
@@ -10038,8 +9885,8 @@ var shapes = {
 	},
 	"graph.node.condition.set": {
 		...at,
-		before: object(condition),
-		value: object(condition)
+		before: object$1(condition),
+		value: object$1(condition)
 	},
 	"graph.node.values.set": {
 		...at,
@@ -10048,20 +9895,20 @@ var shapes = {
 	},
 	"graph.node.resolution.set": {
 		...at,
-		target: object({ kind: literal("flow") }),
-		before: object(wait),
-		value: object(wait)
+		target: object$1({ kind: literal("flow") }),
+		before: object$1(wait),
+		value: object$1(wait)
 	},
 	"graph.node.webhook.set": {
 		...at,
-		target: object({ kind: literal("flow") }),
-		before: object(webhook),
-		value: object(webhook)
+		target: object$1({ kind: literal("flow") }),
+		before: object$1(webhook),
+		value: object$1(webhook)
 	},
 	"graph.node.task.ports.set": {
 		...at,
-		before: object(ports),
-		value: object(ports)
+		before: object$1(ports),
+		value: object$1(ports)
 	},
 	"graph.node.task.name.set": {
 		...at,
@@ -10121,6 +9968,11 @@ var shapes = {
 		before: text.optional(),
 		value: text.optional()
 	},
+	"task.openapi.set": {
+		taskId: text,
+		before: managed,
+		value: managed
+	},
 	"task.agent.set": {
 		taskId: text,
 		before: managed,
@@ -10137,7 +9989,7 @@ var shapes = {
 		value: text
 	}
 };
-array(union([...new Map(Object.entries(shapes).map(([kind, shape]) => [kind, shape instanceof ZodType ? shape : object({
+array(union([...new Map(Object.entries(shapes).map(([kind, shape]) => [kind, shape instanceof ZodType ? shape : object$1({
 	kind: literal(kind),
 	...shape
 })])).values()])).min(1);
@@ -10551,6 +10403,556 @@ function hasRetiredRef(value) {
 	return source.contentMediaType == "oomol/ref" || Object.values(source).some(hasRetiredRef);
 }
 //#endregion
+//#region src/openapi/common/openapi.ts
+var methods = [
+	"get",
+	"put",
+	"post",
+	"delete",
+	"options",
+	"head",
+	"patch",
+	"trace"
+];
+function object(value) {
+	if (value == null || typeof value != "object" || Array.isArray(value)) throw new Error("Expected an OpenAPI object.");
+	return value;
+}
+function httpUrl(value, base) {
+	const url = new URL(value, base);
+	if (!["http:", "https:"].includes(url.protocol) || url.username || url.password || url.hash) throw new Error("An HTTP(S) URL without credentials or fragment is required.");
+	return url.href;
+}
+function parseOpenApi(value) {
+	const doc = object(value);
+	if (typeof doc.openapi != "string" || !/^3\.[01]\.\d+$/.test(doc.openapi)) throw new Error("Only OpenAPI 3.0 and 3.1 JSON documents are supported.");
+	object(doc.paths);
+	return doc;
+}
+function pointer(doc, ref) {
+	if (!ref.startsWith("#/")) throw new Error("External OpenAPI references are not supported.");
+	let value = doc;
+	for (const key of decodeURIComponent(ref.slice(2)).split("/").map((part) => part.replace(/~1/g, "/").replace(/~0/g, "~"))) {
+		const source = object(value);
+		if (!Object.hasOwn(source, key)) throw new Error("An OpenAPI reference is missing.");
+		value = source[key];
+	}
+	return value;
+}
+function resolved(doc, value) {
+	let result = object(value);
+	const seen = /* @__PURE__ */ new Set();
+	while (typeof result.$ref == "string") {
+		if (seen.has(result.$ref)) throw new Error("Circular non-schema reference is unsupported.");
+		seen.add(result.$ref);
+		const { $ref, ...siblings } = result;
+		result = {
+			...object(pointer(doc, $ref)),
+			...siblings
+		};
+	}
+	return result;
+}
+function operation(doc, path, method) {
+	const item = resolved(doc, object(doc.paths)[path]);
+	if (!methods.includes(method) || item[method] == null) throw new Error("The selected operation is no longer available.");
+	return {
+		item,
+		op: object(item[method])
+	};
+}
+function servers(value, path, method) {
+	const doc = parseOpenApi(value);
+	const { item, op } = operation(doc, path, method);
+	const entries = op.servers ?? item.servers ?? doc.servers;
+	if (!Array.isArray(entries) || entries.length == 0) return [{ url: "/" }];
+	return entries.map(object);
+}
+function snapshot(documentValue, path, method) {
+	const doc = parseOpenApi(documentValue);
+	const { item, op } = operation(doc, path, method);
+	const security = op.security ?? doc.security ?? [];
+	const result = {
+		openapi: doc.openapi,
+		paths: { [path]: {
+			[method]: op,
+			...item.parameters == null ? {} : { parameters: item.parameters }
+		} },
+		servers: servers(doc, path, method),
+		security
+	};
+	const visited = /* @__PURE__ */ new Set();
+	function copy(ref) {
+		if (visited.has(ref)) return;
+		visited.add(ref);
+		const value = pointer(doc, ref);
+		const keys = decodeURIComponent(ref.slice(2)).split("/").map((part) => part.replace(/~1/g, "/").replace(/~0/g, "~"));
+		if (keys.some((key) => [
+			"__proto__",
+			"constructor",
+			"prototype"
+		].includes(key))) throw new Error("Unsupported reference key.");
+		let target = result;
+		for (const key of keys.slice(0, -1)) {
+			if (!Object.hasOwn(target, key)) target[key] = {};
+			target = object(target[key]);
+		}
+		target[keys.at(-1)] = structuredClone(value);
+		visit(value);
+	}
+	function visit(value) {
+		if (value == null || typeof value != "object") return;
+		if (Array.isArray(value)) {
+			value.forEach(visit);
+			return;
+		}
+		if (typeof object(value).$ref == "string") copy(object(value).$ref);
+		for (const [key, child] of Object.entries(value)) if (![
+			"example",
+			"examples",
+			"default"
+		].includes(key)) visit(child);
+	}
+	visit(result);
+	for (const entry of security) for (const name of Object.keys(object(entry))) copy(`#/components/securitySchemes/${name.replace(/~/g, "~0").replace(/\//g, "~1")}`);
+	return structuredClone(result);
+}
+function schema$1(doc, schemaValue) {
+	const defs = {};
+	const ids = /* @__PURE__ */ new Map();
+	function convert(value) {
+		if (typeof value == "boolean") return value;
+		const source = object(value);
+		if (source.format == "binary" || source.$dynamicRef != null || source.$id != null) throw new Error("Binary and dynamically scoped schemas are unsupported.");
+		const result = {};
+		for (const [key, child] of Object.entries(source)) {
+			if ([
+				"nullable",
+				"example",
+				"xml",
+				"discriminator",
+				"__proto__"
+			].includes(key)) continue;
+			if (key == "$ref") {
+				if (typeof child != "string") throw new Error("Invalid schema reference.");
+				let id = ids.get(child);
+				if (id == null) {
+					id = `s${ids.size}`;
+					ids.set(child, id);
+					defs[id] = convert(pointer(doc, child));
+				}
+				result.$ref = `#/$defs/${id}`;
+			} else if ([
+				"properties",
+				"patternProperties",
+				"$defs",
+				"definitions",
+				"dependentSchemas"
+			].includes(key)) result[key] = Object.fromEntries(Object.entries(object(child)).map(([name, childSchema]) => [name, convert(childSchema)]));
+			else if ([
+				"allOf",
+				"anyOf",
+				"oneOf",
+				"prefixItems"
+			].includes(key)) {
+				if (!Array.isArray(child)) throw new Error("Invalid schema composition.");
+				result[key] = child.map(convert);
+			} else if ([
+				"items",
+				"additionalProperties",
+				"not",
+				"if",
+				"then",
+				"else",
+				"contains",
+				"propertyNames",
+				"unevaluatedProperties"
+			].includes(key)) result[key] = convert(child);
+			else result[key] = child;
+		}
+		if (source.nullable === true) return { anyOf: [result, { type: "null" }] };
+		for (const key of ["minimum", "maximum"]) {
+			const exclusive = key == "minimum" ? "exclusiveMinimum" : "exclusiveMaximum";
+			if (typeof result[exclusive] == "boolean") {
+				if (result[exclusive] && typeof result[key] == "number") {
+					result[exclusive] = result[key];
+					delete result[key];
+				} else delete result[exclusive];
+			}
+		}
+		return result;
+	}
+	let converted = convert(schemaValue);
+	if (typeof converted == "object" && converted != null && typeof object(converted).$ref == "string") {
+		const id = String(object(converted).$ref).slice(8);
+		const { $ref: _ref, ...siblings } = object(converted);
+		converted = {
+			...object(defs[id]),
+			...siblings
+		};
+	}
+	if (typeof converted == "boolean") return converted;
+	return {
+		$schema: "https://json-schema.org/draft/2020-12/schema",
+		...object(converted),
+		...Object.keys(defs).length ? { $defs: defs } : {}
+	};
+}
+function parameters(config) {
+	const doc = parseOpenApi(config.document);
+	const { item, op } = operation(doc, config.path, config.method);
+	const entries = /* @__PURE__ */ new Map();
+	for (const value of [...item.parameters ?? [], ...op.parameters ?? []]) {
+		const p = resolved(doc, value);
+		if (![
+			"path",
+			"query",
+			"header"
+		].includes(String(p.in)) || typeof p.name != "string" || p.content != null) throw new Error("Only schema-based path, query and header parameters are supported.");
+		if (p.allowReserved === true) throw new Error("allowReserved parameters are unsupported.");
+		if ((p.style ?? (p.in == "query" ? "form" : "simple")) != (p.in == "query" ? "form" : "simple")) throw new Error("Only form query and simple path/header serialization are supported.");
+		entries.set(`${p.in}.${p.in == "header" ? p.name.toLowerCase() : p.name}`, p);
+	}
+	return [...entries.values()];
+}
+function jsonContent(doc, value) {
+	const content = resolved(doc, value);
+	const media = object(content.content);
+	const mediaType = media["application/json"] != null ? "application/json" : Object.keys(media).find((key) => /^application\/.+\+json$/.test(key));
+	const json = mediaType == null ? void 0 : media[mediaType];
+	if (json == null) throw new Error("Only JSON request and response bodies are supported.");
+	return {
+		schema: schema$1(doc, object(json).schema ?? {}),
+		required: content.required === true,
+		mediaType
+	};
+}
+function authHandles(auth) {
+	return auth.flatMap((scheme) => scheme.type == "basic" ? [`auth.${scheme.id}.username`, `auth.${scheme.id}.password`] : [`auth.${scheme.id}.token`]);
+}
+function openApiTask(config, name = "OpenAPI") {
+	if (!config.path) return {
+		name,
+		executor: config,
+		inputs: [],
+		outputs: []
+	};
+	const doc = parseOpenApi(config.document);
+	const { op } = operation(doc, config.path, config.method);
+	const params = parameters(config);
+	const inputs = params.map((p) => {
+		const jsonSchema = schema$1(doc, p.schema ?? {});
+		const defaultValue = typeof jsonSchema == "boolean" ? void 0 : object(jsonSchema).default;
+		return {
+			handle: `${p.in}.${p.name}`,
+			jsonSchema,
+			nullable: p.required !== true && p.in != "path" || matchesSchema(null, jsonSchema),
+			...typeof p.description == "string" ? { description: p.description } : {},
+			...defaultValue === void 0 ? {} : { value: defaultValue }
+		};
+	});
+	if (op.requestBody != null) {
+		if (config.method == "get" || config.method == "head") throw new Error("GET and HEAD request bodies are unsupported.");
+		const body = jsonContent(doc, op.requestBody);
+		inputs.push({
+			handle: "body",
+			jsonSchema: body.schema,
+			nullable: !body.required || matchesSchema(null, body.schema)
+		});
+	}
+	const occupied = new Set(params.map((p) => `${p.in}.${p.in == "header" ? String(p.name).toLowerCase() : p.name}`));
+	for (const auth of config.auth) {
+		const location = auth.type == "apiKey" ? `${auth.in}.${auth.in == "header" ? auth.name?.toLowerCase() : auth.name}` : "header.authorization";
+		if (occupied.has(location)) throw new Error("Authentication conflicts with a parameter or another security scheme.");
+		if (auth.type == "apiKey" && (!auth.name || !["header", "query"].includes(auth.in ?? ""))) throw new Error("API Key requires a name and location.");
+		occupied.add(location);
+	}
+	inputs.push(...authHandles(config.auth).map((handle) => ({
+		handle,
+		jsonSchema: { type: "string" },
+		nullable: false
+	})));
+	const responses = object(op.responses);
+	const schemas = [];
+	for (const [status, response] of Object.entries(responses)) if (/^2\d\d$|^2XX$/.test(status) || status == "default") {
+		const r = resolved(doc, response);
+		if (r.content == null) schemas.push({ type: "null" });
+		else {
+			jsonContent(doc, r);
+			for (const [mediaType, media] of Object.entries(object(r.content))) if (/^application\/(json|.+\+json)$/.test(mediaType)) schemas.push(schema$1(doc, object(media).schema ?? {}));
+		}
+	}
+	if (!schemas.length) throw new Error("A successful JSON response definition is required.");
+	return {
+		name,
+		executor: config,
+		inputs,
+		outputs: [
+			{
+				handle: "body",
+				jsonSchema: schemas.length == 1 ? schemas[0] : {
+					$schema: "https://json-schema.org/draft/2020-12/schema",
+					anyOf: schemas.map((s, index) => inlineSchema(s, index))
+				},
+				nullable: config.method == "head" || schemas.some((item) => matchesSchema(null, item))
+			},
+			{
+				handle: "statusCode",
+				jsonSchema: { type: "integer" },
+				nullable: false
+			},
+			{
+				handle: "headers",
+				jsonSchema: {
+					type: "object",
+					additionalProperties: { type: "string" }
+				},
+				nullable: false
+			}
+		]
+	};
+}
+function inlineSchema(value, index) {
+	if (Array.isArray(value)) return value.map((item) => inlineSchema(item, index));
+	if (value == null || typeof value != "object") return value;
+	return Object.fromEntries(Object.entries(value).map(([key, child]) => [key, key == "$ref" && typeof child == "string" && child.startsWith("#/") ? `#/anyOf/${index}/${child.slice(2)}` : inlineSchema(child, index)]));
+}
+/** The canvas validator and property panel share the same configuration contract. */
+function openApiFieldIssues(task) {
+	if (task.executor.kind != "openapi") return [];
+	const config = task.executor;
+	let field = "sourceUrl";
+	try {
+		if (!config.sourceUrl.trim()) return [{
+			field,
+			message: "Enter an OpenAPI JSON document URL."
+		}];
+		httpUrl(config.sourceUrl);
+		field = "operation";
+		if (!config.path) return [{
+			field,
+			message: "Select an OpenAPI operation."
+		}];
+		field = "serverUrl";
+		httpUrl(config.serverUrl);
+		if (new URL(config.serverUrl).search) throw new Error("Server URLs must not contain a query string.");
+		field = "operation";
+		if (!dequal(config.document, snapshot(config.document, config.path, config.method))) return [{
+			field,
+			message: "Save only the selected operation and its dependencies."
+		}];
+		const expected = openApiTask(config, task.name);
+		if (!dequal(expected.inputs, task.inputs) || !dequal(expected.outputs, task.outputs)) return [{
+			field,
+			message: "OpenAPI ports must match the saved operation."
+		}];
+		return [];
+	} catch (error) {
+		return [{
+			field,
+			message: error.message
+		}];
+	}
+}
+function openApiIssues(task) {
+	return openApiFieldIssues(task).map((issue) => issue.message);
+}
+//#endregion
+//#region src/flow/common/promptTemplate.ts
+var promptReferencePattern = /\{\{\s*([^{}\s]+)\s*\}\}/g;
+function renderPrompt(template, input) {
+	return template.replace(promptReferencePattern, (match, name) => {
+		if (!Object.hasOwn(input, name)) return match;
+		const value = input[name];
+		return typeof value == "string" ? value : JSON.stringify(value);
+	});
+}
+//#endregion
+//#region src/flow/common/connectionUsage.ts
+function connectionUsage(document) {
+	const uses = [];
+	const graphs = [{
+		graph: document.graph,
+		target: { kind: "flow" },
+		name: ""
+	}, ...Object.entries(document.subflows).map(([id, subflow]) => ({
+		graph: subflow.graph,
+		target: {
+			kind: "subflow",
+			id
+		},
+		name: subflow.name
+	}))];
+	for (const { graph, target, name: graphName } of graphs) for (const [nodeId, node] of Object.entries(graph.nodes)) {
+		const task = node.kind == "task" && node.taskId != null ? document.tasks[node.taskId] : void 0;
+		const name = [graphName, node.name ?? task?.name ?? nodeId].filter(Boolean).join(" / ");
+		const add = (kind, actionId, connectionId) => {
+			uses.push({
+				kind,
+				providerId: actionId.split(".")[0],
+				actionId,
+				connectionId,
+				nodeId,
+				name,
+				target
+			});
+		};
+		if (node.kind == "poll" || node.kind == "integration") uses.push({
+			kind: "trigger",
+			providerId: node.definition.provider,
+			connectionId: node.connectionId,
+			nodeId,
+			name,
+			target
+		});
+		if (task?.executor.kind == "connector") add("connector", task.executor.action, task.executor.connectionId);
+		if (node.kind == "task" && node.task != null) {
+			for (const capability of node.task.capabilities ?? []) if ("mode" in capability && capability.mode == "independent") for (const action of capability.actions) add("code", action.action, action.connectionId);
+		}
+		if (task?.executor.kind == "agent") {
+			for (const tool of task.executor.tools) add("agent", tool.action, tool.connectionId);
+			const notification = task.executor.notification == null ? void 0 : document.tasks[task.executor.notification.taskId]?.executor;
+			if (notification?.kind == "connector") add("notification", notification.action, notification.connectionId);
+		}
+	}
+	return uses;
+}
+function removeConnectionUsage(content, connectionId) {
+	const document = content.document;
+	return {
+		...content,
+		document: {
+			...document,
+			tasks: Object.fromEntries(Object.entries(document.tasks).map(([id, task]) => {
+				const executor = task.executor;
+				if (executor.kind == "connector" && executor.connectionId == connectionId) {
+					const { connectionId: _, ...next } = executor;
+					return [id, {
+						...task,
+						executor: next
+					}];
+				}
+				if (executor.kind == "agent") return [id, {
+					...task,
+					executor: {
+						...executor,
+						tools: executor.tools.map((tool) => {
+							if (tool.connectionId != connectionId) return tool;
+							const { connectionId: _, ...next } = tool;
+							return next;
+						})
+					}
+				}];
+				return [id, task];
+			})),
+			graph: clearNodeConnections(document.graph, connectionId),
+			subflows: Object.fromEntries(Object.entries(document.subflows).map(([id, subflow]) => [id, {
+				...subflow,
+				graph: clearNodeConnections(subflow.graph, connectionId)
+			}]))
+		}
+	};
+}
+function clearNodeConnections(graph, connectionId) {
+	return {
+		...graph,
+		nodes: Object.fromEntries(Object.entries(graph.nodes).map(([id, node]) => {
+			if ((node.kind == "poll" || node.kind == "integration") && node.connectionId == connectionId) {
+				const { connectionId: _, ...remaining } = node;
+				return [id, remaining];
+			}
+			if (node.kind != "task" || node.task == null) return [id, node];
+			const capabilities = node.task.capabilities?.map((capability) => {
+				if (!("mode" in capability) || capability.mode != "independent") return capability;
+				return {
+					...capability,
+					actions: capability.actions.map((action) => {
+						if (action.connectionId != connectionId) return action;
+						const { connectionId: _, ...remaining } = action;
+						return remaining;
+					})
+				};
+			});
+			return [id, capabilities == null ? node : {
+				...node,
+				task: {
+					...node.task,
+					capabilities
+				}
+			}];
+		}))
+	};
+}
+//#endregion
+//#region src/base/common/json.ts
+function hasJsonShape(root) {
+	if (root === null || typeof root == "boolean" || typeof root == "string") return true;
+	if (typeof root == "number") return Number.isFinite(root);
+	if (typeof root != "object") return false;
+	const ancestors = /* @__PURE__ */ new Set();
+	const pending = [];
+	let value = root;
+	traversal: while (true) {
+		let keys;
+		let arrayLength;
+		if (Array.isArray(value)) {
+			arrayLength = value.length;
+			keys = Reflect.ownKeys(value);
+			if (keys.length != arrayLength + 1) return false;
+		} else {
+			const prototype = Reflect.getPrototypeOf(value);
+			if (prototype != Object.prototype && prototype != null) return false;
+			keys = Reflect.ownKeys(value);
+			arrayLength = void 0;
+		}
+		ancestors.add(value);
+		let index = 0;
+		while (true) {
+			if (index >= keys.length) {
+				ancestors.delete(value);
+				const parent = pending.pop();
+				if (parent === void 0) return true;
+				value = parent.value;
+				keys = parent.keys;
+				arrayLength = parent.arrayLength;
+				index = parent.index;
+				continue;
+			}
+			const key = keys[index++];
+			if (arrayLength !== void 0) {
+				if (key == "length") continue;
+				if (typeof key != "string") return false;
+				const arrayIndex = Number(key);
+				if (!Number.isSafeInteger(arrayIndex) || arrayIndex < 0 || arrayIndex >= arrayLength || String(arrayIndex) != key) return false;
+			} else if (typeof key != "string") return false;
+			const descriptor = Reflect.getOwnPropertyDescriptor(value, key);
+			if (descriptor?.enumerable != true || !Object.hasOwn(descriptor, "value")) return false;
+			const child = descriptor.value;
+			if (child === null || typeof child == "boolean" || typeof child == "string") continue;
+			if (typeof child == "number") {
+				if (!Number.isFinite(child)) return false;
+				continue;
+			}
+			if (typeof child != "object" || ancestors.has(child)) return false;
+			pending.push({
+				value,
+				keys,
+				arrayLength,
+				index
+			});
+			value = child;
+			continue traversal;
+		}
+	}
+}
+function isJsonObject(value) {
+	try {
+		return value != null && typeof value == "object" && !Array.isArray(value) && hasJsonShape(value);
+	} catch {
+		return false;
+	}
+}
+//#endregion
 //#region src/trigger/common/contract.ts
 var errorOutputs = [
 	{
@@ -11671,7 +12073,7 @@ function validateResolution(nodeId, node, allowed, path, diagnostics) {
 function validateGraph(graph, document, flowInputs, allowTriggers, path, diagnostics) {
 	const analysis = graphPaths(graph);
 	const errorTriggers = Object.entries(graph.nodes).filter(([, node]) => node.kind == "error");
-	if (errorTriggers.length > 1) for (const [nodeId] of errorTriggers) diagnostics.push(graphDiagnostic("graph.error-trigger-duplicate", "A graph can contain only one Error Trigger.", `${path}/nodes/${nodeId}`));
+	if (errorTriggers.length > 1) for (const [nodeId] of errorTriggers) diagnostics.push(graphDiagnostic("graph.error-trigger-duplicate", "A graph can contain only one Flow Error node.", `${path}/nodes/${nodeId}`));
 	const manualTriggers = Object.entries(graph.nodes).filter(([, node]) => node.kind == "manual");
 	if (manualTriggers.length > 1) for (const [nodeId] of manualTriggers) diagnostics.push(graphDiagnostic("graph.manual-trigger-duplicate", "A graph can contain only one manual Trigger.", `${path}/nodes/${nodeId}`));
 	const seen = /* @__PURE__ */ new Set();
@@ -23642,6 +24044,26 @@ async function validateFlow(revision, engine) {
 	for (const taskId of [...closure.dependencies.tasks].toSorted()) {
 		const task = revision.document.tasks[taskId];
 		if (task == null) continue;
+		for (const message of openApiIssues(task)) checked.diagnostics.push({
+			code: "openapi.config-invalid",
+			column: 0,
+			line: 1,
+			message,
+			path: `/document/tasks/${taskId}/executor`
+		});
+		if (task.executor.kind == "openapi") {
+			const handles = authHandles(task.executor.auth);
+			for (const [graphPath, graph] of graphs) for (const [nodeId, node] of Object.entries(graph.nodes)) if (node.kind == "task" && node.taskId == taskId) for (const handle of handles) {
+				const mapping = node.inputs[handle];
+				if (mapping?.kind != "sources" || mapping.sources.length == 0 || mapping.sources.some((source) => source.kind == "flow")) checked.diagnostics.push({
+					code: "openapi.auth-source",
+					column: 0,
+					line: 1,
+					message: "Authentication requires a deployment variable or upstream output.",
+					path: `${graphPath}/nodes/${nodeId}/inputs/${handle}`
+				});
+			}
+		}
 		for (const message of agentConfigIssues(task, revision.document.tasks)) checked.diagnostics.push({
 			code: "agent.config-invalid",
 			column: 0,