@legatoacc3/workflow-builder 0.1.0-alpha.0

package/dist/domain/builder-node-definition.js

@@ -0,0 +1,1275 @@
+//#region src/domain/builder-node-definition.ts
+function formatCodeLanguageLabel(language) {
+	return language === "python" ? "PYTHON3" : "JAVASCRIPT";
+}
+function createInspectorSections(titles) {
+	return titles;
+}
+var difyStandardSections = createInspectorSections([
+	{
+		id: "core",
+		kind: "core",
+		title: "Core Settings",
+		description: "Primary node configuration required for this step."
+	},
+	{
+		id: "advanced",
+		kind: "advanced",
+		title: "Advanced",
+		description: "Optional tuning and advanced behavior."
+	},
+	{
+		id: "outputs",
+		kind: "outputs",
+		title: "Outputs",
+		description: "Variables or response structure produced by this node."
+	},
+	{
+		id: "last-run",
+		kind: "last-run",
+		title: "Last Run",
+		description: "Most recent execution details for this node."
+	}
+]);
+var branchConditionSourceOptions = [
+	{
+		label: "Form Field",
+		value: "form-field"
+	},
+	{
+		label: "Workflow State",
+		value: "workflow-state"
+	},
+	{
+		label: "Approval Decision",
+		value: "approval-decision"
+	},
+	{
+		label: "Confidence Threshold",
+		value: "confidence-threshold"
+	},
+	{
+		label: "Policy Outcome",
+		value: "policy-outcome"
+	}
+];
+function inferLegacyConditionValueType(rawValue) {
+	const normalizedValue = rawValue.trim().replace(/^['"]|['"]$/g, "");
+	if (normalizedValue === "true" || normalizedValue === "false") return "boolean";
+	if (normalizedValue !== "" && Number.isFinite(Number(normalizedValue))) return "number";
+	return "string";
+}
+function parseLegacyBranchConditionExpression(expression) {
+	const normalizedExpression = expression.trim();
+	if (!normalizedExpression) return [];
+	const comparisonMatch = /^([A-Za-z0-9_.-]+)\s*(==|!=|>=|<=|>|<)\s*(.+)$/.exec(normalizedExpression);
+	if (!comparisonMatch) return [{
+		id: crypto.randomUUID(),
+		variableId: normalizedExpression,
+		variableLabel: normalizedExpression,
+		valueType: "string",
+		operator: "exists",
+		value: ""
+	}];
+	const variableId = comparisonMatch[1] ?? normalizedExpression;
+	const operator = comparisonMatch[2] ?? "==";
+	const normalizedValue = (comparisonMatch[3] ?? "").trim().replace(/^['"]|['"]$/g, "");
+	return [{
+		id: crypto.randomUUID(),
+		variableId,
+		variableLabel: variableId,
+		valueType: inferLegacyConditionValueType(normalizedValue),
+		operator: {
+			"==": "is",
+			"!=": "is-not",
+			">": ">",
+			"<": "<",
+			">=": ">=",
+			"<=": "<="
+		}[operator] ?? "is",
+		value: normalizedValue
+	}];
+}
+function formatIfElseConditionValue(value, valueType, operator) {
+	if ([
+		"exists",
+		"not-exists",
+		"empty",
+		"not-empty"
+	].includes(operator)) return "";
+	if (valueType === "number" || valueType === "boolean") return value.trim();
+	return value.trim() ? `"${value.trim()}"` : "\"\"";
+}
+function buildIfElseConditionRowExpression(row) {
+	switch (row.operator) {
+		case "exists": return row.variableId;
+		case "not-exists": return `NOT ${row.variableId}`;
+		case "empty": return `${row.variableId} is empty`;
+		case "not-empty": return `${row.variableId} is not empty`;
+		case "contains": return `${row.variableId} contains ${formatIfElseConditionValue(row.value, row.valueType, row.operator)}`;
+		case "not-contains": return `${row.variableId} not contains ${formatIfElseConditionValue(row.value, row.valueType, row.operator)}`;
+		case "is": return `${row.variableId} == ${formatIfElseConditionValue(row.value, row.valueType, row.operator)}`;
+		case "is-not": return `${row.variableId} != ${formatIfElseConditionValue(row.value, row.valueType, row.operator)}`;
+		default: return `${row.variableId} ${row.operator} ${formatIfElseConditionValue(row.value, row.valueType, row.operator)}`;
+	}
+}
+function buildIfElseConditionExpression(condition) {
+	const rows = condition.rows?.filter((row) => row.variableId.trim()) ?? [];
+	if (!rows.length) return condition.expression?.trim() ?? "";
+	const joiner = condition.logicalOperator === "or" ? " OR " : " AND ";
+	return rows.map(buildIfElseConditionRowExpression).join(joiner);
+}
+function normalizeIfElseCaseComparisonOperator(operator) {
+	const normalizedOperator = String(operator ?? "").trim().toLowerCase();
+	switch (normalizedOperator) {
+		case "=": return "is";
+		case "!=":
+		case "<>": return "is-not";
+		case "not contains": return "not-contains";
+		case "not exists": return "not-exists";
+		case "not empty": return "not-empty";
+		default: return normalizedOperator;
+	}
+}
+function normalizeIfElseCaseValueType(valueType) {
+	if (valueType === "number") return "number";
+	if (valueType === "boolean") return "boolean";
+	return "string";
+}
+function getIfElseOperatorsForValueType(valueType) {
+	if (valueType === "number") return [
+		">",
+		"<",
+		">=",
+		"<=",
+		"is",
+		"is-not",
+		"exists",
+		"not-exists",
+		"empty",
+		"not-empty"
+	];
+	if (valueType === "boolean") return [
+		"is",
+		"is-not",
+		"exists",
+		"not-exists"
+	];
+	return [
+		"contains",
+		"not-contains",
+		"is",
+		"is-not",
+		"exists",
+		"not-exists",
+		"empty",
+		"not-empty"
+	];
+}
+function normalizeIfElseConditionRowOperator(operator, valueType) {
+	const normalizedOperator = normalizeIfElseCaseComparisonOperator(operator);
+	if (new Set(getIfElseOperatorsForValueType(valueType)).has(normalizedOperator)) return normalizedOperator;
+	if (valueType === "number") return ">";
+	if (valueType === "boolean") return "is";
+	return "contains";
+}
+function normalizeIfElseConditionRowValue(value, valueType, operator) {
+	if ([
+		"exists",
+		"not-exists",
+		"empty",
+		"not-empty"
+	].includes(operator)) return "";
+	if (valueType === "boolean") return value === false || String(value).trim().toLowerCase() === "false" ? "false" : "true";
+	if (Array.isArray(value)) return value.join(".");
+	return String(value ?? "");
+}
+function buildIfElseRowFromCaseCondition(condition) {
+	const variableId = Array.isArray(condition.variable_selector) && condition.variable_selector.length > 0 ? condition.variable_selector.join(".") : "";
+	if (!variableId) return null;
+	const valueType = normalizeIfElseCaseValueType(condition.varType);
+	const operator = normalizeIfElseConditionRowOperator(condition.comparison_operator, valueType);
+	return {
+		id: condition.id,
+		variableId,
+		variableLabel: variableId,
+		valueType,
+		operator,
+		value: normalizeIfElseConditionRowValue(condition.value, valueType, operator)
+	};
+}
+function buildIfElseCaseConditionFromRow(row) {
+	return {
+		id: row.id,
+		varType: row.valueType === "number" ? "number" : row.valueType === "boolean" ? "boolean" : "string",
+		variable_selector: row.variableId.split(".").map((segment) => segment.trim()).filter(Boolean),
+		comparison_operator: row.operator,
+		value: row.valueType === "boolean" ? row.value === "false" ? false : true : row.value
+	};
+}
+function buildIfElseCasesFromBranchConditions(branches, branchConditions = []) {
+	return branches.filter((branch) => branch.type !== "else").map((branch) => {
+		const branchCondition = branchConditions.find((condition) => condition.branchId === branch.id);
+		const rows = branchCondition?.rows?.filter((row) => row.variableId.trim()) ?? [];
+		return {
+			case_id: branch.id,
+			logical_operator: branchCondition?.logicalOperator === "or" ? "or" : "and",
+			conditions: rows.map(buildIfElseCaseConditionFromRow)
+		};
+	});
+}
+function buildBranchConditionsFromIfElseCases(branches, cases, existingConditions = []) {
+	return branches.filter((branch) => branch.type !== "else").map((branch) => {
+		const matchingCase = cases?.find((entry) => entry.case_id === branch.id);
+		const existingCondition = existingConditions.find((condition) => condition.branchId === branch.id);
+		const rows = matchingCase?.conditions?.map(buildIfElseRowFromCaseCondition).filter((row) => Boolean(row)) ?? [];
+		const nextCondition = {
+			branchId: branch.id,
+			type: branch.type,
+			source: existingCondition?.source ?? "workflow-state",
+			logicalOperator: matchingCase?.logical_operator === "or" ? "or" : existingCondition?.logicalOperator ?? "and",
+			rows,
+			expression: existingCondition?.expression ?? ""
+		};
+		return {
+			...nextCondition,
+			expression: buildIfElseConditionExpression(nextCondition)
+		};
+	});
+}
+function buildNormalizedBranchConditions(branches, existingConditions = []) {
+	return branches.filter((branch) => branch.type !== "else").map((branch) => {
+		const existingCondition = existingConditions.find((condition) => condition.branchId === branch.id);
+		const rows = existingCondition?.rows?.length ? existingCondition.rows : parseLegacyBranchConditionExpression(existingCondition?.expression ?? "");
+		const normalizedCondition = {
+			branchId: branch.id,
+			type: branch.type,
+			source: existingCondition?.source ?? "workflow-state",
+			logicalOperator: existingCondition?.logicalOperator ?? "and",
+			rows,
+			expression: existingCondition?.expression ?? ""
+		};
+		return {
+			...normalizedCondition,
+			expression: buildIfElseConditionExpression(normalizedCondition)
+		};
+	});
+}
+function buildSingleMetricSummary(eyebrow, badge, description, metricLabel, metricValue, footer) {
+	return {
+		eyebrow,
+		badge,
+		description,
+		metrics: [{
+			label: metricLabel,
+			value: metricValue
+		}],
+		footer
+	};
+}
+function buildModelSummaryValue(model) {
+	if (!model) return "Not configured";
+	const provider = model.provider.trim();
+	const name = model.name.trim();
+	if (provider && name) return `${provider}/${name}`;
+	return name || provider || "Not configured";
+}
+function formatSelectorSummaryValue(value) {
+	if (Array.isArray(value)) return value.length > 0 ? value.join(".") : "Not configured";
+	return String(value ?? "").trim() || "Not configured";
+}
+var builderNodeDefinitions = {
+	start: {
+		kind: "start",
+		family: "start-input",
+		publicLabel: "User Input",
+		badge: "User Input",
+		description: "Collect user-provided variables at workflow start.",
+		supportsDifyParity: true,
+		inspectorSections: difyStandardSections,
+		createDefaultConfig: () => ({
+			kind: "start",
+			variables: []
+		}),
+		buildSummary: (config) => buildSingleMetricSummary("User input", "User Input", "Define the inputs exposed when the workflow starts.", "Variables", String(config.variables.length || 0), config.variables.length > 0 ? "Start input fields" : "No custom fields")
+	},
+	"schedule-trigger": {
+		kind: "schedule-trigger",
+		family: "trigger",
+		publicLabel: "Schedule Trigger",
+		badge: "Trigger",
+		description: "Start this workflow on a schedule.",
+		supportsDifyParity: true,
+		inspectorSections: difyStandardSections,
+		createDefaultConfig: () => ({
+			kind: "schedule-trigger",
+			schedule: "",
+			cron_expression: "",
+			mode: "visual",
+			frequency: "daily",
+			visualConfig: {
+				time: "09:00",
+				weekdays: ["1"],
+				onMinute: 0,
+				monthlyDays: [1]
+			},
+			visual_config: {
+				time: "09:00",
+				weekdays: ["1"],
+				on_minute: 0,
+				monthly_days: [1]
+			}
+		}),
+		buildSummary: (config, input) => ({
+			eyebrow: "Scheduled start",
+			badge: "Trigger",
+			description: "Start this workflow on a recurring schedule.",
+			metrics: [{
+				label: "Schedule",
+				value: input?.nextExecutionLabel || config.schedule || "Not configured"
+			}]
+		})
+	},
+	"webhook-trigger": {
+		kind: "webhook-trigger",
+		family: "trigger",
+		publicLabel: "Webhook Trigger",
+		badge: "Trigger",
+		description: "Start this workflow from an inbound webhook.",
+		supportsDifyParity: true,
+		inspectorSections: difyStandardSections,
+		createDefaultConfig: () => ({
+			kind: "webhook-trigger",
+			webhook_url: "",
+			webhook_debug_url: "",
+			method: "POST",
+			content_type: "application/json",
+			headers: [],
+			params: [],
+			body: [],
+			async_mode: true,
+			status_code: 200,
+			response_body: "",
+			variables: [{
+				id: "webhook-raw",
+				variable: "_webhook_raw",
+				label: "raw",
+				value_selector: [],
+				value_type: "object",
+				required: true
+			}]
+		}),
+		buildSummary: (config) => ({
+			eyebrow: "Webhook start",
+			badge: "Trigger",
+			description: "Run this workflow from an inbound webhook.",
+			metrics: [{
+				label: "URL",
+				value: config.webhook_url || "Not configured"
+			}, {
+				label: "Method",
+				value: config.method
+			}],
+			footer: config.params.length + config.body.length > 0 ? `${config.params.length + config.body.length} extracted variable${config.params.length + config.body.length === 1 ? "" : "s"}` : "Inbound request setup required"
+		})
+	},
+	"trigger-plugin": {
+		kind: "trigger-plugin",
+		family: "trigger",
+		publicLabel: "Trigger Plugin",
+		badge: "Trigger",
+		description: "Start this workflow from a plugin event trigger.",
+		supportsDifyParity: true,
+		inspectorSections: difyStandardSections,
+		createDefaultConfig: () => ({
+			kind: "trigger-plugin",
+			provider_id: "",
+			provider_type: "",
+			provider_name: "",
+			event_name: "",
+			event_label: "",
+			event_parameters: {},
+			event_configurations: {},
+			output_schema: [],
+			parameters_schema: [],
+			event_node_version: "2",
+			config: {},
+			plugin_id: ""
+		}),
+		buildSummary: (config) => ({
+			eyebrow: "Plugin event start",
+			badge: "Trigger",
+			description: "Start this workflow when a plugin event fires.",
+			metrics: [{
+				label: "Provider",
+				value: config.provider_name || config.provider_id || "Not configured"
+			}, {
+				label: "Event",
+				value: config.event_label || config.event_name || "Required"
+			}],
+			footer: config.subscription_id?.trim() ? `Subscription: ${config.subscription_id}` : `${Object.keys(config.event_parameters ?? {}).length} event parameter(s)`
+		})
+	},
+	"data-source": {
+		kind: "data-source",
+		family: "start-input",
+		publicLabel: "Data Source",
+		badge: "Data Source",
+		description: "Start from a configured data source such as local files or plugin data.",
+		supportsDifyParity: true,
+		inspectorSections: difyStandardSections,
+		createDefaultConfig: () => ({
+			kind: "data-source",
+			plugin_id: "",
+			provider_type: "",
+			provider_name: "",
+			datasource_name: "",
+			datasource_label: "",
+			datasource_parameters: {},
+			datasource_configurations: {},
+			output_schema: [],
+			fileExtensions: []
+		}),
+		buildSummary: (config) => ({
+			eyebrow: "Data source start",
+			badge: "Data Source",
+			description: "Start this workflow from data emitted by a configured source.",
+			metrics: [{
+				label: "Provider",
+				value: config.provider_name || config.plugin_id || "Not configured"
+			}, {
+				label: "Source",
+				value: config.datasource_label || config.datasource_name || "Required"
+			}],
+			footer: config.provider_type === "local_file" ? `${config.fileExtensions?.length ?? 0} file extension(s)` : `${Object.keys(config.datasource_parameters ?? {}).length} parameter(s)`
+		})
+	},
+	end: {
+		kind: "end",
+		family: "output-response",
+		publicLabel: "Output",
+		badge: "Output",
+		description: "Expose workflow outputs for downstream consumers.",
+		supportsDifyParity: true,
+		inspectorSections: difyStandardSections,
+		createDefaultConfig: () => ({
+			kind: "end",
+			outputs: [{
+				id: "output-1",
+				variable: "",
+				value_selector: []
+			}]
+		}),
+		buildSummary: (config) => buildSingleMetricSummary("Workflow exit", "Output", "Expose final workflow outputs.", "Outputs", String(config.outputs.filter((entry) => entry.variable.trim()).length), "Named outputs")
+	},
+	answer: {
+		kind: "answer",
+		family: "output-response",
+		publicLabel: "Answer",
+		badge: "Answer",
+		description: "Compose the chat response returned to the user.",
+		supportsDifyParity: true,
+		inspectorSections: difyStandardSections,
+		createDefaultConfig: () => ({
+			kind: "answer",
+			variables: [],
+			answer: ""
+		}),
+		buildSummary: (config) => buildSingleMetricSummary("Chat response", "Answer", "Compose the response body returned in a chat-style flow.", "Content", config.answer.trim() ? "Configured" : "Required", "Supports variable insertion")
+	},
+	llm: {
+		kind: "llm",
+		family: "reasoning-routing",
+		publicLabel: "LLM",
+		badge: "LLM",
+		description: "Reason, generate, or transform using a language model.",
+		supportsDifyParity: true,
+		inspectorSections: difyStandardSections,
+		createDefaultConfig: () => ({
+			kind: "llm",
+			model: {
+				provider: "",
+				name: ""
+			},
+			prompt_template: "",
+			prompt_config: { jinja2_variables: [] },
+			context: {
+				enabled: false,
+				variable_selector: []
+			},
+			memory: {
+				window: {
+					enabled: false,
+					size: 3
+				},
+				query_prompt_template: ""
+			},
+			vision: {
+				enabled: false,
+				configs: {
+					variable_selector: [],
+					detail: "low"
+				}
+			},
+			structured_output_enabled: false,
+			structured_output: { schema: "" },
+			reasoning_format: "tagged"
+		}),
+		buildSummary: (config) => ({
+			eyebrow: "Model step",
+			badge: "LLM",
+			description: "Call a language model to reason, generate text, or transform inputs.",
+			metrics: [{
+				label: "Model",
+				value: buildModelSummaryValue(config.model)
+			}, {
+				label: "Prompt",
+				value: config.prompt_template.trim() ? `${config.prompt_template.trim().length} chars` : "Required"
+			}],
+			footer: config.context.variable_selector.length > 0 ? `Context: ${config.context.variable_selector.join(".")}` : "Prompt required"
+		})
+	},
+	"knowledge-retrieval": {
+		kind: "knowledge-retrieval",
+		family: "reasoning-routing",
+		publicLabel: "Knowledge Retrieval",
+		badge: "Knowledge",
+		description: "Retrieve grounded context from one or more knowledge bases.",
+		supportsDifyParity: true,
+		inspectorSections: difyStandardSections,
+		createDefaultConfig: () => ({
+			kind: "knowledge-retrieval",
+			query_variable_selector: [],
+			query_attachment_selector: [],
+			dataset_ids: [],
+			retrieval_mode: "multiple",
+			multiple_retrieval_config: {
+				top_k: 3,
+				reranking_enable: false,
+				reranking_model: null
+			},
+			single_retrieval_config: { model: null },
+			metadata_filtering_mode: "disabled",
+			metadata_filtering_conditions: {
+				logical_operator: "and",
+				conditions: []
+			},
+			metadata_model_config: null
+		}),
+		buildSummary: (config) => ({
+			eyebrow: "Retrieval step",
+			badge: "Knowledge",
+			description: "Query a knowledge base and pass grounded context downstream.",
+			metrics: [{
+				label: "Datasets",
+				value: String(config.dataset_ids.length)
+			}, {
+				label: "Recall",
+				value: config.retrieval_mode === "single" ? "Single" : `Top ${config.multiple_retrieval_config.top_k}`
+			}],
+			footer: formatSelectorSummaryValue(config.query_variable_selector) !== "Not configured" ? `Query: ${formatSelectorSummaryValue(config.query_variable_selector)}` : "Query variable required"
+		})
+	},
+	"question-classifier": {
+		kind: "question-classifier",
+		family: "reasoning-routing",
+		publicLabel: "Question Classifier",
+		badge: "Classifier",
+		description: "Route by categories inferred from the input.",
+		supportsDifyParity: true,
+		inspectorSections: difyStandardSections,
+		createDefaultConfig: () => ({
+			kind: "question-classifier",
+			query_variable_selector: [],
+			model: {
+				provider: "",
+				name: ""
+			},
+			classes: [{
+				id: "1",
+				name: "",
+				label: "CLASS 1"
+			}, {
+				id: "2",
+				name: "",
+				label: "CLASS 2"
+			}],
+			instruction: "",
+			memory: { window: {
+				enabled: false,
+				size: 3
+			} },
+			vision: {
+				enabled: false,
+				configs: {
+					variable_selector: [],
+					detail: "low"
+				}
+			}
+		}),
+		buildSummary: (config) => ({
+			eyebrow: "Routing step",
+			badge: "Classifier",
+			description: "Classify the incoming question and route to the right branch.",
+			metrics: [{
+				label: "Model",
+				value: buildModelSummaryValue(config.model)
+			}, {
+				label: "Classes",
+				value: String(config.classes.length)
+			}],
+			footer: config.classes.length > 0 ? config.classes.map((entry, index) => (entry.label || entry.name || `CLASS ${index + 1}`).trim()).filter(Boolean).slice(0, 3).join(" / ") || "Input variable required" : "Input variable required"
+		})
+	},
+	"if-else": {
+		kind: "if-else",
+		family: "reasoning-routing",
+		publicLabel: "If-Else",
+		badge: "If-Else",
+		description: "Route through IF, ELIF, or ELSE branches.",
+		supportsDifyParity: true,
+		inspectorSections: difyStandardSections,
+		createDefaultConfig: () => ({
+			kind: "if-else",
+			branchConditions: [],
+			_targetBranches: [{
+				id: "true",
+				name: "IF"
+			}, {
+				id: "false",
+				name: "ELSE"
+			}],
+			cases: [{
+				case_id: "true",
+				logical_operator: "and",
+				conditions: []
+			}],
+			logical_operator: "and",
+			conditions: [],
+			isInIteration: false,
+			isInLoop: false
+		}),
+		buildSummary: (config, input) => ({
+			eyebrow: "Condition step",
+			badge: "If-Else",
+			description: "Evaluate explicit conditions and route through IF, ELIF, or ELSE.",
+			metrics: [{
+				label: "Conditions",
+				value: String(config.branchConditions.length)
+			}, {
+				label: "Branches",
+				value: String(input?.conditionalBranches?.length ?? config.branchConditions.length + 1)
+			}],
+			footer: config.branchConditions.length > 0 ? `${new Set(config.branchConditions.map((condition) => condition.source || "workflow-state")).size} source type(s)` : "Exclusive branch routing"
+		})
+	},
+	"variable-aggregator": {
+		kind: "variable-aggregator",
+		family: "reasoning-routing",
+		publicLabel: "Variable Aggregator",
+		badge: "Aggregator",
+		description: "Converge exclusive-branch variables into grouped outputs.",
+		supportsDifyParity: true,
+		inspectorSections: difyStandardSections,
+		createDefaultConfig: () => ({
+			kind: "variable-aggregator",
+			output_type: "string",
+			variables: [],
+			advanced_settings: {
+				group_enabled: false,
+				groups: [{
+					groupId: "group-1",
+					group_name: "",
+					output_type: "string",
+					variables: []
+				}]
+			}
+		}),
+		buildSummary: (config) => ({
+			eyebrow: "Merge step",
+			badge: "Aggregator",
+			description: "Merge variables from exclusive branches into unified outputs.",
+			metrics: [{
+				label: "Mode",
+				value: config.advanced_settings.group_enabled ? `${config.advanced_settings.groups.length} groups` : "Single output"
+			}, {
+				label: "Sources",
+				value: String(config.advanced_settings.group_enabled ? config.advanced_settings.groups.reduce((count, group) => count + group.variables.length, 0) : config.variables.length)
+			}],
+			footer: config.advanced_settings.group_enabled ? "Exclusive-branch convergence only" : config.variables.length > 0 ? `Input: ${config.variables.map((selector) => selector.join(".")).join(", ")}` : "No source variables configured"
+		})
+	},
+	code: {
+		kind: "code",
+		family: "transformation",
+		publicLabel: "Code",
+		badge: "Code",
+		description: "Execute custom script logic.",
+		supportsDifyParity: true,
+		inspectorSections: difyStandardSections,
+		createDefaultConfig: () => ({
+			kind: "code",
+			language: "python",
+			variables: [],
+			code_language: "python3",
+			code: "",
+			outputs: {},
+			script: "def main():\n    return {\n        \"result\": \"\"\n    }\n",
+			inputVariables: [],
+			outputVariables: [{
+				id: "output-1",
+				name: "result",
+				dataType: "string"
+			}],
+			retryCount: 0,
+			retryIntervalMs: 1e3,
+			errorHandling: "none"
+		}),
+		buildSummary: (config) => ({
+			eyebrow: "Logic step",
+			badge: "Code",
+			description: "Run custom logic to transform data or enforce workflow-specific behavior.",
+			metrics: [{
+				label: "Language",
+				value: formatCodeLanguageLabel(config.language)
+			}, {
+				label: "Outputs",
+				value: String(config.outputVariables.length)
+			}],
+			footer: config.script.trim() ? `${config.script.trim().split("\n").length} line${config.script.trim().split("\n").length === 1 ? "" : "s"}` : (config.retryCount ?? 0) > 0 ? `Retry ${config.retryCount} time${config.retryCount === 1 ? "" : "s"} on failure` : config.inputVariables.length > 0 ? `${config.inputVariables.length} input variable${config.inputVariables.length === 1 ? "" : "s"}` : "Script required"
+		})
+	},
+	template: {
+		kind: "template",
+		family: "transformation",
+		publicLabel: "Template",
+		badge: "Template",
+		description: "Format variables into structured text using a template.",
+		supportsDifyParity: true,
+		inspectorSections: difyStandardSections,
+		createDefaultConfig: () => ({
+			kind: "template",
+			variables: [],
+			template: ""
+		}),
+		buildSummary: (config) => ({
+			eyebrow: "Formatting step",
+			badge: "Template",
+			description: "Format variables into structured text using a reusable template.",
+			metrics: [{
+				label: "Output",
+				value: "output"
+			}],
+			footer: config.template.trim() ? "Template configured" : "Template body required"
+		})
+	},
+	"parameter-extractor": {
+		kind: "parameter-extractor",
+		family: "transformation",
+		publicLabel: "Parameter Extractor",
+		badge: "Extractor",
+		description: "Extract structured parameters from natural language.",
+		supportsDifyParity: true,
+		inspectorSections: difyStandardSections,
+		createDefaultConfig: () => ({
+			kind: "parameter-extractor",
+			query: [],
+			model: {
+				provider: "",
+				name: ""
+			},
+			parameters: [],
+			instruction: "",
+			reasoning_mode: "prompt",
+			memory: { window: {
+				enabled: false,
+				size: 3
+			} },
+			vision: {
+				enabled: false,
+				configs: {
+					variable_selector: [],
+					detail: "low"
+				}
+			}
+		}),
+		buildSummary: (config) => ({
+			eyebrow: "Structured input",
+			badge: "Extractor",
+			description: "Extract structured parameters from natural language input.",
+			metrics: [{
+				label: "Parameters",
+				value: String(config.parameters.length)
+			}, {
+				label: "Model",
+				value: buildModelSummaryValue(config.model)
+			}],
+			footer: config.query.length > 0 ? `Input: ${config.query.join(".")}` : "Input variable required"
+		})
+	},
+	"doc-extractor": {
+		kind: "doc-extractor",
+		family: "transformation",
+		publicLabel: "Doc Extractor",
+		badge: "Doc Extractor",
+		description: "Extract text from uploaded documents.",
+		supportsDifyParity: true,
+		inspectorSections: difyStandardSections,
+		createDefaultConfig: () => ({
+			kind: "doc-extractor",
+			variable_selector: [],
+			is_array_file: false
+		}),
+		buildSummary: (config) => buildSingleMetricSummary("Document parsing", "Doc Extractor", "Extract structured content from uploaded documents and files.", "Source", formatSelectorSummaryValue(config.variable_selector), "Document text extraction")
+	},
+	"list-operator": {
+		kind: "list-operator",
+		family: "transformation",
+		publicLabel: "List Operator",
+		badge: "List Operator",
+		description: "Filter, sort, or reshape arrays.",
+		supportsDifyParity: true,
+		inspectorSections: difyStandardSections,
+		createDefaultConfig: () => ({
+			kind: "list-operator",
+			inputArrayVariable: [],
+			operation: "map",
+			operationConfig: "",
+			variable: [],
+			var_type: "",
+			item_var_type: "",
+			filterEnabled: false,
+			filterCondition: {
+				key: "",
+				operator: "contains",
+				value: ""
+			},
+			filter_by: {
+				enabled: false,
+				conditions: []
+			},
+			extractEnabled: false,
+			extractTemplate: "1",
+			extract_by: {
+				enabled: false,
+				serial: "1"
+			},
+			orderByEnabled: false,
+			orderByKey: [],
+			orderByDirection: "asc",
+			order_by: {
+				enabled: false,
+				key: [],
+				value: "asc"
+			},
+			limit: {
+				enabled: false,
+				size: 10
+			}
+		}),
+		buildSummary: (config) => ({
+			eyebrow: "Array processing",
+			badge: "List Operator",
+			description: "Filter, sort, and select items from an array variable.",
+			metrics: [{
+				label: "Operation",
+				value: config.operation
+			}, {
+				label: "Input",
+				value: formatSelectorSummaryValue(config.inputArrayVariable)
+			}],
+			footer: "Array transformation"
+		})
+	},
+	"variable-assigner": {
+		kind: "variable-assigner",
+		family: "transformation",
+		publicLabel: "Variable Assigner",
+		badge: "Assigner",
+		description: "Persist or update workflow variables.",
+		supportsDifyParity: true,
+		inspectorSections: difyStandardSections,
+		createDefaultConfig: () => ({
+			kind: "variable-assigner",
+			version: "2",
+			items: [{
+				id: "assignment-1",
+				variable_selector: [],
+				input_type: "variable",
+				operation: "over-write",
+				value: ""
+			}]
+		}),
+		buildSummary: (config) => ({
+			eyebrow: "Variable step",
+			badge: "Assigner",
+			description: "Write values into workflow variables for later use.",
+			metrics: [{
+				label: "Assignments",
+				value: String(config.items.length)
+			}, {
+				label: "Write modes",
+				value: String(new Set(config.items.map((assignment) => assignment.operation)).size)
+			}],
+			footer: "Workflow state update"
+		})
+	},
+	iteration: {
+		kind: "iteration",
+		family: "execution-container",
+		publicLabel: "Iteration",
+		badge: "Iteration",
+		description: "Run a subflow once per array item.",
+		supportsDifyParity: true,
+		inspectorSections: difyStandardSections,
+		createDefaultConfig: () => ({
+			kind: "iteration",
+			startNodeType: "iteration-start",
+			start_node_id: "",
+			iterator_selector: [],
+			iterator_input_type: "array",
+			output_selector: [],
+			output_type: "array",
+			iteration_id: "",
+			_isShowTips: false,
+			is_parallel: false,
+			parallel_nums: 10,
+			error_handle_mode: "terminated",
+			flatten_output: true
+		}),
+		buildSummary: (config) => ({
+			eyebrow: "List processing",
+			badge: "Iteration",
+			description: "Run the connected downstream path once for each item in an array and collect the outputs.",
+			metrics: [{
+				label: "Mode",
+				value: config.is_parallel ? "parallel" : "sequential"
+			}, {
+				label: "Failure",
+				value: config.error_handle_mode
+			}],
+			footer: config.iterator_selector.length > 0 ? `Input: ${config.iterator_selector.join(".")}` : "Input array required"
+		})
+	},
+	"http-request": {
+		kind: "http-request",
+		family: "external-action",
+		publicLabel: "HTTP Request",
+		badge: "HTTP",
+		description: "Call an external API or webhook.",
+		supportsDifyParity: true,
+		inspectorSections: difyStandardSections,
+		createDefaultConfig: () => ({
+			kind: "http-request",
+			variables: [],
+			method: "get",
+			url: "",
+			headers: "",
+			params: "",
+			body: {
+				type: "none",
+				data: []
+			},
+			authorization: {
+				type: "no-auth",
+				config: null
+			},
+			timeout: {
+				max_connect_timeout: 0,
+				max_read_timeout: 0,
+				max_write_timeout: 0
+			},
+			retry_config: {
+				retry_enabled: true,
+				max_retries: 3,
+				retry_interval: 100
+			},
+			ssl_verify: true
+		}),
+		buildSummary: (config) => ({
+			eyebrow: "External call",
+			badge: "HTTP",
+			description: "Call an external API or webhook from the workflow.",
+			metrics: [
+				{
+					label: "Method",
+					value: config.method
+				},
+				{
+					label: "Target",
+					value: config.url.replace(/^https?:\/\/[^/]+/i, "") || config.url || "Not configured"
+				},
+				{
+					label: "Retry",
+					value: config.retry_config.retry_enabled ? `${config.retry_config.max_retries}x` : "Off"
+				}
+			],
+			footer: config.authorization.type === "no-auth" ? "Outbound integration call" : `Auth: ${config.authorization.config?.type ?? "api-key"}`
+		})
+	},
+	tool: {
+		kind: "tool",
+		family: "external-action",
+		publicLabel: "Tool",
+		badge: "Tool",
+		description: "Invoke a built-in or custom tool.",
+		supportsDifyParity: true,
+		inspectorSections: difyStandardSections,
+		createDefaultConfig: () => ({
+			kind: "tool",
+			reference: {
+				id: "",
+				providerType: "",
+				providerName: "",
+				toolName: "",
+				label: ""
+			},
+			parameters: [],
+			configurations: [],
+			outputSchema: [],
+			provider_id: "",
+			provider_type: "",
+			provider_name: "",
+			tool_name: "",
+			tool_label: "",
+			tool_parameters: {},
+			tool_configurations: {},
+			output_schema: [],
+			tool_node_version: "2"
+		}),
+		buildSummary: (config) => ({
+			eyebrow: "Capability call",
+			badge: "Tool",
+			description: "Invoke a built-in tool, custom capability, or sub-workflow.",
+			metrics: [{
+				label: "Tool",
+				value: config.reference.label || config.reference.toolName || "Not configured"
+			}, {
+				label: "Inputs",
+				value: String(Object.keys(config.tool_parameters ?? {}).length || config.parameters.length)
+			}],
+			footer: config.credentialBinding?.trim() ? `Credential: ${config.credentialBinding}` : config.reference.providerName.trim() ? `Provider: ${config.reference.providerName}` : "Tool binding required"
+		})
+	},
+	agent: {
+		kind: "agent",
+		family: "external-action",
+		publicLabel: "Agent",
+		badge: "Agent",
+		description: "Run an agentic step with optional tool use.",
+		supportsDifyParity: true,
+		inspectorSections: difyStandardSections,
+		createDefaultConfig: () => ({
+			kind: "agent",
+			model: {
+				provider: "",
+				name: ""
+			},
+			strategy: {
+				mode: "function-calling",
+				providerName: "",
+				name: "",
+				label: ""
+			},
+			instructions: "",
+			enabledTools: [],
+			memory: {
+				enabled: false,
+				windowSize: 3,
+				window: {
+					enabled: false,
+					size: 3
+				}
+			},
+			strategyParameters: [],
+			outputSchema: [],
+			agent_strategy_provider_name: "",
+			agent_strategy_name: "",
+			agent_strategy_label: "",
+			agent_parameters: {},
+			output_schema: [],
+			meta: null,
+			tool_node_version: "2"
+		}),
+		buildSummary: (config) => ({
+			eyebrow: "Agentic step",
+			badge: "Agent",
+			description: "Run an agentic step that can reason and invoke tools.",
+			metrics: [{
+				label: "Strategy",
+				value: config.strategy.label || config.strategy.name || config.strategy.mode
+			}, {
+				label: "Tools",
+				value: String(Object.keys(config.agent_parameters ?? {}).length || config.enabledTools.length)
+			}],
+			footer: buildModelSummaryValue(config.model) !== "Not configured" ? `Model: ${buildModelSummaryValue(config.model)}` : config.strategy.providerName.trim() ? `Provider: ${config.strategy.providerName}` : "Strategy required"
+		})
+	},
+	loop: {
+		kind: "loop",
+		family: "execution-container",
+		publicLabel: "Loop",
+		badge: "Loop",
+		description: "Repeat a subflow until an exit condition is met.",
+		supportsDifyParity: true,
+		inspectorSections: difyStandardSections,
+		createDefaultConfig: () => ({
+			kind: "loop",
+			startNodeType: "loop-start",
+			start_node_id: "",
+			logical_operator: "and",
+			break_conditions: [],
+			loop_count: 10,
+			error_handle_mode: "terminated",
+			loop_variables: [],
+			loop_id: ""
+		}),
+		buildSummary: (config) => ({
+			eyebrow: "Cycle control",
+			badge: "Loop",
+			description: "Repeat part of the workflow until a stopping rule is met.",
+			metrics: [{
+				label: "Variables",
+				value: String(config.loop_variables.length)
+			}, {
+				label: "Max",
+				value: config.loop_count ? String(config.loop_count) : "None"
+			}],
+			footer: config.break_conditions.length > 0 ? "Exit condition configured" : "Exit condition required"
+		})
+	},
+	"human-input": {
+		kind: "human-input",
+		family: "reasoning-routing",
+		publicLabel: "Human Input",
+		badge: "Human Input",
+		description: "Pause the workflow and collect structured input from a person.",
+		supportsDifyParity: true,
+		inspectorSections: difyStandardSections,
+		createDefaultConfig: () => ({
+			kind: "human-input",
+			delivery_methods: [],
+			user_actions: [],
+			form_content: "",
+			inputs: [],
+			timeout: 3,
+			timeout_unit: "day"
+		}),
+		buildSummary: (config) => ({
+			eyebrow: "Human review",
+			badge: "Human Input",
+			description: "Pause the workflow and collect a response from a person.",
+			metrics: [{
+				label: "Methods",
+				value: String(config.delivery_methods.filter((method) => method.enabled).length)
+			}, {
+				label: "Inputs",
+				value: String(config.inputs.length)
+			}],
+			footer: config.user_actions.length > 0 ? `${config.user_actions.length} action(s)` : "No user actions configured"
+		})
+	},
+	"knowledge-base": {
+		kind: "knowledge-base",
+		family: "reasoning-routing",
+		publicLabel: "Knowledge Base",
+		badge: "Knowledge Base",
+		description: "Index incoming chunks into a knowledge base.",
+		supportsDifyParity: true,
+		inspectorSections: difyStandardSections,
+		createDefaultConfig: () => ({
+			kind: "knowledge-base",
+			index_chunk_variable_selector: [],
+			keyword_number: 10,
+			retrieval_model: {
+				top_k: 3,
+				score_threshold_enabled: false,
+				score_threshold: .5
+			}
+		}),
+		buildSummary: (config) => ({
+			eyebrow: "Knowledge indexing",
+			badge: "Knowledge Base",
+			description: "Index selected chunks into a knowledge base for retrieval.",
+			metrics: [{
+				label: "Chunks",
+				value: formatSelectorSummaryValue(config.index_chunk_variable_selector)
+			}, {
+				label: "Index",
+				value: config.indexing_technique || "Not configured"
+			}],
+			footer: config.retrieval_model.search_method ? `Retrieval: ${config.retrieval_model.search_method} · Top ${config.retrieval_model.top_k}` : "Retrieval setting required"
+		})
+	},
+	approval: {
+		kind: "approval",
+		family: "lsflow-specific",
+		publicLabel: "Approval",
+		badge: "Approval",
+		description: "Route work to a reviewer and continue by decision outcome.",
+		supportsDifyParity: false,
+		inspectorSections: difyStandardSections,
+		createDefaultConfig: () => ({
+			kind: "approval",
+			approvalOwner: ""
+		}),
+		buildSummary: (config) => buildSingleMetricSummary("Approval step", "Approval", "Assign reviewers, set the decision path, and continue the draft flow.", "Owner", config.approvalOwner || "Not configured", "LSFlow-specific approval routing")
+	},
+	email: {
+		kind: "email",
+		family: "lsflow-specific",
+		publicLabel: "Email",
+		badge: "Email",
+		description: "Send an email notification or outbound workflow message.",
+		supportsDifyParity: false,
+		inspectorSections: difyStandardSections,
+		createDefaultConfig: () => ({
+			kind: "email",
+			to: "",
+			subject: "",
+			body: ""
+		}),
+		buildSummary: (config) => ({
+			eyebrow: "Outbound message",
+			badge: "Email",
+			description: "Send an email notification, update, or outbound workflow message.",
+			metrics: [{
+				label: "To",
+				value: config.to || "Not configured"
+			}],
+			footer: config.subject.trim() ? config.subject : "Subject required"
+		})
+	},
+	note: {
+		kind: "note",
+		family: "lsflow-note",
+		publicLabel: "Note",
+		badge: "Note",
+		description: "Capture reminders, guidance, or annotations on the canvas.",
+		supportsDifyParity: false,
+		inspectorSections: difyStandardSections,
+		createDefaultConfig: () => ({ kind: "note" }),
+		buildSummary: () => ({
+			eyebrow: "Canvas note",
+			badge: "Note",
+			description: "Capture reminders, guidance, or annotations directly on the canvas.",
+			metrics: [],
+			footer: "Non-executable note"
+		})
+	}
+};
+function getBuilderNodeDefinition(kind) {
+	if (!kind || !(kind in builderNodeDefinitions)) return null;
+	return builderNodeDefinitions[kind];
+}
+function getBuilderPublicNodeLabel(kind) {
+	return getBuilderNodeDefinition(kind)?.publicLabel ?? "Node";
+}
+function isDifyMappedNodeKind(kind) {
+	return Boolean(getBuilderNodeDefinition(kind)?.supportsDifyParity);
+}
+function createDefaultNodeConfigurationV2(kind) {
+	return getBuilderNodeDefinition(kind)?.createDefaultConfig();
+}
+//#endregion
+export { branchConditionSourceOptions, buildBranchConditionsFromIfElseCases, buildIfElseCasesFromBranchConditions, buildIfElseConditionExpression, buildNormalizedBranchConditions, builderNodeDefinitions, createDefaultNodeConfigurationV2, getBuilderNodeDefinition, getBuilderPublicNodeLabel, isDifyMappedNodeKind };