@legatoacc3/workflow-builder 0.1.0-alpha.0

package/dist/domain/workflow-draft.js

@@ -0,0 +1,2115 @@
+import { buildBranchConditionsFromIfElseCases, buildIfElseCasesFromBranchConditions, buildNormalizedBranchConditions, createDefaultNodeConfigurationV2 } from "./builder-node-definition.js";
+import { createWorkflowGraph } from "@legatoacc3/workflow-canvas/graph";
+//#region src/domain/workflow-draft.ts
+var workflowFieldInputTypes = [
+	"short-text",
+	"long-text",
+	"number",
+	"date",
+	"select",
+	"checkbox",
+	"email",
+	"file",
+	"file-list",
+	"json_object"
+];
+function mapStartVariableTypeToFormFieldType(type) {
+	switch (type) {
+		case "paragraph": return "long-text";
+		case "number": return "number";
+		case "select": return "select";
+		case "checkbox": return "checkbox";
+		case "file": return "file";
+		case "file-list":
+		case "files": return "file-list";
+		case "json":
+		case "json_object": return "json_object";
+		default: return "short-text";
+	}
+}
+function readStartVariableLabel(variable) {
+	if (typeof variable.label === "string") return variable.label.trim();
+	return variable.label.variable.trim() || variable.label.nodeName.trim() || variable.label.nodeType.trim();
+}
+function buildFormFieldFromStartVariable(variable) {
+	const variableName = variable.variable.trim();
+	const variableLabel = readStartVariableLabel(variable);
+	const options = variable.options;
+	return {
+		id: variableName || variable.id,
+		label: variableLabel || variableName || variable.id,
+		type: mapStartVariableTypeToFormFieldType(variable.type),
+		helperText: variable.hint?.trim() ?? "",
+		required: variable.required,
+		placeholder: variable.placeholder?.trim() || void 0,
+		options: Array.isArray(options) && options.length > 0 ? options.map((option) => {
+			const normalizedOption = option.trim();
+			return {
+				label: normalizedOption,
+				value: normalizedOption
+			};
+		}) : void 0,
+		validation: { maxLength: variable.maxLength }
+	};
+}
+function getStartNodeConfiguration(draft) {
+	const startNode = draft.graphState.nodes.find((node) => node.data?.kind === "start");
+	if (!startNode) return null;
+	const config = draft.nodeConfigurations[startNode.id];
+	return config?.kind === "start" ? config : null;
+}
+function buildFormSchemaFromStartNode(draft) {
+	const startConfig = getStartNodeConfiguration(draft);
+	const fallbackSchema = normalizeWorkflowFormSchema(draft.formSchema);
+	if (!startConfig) return fallbackSchema;
+	const visibleVariables = startConfig.variables.filter((variable) => !variable.hide && variable.variable.trim());
+	if (visibleVariables.length === 0) return fallbackSchema;
+	return normalizeWorkflowFormSchema({
+		title: fallbackSchema.title,
+		description: fallbackSchema.description,
+		fields: visibleVariables.map(buildFormFieldFromStartVariable)
+	});
+}
+function isInternalWorkflowNodeKind(kind) {
+	return kind === "note" || kind === "iteration-start" || kind === "loop-start";
+}
+function buildInitialGraphState() {
+	return createWorkflowGraph({
+		nodes: [],
+		edges: []
+	});
+}
+function buildInitialFormSchema() {
+	return {
+		title: "Request form",
+		description: "Collect the structured information required to start this workflow.",
+		fields: []
+	};
+}
+function buildInitialValidationResult() {
+	return {
+		status: "idle",
+		validatedAt: null,
+		issues: []
+	};
+}
+function normalizeWorkflowFormField(input) {
+	return {
+		id: input.id,
+		label: input.label ?? "",
+		type: input.type ?? "short-text",
+		helperText: input.helperText ?? "",
+		required: Boolean(input.required),
+		placeholder: input.placeholder ?? "",
+		options: input.options?.map((option) => ({
+			label: option.label ?? "",
+			value: option.value ?? ""
+		})),
+		validation: {
+			pattern: input.validation?.pattern ?? void 0,
+			minLength: input.validation?.minLength ?? void 0,
+			maxLength: input.validation?.maxLength ?? void 0,
+			min: input.validation?.min ?? void 0,
+			max: input.validation?.max ?? void 0
+		}
+	};
+}
+function normalizeWorkflowFormSchema(input) {
+	if (!input) return buildInitialFormSchema();
+	return {
+		title: input.title?.trim() || "Request form",
+		description: input.description?.trim() || "Collect the structured information required to start this workflow.",
+		fields: (input.fields ?? []).map((field) => normalizeWorkflowFormField(field))
+	};
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readRecordProperty(value, key) {
+	return isRecord(value) ? value[key] : void 0;
+}
+function normalizeStringValue(value) {
+	return typeof value === "string" ? value.trim() : "";
+}
+function normalizeLegacyFieldInputType(value) {
+	switch (String(value ?? "").trim().toLowerCase()) {
+		case "long-text": return "paragraph";
+		case "number": return "number";
+		case "select": return "select";
+		case "checkbox": return "checkbox";
+		case "email":
+		case "url": return "url";
+		case "file": return "file";
+		case "file-list": return "file-list";
+		case "contexts": return "contexts";
+		case "iterator": return "iterator";
+		case "loop": return "loop";
+		case "json": return "json";
+		default: return "text-input";
+	}
+}
+function normalizeBooleanValue(value, fallback = false) {
+	return typeof value === "boolean" ? value : fallback;
+}
+function normalizePositiveNumber(value, fallback) {
+	return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : fallback;
+}
+function parseOptionalNumber(value) {
+	if (typeof value === "number" && Number.isFinite(value)) return value;
+	if (typeof value !== "string") return;
+	const normalized = value.trim();
+	if (!normalized) return;
+	const parsed = Number(normalized);
+	return Number.isFinite(parsed) ? parsed : void 0;
+}
+function normalizeSelectorPath(value) {
+	if (typeof value === "string") return value.split(".").map((entry) => entry.trim()).filter(Boolean);
+	if (Array.isArray(value)) return value.map((entry) => String(entry ?? "").trim()).filter(Boolean);
+	if (isRecord(value)) {
+		const singleValue = normalizeStringValue(value.name) || normalizeStringValue(value.variable) || normalizeStringValue(value.id);
+		return singleValue ? [singleValue] : [];
+	}
+	return [];
+}
+function deriveVariableNameFromSelector(selector) {
+	return selector.map((entry) => entry.trim()).filter(Boolean).at(-1) ?? "";
+}
+function deriveEndOutputNameFromSelector(selector) {
+	return selector.map((entry) => entry.trim()).filter(Boolean).join(".");
+}
+function normalizeVariableLabel(value) {
+	if (typeof value === "string") return value.trim() || void 0;
+	if (!isRecord(value)) return;
+	const nodeType = normalizeStringValue(value.nodeType);
+	const nodeName = normalizeStringValue(value.nodeName);
+	const variable = normalizeStringValue(value.variable);
+	if (!nodeType || !nodeName || !variable) return;
+	return {
+		nodeType,
+		nodeName,
+		variable,
+		isChatVar: typeof value.isChatVar === "boolean" ? value.isChatVar : void 0
+	};
+}
+function normalizeModelReference(value) {
+	if (typeof value === "string") return value.trim();
+	if (!isRecord(value)) return "";
+	const provider = normalizeStringValue(value.provider);
+	const name = normalizeStringValue(value.name);
+	const model = normalizeStringValue(value.model);
+	if (provider && model) return `${provider}/${model}`;
+	return model || name;
+}
+function normalizeModelConfig(value) {
+	if (typeof value === "string") return {
+		provider: "",
+		name: value.trim()
+	};
+	if (!isRecord(value)) return {
+		provider: "",
+		name: ""
+	};
+	return {
+		provider: normalizeStringValue(value.provider),
+		name: normalizeStringValue(value.name ?? value.model ?? value.modelId),
+		mode: normalizeStringValue(value.mode) || void 0,
+		completion_params: isRecord(value.completion_params ?? value.completionParams) ? structuredClone(value.completion_params ?? value.completionParams) : void 0
+	};
+}
+function normalizeKnowledgeRetrievalRerankingModelConfig(value) {
+	if (typeof value === "string") return {
+		provider: "",
+		model: value.trim()
+	};
+	if (!isRecord(value)) return {
+		provider: "",
+		model: ""
+	};
+	return {
+		provider: normalizeStringValue(value.provider),
+		model: normalizeStringValue(value.model ?? value.name ?? value.modelId)
+	};
+}
+function normalizeNodeMemoryConfig(value, fallbackWindowSize = 3) {
+	if (!isRecord(value)) return {
+		enabled: false,
+		windowSize: fallbackWindowSize
+	};
+	return {
+		enabled: normalizeBooleanValue(value.enabled, false),
+		windowSize: typeof value.windowSize === "number" && Number.isFinite(value.windowSize) ? value.windowSize : typeof value.window_size === "number" && Number.isFinite(value.window_size) ? value.window_size : fallbackWindowSize
+	};
+}
+function normalizeDifyMemoryConfig(value, fallbackWindowSize = 3) {
+	const record = isRecord(value) ? value : null;
+	const rolePrefix = isRecord(record?.role_prefix) ? record.role_prefix : null;
+	const windowConfig = isRecord(record?.window) ? record.window : null;
+	const normalizedMemory = windowConfig ? {
+		enabled: normalizeBooleanValue(windowConfig.enabled, false),
+		windowSize: typeof windowConfig.size === "number" && Number.isFinite(windowConfig.size) ? windowConfig.size : fallbackWindowSize
+	} : normalizeNodeMemoryConfig(value, fallbackWindowSize);
+	return {
+		role_prefix: rolePrefix ? {
+			user: normalizeStringValue(rolePrefix.user) || void 0,
+			assistant: normalizeStringValue(rolePrefix.assistant) || void 0
+		} : void 0,
+		window: {
+			enabled: normalizedMemory.enabled,
+			size: normalizedMemory.windowSize
+		},
+		query_prompt_template: normalizeStringValue(record?.query_prompt_template) || void 0
+	};
+}
+function normalizeLlmVisionConfig(value) {
+	if (!isRecord(value)) return {
+		enabled: false,
+		configs: {
+			variable_selector: [],
+			detail: "low"
+		}
+	};
+	const configs = isRecord(value.configs) ? value.configs : value;
+	return {
+		enabled: normalizeBooleanValue(value.enabled, false),
+		configs: {
+			variable_selector: normalizeSelectorPath(configs.variable_selector),
+			detail: normalizeStringValue(configs.detail ?? configs.resolution).toLowerCase() === "high" ? "high" : "low"
+		}
+	};
+}
+function normalizePromptVariables(value) {
+	if (!Array.isArray(value)) return [];
+	return value.map((entry, index) => {
+		if (isRecord(entry)) {
+			const variable = normalizeStringValue(entry.variable ?? entry.name);
+			const valueSelector = normalizeSelectorPath(entry.value_selector ?? entry.valueSelector);
+			if (!variable) return null;
+			return {
+				id: normalizeStringValue(entry.id) || `llm-prompt-variable-${index + 1}`,
+				variable,
+				value_selector: valueSelector,
+				label: normalizeStringValue(entry.label) || void 0
+			};
+		}
+		const variable = normalizeStringValue(entry);
+		if (!variable) return null;
+		return {
+			id: `llm-prompt-variable-${index + 1}`,
+			variable,
+			value_selector: []
+		};
+	}).filter((entry) => Boolean(entry));
+}
+function normalizePromptTemplate(value) {
+	if (typeof value === "string") return value.trim();
+	if (!Array.isArray(value)) return "";
+	return value.map((entry) => {
+		if (!isRecord(entry)) return "";
+		const role = normalizeStringValue(entry.role || entry.type);
+		const text = normalizeStringValue(entry.text ?? entry.content);
+		if (!text) return "";
+		return role ? `[${role}] ${text}` : text;
+	}).filter(Boolean).join("\n\n");
+}
+function normalizeKnowledgeRetrievalMetadataConditions(value) {
+	const record = isRecord(value) ? value : null;
+	const conditions = Array.isArray(record?.conditions) ? record.conditions : [];
+	return {
+		logical_operator: normalizeStringValue(record?.logical_operator ?? record?.logicalOperator).toLowerCase() === "or" ? "or" : "and",
+		conditions: conditions.flatMap((entry, index) => {
+			if (!isRecord(entry)) return [];
+			return [{
+				id: normalizeStringValue(entry.id) || `metadata-condition-${index + 1}`,
+				name: normalizeStringValue(entry.name ?? entry.metadata_id),
+				metadata_id: normalizeStringValue(entry.metadata_id),
+				type: normalizeStringValue(entry.type).toLowerCase() === "number" ? "number" : normalizeStringValue(entry.type).toLowerCase() === "time" ? "time" : normalizeStringValue(entry.type).toLowerCase() === "select" ? "select" : normalizeStringValue(entry.type).toLowerCase() === "string" ? "string" : void 0,
+				comparison_operator: normalizeStringValue(entry.comparisonOperator ?? entry.comparison_operator),
+				value: typeof entry.value === "number" ? entry.value : normalizeStringValue(entry.value)
+			}];
+		})
+	};
+}
+function normalizeQuestionClassifierClasses(value) {
+	if (!Array.isArray(value)) return [];
+	return value.flatMap((entry, index) => {
+		if (!isRecord(entry)) return [];
+		const label = normalizeStringValue(entry.label ?? entry.description ?? entry.name);
+		const name = Object.prototype.hasOwnProperty.call(entry, "name") ? normalizeStringValue(entry.name) : normalizeStringValue(entry.label) || (label ? label.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "") : "");
+		return [{
+			id: normalizeStringValue(entry.id) || `class-${index + 1}`,
+			name,
+			label
+		}];
+	});
+}
+function normalizeHumanInputDeliveryMethods(value) {
+	if (!Array.isArray(value)) return [];
+	return value.flatMap((entry, index) => {
+		if (!isRecord(entry)) return [];
+		const type = normalizeStringValue(entry.type).toLowerCase();
+		const normalizedType = type === "email" || type === "slack" || type === "teams" || type === "discord" ? type : "webapp";
+		const config = isRecord(entry.config) ? entry.config : null;
+		const recipients = isRecord(config?.recipients) ? config?.recipients : null;
+		const recipientItems = Array.isArray(recipients?.items) ? recipients.items : [];
+		return [{
+			id: normalizeStringValue(entry.id) || `human-input-delivery-${index + 1}`,
+			type: normalizedType,
+			enabled: normalizeBooleanValue(entry.enabled, normalizedType === "webapp"),
+			config: normalizedType === "email" ? {
+				recipients: {
+					whole_workspace: normalizeBooleanValue(recipients?.whole_workspace, false),
+					items: recipientItems.flatMap((recipient) => {
+						if (!isRecord(recipient)) return [];
+						return [{
+							type: normalizeStringValue(recipient.type).toLowerCase() === "external" ? "external" : "member",
+							email: normalizeStringValue(recipient.email) || void 0,
+							user_id: normalizeStringValue(recipient.user_id ?? recipient.userId) || void 0
+						}];
+					})
+				},
+				subject: normalizeStringValue(config?.subject),
+				body: normalizeStringValue(config?.body),
+				debug_mode: normalizeBooleanValue(config?.debug_mode ?? config?.debugMode, false)
+			} : void 0
+		}];
+	});
+}
+function normalizeHumanInputItems(value) {
+	if (!Array.isArray(value)) return [];
+	return value.flatMap((entry, index) => {
+		if (!isRecord(entry)) return [];
+		const defaultValue = isRecord(entry.default) ? entry.default : null;
+		const rawType = normalizeStringValue(entry.type);
+		return [{
+			type: rawType === "text-input" || rawType === "paragraph" || rawType === "select" || rawType === "number" || rawType === "url" || rawType === "file" || rawType === "file-list" || rawType === "json" || rawType === "files" || rawType === "json_object" || rawType === "contexts" || rawType === "iterator" || rawType === "loop" || rawType === "checkbox" ? rawType : "text-input",
+			output_variable_name: normalizeStringValue(entry.output_variable_name ?? entry.outputVariableName) || `field_${index + 1}`,
+			default: {
+				selector: normalizeSelectorPath(defaultValue?.selector),
+				type: normalizeStringValue(defaultValue?.type).toLowerCase() === "constant" ? "constant" : "variable",
+				value: normalizeStringValue(defaultValue?.value)
+			}
+		}];
+	});
+}
+function normalizeHumanInputActions(value) {
+	if (!Array.isArray(value)) return [];
+	return value.flatMap((entry, index) => {
+		if (!isRecord(entry)) return [];
+		const rawStyle = normalizeStringValue(entry.button_style ?? entry.buttonStyle).toLowerCase();
+		const buttonStyle = rawStyle === "primary" || rawStyle === "accent" || rawStyle === "ghost" ? rawStyle : "default";
+		return [{
+			id: normalizeStringValue(entry.id) || `action_${index + 1}`,
+			title: normalizeStringValue(entry.title) || `Button Text ${index + 1}`,
+			button_style: buttonStyle
+		}];
+	});
+}
+function buildQuestionClassifierConditionalBranches(classes) {
+	return classes.map((item, index) => {
+		const label = normalizeStringValue(item.label) || `CLASS ${index + 1}`;
+		return {
+			id: normalizeStringValue(item.id) || `class-${index + 1}`,
+			type: "if",
+			label,
+			description: `${label} branch`
+		};
+	});
+}
+function normalizeParameterDataType(value) {
+	switch (String(value ?? "").trim().toLowerCase()) {
+		case "number": return "number";
+		case "select": return "select";
+		case "array[number]": return "array[number]";
+		case "boolean":
+		case "bool": return "boolean";
+		case "array[boolean]":
+		case "array[bool]": return "array[boolean]";
+		case "object": return "object";
+		case "array[object]": return "array[object]";
+		case "array[string]": return "array[string]";
+		case "array": return "array";
+		default: return "string";
+	}
+}
+function normalizeParameterOptions(value) {
+	if (!Array.isArray(value)) return;
+	const options = value.map((entry) => String(entry ?? "").trim()).filter(Boolean);
+	return options.length ? options : void 0;
+}
+function normalizeParameterExtractorParameters(value) {
+	if (!Array.isArray(value)) return [];
+	return value.flatMap((entry, index) => {
+		if (!isRecord(entry)) return [];
+		return [{
+			id: normalizeStringValue(entry.id) || `parameter-${index + 1}`,
+			name: normalizeStringValue(entry.name),
+			dataType: normalizeParameterDataType(entry.dataType ?? entry.type),
+			description: normalizeStringValue(entry.description ?? entry.llm_description),
+			required: normalizeBooleanValue(entry.required, false),
+			options: normalizeParameterOptions(entry.options)
+		}];
+	});
+}
+function normalizeParameterSchemaFields(value) {
+	return normalizeParameterExtractorParameters(value);
+}
+function normalizeListOperatorComparisonOperator(value) {
+	switch (String(value ?? "").trim().toLowerCase()) {
+		case "contains": return "contains";
+		case "not contains":
+		case "not-contains": return "not-contains";
+		case "is":
+		case "=":
+		case "equal": return "is";
+		case "is not":
+		case "is-not":
+		case "!=":
+		case "≠":
+		case "not equal": return "is-not";
+		case ">":
+		case "larger than": return ">";
+		case "<":
+		case "less than": return "<";
+		case ">=":
+		case "≥":
+		case "larger than or equal": return ">=";
+		case "<=":
+		case "≤":
+		case "less than or equal": return "<=";
+		case "empty":
+		case "is null": return "empty";
+		case "not empty":
+		case "is not null": return "not-empty";
+		case "exists": return "exists";
+		case "not exists":
+		case "not-exists": return "not-exists";
+		case "in": return "in";
+		case "not in":
+		case "not-in": return "not-in";
+		case "all of":
+		case "all-of": return "all-of";
+		default: return "contains";
+	}
+}
+function normalizeListOperatorValue(value) {
+	if (Array.isArray(value)) return value.map((entry) => String(entry ?? "").trim()).filter(Boolean).join(", ");
+	if (typeof value === "boolean" || typeof value === "number") return String(value);
+	return normalizeStringValue(value);
+}
+function normalizeDifyResourceConstantValue(value) {
+	if (typeof value === "boolean" || typeof value === "number") return value;
+	if (Array.isArray(value)) return value.map((entry) => isRecord(entry) ? structuredClone(entry) : entry);
+	if (isRecord(value)) return structuredClone(value);
+	return normalizeStringValue(value);
+}
+function normalizeAssignerValue(value, inputType) {
+	if (inputType === "variable") return normalizeSelectorPath(value);
+	if (typeof value === "boolean" || typeof value === "number") return value;
+	if (Array.isArray(value)) return value.map((entry) => String(entry ?? "").trim()).filter(Boolean);
+	return normalizeStringValue(value);
+}
+function normalizeValueType(value) {
+	switch (String(value ?? "").trim().toLowerCase()) {
+		case "string": return "string";
+		case "number": return "number";
+		case "integer": return "integer";
+		case "secret": return "secret";
+		case "boolean":
+		case "bool": return "boolean";
+		case "object": return "object";
+		case "array": return "array";
+		case "array[string]": return "array[string]";
+		case "array[number]": return "array[number]";
+		case "array[object]": return "array[object]";
+		case "array[boolean]":
+		case "array[bool]": return "array[boolean]";
+		case "array[file]": return "array[file]";
+		case "file": return "file";
+		default: return "any";
+	}
+}
+function normalizeConcreteValueType(value, fallback = "string") {
+	const normalized = normalizeValueType(value);
+	return normalized === "any" ? fallback : normalized;
+}
+function normalizeAggregatorOutputType(value) {
+	const normalized = normalizeValueType(value);
+	if (normalized === "number" || normalized === "boolean" || normalized === "object" || normalized === "array" || normalized === "file") return normalized;
+	return "string";
+}
+function normalizeStartVariableOptions(value) {
+	if (!Array.isArray(value)) return;
+	const options = value.map((entry) => {
+		if (isRecord(entry)) return normalizeStringValue(entry.value ?? entry.label);
+		return normalizeStringValue(entry);
+	}).filter(Boolean);
+	return options.length ? options : void 0;
+}
+function normalizeStringArray(value) {
+	if (!Array.isArray(value)) return;
+	const entries = value.map((entry) => normalizeStringValue(entry)).filter(Boolean);
+	return entries.length ? entries : void 0;
+}
+function normalizeStartVariableDefaultValue(value) {
+	if (typeof value === "string") return value;
+	if (typeof value === "number" && Number.isFinite(value)) return value;
+	if (typeof value === "boolean") return value;
+}
+function normalizeStartVariableType(value) {
+	const normalized = normalizeStringValue(value);
+	return normalized === "text-input" || normalized === "paragraph" || normalized === "select" || normalized === "number" || normalized === "url" || normalized === "file" || normalized === "file-list" || normalized === "files" || normalized === "json" || normalized === "json_object" || normalized === "contexts" || normalized === "iterator" || normalized === "loop" || normalized === "checkbox" ? normalized : "text-input";
+}
+function normalizeStartVariables(value) {
+	if (!Array.isArray(value)) return [];
+	return value.flatMap((entry, index) => {
+		if (!isRecord(entry)) return [];
+		return [{
+			id: normalizeStringValue(entry.id) || `start-variable-${index + 1}`,
+			variable: normalizeStringValue(entry.variable ?? entry.name),
+			label: normalizeVariableLabel(entry.label) || normalizeStringValue(entry.variable ?? entry.name),
+			type: normalizeStartVariableType(entry.type),
+			required: normalizeBooleanValue(entry.required, false),
+			hint: normalizeStringValue(entry.hint ?? entry.helperText) || void 0,
+			placeholder: normalizeStringValue(entry.placeholder) || void 0,
+			options: normalizeStartVariableOptions(entry.options),
+			defaultValue: normalizeStartVariableDefaultValue(entry.default ?? entry.defaultValue),
+			maxLength: typeof entry.max_length === "number" && Number.isFinite(entry.max_length) ? entry.max_length : typeof entry.maxLength === "number" && Number.isFinite(entry.maxLength) ? entry.maxLength : void 0,
+			unit: normalizeStringValue(entry.unit) || void 0,
+			value_selector: normalizeSelectorPath(entry.value_selector ?? entry.valueSelector),
+			getVarValueFromDependent: normalizeBooleanValue(entry.getVarValueFromDependent, false),
+			hide: normalizeBooleanValue(entry.hide, false),
+			isFileItem: normalizeBooleanValue(entry.isFileItem, false),
+			json_schema: typeof entry.json_schema === "string" ? entry.json_schema : isRecord(entry.json_schema) ? structuredClone(entry.json_schema) : void 0,
+			allowed_file_upload_methods: normalizeStringArray(entry.allowed_file_upload_methods),
+			allowed_upload_methods: normalizeStringArray(entry.allowed_upload_methods),
+			allowed_file_types: normalizeStringArray(entry.allowed_file_types),
+			allowed_file_extensions: normalizeStringArray(entry.allowed_file_extensions),
+			number_limits: typeof entry.number_limits === "number" && Number.isFinite(entry.number_limits) ? entry.number_limits : void 0
+		}];
+	});
+}
+function normalizeLegacyStartFieldVariables(value) {
+	if (!Array.isArray(value)) return [];
+	return value.flatMap((entry, index) => {
+		if (!isRecord(entry)) return [];
+		const validation = isRecord(entry.validation) ? entry.validation : null;
+		return [{
+			id: normalizeStringValue(entry.id) || `start-variable-${index + 1}`,
+			variable: normalizeStringValue(entry.variableName ?? entry.variable ?? entry.name),
+			label: normalizeVariableLabel(entry.label) || normalizeStringValue(entry.variableName ?? entry.variable ?? entry.name),
+			type: normalizeLegacyFieldInputType(entry.type),
+			required: normalizeBooleanValue(entry.required, false),
+			hint: normalizeStringValue(entry.helperText ?? entry.hint) || void 0,
+			placeholder: normalizeStringValue(entry.placeholder) || void 0,
+			options: normalizeStartVariableOptions(entry.options),
+			defaultValue: normalizeStartVariableDefaultValue(entry.default ?? entry.defaultValue),
+			maxLength: typeof entry.max_length === "number" && Number.isFinite(entry.max_length) ? entry.max_length : typeof entry.maxLength === "number" && Number.isFinite(entry.maxLength) ? entry.maxLength : typeof validation?.maxLength === "number" && Number.isFinite(validation.maxLength) ? validation.maxLength : void 0,
+			unit: normalizeStringValue(entry.unit) || void 0,
+			value_selector: normalizeSelectorPath(entry.value_selector ?? entry.valueSelector),
+			getVarValueFromDependent: normalizeBooleanValue(entry.getVarValueFromDependent, false),
+			hide: normalizeBooleanValue(entry.hide, false),
+			isFileItem: normalizeBooleanValue(entry.isFileItem, false),
+			json_schema: typeof entry.json_schema === "string" ? entry.json_schema : isRecord(entry.json_schema) ? structuredClone(entry.json_schema) : void 0,
+			allowed_file_upload_methods: normalizeStringArray(entry.allowed_file_upload_methods),
+			allowed_upload_methods: normalizeStringArray(entry.allowed_upload_methods),
+			allowed_file_types: normalizeStringArray(entry.allowed_file_types),
+			allowed_file_extensions: normalizeStringArray(entry.allowed_file_extensions),
+			number_limits: typeof entry.number_limits === "number" && Number.isFinite(entry.number_limits) ? entry.number_limits : void 0
+		}];
+	});
+}
+function normalizeWebhookVariableType(value) {
+	switch (String(value ?? "").trim().toLowerCase()) {
+		case "number": return "number";
+		case "boolean":
+		case "bool": return "boolean";
+		case "object":
+		case "json": return "object";
+		case "array": return "array";
+		case "file":
+		case "files": return "file";
+		default: return "string";
+	}
+}
+function normalizeWebhookParameters(value) {
+	if (!Array.isArray(value)) return [];
+	return value.flatMap((entry, index) => {
+		if (!isRecord(entry)) return [];
+		return [{
+			id: normalizeStringValue(entry.id) || `webhook-variable-${index + 1}`,
+			name: normalizeStringValue(entry.name),
+			required: normalizeBooleanValue(entry.required, false),
+			type: normalizeWebhookVariableType(entry.type ?? entry.dataType)
+		}];
+	});
+}
+function normalizeWebhookHeaders(value) {
+	if (!Array.isArray(value)) return [];
+	return value.flatMap((entry, index) => {
+		if (!isRecord(entry)) return [];
+		return [{
+			id: normalizeStringValue(entry.id) || `webhook-header-${index + 1}`,
+			name: normalizeStringValue(entry.name),
+			required: normalizeBooleanValue(entry.required, false)
+		}];
+	});
+}
+function normalizeHttpMethod(value) {
+	switch (String(value ?? "").trim().toLowerCase()) {
+		case "get":
+		case "post":
+		case "put":
+		case "patch":
+		case "delete":
+		case "head": return String(value).trim().toLowerCase();
+		default: return "get";
+	}
+}
+function normalizeWebhookMethod(value) {
+	switch (String(value ?? "").trim().toUpperCase()) {
+		case "GET":
+		case "POST":
+		case "PUT":
+		case "PATCH":
+		case "DELETE":
+		case "HEAD": return String(value).trim().toUpperCase();
+		default: return "POST";
+	}
+}
+function normalizeWebhookContentType(value) {
+	const normalized = normalizeStringValue(value);
+	switch (normalized) {
+		case "application/json":
+		case "application/x-www-form-urlencoded":
+		case "text/plain":
+		case "application/octet-stream":
+		case "multipart/form-data": return normalized;
+		default: return "application/json";
+	}
+}
+function normalizeHttpKeyValueEntries(value, fallbackPrefix) {
+	if (Array.isArray(value)) return value.flatMap((entry, index) => {
+		if (!isRecord(entry)) return [];
+		return [{
+			id: normalizeStringValue(entry.id) || `${fallbackPrefix}-${index + 1}`,
+			key: normalizeStringValue(entry.key ?? entry.name),
+			value: normalizeListOperatorValue(entry.value),
+			type: normalizeStringValue(entry.type) === "secret" ? "secret" : normalizeStringValue(entry.type) === "variable" ? "variable" : void 0,
+			file: normalizeSelectorPath(entry.file ?? entry.fileVariable)
+		}];
+	});
+	if (typeof value === "string") return value.split("\n").map((line) => line.trim()).filter(Boolean).map((line, index) => {
+		const separatorIndex = line.indexOf(":");
+		const key = separatorIndex >= 0 ? line.slice(0, separatorIndex) : line;
+		const rawValue = separatorIndex >= 0 ? line.slice(separatorIndex + 1) : "";
+		return {
+			id: `${fallbackPrefix}-${index + 1}`,
+			key: key.trim(),
+			value: rawValue.trim()
+		};
+	});
+	return [];
+}
+function normalizeHttpBodyType(value) {
+	switch (String(value ?? "").trim().toLowerCase()) {
+		case "form-data": return "form-data";
+		case "x-www-form-urlencoded": return "x-www-form-urlencoded";
+		case "raw-text": return "raw-text";
+		case "binary": return "binary";
+		case "json": return "json";
+		default: return "none";
+	}
+}
+function normalizeHttpBodyPayloadEntries(value) {
+	if (!Array.isArray(value)) return [];
+	return value.flatMap((entry, index) => {
+		if (!isRecord(entry)) return [];
+		return [{
+			id: normalizeStringValue(entry.id) || `body-entry-${index + 1}`,
+			key: normalizeStringValue(entry.key),
+			type: normalizeStringValue(entry.type) === "file" ? "file" : "text",
+			value: normalizeListOperatorValue(entry.value) || void 0,
+			file: normalizeSelectorPath(entry.file ?? entry.fileVariable)
+		}];
+	});
+}
+function normalizeRecordEntries(value) {
+	if (!isRecord(value)) return [];
+	return Object.entries(value).map(([key, entry], index) => {
+		const normalizedEntry = isRecord(entry) ? entry : null;
+		const normalizedValueType = normalizeStringValue(normalizedEntry?.type ?? normalizedEntry?.valueType) === "variable" ? "variable" : "constant";
+		const rawValue = normalizedEntry && "value" in normalizedEntry ? normalizedEntry.value : entry;
+		const normalizedValue = normalizedValueType === "variable" ? normalizeSelectorPath(rawValue) : normalizeDifyResourceConstantValue(rawValue);
+		return {
+			id: `${key || "entry"}-${index + 1}`,
+			name: key,
+			valueType: normalizedValueType,
+			value: normalizedValue
+		};
+	});
+}
+function normalizeToolProviderType(value) {
+	const normalizedValue = normalizeStringValue(value);
+	return normalizedValue === "builtin" || normalizedValue === "custom" || normalizedValue === "workflow" || normalizedValue === "mcp" ? normalizedValue : "";
+}
+function normalizeTriggerPluginProviderType(value) {
+	return normalizeToolProviderType(value);
+}
+function normalizeResourceParameters(value) {
+	return Object.fromEntries(normalizeRecordEntries(value).filter((entry) => entry.name.trim()).map((entry) => [entry.name, {
+		type: entry.valueType,
+		value: entry.value
+	}]));
+}
+function normalizeResourceConfigurations(value) {
+	if (Array.isArray(value)) return Object.fromEntries(value.flatMap((entry, index) => {
+		if (!isRecord(entry)) return [];
+		return [[normalizeStringValue(entry.name) || `config_${index + 1}`, normalizeDifyResourceConstantValue(entry.value)]];
+	}));
+	return isRecord(value) ? structuredClone(value) : {};
+}
+function normalizeFileExtensions(value) {
+	if (Array.isArray(value)) return value.map((entry) => normalizeStringValue(entry)).filter(Boolean);
+	return normalizeStringValue(value).split(",").map((entry) => entry.trim()).filter(Boolean);
+}
+function normalizeKnowledgeBaseChunkStructure(value) {
+	const normalized = normalizeStringValue(value);
+	return normalized === "text_model" || normalized === "hierarchical_model" || normalized === "qa_model" ? normalized : void 0;
+}
+function normalizeKnowledgeBaseRetrievalModel(value, fallback) {
+	const raw = isRecord(value) ? value : null;
+	const rawRerankingModel = isRecord(raw?.reranking_model) ? raw?.reranking_model : null;
+	return {
+		search_method: normalizeStringValue(raw?.search_method) || void 0,
+		reranking_enable: normalizeBooleanValue(raw?.reranking_enable, false),
+		reranking_model: rawRerankingModel ? {
+			reranking_provider_name: normalizeStringValue(rawRerankingModel.reranking_provider_name),
+			reranking_model_name: normalizeStringValue(rawRerankingModel.reranking_model_name)
+		} : void 0,
+		weights: isRecord(raw?.weights) ? structuredClone(raw.weights) : void 0,
+		top_k: normalizePositiveNumber(raw?.top_k, fallback.top_k),
+		score_threshold_enabled: normalizeBooleanValue(raw?.score_threshold_enabled, fallback.score_threshold_enabled),
+		score_threshold: typeof raw?.score_threshold === "number" && Number.isFinite(raw.score_threshold) ? raw.score_threshold : fallback.score_threshold,
+		reranking_mode: normalizeStringValue(raw?.reranking_mode) || void 0
+	};
+}
+function normalizeToolConfigurationEntries(value) {
+	if (Array.isArray(value)) return value.map((entry, index) => ({
+		id: normalizeStringValue(isRecord(entry) ? entry.id : void 0) || `tool-config-${index + 1}`,
+		name: normalizeStringValue(isRecord(entry) ? entry.name : void 0),
+		value: normalizeDifyResourceConstantValue(isRecord(entry) ? entry.value : entry)
+	}));
+	return normalizeRecordEntries(value).map((entry, index) => ({
+		id: entry.id || `tool-config-${index + 1}`,
+		name: entry.name,
+		value: Array.isArray(entry.value) ? structuredClone(entry.value) : entry.value
+	}));
+}
+function normalizeVariableAggregatorGroups(value) {
+	if (!Array.isArray(value)) return [];
+	return value.flatMap((entry, index) => {
+		if (!isRecord(entry)) return [];
+		const rawVariables = entry.variables ?? entry.sourceVariables;
+		const hasExplicitGroupName = Object.prototype.hasOwnProperty.call(entry, "groupName") || Object.prototype.hasOwnProperty.call(entry, "group_name") || Object.prototype.hasOwnProperty.call(entry, "outputVariable");
+		const variables = Array.isArray(rawVariables) ? rawVariables.map((variable) => normalizeSelectorPath(variable)) : [];
+		return [{
+			groupId: normalizeStringValue(entry.id ?? entry.groupId) || `group-${index + 1}`,
+			group_name: hasExplicitGroupName ? normalizeStringValue(entry.groupName ?? entry.group_name ?? entry.outputVariable) : `group_${index + 1}`,
+			output_type: normalizeAggregatorOutputType(entry.valueType ?? entry.output_type),
+			variables
+		}];
+	});
+}
+function normalizeLoopVariables(value) {
+	if (!Array.isArray(value)) return [];
+	return value.flatMap((entry, index) => {
+		if (!isRecord(entry)) return [];
+		return [{
+			id: normalizeStringValue(entry.id) || `loop-variable-${index + 1}`,
+			name: normalizeStringValue(entry.name ?? entry.label),
+			dataType: normalizeConcreteValueType(entry.dataType ?? entry.var_type),
+			valueType: normalizeStringValue(entry.valueType ?? entry.value_type) === "variable" ? "variable" : "constant",
+			value: normalizeStringValue(entry.valueType ?? entry.value_type) === "variable" ? normalizeSelectorPath(entry.value) : typeof entry.value === "boolean" || typeof entry.value === "number" ? entry.value : Array.isArray(entry.value) ? entry.value.map((item) => String(item ?? "").trim()).filter(Boolean) : isRecord(entry) && "value" in entry ? normalizeListOperatorValue(entry.value) : ""
+		}];
+	});
+}
+function normalizeOutputSchema(value) {
+	if (Array.isArray(value)) return value.flatMap((entry, index) => {
+		if (!isRecord(entry)) return [];
+		return [{
+			id: normalizeStringValue(entry.id) || `output-${index + 1}`,
+			name: normalizeStringValue(entry.name ?? entry.variable),
+			type: normalizeParameterDataType(entry.type),
+			description: normalizeStringValue(entry.description)
+		}];
+	});
+	if (!isRecord(value)) return [];
+	const schemaProperties = isRecord(value.properties) ? value.properties : value;
+	return Object.entries(schemaProperties).map(([key, entry], index) => ({
+		id: `${key || "output"}-${index + 1}`,
+		name: key,
+		type: normalizeParameterDataType(isRecord(entry) ? entry.type : void 0),
+		description: normalizeStringValue(isRecord(entry) ? entry.description : void 0)
+	}));
+}
+function buildPublishedOutputSchema(fields) {
+	return {
+		type: "object",
+		properties: Object.fromEntries(fields.filter((field) => field.name.trim()).map((field) => [field.name, {
+			type: normalizeParameterDataType(field.type),
+			...field.description.trim() ? { description: field.description.trim() } : {}
+		}]))
+	};
+}
+function normalizeScheduleFrequency(value) {
+	switch (normalizeStringValue(value).toLowerCase()) {
+		case "hourly":
+		case "weekly":
+		case "monthly": return normalizeStringValue(value).toLowerCase();
+		default: return "daily";
+	}
+}
+function normalizeScheduleVisualConfig(value) {
+	if (!isRecord(value)) return {
+		time: "09:00",
+		weekdays: ["1"],
+		onMinute: 0,
+		monthlyDays: [1]
+	};
+	return {
+		time: normalizeStringValue(value.time) || void 0,
+		weekdays: Array.isArray(value.weekdays) ? value.weekdays.map((entry) => normalizeStringValue(entry)).filter(Boolean) : void 0,
+		onMinute: typeof value.on_minute === "number" && Number.isFinite(value.on_minute) ? value.on_minute : typeof value.onMinute === "number" && Number.isFinite(value.onMinute) ? value.onMinute : void 0,
+		monthlyDays: Array.isArray(value.monthly_days) ? value.monthly_days.flatMap((entry) => entry === "last" || typeof entry === "number" && Number.isFinite(entry) ? [entry] : []) : Array.isArray(value.monthlyDays) ? value.monthlyDays.flatMap((entry) => entry === "last" || typeof entry === "number" && Number.isFinite(entry) ? [entry] : []) : void 0
+	};
+}
+function normalizeTemplateVariables(value) {
+	if (!Array.isArray(value)) return [];
+	return value.flatMap((entry, index) => {
+		if (!isRecord(entry)) return [];
+		return [{
+			id: normalizeStringValue(entry.id) || `template-variable-${index + 1}`,
+			variable: normalizeStringValue(entry.variable ?? entry.name),
+			value_selector: normalizeSelectorPath(entry.value_selector ?? entry.valueSelector ?? entry.value),
+			label: normalizeVariableLabel(entry.label),
+			value_type: normalizeWebhookVariableType(entry.value_type ?? entry.valueType),
+			variable_type: normalizeStringValue(entry.variable_type ?? entry.variableType) || void 0,
+			value: normalizeStringValue(entry.value),
+			options: normalizeStartVariableOptions(entry.options),
+			required: normalizeBooleanValue(entry.required, false),
+			isParagraph: normalizeBooleanValue(entry.isParagraph, false)
+		}];
+	});
+}
+function normalizeCodeLanguage(value) {
+	return normalizeStringValue(value).toLowerCase() === "javascript" ? "javascript" : "python";
+}
+function normalizeCodeInputVariables(value) {
+	if (Array.isArray(value)) return value.map((entry) => {
+		if (isRecord(entry)) return normalizeStringValue(entry.name ?? entry.variable);
+		return normalizeStringValue(entry);
+	}).filter(Boolean);
+	return [];
+}
+function normalizeCodeVariables(value) {
+	if (!Array.isArray(value)) return [];
+	return value.flatMap((entry, index) => {
+		if (!isRecord(entry)) return [];
+		const variable = normalizeStringValue(entry.variable ?? entry.name);
+		if (!variable) return [];
+		return [{
+			id: normalizeStringValue(entry.id) || `code-variable-${index + 1}`,
+			variable,
+			value_selector: normalizeSelectorPath(entry.value_selector ?? entry.valueSelector ?? variable)
+		}];
+	});
+}
+function normalizeCodeOutputVariables(value) {
+	if (Array.isArray(value)) return value.flatMap((entry, index) => {
+		if (!isRecord(entry)) return [];
+		return [{
+			id: normalizeStringValue(entry.id) || `output-${index + 1}`,
+			name: normalizeStringValue(entry.name ?? entry.variable),
+			dataType: normalizeParameterDataType(entry.dataType ?? entry.type)
+		}];
+	});
+	if (!isRecord(value)) return [];
+	return Object.entries(value).map(([key, entry], index) => ({
+		id: `${key || "output"}-${index + 1}`,
+		name: key,
+		dataType: normalizeParameterDataType(isRecord(entry) ? entry.type : void 0)
+	}));
+}
+function normalizeEndOutputs(value) {
+	if (Array.isArray(value)) return value.flatMap((entry, index) => {
+		if (!isRecord(entry)) return [];
+		const selector = normalizeSelectorPath(entry.valueSelector ?? entry.value_selector ?? entry.sourceVariable ?? entry.source_variable);
+		const variable = normalizeStringValue(entry.variable) || normalizeStringValue(entry.outputName ?? entry.name) || deriveEndOutputNameFromSelector(selector);
+		return [{
+			id: normalizeStringValue(entry.id) || `output-${index + 1}`,
+			variable,
+			value_selector: selector,
+			label: normalizeVariableLabel(entry.label),
+			value_type: normalizeWebhookVariableType(entry.value_type ?? entry.valueType),
+			required: normalizeBooleanValue(entry.required, false)
+		}];
+	});
+	return [];
+}
+function normalizeDifyVariables(value, fallbackPrefix) {
+	if (Array.isArray(value)) return value.flatMap((entry, index) => {
+		if (!isRecord(entry)) return [];
+		const selector = normalizeSelectorPath(entry.valueSelector ?? entry.value_selector ?? entry.sourceVariable ?? entry.source_variable);
+		const variable = normalizeStringValue(entry.variable ?? entry.name ?? entry.outputName) || deriveVariableNameFromSelector(selector);
+		if (!variable) return [];
+		return [{
+			id: normalizeStringValue(entry.id) || `${fallbackPrefix}-${index + 1}`,
+			variable,
+			value_selector: selector,
+			label: normalizeVariableLabel(entry.label),
+			value_type: normalizeWebhookVariableType(entry.value_type ?? entry.valueType),
+			required: normalizeBooleanValue(entry.required, false)
+		}];
+	});
+	return [];
+}
+var WEBHOOK_RAW_VARIABLE_NAME = "_webhook_raw";
+function normalizeWebhookVariableKey(name, sourceType) {
+	return sourceType === "header" ? name.replace(/-/g, "_") : name;
+}
+function normalizeWebhookVariables(value, params, headers, body) {
+	const rawVariable = {
+		id: "webhook-raw",
+		variable: WEBHOOK_RAW_VARIABLE_NAME,
+		label: "raw",
+		value_selector: [],
+		value_type: "object",
+		required: true
+	};
+	const existing = Array.isArray(value) ? value.flatMap((entry, index) => {
+		if (!isRecord(entry)) return [];
+		const variable = normalizeStringValue(entry.variable ?? entry.name);
+		if (!variable) return [];
+		return [{
+			id: normalizeStringValue(entry.id) || `webhook-existing-${index + 1}`,
+			variable,
+			label: normalizeVariableLabel(entry.label),
+			value_selector: normalizeSelectorPath(entry.value_selector ?? entry.valueSelector),
+			value_type: normalizeWebhookVariableType(entry.value_type ?? entry.valueType),
+			required: normalizeBooleanValue(entry.required, false)
+		}];
+	}) : [];
+	const existingByVariable = new Map(existing.map((entry) => [entry.variable, entry]));
+	const mapped = [
+		...params.map((entry, index) => {
+			const variable = normalizeWebhookVariableKey(entry.name, "param");
+			const existingEntry = existingByVariable.get(variable);
+			return {
+				id: existingEntry?.id || `webhook-param-${index + 1}`,
+				variable,
+				label: "param",
+				value_selector: existingEntry?.value_selector ?? [],
+				value_type: entry.type,
+				required: entry.required
+			};
+		}),
+		...headers.map((entry, index) => {
+			const variable = normalizeWebhookVariableKey(entry.name, "header");
+			const existingEntry = existingByVariable.get(variable);
+			return {
+				id: existingEntry?.id || `webhook-header-${index + 1}`,
+				variable,
+				label: "header",
+				value_selector: existingEntry?.value_selector ?? [],
+				value_type: "string",
+				required: entry.required
+			};
+		}),
+		...body.map((entry, index) => {
+			const variable = normalizeWebhookVariableKey(entry.name, "body");
+			const existingEntry = existingByVariable.get(variable);
+			return {
+				id: existingEntry?.id || `webhook-body-${index + 1}`,
+				variable,
+				label: "body",
+				value_selector: existingEntry?.value_selector ?? [],
+				value_type: entry.type,
+				required: entry.required
+			};
+		})
+	];
+	return existing.some((entry) => entry.variable === WEBHOOK_RAW_VARIABLE_NAME) ? [...mapped, existingByVariable.get(WEBHOOK_RAW_VARIABLE_NAME) ?? rawVariable] : [...mapped, rawVariable];
+}
+function normalizeNodeConfigurationByKind(kind, value) {
+	const defaultConfig = structuredClone(createDefaultNodeConfigurationV2(kind) ?? createDefaultNodeConfigurationV2("note"));
+	if (!isRecord(value)) return defaultConfig;
+	switch (kind) {
+		case "start": {
+			const normalizedConfig = defaultConfig.kind === "start" ? defaultConfig : null;
+			if (!normalizedConfig) return defaultConfig;
+			const variables = normalizeStartVariables(value.variables);
+			const legacyVariables = normalizeLegacyStartFieldVariables(value.fields);
+			return {
+				...normalizedConfig,
+				variables: variables.length ? variables : legacyVariables
+			};
+		}
+		case "webhook-trigger": {
+			const normalizedConfig = defaultConfig.kind === "webhook-trigger" ? defaultConfig : null;
+			if (!normalizedConfig) return defaultConfig;
+			const legacyParameters = Array.isArray(value.parameters) ? value.parameters : [];
+			const params = Array.isArray(value.params) ? normalizeWebhookParameters(value.params) : normalizeWebhookParameters(legacyParameters.filter((entry) => isRecord(entry) && normalizeStringValue(entry.source) === "query"));
+			const body = Array.isArray(value.body) ? normalizeWebhookParameters(value.body) : normalizeWebhookParameters(legacyParameters.filter((entry) => isRecord(entry) && normalizeStringValue(entry.source) === "body"));
+			const headers = Array.isArray(value.headers) ? normalizeWebhookHeaders(value.headers) : [];
+			const webhookUrl = normalizeStringValue(value.webhookUrl ?? value.webhook_url);
+			const webhookDebugUrl = normalizeStringValue(value.webhookDebugUrl ?? value.webhook_debug_url);
+			return {
+				...normalizedConfig,
+				webhook_url: webhookUrl || normalizeStringValue(value.path),
+				webhook_debug_url: webhookDebugUrl,
+				method: normalizeWebhookMethod(value.method),
+				content_type: normalizeWebhookContentType(value.contentType ?? value.content_type),
+				headers,
+				params,
+				body,
+				async_mode: typeof value.asyncMode === "boolean" ? value.asyncMode : normalizeBooleanValue(value.async_mode, true),
+				status_code: typeof value.response === "object" && value.response && "statusCode" in value.response ? Number(value.response.statusCode) || 200 : typeof value.status_code === "number" ? value.status_code : normalizedConfig.status_code,
+				response_body: typeof value.response === "object" && value.response && "body" in value.response ? normalizeStringValue(value.response.body) : normalizeStringValue(value.response_body),
+				variables: normalizeWebhookVariables(value.variables, params, headers, body)
+			};
+		}
+		case "schedule-trigger": {
+			const normalizedConfig = defaultConfig.kind === "schedule-trigger" ? defaultConfig : null;
+			if (!normalizedConfig) return defaultConfig;
+			const schedule = normalizeStringValue(value.schedule ?? value.cron_expression);
+			const visualConfig = normalizeScheduleVisualConfig(value.visualConfig ?? value.visual_config);
+			return {
+				...normalizedConfig,
+				schedule,
+				cron_expression: schedule,
+				mode: normalizeStringValue(value.mode).toLowerCase() === "cron" ? "cron" : "visual",
+				frequency: normalizeScheduleFrequency(value.frequency),
+				visualConfig,
+				visual_config: {
+					time: visualConfig.time,
+					weekdays: visualConfig.weekdays,
+					on_minute: visualConfig.onMinute,
+					monthly_days: visualConfig.monthlyDays
+				},
+				timezone: normalizeStringValue(value.timezone) || void 0
+			};
+		}
+		case "end": {
+			const normalizedConfig = defaultConfig.kind === "end" ? defaultConfig : null;
+			if (!normalizedConfig) return defaultConfig;
+			return {
+				...normalizedConfig,
+				outputs: normalizeEndOutputs(value.outputs).length ? normalizeEndOutputs(value.outputs) : normalizedConfig.outputs
+			};
+		}
+		case "llm": {
+			const normalizedConfig = defaultConfig.kind === "llm" ? defaultConfig : null;
+			if (!normalizedConfig) return defaultConfig;
+			const promptConfig = isRecord(value.prompt_config) ? value.prompt_config : null;
+			const contextConfig = isRecord(value.context) ? value.context : null;
+			const memoryConfig = isRecord(value.memory) ? value.memory : null;
+			const memoryWindowConfig = memoryConfig && isRecord(memoryConfig.window) ? memoryConfig.window : null;
+			const structuredOutput = isRecord(value.structured_output) ? value.structured_output : null;
+			const normalizedMemoryConfig = normalizeNodeMemoryConfig(value.memory, normalizedConfig.memory.window.size ?? 3);
+			return {
+				...normalizedConfig,
+				model: normalizeModelConfig(value.model),
+				prompt_template: normalizePromptTemplate(promptConfig?.prompt_template ?? value.prompt_template ?? value.promptTemplate ?? value.prompt),
+				prompt_config: { jinja2_variables: normalizePromptVariables(promptConfig?.jinja2_variables ?? value.promptVariables) },
+				context: {
+					enabled: typeof value.contextEnabled === "boolean" ? value.contextEnabled : normalizeBooleanValue(contextConfig?.enabled, false),
+					variable_selector: Array.isArray(value.contextBindings) ? value.contextBindings.map((entry) => normalizeStringValue(entry)).filter(Boolean) : isRecord(contextConfig) && Array.isArray(contextConfig.variableBindings) ? contextConfig.variableBindings.map((entry) => normalizeStringValue(entry)).filter(Boolean) : Array.isArray(contextConfig?.variable_selector) ? contextConfig.variable_selector.map((entry) => normalizeStringValue(entry)).filter(Boolean) : []
+				},
+				memory: {
+					window: {
+						enabled: typeof value.memoryEnabled === "boolean" ? value.memoryEnabled : normalizeBooleanValue(memoryWindowConfig?.enabled, normalizedMemoryConfig.enabled),
+						size: typeof memoryWindowConfig?.size === "number" && Number.isFinite(memoryWindowConfig.size) ? memoryWindowConfig.size : normalizedMemoryConfig.windowSize
+					},
+					query_prompt_template: normalizeStringValue(memoryConfig?.query_prompt_template) || void 0
+				},
+				vision: typeof value.visionEnabled === "boolean" ? {
+					enabled: value.visionEnabled,
+					configs: {
+						variable_selector: normalizedConfig.vision.configs.variable_selector,
+						detail: normalizedConfig.vision.configs.detail
+					}
+				} : normalizeLlmVisionConfig(value.vision),
+				structured_output_enabled: typeof value.structuredOutputEnabled === "boolean" ? value.structuredOutputEnabled : typeof value.structured_output_enabled === "boolean" ? value.structured_output_enabled : isRecord(value.structuredOutput) ? normalizeBooleanValue(value.structuredOutput.enabled, false) : false,
+				structured_output: { schema: normalizeStringValue(value.structuredOutputSchema) || normalizeStringValue(isRecord(value.structuredOutput) ? value.structuredOutput.schema : void 0) || normalizeStringValue(structuredOutput?.schema ? JSON.stringify(structuredOutput.schema, null, 2) : "") },
+				reasoning_format: normalizeStringValue(value.reasoningFormat ?? value.reasoning_format).toLowerCase() === "separated" ? "separated" : "tagged"
+			};
+		}
+		case "knowledge-retrieval": {
+			const normalizedConfig = defaultConfig.kind === "knowledge-retrieval" ? defaultConfig : null;
+			if (!normalizedConfig) return defaultConfig;
+			const multipleRetrievalConfig = isRecord(value.multiple_retrieval_config) ? value.multiple_retrieval_config : null;
+			const singleRetrievalConfig = isRecord(value.single_retrieval_config) ? value.single_retrieval_config : null;
+			return {
+				...normalizedConfig,
+				query_variable_selector: normalizeSelectorPath(value.queryVariableSelector ?? value.query_variable_selector ?? value.queryVariable),
+				query_attachment_selector: normalizeSelectorPath(value.queryAttachmentSelector ?? value.query_attachment_selector),
+				dataset_ids: Array.isArray(value.datasetIds) ? value.datasetIds.map((entry) => normalizeStringValue(entry)).filter(Boolean) : Array.isArray(value.dataset_ids) ? value.dataset_ids.map((entry) => normalizeStringValue(entry)).filter(Boolean) : Array.isArray(value.datasets) ? value.datasets.map((entry) => normalizeStringValue(entry)).filter(Boolean) : [],
+				retrieval_mode: normalizeStringValue(value.retrievalMode ?? value.retrieval_mode).toLowerCase() === "single" ? "single" : "multiple",
+				multiple_retrieval_config: {
+					top_k: normalizePositiveNumber(value.topK ?? multipleRetrievalConfig?.top_k, normalizedConfig.multiple_retrieval_config.top_k),
+					score_threshold: parseOptionalNumber(value.scoreThreshold ?? multipleRetrievalConfig?.score_threshold),
+					reranking_enable: typeof value.rerankingEnabled === "boolean" ? value.rerankingEnabled : normalizeBooleanValue(multipleRetrievalConfig?.reranking_enable, false),
+					reranking_model: normalizeModelReference(value.rerankModel ?? multipleRetrievalConfig?.reranking_model) ? normalizeKnowledgeRetrievalRerankingModelConfig(value.rerankModel ?? multipleRetrievalConfig?.reranking_model) : null,
+					reranking_mode: normalizeStringValue(value.rerankingMode ?? multipleRetrievalConfig?.reranking_mode) || void 0
+				},
+				single_retrieval_config: { model: normalizeModelReference(value.singleRetrievalModel ?? singleRetrievalConfig?.model) ? normalizeModelConfig(value.singleRetrievalModel ?? singleRetrievalConfig?.model) : null },
+				metadata_filtering_mode: normalizeStringValue(value.metadataFilteringMode ?? value.metadata_filtering_mode).toLowerCase() === "automatic" ? "automatic" : normalizeStringValue(value.metadataFilteringMode ?? value.metadata_filtering_mode).toLowerCase() === "manual" ? "manual" : "disabled",
+				metadata_filtering_conditions: normalizeKnowledgeRetrievalMetadataConditions(value.metadataFilteringConditions ?? value.metadata_filtering_conditions),
+				metadata_model_config: normalizeModelReference(value.metadataModelConfig ?? value.metadata_model_config) ? normalizeModelConfig(value.metadataModelConfig ?? value.metadata_model_config) : null
+			};
+		}
+		case "question-classifier": {
+			const normalizedConfig = defaultConfig.kind === "question-classifier" ? defaultConfig : null;
+			if (!normalizedConfig) return defaultConfig;
+			return {
+				...normalizedConfig,
+				query_variable_selector: normalizeSelectorPath(value.queryVariableSelector ?? value.query_variable_selector ?? value.inputVariable),
+				model: normalizeModelConfig(value.model),
+				classes: normalizeQuestionClassifierClasses(value.classes ?? value.categories),
+				instruction: normalizeStringValue(value.instruction ?? value.instructions),
+				memory: normalizeDifyMemoryConfig(typeof value.memoryEnabled === "boolean" ? { window: {
+					enabled: value.memoryEnabled,
+					size: normalizedConfig.memory.window.size
+				} } : isRecord(value.memory) && typeof value.memory.enabled === "boolean" ? {
+					...value.memory,
+					window: {
+						enabled: value.memory.enabled,
+						size: typeof value.memory.windowSize === "number" && Number.isFinite(value.memory.windowSize) ? value.memory.windowSize : typeof value.memory.window_size === "number" && Number.isFinite(value.memory.window_size) ? value.memory.window_size : normalizedConfig.memory.window.size
+					}
+				} : value.memory, normalizedConfig.memory.window.size ?? 3),
+				vision: typeof value.visionEnabled === "boolean" ? {
+					enabled: value.visionEnabled,
+					configs: {
+						variable_selector: normalizedConfig.vision.configs.variable_selector,
+						detail: normalizedConfig.vision.configs.detail
+					}
+				} : normalizeLlmVisionConfig(typeof value.visionEnabled === "boolean" ? {
+					enabled: value.visionEnabled,
+					configs: {
+						variable_selector: normalizedConfig.vision.configs.variable_selector,
+						detail: normalizedConfig.vision.configs.detail
+					}
+				} : value.vision)
+			};
+		}
+		case "if-else": {
+			const normalizedConfig = defaultConfig.kind === "if-else" ? defaultConfig : null;
+			if (!normalizedConfig) return defaultConfig;
+			const targetBranches = Array.isArray(value._targetBranches) ? value._targetBranches.flatMap((entry, index) => {
+				if (!isRecord(entry)) return [];
+				return [{
+					id: normalizeStringValue(entry.id) || (index === 0 ? "true" : index === 1 ? "false" : `branch-${index + 1}`),
+					name: normalizeStringValue(entry.name) || (index === 0 ? "IF" : index === 1 ? "ELSE" : `ELIF ${index}`)
+				}];
+			}) : normalizedConfig._targetBranches ?? [];
+			const normalizedCases = Array.isArray(value.cases) && value.cases.length > 0 ? structuredClone(value.cases) : normalizedConfig.cases;
+			const normalizedBranchConditions = Array.isArray(value.branchConditions) && value.branchConditions.length > 0 ? structuredClone(value.branchConditions) : normalizedConfig.branchConditions;
+			return {
+				...normalizedConfig,
+				branchConditions: normalizedBranchConditions,
+				_targetBranches: targetBranches.length > 0 ? targetBranches : normalizedConfig._targetBranches,
+				cases: normalizedCases,
+				logical_operator: normalizeStringValue(value.logical_operator).toLowerCase() === "or" ? "or" : "and",
+				conditions: Array.isArray(value.conditions) ? structuredClone(value.conditions) : normalizedConfig.conditions,
+				isInIteration: normalizeBooleanValue(value.isInIteration, false),
+				isInLoop: normalizeBooleanValue(value.isInLoop, false)
+			};
+		}
+		case "parameter-extractor": {
+			const normalizedConfig = defaultConfig.kind === "parameter-extractor" ? defaultConfig : null;
+			if (!normalizedConfig) return defaultConfig;
+			return {
+				...normalizedConfig,
+				query: normalizeSelectorPath(value.inputVariable ?? value.query),
+				model: normalizeModelConfig(value.model),
+				parameters: normalizeParameterExtractorParameters(value.parameters),
+				instruction: normalizeStringValue(value.extractionInstructions ?? value.instruction),
+				reasoning_mode: String(value.reasoningMode ?? value.reasoning_mode).trim() === "function_call" ? "function_call" : "prompt",
+				memory: normalizeDifyMemoryConfig(typeof value.memoryEnabled === "boolean" ? { window: {
+					enabled: value.memoryEnabled,
+					size: normalizedConfig.memory.window.size
+				} } : isRecord(value.memory) && typeof value.memory.enabled === "boolean" ? {
+					...value.memory,
+					window: {
+						enabled: value.memory.enabled,
+						size: typeof value.memory.windowSize === "number" && Number.isFinite(value.memory.windowSize) ? value.memory.windowSize : typeof value.memory.window_size === "number" && Number.isFinite(value.memory.window_size) ? value.memory.window_size : normalizedConfig.memory.window.size
+					}
+				} : value.memory, normalizedConfig.memory.window.size ?? 3),
+				vision: typeof value.visionEnabled === "boolean" ? {
+					enabled: value.visionEnabled,
+					configs: {
+						variable_selector: normalizedConfig.vision.configs.variable_selector,
+						detail: normalizedConfig.vision.configs.detail
+					}
+				} : normalizeLlmVisionConfig(value.vision)
+			};
+		}
+		case "doc-extractor": {
+			const normalizedConfig = defaultConfig.kind === "doc-extractor" ? defaultConfig : null;
+			if (!normalizedConfig) return defaultConfig;
+			return {
+				...normalizedConfig,
+				variable_selector: normalizeSelectorPath(value.sourceVariable ?? value.variable_selector),
+				is_array_file: typeof value.isArrayFile === "boolean" ? value.isArrayFile : normalizeBooleanValue(value.is_array_file, false)
+			};
+		}
+		case "human-input": {
+			const normalizedConfig = defaultConfig.kind === "human-input" ? defaultConfig : null;
+			if (!normalizedConfig) return defaultConfig;
+			return {
+				...normalizedConfig,
+				delivery_methods: normalizeHumanInputDeliveryMethods(value.delivery_methods ?? value.deliveryMethods),
+				form_content: normalizeStringValue(value.form_content ?? value.formContent),
+				inputs: normalizeHumanInputItems(value.inputs),
+				user_actions: normalizeHumanInputActions(value.user_actions ?? value.userActions),
+				timeout: normalizePositiveNumber(value.timeout, normalizedConfig.timeout),
+				timeout_unit: normalizeStringValue(value.timeout_unit ?? value.timeoutUnit).toLowerCase() === "hour" ? "hour" : "day"
+			};
+		}
+		case "data-source": {
+			const normalizedConfig = defaultConfig.kind === "data-source" ? defaultConfig : null;
+			if (!normalizedConfig) return defaultConfig;
+			return {
+				...normalizedConfig,
+				fileExtensions: normalizeFileExtensions(value.fileExtensions ?? value.file_extensions ?? value.fileExtensions),
+				plugin_id: normalizeStringValue(value.plugin_id ?? value.pluginId),
+				provider_type: normalizeStringValue(value.provider_type ?? value.providerType),
+				provider_name: normalizeStringValue(value.provider_name ?? value.providerName),
+				datasource_name: normalizeStringValue(value.datasource_name ?? value.datasourceName),
+				datasource_label: normalizeStringValue(value.datasource_label ?? value.datasourceLabel),
+				datasource_parameters: normalizeResourceParameters(value.datasource_parameters ?? value.datasourceParameters),
+				datasource_configurations: normalizeResourceConfigurations(value.datasource_configurations ?? value.datasourceConfigurations),
+				output_schema: isRecord(value.output_schema) ? structuredClone(value.output_schema) : normalizeOutputSchema(value.outputSchema ?? value.output_schema),
+				plugin_unique_identifier: normalizeStringValue(value.plugin_unique_identifier ?? value.pluginUniqueIdentifier) || void 0
+			};
+		}
+		case "knowledge-base": {
+			const normalizedConfig = defaultConfig.kind === "knowledge-base" ? defaultConfig : null;
+			if (!normalizedConfig) return defaultConfig;
+			const summaryIndexSettingValue = value.summary_index_setting ?? value.summaryIndexSetting;
+			const rawSummaryIndexSetting = isRecord(summaryIndexSettingValue) ? summaryIndexSettingValue : null;
+			return {
+				...normalizedConfig,
+				index_chunk_variable_selector: normalizeSelectorPath(value.index_chunk_variable_selector ?? value.indexChunkVariableSelector),
+				chunk_structure: normalizeKnowledgeBaseChunkStructure(value.chunk_structure ?? value.chunkStructure),
+				indexing_technique: normalizeStringValue(value.indexing_technique ?? value.indexingTechnique) || void 0,
+				embedding_model: normalizeStringValue(value.embedding_model ?? value.embeddingModel) || void 0,
+				embedding_model_provider: normalizeStringValue(value.embedding_model_provider ?? value.embeddingModelProvider) || void 0,
+				keyword_number: normalizePositiveNumber(value.keyword_number ?? value.keywordNumber, normalizedConfig.keyword_number),
+				retrieval_model: normalizeKnowledgeBaseRetrievalModel(value.retrieval_model ?? value.retrievalModel, normalizedConfig.retrieval_model),
+				summary_index_setting: rawSummaryIndexSetting ? {
+					enable: normalizeBooleanValue(rawSummaryIndexSetting.enable, false),
+					model_name: normalizeStringValue(rawSummaryIndexSetting.model_name ?? rawSummaryIndexSetting.modelName) || void 0,
+					model_provider_name: normalizeStringValue(rawSummaryIndexSetting.model_provider_name ?? rawSummaryIndexSetting.modelProviderName) || void 0,
+					summary_prompt: normalizeStringValue(rawSummaryIndexSetting.summary_prompt ?? rawSummaryIndexSetting.summaryPrompt) || void 0
+				} : void 0
+			};
+		}
+		case "trigger-plugin": {
+			const normalizedConfig = defaultConfig.kind === "trigger-plugin" ? defaultConfig : null;
+			if (!normalizedConfig) return defaultConfig;
+			const normalizedEventParameters = normalizeResourceParameters(value.event_parameters ?? value.eventParameters);
+			const normalizedLegacyConfigParameters = normalizeResourceParameters(value.config);
+			return {
+				...normalizedConfig,
+				provider_id: normalizeStringValue(value.provider_id ?? value.providerId),
+				provider_type: normalizeTriggerPluginProviderType(value.provider_type ?? value.providerType),
+				provider_name: normalizeStringValue(value.provider_name ?? value.providerName),
+				event_name: normalizeStringValue(value.event_name ?? value.eventName),
+				event_label: normalizeStringValue(value.event_label ?? value.eventLabel),
+				event_parameters: Object.keys(normalizedEventParameters).length > 0 ? normalizedEventParameters : normalizedLegacyConfigParameters,
+				event_configurations: normalizeResourceConfigurations(value.event_configurations ?? value.eventConfigurations),
+				output_schema: isRecord(value.output_schema) ? structuredClone(value.output_schema) : normalizeOutputSchema(value.outputSchema ?? value.output_schema),
+				parameters_schema: normalizeParameterSchemaFields(value.parameters_schema ?? value.parametersSchema),
+				version: normalizeStringValue(value.version) || void 0,
+				event_node_version: normalizeStringValue(value.event_node_version ?? value.eventNodeVersion) || "2",
+				plugin_id: normalizeStringValue(value.plugin_id ?? value.pluginId) || void 0,
+				config: isRecord(value.config) ? structuredClone(value.config) : {},
+				plugin_unique_identifier: normalizeStringValue(value.plugin_unique_identifier ?? value.pluginUniqueIdentifier) || void 0,
+				subscription_id: normalizeStringValue(value.subscription_id ?? value.subscriptionId) || void 0
+			};
+		}
+		case "list-operator": {
+			const normalizedConfig = defaultConfig.kind === "list-operator" ? defaultConfig : null;
+			const rawFilterBy = isRecord(value.filter_by) ? value.filter_by : null;
+			const rawFilterCondition = isRecord(value.filterCondition) ? value.filterCondition : Array.isArray(rawFilterBy?.conditions) && isRecord(rawFilterBy.conditions[0]) ? rawFilterBy.conditions[0] : null;
+			const rawExtractBy = isRecord(value.extract_by) ? value.extract_by : null;
+			const rawOrderBy = isRecord(value.order_by) ? value.order_by : null;
+			const rawLimit = isRecord(value.limit) ? value.limit : null;
+			if (!normalizedConfig) return defaultConfig;
+			const inputArrayVariable = normalizeSelectorPath(value.inputArrayVariable ?? value.variable);
+			const filterEnabled = typeof value.filterEnabled === "boolean" ? value.filterEnabled : normalizeBooleanValue(rawFilterBy?.enabled, false);
+			const filterCondition = {
+				key: normalizeStringValue(rawFilterCondition?.key),
+				operator: normalizeListOperatorComparisonOperator(rawFilterCondition?.operator ?? rawFilterCondition?.comparison_operator),
+				value: normalizeListOperatorValue(rawFilterCondition?.value)
+			};
+			const extractEnabled = typeof value.extractEnabled === "boolean" ? value.extractEnabled : normalizeBooleanValue(rawExtractBy?.enabled, false);
+			const extractTemplate = normalizeStringValue(value.extractTemplate ?? rawExtractBy?.serial) || normalizedConfig.extractTemplate;
+			const orderByEnabled = typeof value.orderByEnabled === "boolean" ? value.orderByEnabled : normalizeBooleanValue(rawOrderBy?.enabled, false);
+			const orderByKey = normalizeSelectorPath(value.orderByKey ?? rawOrderBy?.key);
+			const orderByDirection = String(value.orderByDirection ?? rawOrderBy?.value).trim().toLowerCase() === "desc" ? "desc" : "asc";
+			return {
+				...normalizedConfig,
+				inputArrayVariable,
+				operation: value.operation === "map" || value.operation === "filter" || value.operation === "flatten" || value.operation === "deduplicate" || value.operation === "aggregate" ? value.operation : normalizeBooleanValue(rawFilterBy?.enabled, false) ? "filter" : normalizedConfig.operation,
+				operationConfig: normalizeStringValue(value.operationConfig),
+				variable: inputArrayVariable,
+				var_type: normalizeStringValue(value.var_type),
+				item_var_type: normalizeStringValue(value.item_var_type),
+				filterEnabled,
+				filterCondition,
+				filter_by: {
+					enabled: filterEnabled,
+					conditions: filterEnabled && (filterCondition.key || filterCondition.operator || filterCondition.value) ? [{
+						key: filterCondition.key,
+						comparison_operator: filterCondition.operator,
+						value: filterCondition.value
+					}] : []
+				},
+				extractEnabled,
+				extractTemplate,
+				extract_by: {
+					enabled: extractEnabled,
+					serial: extractTemplate || void 0
+				},
+				orderByEnabled,
+				orderByKey,
+				orderByDirection,
+				order_by: {
+					enabled: orderByEnabled,
+					key: orderByKey,
+					value: orderByDirection
+				},
+				limit: {
+					enabled: isRecord(value.limit) && typeof value.limit.enabled === "boolean" ? value.limit.enabled : normalizeBooleanValue(rawLimit?.enabled, false),
+					size: normalizePositiveNumber(isRecord(value.limit) ? value.limit.size : rawLimit?.size, normalizedConfig.limit.size)
+				}
+			};
+		}
+		case "iteration": {
+			const normalizedConfig = defaultConfig.kind === "iteration" ? defaultConfig : null;
+			if (!normalizedConfig) return defaultConfig;
+			return {
+				...normalizedConfig,
+				startNodeType: normalizeStringValue(value.startNodeType) || normalizedConfig.startNodeType,
+				start_node_id: normalizeStringValue(value.start_node_id),
+				iterator_selector: normalizeSelectorPath(value.inputArrayVariable ?? value.iterator_selector),
+				iterator_input_type: normalizeConcreteValueType(value.iterator_input_type, "array"),
+				output_selector: normalizeSelectorPath(value.outputVariable ?? value.output_selector),
+				output_type: normalizeConcreteValueType(value.output_type, "array"),
+				is_parallel: value.executionMode === "parallel" ? true : value.executionMode === "sequential" ? false : normalizeBooleanValue(value.is_parallel, false),
+				parallel_nums: normalizePositiveNumber(value.parallelCount ?? value.parallel_nums, normalizedConfig.parallel_nums),
+				error_handle_mode: value.failureMode === "continue" ? "continue-on-error" : value.failureMode === "remove-failed-results" ? "remove-abnormal-output" : value.failureMode === "terminate" ? "terminated" : normalizeStringValue(value.error_handle_mode) === "continue-on-error" ? "continue-on-error" : normalizeStringValue(value.error_handle_mode) === "remove-abnormal-output" ? "remove-abnormal-output" : "terminated",
+				flatten_output: typeof value.flattenOutput === "boolean" ? value.flattenOutput : normalizeBooleanValue(value.flatten_output, true),
+				iteration_id: normalizeStringValue(value.iteration_id) || void 0,
+				_isShowTips: typeof value._isShowTips === "boolean" ? value._isShowTips : normalizedConfig._isShowTips ?? false
+			};
+		}
+		case "code": {
+			const normalizedConfig = defaultConfig.kind === "code" ? defaultConfig : null;
+			if (!normalizedConfig) return defaultConfig;
+			const language = normalizeCodeLanguage(value.language ?? value.code_language);
+			const script = normalizeStringValue(value.script ?? value.code);
+			const inputVariables = normalizeCodeInputVariables(value.inputVariables ?? value.variables);
+			const normalizedVariables = normalizeCodeVariables(value.variables);
+			const outputVariables = normalizeCodeOutputVariables(value.outputVariables ?? value.outputs);
+			return {
+				...normalizedConfig,
+				language,
+				code_language: language === "python" ? "python3" : "javascript",
+				script,
+				code: script,
+				inputVariables: normalizedVariables.length > 0 ? normalizedVariables.map((entry) => entry.variable) : inputVariables,
+				variables: normalizedVariables.length > 0 ? normalizedVariables : inputVariables.map((variable, index) => ({
+					id: `code-variable-${index + 1}`,
+					variable,
+					value_selector: normalizeSelectorPath(variable)
+				})),
+				outputVariables,
+				outputs: Object.fromEntries(outputVariables.filter((entry) => entry.name.trim()).map((entry) => [entry.name, {
+					type: entry.dataType,
+					children: null
+				}])),
+				retryCount: normalizePositiveNumber(value.retryCount, normalizedConfig.retryCount ?? 0),
+				retryIntervalMs: normalizePositiveNumber(value.retryIntervalMs, normalizedConfig.retryIntervalMs ?? 1e3),
+				errorHandling: normalizeStringValue(value.errorHandling).toLowerCase() === "continue-on-error" ? "continue-on-error" : normalizeStringValue(value.errorHandling).toLowerCase() === "fallback-branch" ? "fallback-branch" : normalizedConfig.errorHandling
+			};
+		}
+		case "template": {
+			const normalizedConfig = defaultConfig.kind === "template" ? defaultConfig : null;
+			if (!normalizedConfig) return defaultConfig;
+			return {
+				...normalizedConfig,
+				variables: normalizeTemplateVariables(value.variables),
+				template: normalizeStringValue(value.templateBody ?? value.template)
+			};
+		}
+		case "variable-aggregator": {
+			const normalizedConfig = defaultConfig.kind === "variable-aggregator" ? defaultConfig : null;
+			const advancedSettings = isRecord(value.advanced_settings) ? value.advanced_settings : null;
+			if (!normalizedConfig) return defaultConfig;
+			const rawSourceVariables = value.sourceVariables ?? value.variables;
+			const normalizedSourceVariables = Array.isArray(rawSourceVariables) ? rawSourceVariables.map((variable) => normalizeSelectorPath(variable)) : [];
+			return {
+				...normalizedConfig,
+				output_type: normalizeAggregatorOutputType(value.valueType ?? value.output_type),
+				variables: normalizedSourceVariables,
+				advanced_settings: {
+					group_enabled: typeof value.groupEnabled === "boolean" ? value.groupEnabled : normalizeBooleanValue(advancedSettings?.group_enabled, false),
+					groups: normalizeVariableAggregatorGroups(value.groups ?? advancedSettings?.groups)
+				}
+			};
+		}
+		case "variable-assigner": {
+			const normalizedConfig = defaultConfig.kind === "variable-assigner" ? defaultConfig : null;
+			if (!normalizedConfig) return defaultConfig;
+			const normalizedItems = Array.isArray(value.items) ? value.items : Array.isArray(value.assignments) ? value.assignments : Array.isArray(value.variables) ? value.variables.map((variable, index) => ({
+				id: `assignment-${index + 1}`,
+				variable_selector: normalizeSelectorPath(variable),
+				input_type: "variable",
+				operation: "over-write",
+				value: ""
+			})) : normalizedConfig.items;
+			return {
+				...normalizedConfig,
+				version: normalizeStringValue(value.version) === "1" ? "1" : "2",
+				items: normalizedItems.map((assignment, index) => ({
+					input_type: normalizeStringValue(assignment.valueType ?? assignment.input_type).toLowerCase() === "constant" ? "constant" : "variable",
+					id: normalizeStringValue(assignment.id) || `assignment-${index + 1}`,
+					variable_selector: normalizeSelectorPath(assignment.variable ?? assignment.variable_selector),
+					operation: assignment.operation === "over-write" || assignment.operation === "clear" || assignment.operation === "append" || assignment.operation === "extend" || assignment.operation === "set" || assignment.operation === "remove-first" || assignment.operation === "remove-last" || assignment.operation === "+=" || assignment.operation === "-=" || assignment.operation === "*=" || assignment.operation === "/=" ? assignment.operation : assignment.operation === "increment" ? "+=" : assignment.operation === "decrement" ? "-=" : assignment.operation === "multiply" ? "*=" : assignment.operation === "divide" ? "/=" : "over-write",
+					value: normalizeAssignerValue(assignment.value, normalizeStringValue(assignment.valueType ?? assignment.input_type).toLowerCase() === "constant" ? "constant" : "variable")
+				}))
+			};
+		}
+		case "tool": {
+			const normalizedConfig = defaultConfig.kind === "tool" ? defaultConfig : null;
+			if (!normalizedConfig) return defaultConfig;
+			const reference = isRecord(value.reference) ? value.reference : null;
+			const rawToolParameterValue = value.parameters ?? value.dynamicInputs;
+			const rawToolParameters = Array.isArray(rawToolParameterValue) ? rawToolParameterValue : null;
+			const normalizedToolParameters = rawToolParameters && rawToolParameters.length > 0 ? rawToolParameters.map((entry, index) => ({
+				id: normalizeStringValue(readRecordProperty(entry, "id")) || `tool-input-${index + 1}`,
+				name: normalizeStringValue(readRecordProperty(entry, "name")),
+				valueType: normalizeStringValue(readRecordProperty(entry, "valueType") ?? readRecordProperty(entry, "type")) === "variable" ? "variable" : "constant",
+				value: normalizeStringValue(readRecordProperty(entry, "valueType") ?? readRecordProperty(entry, "type")) === "variable" ? normalizeSelectorPath(readRecordProperty(entry, "value")) : normalizeDifyResourceConstantValue(readRecordProperty(entry, "value"))
+			})) : normalizeRecordEntries(value.tool_parameters);
+			return {
+				...normalizedConfig,
+				reference: {
+					id: normalizeStringValue(reference?.id ?? value.toolReferenceId ?? value.provider_id),
+					providerType: normalizeToolProviderType(reference?.providerType ?? value.toolProviderType ?? value.provider_type),
+					providerName: normalizeStringValue(reference?.providerName ?? value.toolReferenceSource ?? value.provider_name),
+					toolName: normalizeStringValue(reference?.toolName ?? value.toolName ?? value.tool_name),
+					label: normalizeStringValue(reference?.label ?? value.toolReferenceLabel ?? value.tool_label),
+					version: normalizeStringValue(reference?.version ?? value.toolReferenceVersion ?? value.version) || void 0,
+					description: normalizeStringValue(reference?.description ?? value.tool_description) || void 0,
+					pluginUniqueIdentifier: normalizeStringValue(reference?.pluginUniqueIdentifier ?? value.plugin_unique_identifier) || void 0
+				},
+				credentialBinding: normalizeStringValue(value.credentialBinding),
+				parameters: normalizedToolParameters,
+				configurations: normalizeToolConfigurationEntries(value.configurations ?? value.toolConfigurations ?? value.tool_configurations),
+				outputSchema: normalizeOutputSchema(value.outputSchema ?? value.output_schema),
+				provider_id: normalizeStringValue(reference?.id ?? value.toolReferenceId ?? value.provider_id),
+				provider_type: normalizeToolProviderType(reference?.providerType ?? value.toolProviderType ?? value.provider_type),
+				provider_name: normalizeStringValue(reference?.providerName ?? value.toolReferenceSource ?? value.provider_name),
+				tool_name: normalizeStringValue(reference?.toolName ?? value.toolName ?? value.tool_name),
+				tool_label: normalizeStringValue(reference?.label ?? value.toolReferenceLabel ?? value.tool_label),
+				tool_parameters: Object.fromEntries(normalizedToolParameters.filter((entry) => entry.name.trim()).map((entry) => [entry.name, {
+					type: entry.valueType,
+					value: entry.value
+				}])),
+				tool_configurations: Object.fromEntries(normalizeToolConfigurationEntries(value.configurations ?? value.toolConfigurations ?? value.tool_configurations).filter((entry) => entry.name.trim()).map((entry) => [entry.name, entry.value])),
+				output_schema: normalizeOutputSchema(value.outputSchema ?? value.output_schema),
+				version: normalizeStringValue(reference?.version ?? value.toolReferenceVersion ?? value.version) || void 0,
+				tool_description: normalizeStringValue(reference?.description ?? value.tool_description) || void 0,
+				is_team_authorization: typeof value.is_team_authorization === "boolean" ? value.is_team_authorization : void 0,
+				params: isRecord(value.params) ? structuredClone(value.params) : void 0,
+				provider_icon: typeof value.provider_icon === "string" || isRecord(value.provider_icon) ? structuredClone(value.provider_icon) : void 0,
+				provider_icon_dark: typeof value.provider_icon_dark === "string" || isRecord(value.provider_icon_dark) ? structuredClone(value.provider_icon_dark) : void 0,
+				plugin_unique_identifier: normalizeStringValue(reference?.pluginUniqueIdentifier ?? value.plugin_unique_identifier) || void 0,
+				tool_node_version: normalizeStringValue(value.tool_node_version) || "2"
+			};
+		}
+		case "agent": {
+			const normalizedConfig = defaultConfig.kind === "agent" ? defaultConfig : null;
+			if (!normalizedConfig) return defaultConfig;
+			const strategy = isRecord(value.strategy) ? value.strategy : null;
+			const rawStrategyParameters = Array.isArray(value.strategyParameters) ? value.strategyParameters : null;
+			const strategyParameters = rawStrategyParameters && rawStrategyParameters.length > 0 ? rawStrategyParameters.map((entry, index) => ({
+				id: normalizeStringValue(readRecordProperty(entry, "id")) || `agent-parameter-${index + 1}`,
+				name: normalizeStringValue(readRecordProperty(entry, "name")),
+				valueType: normalizeStringValue(readRecordProperty(entry, "valueType") ?? readRecordProperty(entry, "type")) === "variable" ? "variable" : "constant",
+				value: normalizeStringValue(readRecordProperty(entry, "valueType") ?? readRecordProperty(entry, "type")) === "variable" ? normalizeSelectorPath(readRecordProperty(entry, "value")) : normalizeDifyResourceConstantValue(readRecordProperty(entry, "value"))
+			})) : normalizeRecordEntries(value.agent_parameters);
+			const normalizedMemory = normalizeDifyMemoryConfig(value.memory, normalizedConfig.memory.windowSize ?? 3);
+			return {
+				...normalizedConfig,
+				model: normalizeModelConfig(value.model),
+				strategy: {
+					mode: normalizeStringValue(strategy?.mode ?? value.strategy).toLowerCase() === "react" ? "react" : normalizedConfig.strategy.mode,
+					providerName: normalizeStringValue(strategy?.providerName ?? value.strategyProviderName ?? value.agent_strategy_provider_name),
+					name: normalizeStringValue(strategy?.name ?? value.strategyName ?? value.agent_strategy_name),
+					label: normalizeStringValue(strategy?.label ?? value.strategyLabel ?? value.agent_strategy_label),
+					pluginUniqueIdentifier: normalizeStringValue(strategy?.pluginUniqueIdentifier ?? value.plugin_unique_identifier) || void 0,
+					version: normalizeStringValue(strategy?.version ?? value.version ?? value.tool_node_version) || void 0,
+					meta: isRecord(strategy?.meta) ? structuredClone(strategy.meta) : isRecord(value.meta) ? structuredClone(value.meta) : null
+				},
+				instructions: normalizeStringValue(value.instructions),
+				enabledTools: Array.isArray(value.enabledTools) ? value.enabledTools.map((entry) => normalizeStringValue(entry)).filter(Boolean) : [],
+				maxIterations: typeof value.maxIterations === "number" && Number.isFinite(value.maxIterations) ? value.maxIterations : normalizedConfig.maxIterations,
+				memory: typeof value.memoryEnabled === "boolean" ? {
+					enabled: value.memoryEnabled,
+					windowSize: normalizedConfig.memory.windowSize,
+					window: {
+						enabled: value.memoryEnabled,
+						size: normalizedConfig.memory.windowSize
+					}
+				} : {
+					enabled: normalizedMemory.window.enabled,
+					windowSize: normalizedMemory.window.size,
+					window: normalizedMemory.window,
+					role_prefix: normalizedMemory.role_prefix,
+					query_prompt_template: normalizedMemory.query_prompt_template
+				},
+				strategyParameters,
+				outputSchema: normalizeOutputSchema(value.outputSchema ?? value.output_schema),
+				agent_strategy_provider_name: normalizeStringValue(strategy?.providerName ?? value.strategyProviderName ?? value.agent_strategy_provider_name),
+				agent_strategy_name: normalizeStringValue(strategy?.name ?? value.strategyName ?? value.agent_strategy_name),
+				agent_strategy_label: normalizeStringValue(strategy?.label ?? value.strategyLabel ?? value.agent_strategy_label),
+				agent_parameters: Object.fromEntries(strategyParameters.filter((entry) => entry.name.trim()).map((entry) => [entry.name, {
+					type: entry.valueType,
+					value: entry.value
+				}])),
+				output_schema: isRecord(value.output_schema) ? structuredClone(value.output_schema) : normalizeOutputSchema(value.outputSchema ?? value.output_schema),
+				plugin_unique_identifier: normalizeStringValue(strategy?.pluginUniqueIdentifier ?? value.plugin_unique_identifier) || void 0,
+				meta: isRecord(strategy?.meta) ? structuredClone(strategy.meta) : isRecord(value.meta) ? structuredClone(value.meta) : null,
+				version: normalizeStringValue(strategy?.version ?? value.version ?? value.tool_node_version) || void 0,
+				tool_node_version: normalizeStringValue(value.tool_node_version) || "2"
+			};
+		}
+		case "loop": {
+			const normalizedConfig = defaultConfig.kind === "loop" ? defaultConfig : null;
+			if (!normalizedConfig) return defaultConfig;
+			const breakConditions = Array.isArray(value.break_conditions) ? value.break_conditions : [];
+			isRecord(breakConditions[0]) && breakConditions[0];
+			return {
+				...normalizedConfig,
+				startNodeType: normalizeStringValue(value.startNodeType) || normalizedConfig.startNodeType,
+				start_node_id: normalizeStringValue(value.start_node_id),
+				logical_operator: normalizeStringValue(value.logical_operator).toLowerCase() === "or" ? "or" : "and",
+				break_conditions: breakConditions.length > 0 ? breakConditions.map((entry, index) => ({
+					id: normalizeStringValue(isRecord(entry) ? entry.id : void 0) || `loop-condition-${index + 1}`,
+					varType: normalizeConcreteValueType(isRecord(entry) ? entry.varType ?? entry.var_type : void 0),
+					variable_selector: normalizeSelectorPath(isRecord(entry) ? entry.variable_selector : void 0),
+					key: normalizeStringValue(isRecord(entry) ? entry.key : void 0) || void 0,
+					comparison_operator: normalizeStringValue(isRecord(entry) ? entry.comparison_operator ?? entry.comparisonOperator : void 0) || void 0,
+					value: typeof (isRecord(entry) ? entry.value : void 0) === "boolean" ? Boolean(entry.value) : Array.isArray(isRecord(entry) ? entry.value : void 0) ? entry.value : normalizeListOperatorValue(isRecord(entry) ? entry.value : void 0),
+					numberVarType: normalizeStringValue(isRecord(entry) ? entry.numberVarType : void 0) || void 0,
+					sub_variable_condition: isRecord(isRecord(entry) ? entry.sub_variable_condition : void 0) ? {
+						logical_operator: normalizeStringValue(entry.sub_variable_condition && isRecord(entry.sub_variable_condition) ? entry.sub_variable_condition.logical_operator : void 0).toLowerCase() === "or" ? "or" : "and",
+						conditions: Array.isArray(entry.sub_variable_condition && isRecord(entry.sub_variable_condition) ? entry.sub_variable_condition.conditions : void 0) ? (entry.sub_variable_condition.conditions ?? []).flatMap((subEntry, subIndex) => {
+							if (!isRecord(subEntry)) return [];
+							return [{
+								id: normalizeStringValue(subEntry.id) || `loop-sub-condition-${index + 1}-${subIndex + 1}`,
+								varType: normalizeConcreteValueType(subEntry.varType ?? subEntry.var_type),
+								variable_selector: normalizeSelectorPath(subEntry.variable_selector),
+								key: normalizeStringValue(subEntry.key) || void 0,
+								comparison_operator: normalizeStringValue(subEntry.comparison_operator ?? subEntry.comparisonOperator) || void 0,
+								value: typeof subEntry.value === "boolean" ? subEntry.value : Array.isArray(subEntry.value) ? subEntry.value.map((item) => normalizeStringValue(item)).filter(Boolean) : normalizeListOperatorValue(subEntry.value)
+							}];
+						}) : []
+					} : void 0
+				})) : normalizeStringValue(value.exitCondition ?? value.breakCondition) ? [{
+					id: "loop-condition-1",
+					varType: "string",
+					variable_selector: normalizeSelectorPath(value.exitCondition ?? value.breakCondition),
+					comparison_operator: "exists",
+					value: ""
+				}] : normalizedConfig.break_conditions,
+				loop_count: normalizePositiveNumber(value.maxIterations ?? value.loop_count, normalizedConfig.loop_count ?? 10),
+				error_handle_mode: value.failureMode === "continue" ? "continue-on-error" : value.failureMode === "remove-failed-results" ? "remove-abnormal-output" : value.failureMode === "terminate" ? "terminated" : normalizeStringValue(value.error_handle_mode) === "continue-on-error" ? "continue-on-error" : normalizeStringValue(value.error_handle_mode) === "remove-abnormal-output" ? "remove-abnormal-output" : "terminated",
+				loop_variables: normalizeLoopVariables(value.loopVariables ?? value.loop_variables).map((entry) => ({
+					id: entry.id,
+					label: entry.name,
+					var_type: normalizeConcreteValueType(entry.dataType),
+					value_type: entry.valueType === "variable" ? "variable" : "constant",
+					value: entry.value
+				})),
+				loop_id: normalizeStringValue(value.loop_id) || void 0
+			};
+		}
+		case "answer": {
+			const normalizedConfig = defaultConfig.kind === "answer" ? defaultConfig : null;
+			if (!normalizedConfig) return defaultConfig;
+			return {
+				...normalizedConfig,
+				variables: Array.isArray(value.variables) ? normalizeDifyVariables(value.variables, "answer-variable") : normalizedConfig.variables,
+				answer: normalizeStringValue(value.answer ?? value.answerContent ?? value.content)
+			};
+		}
+		case "http-request": {
+			const normalizedConfig = defaultConfig.kind === "http-request" ? defaultConfig : null;
+			if (!normalizedConfig) return defaultConfig;
+			const rawAuthorization = isRecord(value.authorization) ? value.authorization : null;
+			const authorizationConfig = isRecord(rawAuthorization?.config) ? rawAuthorization.config : rawAuthorization;
+			const bodyConfig = isRecord(value.body) ? value.body : null;
+			const timeoutConfig = isRecord(value.timeout) ? value.timeout : null;
+			const retryConfig = isRecord(value.retry_config) ? value.retry_config : null;
+			const variables = Array.isArray(value.variables) ? normalizeDifyVariables(value.variables, "http-variable") : [];
+			return {
+				...normalizedConfig,
+				variables,
+				method: normalizeHttpMethod(value.method),
+				url: normalizeStringValue(value.url),
+				headers: typeof value.headers === "string" ? value.headers : normalizeHttpKeyValueEntries(value.headers, "header").map((entry) => `${entry.key}: ${entry.value}`).join("\n"),
+				params: typeof value.params === "string" ? value.params : normalizeHttpKeyValueEntries(value.params ?? value.query, "param").map((entry) => `${entry.key}: ${entry.value}`).join("\n"),
+				body: {
+					type: normalizeHttpBodyType(bodyConfig?.type),
+					data: Array.isArray(bodyConfig?.data) ? normalizeHttpBodyPayloadEntries(bodyConfig?.data) : typeof bodyConfig?.data === "string" ? bodyConfig.data : normalizeStringValue(bodyConfig?.data ?? value.body)
+				},
+				authorization: {
+					type: normalizeStringValue(rawAuthorization?.type ?? value.authType).toLowerCase() === "api-key" ? "api-key" : "no-auth",
+					config: authorizationConfig ? {
+						type: normalizeStringValue(authorizationConfig.type).toLowerCase() === "basic" ? "basic" : normalizeStringValue(authorizationConfig.type).toLowerCase() === "bearer" ? "bearer" : "custom",
+						api_key: normalizeStringValue(authorizationConfig.api_key ?? authorizationConfig.apiKey),
+						header: normalizeStringValue(authorizationConfig.header) || void 0
+					} : null
+				},
+				timeout: {
+					connect: typeof timeoutConfig?.connect === "number" ? timeoutConfig.connect : typeof value.timeoutMs === "number" ? Math.max(1, Math.round(value.timeoutMs / 1e3)) : normalizedConfig.timeout.connect,
+					read: typeof timeoutConfig?.read === "number" ? timeoutConfig.read : normalizedConfig.timeout.read,
+					write: typeof timeoutConfig?.write === "number" ? timeoutConfig.write : normalizedConfig.timeout.write,
+					max_connect_timeout: typeof timeoutConfig?.max_connect_timeout === "number" ? timeoutConfig.max_connect_timeout : typeof timeoutConfig?.maxConnect === "number" ? timeoutConfig.maxConnect : normalizedConfig.timeout.max_connect_timeout,
+					max_read_timeout: typeof timeoutConfig?.max_read_timeout === "number" ? timeoutConfig.max_read_timeout : typeof timeoutConfig?.maxRead === "number" ? timeoutConfig.maxRead : normalizedConfig.timeout.max_read_timeout,
+					max_write_timeout: typeof timeoutConfig?.max_write_timeout === "number" ? timeoutConfig.max_write_timeout : typeof timeoutConfig?.maxWrite === "number" ? timeoutConfig.maxWrite : normalizedConfig.timeout.max_write_timeout
+				},
+				retry_config: {
+					retry_enabled: typeof retryConfig?.retry_enabled === "boolean" ? retryConfig.retry_enabled : typeof value.retryEnabled === "boolean" ? value.retryEnabled : normalizedConfig.retry_config.retry_enabled,
+					max_retries: typeof retryConfig?.max_retries === "number" && Number.isFinite(retryConfig.max_retries) ? Math.max(1, Math.min(10, Math.round(retryConfig.max_retries))) : typeof value.maxRetries === "number" && Number.isFinite(value.maxRetries) ? Math.max(1, Math.min(10, Math.round(value.maxRetries))) : normalizedConfig.retry_config.max_retries,
+					retry_interval: typeof retryConfig?.retry_interval === "number" && Number.isFinite(retryConfig.retry_interval) ? Math.max(100, Math.min(5e3, Math.round(retryConfig.retry_interval))) : typeof value.retryInterval === "number" && Number.isFinite(value.retryInterval) ? Math.max(100, Math.min(5e3, Math.round(value.retryInterval))) : normalizedConfig.retry_config.retry_interval
+				},
+				ssl_verify: typeof value.ssl_verify === "boolean" ? value.ssl_verify : typeof value.sslVerify === "boolean" ? value.sslVerify : normalizeBooleanValue(value.ssl_verify, true)
+			};
+		}
+		default: return {
+			...defaultConfig,
+			...value,
+			kind
+		};
+	}
+}
+function readRequiredString(value, path, options = {}) {
+	if (typeof value !== "string") throw new Error(`${path} must be a string.`);
+	if (options.allowEmpty === false && !value.trim()) throw new Error(`${path} must not be empty.`);
+	return value;
+}
+function readOptionalString(value, path) {
+	if (value === void 0) return;
+	return readRequiredString(value, path);
+}
+function readOptionalBoolean(value, path) {
+	if (value === void 0) return;
+	if (typeof value !== "boolean") throw new Error(`${path} must be a boolean.`);
+	return value;
+}
+function readOptionalNumber(value, path) {
+	if (value === void 0) return;
+	if (typeof value !== "number" || !Number.isFinite(value)) throw new Error(`${path} must be a finite number.`);
+	return value;
+}
+function isWorkflowFieldInputType(value) {
+	return typeof value === "string" && workflowFieldInputTypes.includes(value);
+}
+function parseWorkflowFormFieldValidation(value, path) {
+	if (value === void 0) return {};
+	if (!isRecord(value)) throw new Error(`${path} must be an object.`);
+	return {
+		pattern: readOptionalString(value.pattern, `${path}.pattern`),
+		minLength: readOptionalNumber(value.minLength, `${path}.minLength`),
+		maxLength: readOptionalNumber(value.maxLength, `${path}.maxLength`),
+		min: readOptionalNumber(value.min, `${path}.min`),
+		max: readOptionalNumber(value.max, `${path}.max`)
+	};
+}
+function parseWorkflowFormFieldOption(value, path) {
+	if (!isRecord(value)) throw new Error(`${path} must be an object.`);
+	return {
+		label: readRequiredString(value.label, `${path}.label`),
+		value: readRequiredString(value.value, `${path}.value`)
+	};
+}
+function parseWorkflowFormSchema(value) {
+	if (!isRecord(value)) throw new Error("formSchema must be an object.");
+	if (!Array.isArray(value.fields)) throw new Error("formSchema.fields must be an array.");
+	const seenFieldIds = /* @__PURE__ */ new Set();
+	const fields = value.fields.map((field, index) => {
+		const path = `formSchema.fields[${index}]`;
+		if (!isRecord(field)) throw new Error(`${path} must be an object.`);
+		if (!isWorkflowFieldInputType(field.type)) throw new Error(`${path}.type must be one of: ${workflowFieldInputTypes.join(", ")}.`);
+		if (field.options !== void 0 && !Array.isArray(field.options)) throw new Error(`${path}.options must be an array when provided.`);
+		const parsedField = {
+			id: readRequiredString(field.id, `${path}.id`, { allowEmpty: false }),
+			label: readRequiredString(field.label, `${path}.label`),
+			type: field.type,
+			helperText: readOptionalString(field.helperText, `${path}.helperText`) ?? "",
+			required: readOptionalBoolean(field.required, `${path}.required`) ?? false,
+			placeholder: readOptionalString(field.placeholder, `${path}.placeholder`),
+			options: field.options?.map((option, optionIndex) => parseWorkflowFormFieldOption(option, `${path}.options[${optionIndex}]`)),
+			validation: parseWorkflowFormFieldValidation(field.validation, `${path}.validation`)
+		};
+		if (seenFieldIds.has(parsedField.id)) throw new Error(`formSchema.fields contains a duplicate id: ${parsedField.id}.`);
+		seenFieldIds.add(parsedField.id);
+		return parsedField;
+	});
+	return normalizeWorkflowFormSchema({
+		title: readRequiredString(value.title, "formSchema.title"),
+		description: readRequiredString(value.description, "formSchema.description"),
+		fields
+	});
+}
+function buildWorkflowFormSchemaDocument(formSchema) {
+	return {
+		schemaVersion: "1.0",
+		kind: "lsflow.workflow-form-schema",
+		formSchema: normalizeWorkflowFormSchema(formSchema)
+	};
+}
+function stringifyWorkflowFormSchema(formSchema) {
+	return JSON.stringify(buildWorkflowFormSchemaDocument(formSchema), null, 2);
+}
+function parseWorkflowFormSchemaJson(input) {
+	let parsed;
+	try {
+		parsed = JSON.parse(input);
+	} catch {
+		throw new Error("The imported form schema file is not valid JSON.");
+	}
+	if (!isRecord(parsed)) throw new Error("The imported form schema document must be a JSON object.");
+	if (parsed.schemaVersion !== "1.0") throw new Error("The imported form schema document must use schemaVersion \"1.0\".");
+	if (parsed.kind !== "lsflow.workflow-form-schema") throw new Error("The imported form schema document must have kind \"lsflow.workflow-form-schema\".");
+	return parseWorkflowFormSchema(parsed.formSchema);
+}
+function normalizeWorkflowValidationResult(validation) {
+	const initialValidation = buildInitialValidationResult();
+	return {
+		status: validation?.status ?? initialValidation.status,
+		validatedAt: validation?.validatedAt ?? initialValidation.validatedAt,
+		issues: validation?.issues ?? initialValidation.issues
+	};
+}
+function buildInitialWorkflowAuditLog(workflowId, scope) {
+	return [buildAuditRecord(workflowId, scope, "draft-created", "Draft created in builder.")];
+}
+function buildAuditRecord(workflowId, scope, action, detail) {
+	return {
+		id: crypto.randomUUID(),
+		workflowId,
+		actorId: "admin-demo",
+		tenantId: scope.tenantId,
+		workspaceId: scope.workspaceId,
+		action,
+		timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+		detail
+	};
+}
+function createInitialWorkflowDraft(input) {
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	const workflowId = crypto.randomUUID();
+	return {
+		id: workflowId,
+		schemaVersion: "2.0",
+		tenantId: input.tenantId,
+		workspaceId: input.workspaceId,
+		status: "draft",
+		metadata: {
+			name: input.name?.trim() || "Untitled workflow draft",
+			description: input.description?.trim() || "Draft workflow opened in the LSFlow builder."
+		},
+		graphState: buildInitialGraphState(),
+		formSchema: buildInitialFormSchema(),
+		nodeConfigurations: {},
+		validation: buildInitialValidationResult(),
+		createdAt: now,
+		updatedAt: now,
+		publishedVersionId: null,
+		publishedVersions: [],
+		auditLog: buildInitialWorkflowAuditLog(workflowId, {
+			tenantId: input.tenantId,
+			workspaceId: input.workspaceId
+		})
+	};
+}
+function normalizeWorkflowDraft(input) {
+	const normalizedDraft = structuredClone(input);
+	const normalizedGraphState = createWorkflowGraph(normalizedDraft.graphState);
+	if (normalizedDraft.schemaVersion !== "2.0") throw new Error("Legacy workflow drafts are not supported by the redesigned builder.");
+	normalizedGraphState.nodes = normalizedGraphState.nodes.map((node) => {
+		const rawNodeData = node.data;
+		const rawKind = typeof rawNodeData?.kind === "string" ? rawNodeData.kind : void 0;
+		const rawLabel = typeof rawNodeData?.label === "string" ? rawNodeData.label : void 0;
+		const rawDescription = typeof rawNodeData?.description === "string" ? rawNodeData.description : void 0;
+		const normalizedKind = rawKind === "outcome" ? "end" : rawKind;
+		return {
+			...node,
+			type: normalizedKind === "end" ? "output" : node.type,
+			data: rawNodeData ? {
+				...rawNodeData,
+				kind: normalizedKind ?? rawNodeData.kind,
+				label: rawKind === "outcome" && rawLabel === "Outcome" ? "Output" : rawLabel,
+				description: rawKind === "outcome" && rawDescription === "Published behavior stays separate from mutable draft edits." ? "Finish the workflow and expose the final outputs for downstream use." : rawDescription
+			} : node.data
+		};
+	});
+	normalizedDraft.status = "draft";
+	normalizedDraft.schemaVersion = "2.0";
+	normalizedDraft.metadata = {
+		name: normalizedDraft.metadata?.name?.trim() || "Untitled workflow draft",
+		description: normalizedDraft.metadata?.description?.trim() || "Draft workflow opened in the LSFlow builder."
+	};
+	normalizedDraft.graphState = normalizedGraphState;
+	normalizedDraft.formSchema = normalizeWorkflowFormSchema(normalizedDraft.formSchema);
+	normalizedDraft.nodeConfigurations = normalizedDraft.nodeConfigurations ?? {};
+	for (const node of normalizedDraft.graphState.nodes) {
+		const kind = node.data?.kind;
+		if (!kind || isInternalWorkflowNodeKind(kind)) continue;
+		if (!normalizedDraft.nodeConfigurations[node.id]) {
+			const defaultConfig = createDefaultNodeConfigurationV2(kind);
+			if (defaultConfig) normalizedDraft.nodeConfigurations[node.id] = structuredClone(defaultConfig);
+		}
+		normalizedDraft.nodeConfigurations[node.id] = normalizeNodeConfigurationByKind(kind, normalizedDraft.nodeConfigurations[node.id]);
+		if (kind === "question-classifier" && node.data) {
+			const existingConfig = normalizedDraft.nodeConfigurations[node.id];
+			if (existingConfig?.kind === "question-classifier") node.data = {
+				...node.data,
+				conditionalBranches: buildQuestionClassifierConditionalBranches(existingConfig.classes)
+			};
+		}
+		if (kind === "if-else") {
+			const existingConfig = normalizedDraft.nodeConfigurations[node.id];
+			const conditionalBranches = node.data?.conditionalBranches ?? [];
+			if (existingConfig?.kind === "if-else") {
+				const nextBranchConditions = Array.isArray(existingConfig.cases) && existingConfig.cases.length > 0 ? buildBranchConditionsFromIfElseCases(conditionalBranches, existingConfig.cases, existingConfig.branchConditions) : buildNormalizedBranchConditions(conditionalBranches, existingConfig.branchConditions);
+				existingConfig.branchConditions = nextBranchConditions;
+				existingConfig.cases = buildIfElseCasesFromBranchConditions(conditionalBranches, nextBranchConditions);
+			}
+		}
+	}
+	normalizedDraft.validation = normalizeWorkflowValidationResult(normalizedDraft.validation);
+	normalizedDraft.publishedVersionId = normalizedDraft.publishedVersionId ?? null;
+	normalizedDraft.publishedVersions = normalizedDraft.publishedVersions ?? [];
+	normalizedDraft.auditLog = normalizedDraft.auditLog?.length ? normalizedDraft.auditLog : buildInitialWorkflowAuditLog(normalizedDraft.id, {
+		tenantId: normalizedDraft.tenantId,
+		workspaceId: normalizedDraft.workspaceId
+	});
+	return normalizedDraft;
+}
+function buildWorkflowPublishSnapshot(draft) {
+	const effectiveFormSchema = draft.formSchema.fields.length > 0 ? structuredClone(draft.formSchema) : buildFormSchemaFromStartNode(draft);
+	return {
+		metadata: structuredClone(draft.metadata),
+		graphState: structuredClone(draft.graphState),
+		formSchema: effectiveFormSchema,
+		nodeConfigurations: structuredClone(draft.nodeConfigurations),
+		validation: structuredClone(draft.validation)
+	};
+}
+function getNodeParentId(node) {
+	return node.parentNodeId ?? node.parentNode;
+}
+function getEdgeBranchLabel(edge) {
+	const data = edge.data;
+	return typeof data?.branchLabel === "string" ? data.branchLabel : void 0;
+}
+function getTriggerKind(kind) {
+	switch (kind) {
+		case "start": return "user-input";
+		case "schedule-trigger": return "schedule";
+		case "webhook-trigger": return "webhook";
+		case "trigger-plugin": return "plugin";
+		case "data-source": return "data-source";
+		default: return null;
+	}
+}
+function buildPublishedNodeConfiguration(kind, configuration) {
+	const normalizedConfiguration = structuredClone(configuration ?? buildDefaultNodeConfiguration(kind));
+	if (normalizedConfiguration.kind === "start") return {
+		kind: "start",
+		variables: normalizedConfiguration.variables.map((variable) => ({
+			id: variable.id,
+			variable: variable.variable,
+			label: variable.label,
+			type: variable.type,
+			required: variable.required,
+			hint: variable.hint,
+			placeholder: variable.placeholder,
+			options: variable.options,
+			default: variable.defaultValue,
+			max_length: variable.maxLength,
+			unit: variable.unit,
+			value_selector: variable.value_selector,
+			getVarValueFromDependent: variable.getVarValueFromDependent,
+			hide: variable.hide,
+			isFileItem: variable.isFileItem,
+			json_schema: variable.json_schema,
+			allowed_file_upload_methods: variable.allowed_file_upload_methods,
+			allowed_upload_methods: variable.allowed_upload_methods,
+			allowed_file_types: variable.allowed_file_types,
+			allowed_file_extensions: variable.allowed_file_extensions,
+			number_limits: variable.number_limits
+		}))
+	};
+	if (normalizedConfiguration.kind === "end") return {
+		kind: "end",
+		outputs: normalizedConfiguration.outputs.map((output) => {
+			const sourceVariable = deriveEndOutputNameFromSelector(normalizeSelectorPath(output.value_selector));
+			return {
+				outputName: normalizeStringValue(output.variable) || sourceVariable,
+				sourceVariable
+			};
+		}).filter((output) => output.outputName && output.sourceVariable)
+	};
+	if (normalizedConfiguration.kind === "tool") {
+		const toolReference = normalizedConfiguration.reference;
+		return {
+			kind: "tool",
+			provider_id: normalizedConfiguration.provider_id ?? toolReference.id,
+			provider_type: normalizedConfiguration.provider_type ?? toolReference.providerType,
+			provider_name: normalizedConfiguration.provider_name ?? toolReference.providerName,
+			tool_name: normalizedConfiguration.tool_name ?? toolReference.toolName,
+			tool_label: normalizedConfiguration.tool_label ?? toolReference.label,
+			tool_parameters: normalizedConfiguration.tool_parameters ?? Object.fromEntries(normalizedConfiguration.parameters.filter((entry) => entry.name.trim()).map((entry) => [entry.name, {
+				type: entry.valueType,
+				value: entry.value
+			}])),
+			tool_configurations: normalizedConfiguration.tool_configurations ?? Object.fromEntries(normalizedConfiguration.configurations.filter((entry) => entry.name.trim()).map((entry) => [entry.name, entry.value])),
+			output_schema: normalizedConfiguration.output_schema && normalizedConfiguration.output_schema.length > 0 ? normalizedConfiguration.output_schema : normalizedConfiguration.outputSchema,
+			version: normalizedConfiguration.version ?? toolReference.version,
+			tool_description: normalizedConfiguration.tool_description ?? toolReference.description,
+			is_team_authorization: normalizedConfiguration.is_team_authorization,
+			params: normalizedConfiguration.params,
+			provider_icon: normalizedConfiguration.provider_icon,
+			provider_icon_dark: normalizedConfiguration.provider_icon_dark,
+			plugin_unique_identifier: normalizedConfiguration.plugin_unique_identifier ?? toolReference.pluginUniqueIdentifier,
+			tool_node_version: normalizedConfiguration.tool_node_version ?? "2"
+		};
+	}
+	if (normalizedConfiguration.kind === "agent") {
+		const publishedOutputFields = Array.isArray(normalizedConfiguration.output_schema) && normalizedConfiguration.output_schema.length > 0 ? normalizedConfiguration.output_schema : normalizedConfiguration.outputSchema;
+		return {
+			kind: "agent",
+			agent_strategy_provider_name: normalizedConfiguration.agent_strategy_provider_name ?? normalizedConfiguration.strategy.providerName,
+			agent_strategy_name: normalizedConfiguration.agent_strategy_name ?? normalizedConfiguration.strategy.name,
+			agent_strategy_label: normalizedConfiguration.agent_strategy_label ?? normalizedConfiguration.strategy.label,
+			agent_parameters: normalizedConfiguration.agent_parameters ?? Object.fromEntries(normalizedConfiguration.strategyParameters.filter((entry) => entry.name.trim()).map((entry) => [entry.name, {
+				type: entry.valueType === "variable" ? "variable" : "constant",
+				value: entry.value
+			}])),
+			output_schema: normalizedConfiguration.output_schema && !Array.isArray(normalizedConfiguration.output_schema) ? structuredClone(normalizedConfiguration.output_schema) : buildPublishedOutputSchema(publishedOutputFields),
+			plugin_unique_identifier: normalizedConfiguration.plugin_unique_identifier ?? normalizedConfiguration.strategy.pluginUniqueIdentifier,
+			meta: normalizedConfiguration.meta ?? normalizedConfiguration.strategy.meta ?? null,
+			memory: {
+				enabled: normalizedConfiguration.memory.enabled,
+				window: {
+					enabled: normalizedConfiguration.memory.enabled,
+					size: normalizedConfiguration.memory.windowSize
+				}
+			},
+			version: normalizedConfiguration.version ?? normalizedConfiguration.strategy.version ?? normalizedConfiguration.tool_node_version,
+			tool_node_version: normalizedConfiguration.tool_node_version ?? "2"
+		};
+	}
+	return normalizedConfiguration;
+}
+function buildPublishedConditionalBranches(kind, branches) {
+	if (kind !== "human-input") return structuredClone(branches);
+	return branches.map((branch) => ({
+		...structuredClone(branch),
+		expression: `__action_id == "${escapeBranchExpressionValue(branch.id)}"`
+	}));
+}
+function escapeBranchExpressionValue(value) {
+	return value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"");
+}
+function buildPublishedWorkflowDefinition(draft, input) {
+	const effectiveFormSchema = draft.formSchema.fields.length > 0 ? structuredClone(draft.formSchema) : buildFormSchemaFromStartNode(draft);
+	const executableNodes = draft.graphState.nodes.filter((node) => {
+		const kind = node.data?.kind;
+		return Boolean(kind) && !isInternalWorkflowNodeKind(kind);
+	});
+	const childNodeIdsByParent = /* @__PURE__ */ new Map();
+	executableNodes.forEach((node) => {
+		const parentNodeId = getNodeParentId(node);
+		if (!parentNodeId) return;
+		const currentChildNodeIds = childNodeIdsByParent.get(parentNodeId) ?? [];
+		currentChildNodeIds.push(node.id);
+		childNodeIdsByParent.set(parentNodeId, currentChildNodeIds);
+	});
+	const graphNodes = executableNodes.flatMap((node) => {
+		const nodeData = node.data;
+		const kind = nodeData?.kind;
+		if (!kind) return [];
+		return [{
+			id: node.id,
+			kind,
+			label: nodeData.label,
+			description: nodeData.description,
+			parentNodeId: getNodeParentId(node),
+			childNodeIds: childNodeIdsByParent.get(node.id) ?? [],
+			configuration: buildPublishedNodeConfiguration(kind, draft.nodeConfigurations[node.id]),
+			conditionalBranches: nodeData.conditionalBranches ? buildPublishedConditionalBranches(kind, nodeData.conditionalBranches) : void 0
+		}];
+	});
+	const graphEdges = draft.graphState.edges.map((edge) => ({
+		id: edge.id,
+		sourceNodeId: edge.source,
+		sourceHandleId: edge.sourceHandle,
+		targetNodeId: edge.target,
+		targetHandleId: edge.targetHandle,
+		branchLabel: getEdgeBranchLabel(edge)
+	}));
+	const triggers = graphNodes.flatMap((node) => {
+		const triggerType = getTriggerKind(node.kind);
+		if (!triggerType) return [];
+		return [{
+			id: `${node.id}::trigger`,
+			nodeId: node.id,
+			type: triggerType,
+			name: node.label,
+			configuration: structuredClone(node.configuration)
+		}];
+	});
+	return {
+		schemaVersion: "2.0",
+		workflowId: draft.id,
+		draftId: draft.id,
+		versionId: input.versionId,
+		versionNumber: input.versionNumber,
+		publishedAt: input.publishedAt,
+		metadata: structuredClone(draft.metadata),
+		formSchema: effectiveFormSchema,
+		validation: structuredClone(draft.validation),
+		triggers,
+		graph: {
+			triggerNodeIds: triggers.map((trigger) => trigger.nodeId),
+			nodes: graphNodes,
+			edges: graphEdges
+		}
+	};
+}
+function buildDefaultNodeConfiguration(kind) {
+	return structuredClone(createDefaultNodeConfigurationV2(kind) ?? { kind: "note" });
+}
+//#endregion
+export { buildDefaultNodeConfiguration, buildFormSchemaFromStartNode, buildPublishedWorkflowDefinition, buildQuestionClassifierConditionalBranches, buildWorkflowFormSchemaDocument, buildWorkflowPublishSnapshot, createInitialWorkflowDraft, getStartNodeConfiguration, normalizeWorkflowDraft, parseWorkflowFormSchemaJson, stringifyWorkflowFormSchema };