n8n-editor-ui 2.3.1 → 2.4.0

package/dist/assets/{useRunWorkflow-DfbxLgl-.js → useRunWorkflow-CBEpMo-i.js}

@@ -1,501 +1,120 @@
-import { o as __toESM } from "./chunk-6z4oVpB-.js";
-import { C as computed, It as ref, _t as watch } from "./vue.runtime.esm-bundler-tP5dCd7J.js";
-import { M as useLocalStorage, _t as useI18n } from "./_MapCache-ficiegRb.js";
-import { r as require_get } from "./truncate-B1HVeveJ.js";
-import { $r as BulkCommand, Ec as STORES, Gn as useNodeHelpers, Jr as CanvasNodeDirtiness, Kn as injectWorkflowState, N as useWorkflowsStore, O as useTelemetry, Qr as AddNodeCommand, Rn as useWorkflowHelpers, Ui as isEmpty, Xr as useHistoryStore, Yn as useDocumentTitle, Zr as AddConnectionCommand, b as useExternalHooks, gs as useSettingsStore, ii as RemoveNodeCommand, n as useWorkflowSaving, ri as RemoveConnectionCommand, ti as EnableNodeToggleCommand, v as useToast, wt as displayForm } from "./builder.store-D6GyopzN.js";
-import { Ga as NodeConnectionTypes, Jr as createHeartbeatMessage, M as IN_PROGRESS_EXECUTION_ID, Ui as createRunExecutionData, Us as LOCAL_STORAGE_RUN_DATA_WORKER, Yi as generateNodesGraph, zt as CHAT_TRIGGER_NODE_TYPE } from "./constants-DRIItkNt.js";
-import { k as defineStore, r as useRootStore } from "./_baseOrderBy-UJkFlXQy.js";
-import { t as retry } from "./retry-dP46utx2.js";
-import { t as useExecutionsStore } from "./executions.store-a5l7sYPn.js";
-import { t as useCanvasOperations } from "./useCanvasOperations-DmDkQZsZ.js";
-const useHeartbeat = (options) => {
-	const { interval, onHeartbeat } = options;
-	const heartbeatTimer = ref(null);
-	const startHeartbeat = () => {
-		heartbeatTimer.value = setInterval(onHeartbeat, interval);
-	};
-	const stopHeartbeat = () => {
-		if (heartbeatTimer.value) {
-			clearInterval(heartbeatTimer.value);
-			heartbeatTimer.value = null;
-		}
-	};
-	return {
-		startHeartbeat,
-		stopHeartbeat
-	};
-};
-const useReconnectTimer = ({ onAttempt, onAttemptScheduled }) => {
-	const initialReconnectDelay = 1e3;
-	const maxReconnectDelay = 15e3;
-	const reconnectTimer = ref(null);
-	const reconnectAttempts = ref(0);
-	const scheduleReconnect = () => {
-		const delay = Math.min(initialReconnectDelay * 2 ** reconnectAttempts.value, maxReconnectDelay);
-		reconnectAttempts.value++;
-		onAttemptScheduled(delay);
-		reconnectTimer.value = setTimeout(() => {
-			onAttempt();
-		}, delay);
-	};
-	const stopReconnectTimer = () => {
-		if (reconnectTimer.value) {
-			clearTimeout(reconnectTimer.value);
-			reconnectTimer.value = null;
-		}
-	};
-	const resetConnectionAttempts = () => {
-		reconnectAttempts.value = 0;
-	};
-	return {
-		scheduleReconnect,
-		stopReconnectTimer,
-		resetConnectionAttempts
-	};
+import { o as __toESM } from "./chunk-r2Y0G7H8.js";
+import { C as computed, Pt as reactive } from "./vue.runtime.esm-bundler-XtMkEjzB.js";
+import { M as useLocalStorage, _t as useI18n } from "./_MapCache-DkLivSSb.js";
+import { r as require_get } from "./truncate-BrM_9cme.js";
+import { $r as useHistoryStore, It as injectWorkflowState, Ki as isEmpty, Mt as useTelemetry, Sr as useExternalHooks, Zr as CanvasNodeDirtiness, an as useDocumentTitle, br as useToast, ei as AddConnectionCommand, ii as EnableNodeToggleCommand, jt as useNodeHelpers, ls as useSettingsStore, m as displayForm, ni as BulkCommand, oi as RemoveConnectionCommand, on as useWorkflowSaving, s as useWorkflowsStore, si as RemoveNodeCommand, ti as AddNodeCommand, wt as useWorkflowHelpers } from "./users.store-Dh2O3NbU.js";
+import { M as IN_PROGRESS_EXECUTION_ID, Rt as CHAT_TRIGGER_NODE_TYPE, Ti as createResultOk, Vi as createRunExecutionData, Wa as NodeConnectionTypes, qi as generateNodesGraph, wi as createResultError } from "./constants-D48cSFnx.js";
+import { f as request, k as defineStore, r as useRootStore } from "./_baseOrderBy-DvuuRU7J.js";
+import { t as useExecutionsStore } from "./executions.store-SHgwsnWe.js";
+import { t as useCanvasOperations } from "./useCanvasOperations-DVIzBTSq.js";
+import { t as usePushConnectionStore } from "./pushConnection.store-DEMBEciq.js";
+import { t as retry } from "./retry-BLsJRFf0.js";
+var padVersion = (version) => {
+	return version.toString().split(".").concat(["0", "0"]).slice(0, 3).join(".");
 };
-const useWebSocketClient = (options) => {
-	const isConnected = ref(false);
-	const socket = ref(null);
-	const { startHeartbeat, stopHeartbeat } = useHeartbeat({
-		interval: 3e4,
-		onHeartbeat: () => {
-			socket.value?.send(JSON.stringify(createHeartbeatMessage()));
-		}
-	});
-	const onConnected = () => {
-		socket.value?.removeEventListener("open", onConnected);
-		isConnected.value = true;
-		startHeartbeat();
-		reconnectTimer.resetConnectionAttempts();
-	};
-	const onConnectionLost = (event) => {
-		console.warn(`[WebSocketClient] Connection lost, code=${event.code ?? "unknown"}`);
-		disconnect();
-		reconnectTimer.scheduleReconnect();
-	};
-	const onMessage = (event) => {
-		options.onMessage(event.data);
-	};
-	const onError = (error) => {
-		console.warn("[WebSocketClient] Connection error:", error);
-	};
-	const disconnect = () => {
-		if (socket.value) {
-			stopHeartbeat();
-			reconnectTimer.stopReconnectTimer();
-			socket.value.removeEventListener("message", onMessage);
-			socket.value.removeEventListener("error", onError);
-			socket.value.removeEventListener("close", onConnectionLost);
-			socket.value.close(1e3);
-			socket.value = null;
-		}
-		isConnected.value = false;
-	};
-	const connect = () => {
-		disconnect();
-		socket.value = new WebSocket(options.url);
-		socket.value.addEventListener("open", onConnected);
-		socket.value.addEventListener("message", onMessage);
-		socket.value.addEventListener("error", onError);
-		socket.value.addEventListener("close", onConnectionLost);
-		socket.value.binaryType = "arraybuffer";
-	};
-	const reconnectTimer = useReconnectTimer({
-		onAttempt: connect,
-		onAttemptScheduled: (delay) => {
-			console.log(`[WebSocketClient] Attempting to reconnect in ${delay}ms`);
-		}
-	});
-	const sendMessage = (serializedMessage) => {
-		if (!isConnected.value || !socket.value) throw new Error("Not connected to the server");
-		socket.value.send(serializedMessage);
-	};
-	return {
-		isConnected,
-		connect,
-		disconnect,
-		sendMessage
-	};
+var isNonEmptyJsonSchema = (response) => {
+	return !!response && typeof response === "object" && "type" in response && "properties" in response && !isEmpty(response.properties);
 };
-const useEventSourceClient = (options) => {
-	const isConnected = ref(false);
-	const eventSource = ref(null);
-	const onConnected = () => {
-		isConnected.value = true;
-		reconnectTimer.resetConnectionAttempts();
-	};
-	const onConnectionLost = () => {
-		console.warn("[EventSourceClient] Connection lost");
-		isConnected.value = false;
-		reconnectTimer.scheduleReconnect();
-	};
-	const onMessage = (event) => {
-		options.onMessage(event.data);
-	};
-	const disconnect = () => {
-		if (eventSource.value) {
-			reconnectTimer.stopReconnectTimer();
-			eventSource.value.close();
-			eventSource.value = null;
-		}
-		isConnected.value = false;
-	};
-	const connect = () => {
-		disconnect();
-		eventSource.value = new EventSource(options.url, { withCredentials: true });
-		eventSource.value.addEventListener("open", onConnected);
-		eventSource.value.addEventListener("message", onMessage);
-		eventSource.value.addEventListener("close", onConnectionLost);
-	};
-	const reconnectTimer = useReconnectTimer({
-		onAttempt: connect,
-		onAttemptScheduled: (delay) => {
-			console.log(`[EventSourceClient] Attempting to reconnect in ${delay}ms`);
-		}
+const getSchemaPreview = async (baseUrl, options) => {
+	const { nodeType, version, resource, operation } = options;
+	const versionString = padVersion(version);
+	const response = await request({
+		method: "GET",
+		baseURL: baseUrl,
+		endpoint: `${[
+			"schemas",
+			nodeType.replace("@n8n/", ""),
+			versionString,
+			resource,
+			operation
+		].filter(Boolean).join("/")}.json`,
+		withCredentials: false
 	});
-	const sendMessage = (_) => {};
-	return {
-		isConnected,
-		connect,
-		disconnect,
-		sendMessage
-	};
+	if (!isNonEmptyJsonSchema(response)) throw new Error("Invalid JSON schema");
+	return response;
 };
-/**
-* @license
-* Copyright 2019 Google LLC
-* SPDX-License-Identifier: Apache-2.0
-*/
-var proxyMarker = Symbol("Comlink.proxy");
-var createEndpoint = Symbol("Comlink.endpoint");
-var releaseProxy = Symbol("Comlink.releaseProxy");
-var finalizer = Symbol("Comlink.finalizer");
-var throwMarker = Symbol("Comlink.thrown");
-var isObject = (val) => typeof val === "object" && val !== null || typeof val === "function";
-var transferHandlers = new Map([["proxy", {
-	canHandle: (val) => isObject(val) && val[proxyMarker],
-	serialize(obj) {
-		const { port1, port2 } = new MessageChannel();
-		expose(obj, port1);
-		return [port2, [port2]];
-	},
-	deserialize(port) {
-		port.start();
-		return wrap(port);
-	}
-}], ["throw", {
-	canHandle: (value) => isObject(value) && throwMarker in value,
-	serialize({ value }) {
-		let serialized;
-		if (value instanceof Error) serialized = {
-			isError: true,
-			value: {
-				message: value.message,
-				name: value.name,
-				stack: value.stack
-			}
-		};
-		else serialized = {
-			isError: false,
-			value
-		};
-		return [serialized, []];
-	},
-	deserialize(serialized) {
-		if (serialized.isError) throw Object.assign(new Error(serialized.value.message), serialized.value);
-		throw serialized.value;
-	}
-}]]);
-function isAllowedOrigin(allowedOrigins, origin) {
-	for (const allowedOrigin of allowedOrigins) {
-		if (origin === allowedOrigin || allowedOrigin === "*") return true;
-		if (allowedOrigin instanceof RegExp && allowedOrigin.test(origin)) return true;
-	}
-	return false;
+function generateJsonSchema(json) {
+	return inferType(json);
 }
-function expose(obj, ep = globalThis, allowedOrigins = ["*"]) {
-	ep.addEventListener("message", function callback(ev) {
-		if (!ev || !ev.data) return;
-		if (!isAllowedOrigin(allowedOrigins, ev.origin)) {
-			console.warn(`Invalid origin '${ev.origin}' for comlink proxy`);
-			return;
-		}
-		const { id, type, path } = Object.assign({ path: [] }, ev.data);
-		const argumentList = (ev.data.argumentList || []).map(fromWireValue);
-		let returnValue;
-		try {
-			const parent = path.slice(0, -1).reduce((obj$1, prop) => obj$1[prop], obj);
-			const rawValue = path.reduce((obj$1, prop) => obj$1[prop], obj);
-			switch (type) {
-				case "GET":
-					returnValue = rawValue;
-					break;
-				case "SET":
-					parent[path.slice(-1)[0]] = fromWireValue(ev.data.value);
-					returnValue = true;
-					break;
-				case "APPLY":
-					returnValue = rawValue.apply(parent, argumentList);
-					break;
-				case "CONSTRUCT":
-					returnValue = proxy(new rawValue(...argumentList));
-					break;
-				case "ENDPOINT":
-					{
-						const { port1, port2 } = new MessageChannel();
-						expose(obj, port2);
-						returnValue = transfer(port1, [port1]);
-					}
-					break;
-				case "RELEASE":
-					returnValue = void 0;
-					break;
-				default: return;
-			}
-		} catch (value) {
-			returnValue = {
-				value,
-				[throwMarker]: 0
-			};
-		}
-		Promise.resolve(returnValue).catch((value) => {
-			return {
-				value,
-				[throwMarker]: 0
-			};
-		}).then((returnValue$1) => {
-			const [wireValue, transferables] = toWireValue(returnValue$1);
-			ep.postMessage(Object.assign(Object.assign({}, wireValue), { id }), transferables);
-			if (type === "RELEASE") {
-				ep.removeEventListener("message", callback);
-				closeEndPoint(ep);
-				if (finalizer in obj && typeof obj[finalizer] === "function") obj[finalizer]();
-			}
-		}).catch((error) => {
-			const [wireValue, transferables] = toWireValue({
-				value: /* @__PURE__ */ new TypeError("Unserializable return value"),
-				[throwMarker]: 0
-			});
-			ep.postMessage(Object.assign(Object.assign({}, wireValue), { id }), transferables);
-		});
-	});
-	if (ep.start) ep.start();
-}
-function isMessagePort(endpoint) {
-	return endpoint.constructor.name === "MessagePort";
-}
-function closeEndPoint(endpoint) {
-	if (isMessagePort(endpoint)) endpoint.close();
-}
-function wrap(ep, target) {
-	return createProxy(ep, [], target);
-}
-function throwIfProxyReleased(isReleased) {
-	if (isReleased) throw new Error("Proxy has been released and is not useable");
-}
-function releaseEndpoint(ep) {
-	return requestResponseMessage(ep, { type: "RELEASE" }).then(() => {
-		closeEndPoint(ep);
-	});
+function isPrimitive(type) {
+	return [
+		"string",
+		"number",
+		"boolean"
+	].includes(type);
 }
-var proxyCounter = /* @__PURE__ */ new WeakMap();
-var proxyFinalizers = "FinalizationRegistry" in globalThis && new FinalizationRegistry((ep) => {
-	const newCount = (proxyCounter.get(ep) || 0) - 1;
-	proxyCounter.set(ep, newCount);
-	if (newCount === 0) releaseEndpoint(ep);
-});
-function registerProxy(proxy$1, ep) {
-	const newCount = (proxyCounter.get(ep) || 0) + 1;
-	proxyCounter.set(ep, newCount);
-	if (proxyFinalizers) proxyFinalizers.register(proxy$1, ep, proxy$1);
-}
-function unregisterProxy(proxy$1) {
-	if (proxyFinalizers) proxyFinalizers.unregister(proxy$1);
-}
-function createProxy(ep, path = [], target = function() {}) {
-	let isProxyReleased = false;
-	const proxy$1 = new Proxy(target, {
-		get(_target, prop) {
-			throwIfProxyReleased(isProxyReleased);
-			if (prop === releaseProxy) return () => {
-				unregisterProxy(proxy$1);
-				releaseEndpoint(ep);
-				isProxyReleased = true;
-			};
-			if (prop === "then") {
-				if (path.length === 0) return { then: () => proxy$1 };
-				const r = requestResponseMessage(ep, {
-					type: "GET",
-					path: path.map((p) => p.toString())
-				}).then(fromWireValue);
-				return r.then.bind(r);
-			}
-			return createProxy(ep, [...path, prop]);
-		},
-		set(_target, prop, rawValue) {
-			throwIfProxyReleased(isProxyReleased);
-			const [value, transferables] = toWireValue(rawValue);
-			return requestResponseMessage(ep, {
-				type: "SET",
-				path: [...path, prop].map((p) => p.toString()),
-				value
-			}, transferables).then(fromWireValue);
-		},
-		apply(_target, _thisArg, rawArgumentList) {
-			throwIfProxyReleased(isProxyReleased);
-			const last = path[path.length - 1];
-			if (last === createEndpoint) return requestResponseMessage(ep, { type: "ENDPOINT" }).then(fromWireValue);
-			if (last === "bind") return createProxy(ep, path.slice(0, -1));
-			const [argumentList, transferables] = processArguments(rawArgumentList);
-			return requestResponseMessage(ep, {
-				type: "APPLY",
-				path: path.map((p) => p.toString()),
-				argumentList
-			}, transferables).then(fromWireValue);
-		},
-		construct(_target, rawArgumentList) {
-			throwIfProxyReleased(isProxyReleased);
-			const [argumentList, transferables] = processArguments(rawArgumentList);
-			return requestResponseMessage(ep, {
-				type: "CONSTRUCT",
-				path: path.map((p) => p.toString()),
-				argumentList
-			}, transferables).then(fromWireValue);
-		}
-	});
-	registerProxy(proxy$1, ep);
-	return proxy$1;
-}
-function myFlat(arr) {
-	return Array.prototype.concat.apply([], arr);
-}
-function processArguments(argumentList) {
-	const processed = argumentList.map(toWireValue);
-	return [processed.map((v) => v[0]), myFlat(processed.map((v) => v[1]))];
+function inferType(value) {
+	if (value === null) return { type: "null" };
+	const type = typeof value;
+	if (isPrimitive(type)) return { type };
+	if (Array.isArray(value)) return inferArrayType(value);
+	if (value && type === "object") return inferObjectType(value);
+	return { type: "string" };
 }
-var transferCache = /* @__PURE__ */ new WeakMap();
-function transfer(obj, transfers) {
-	transferCache.set(obj, transfers);
-	return obj;
-}
-function proxy(obj) {
-	return Object.assign(obj, { [proxyMarker]: true });
-}
-function toWireValue(value) {
-	for (const [name, handler] of transferHandlers) if (handler.canHandle(value)) {
-		const [serializedValue, transferables] = handler.serialize(value);
-		return [{
-			type: "HANDLER",
-			name,
-			value: serializedValue
-		}, transferables];
-	}
-	return [{
-		type: "RAW",
-		value
-	}, transferCache.get(value) || []];
-}
-function fromWireValue(value) {
-	switch (value.type) {
-		case "HANDLER": return transferHandlers.get(value.name).deserialize(value.value);
-		case "RAW": return value.value;
-	}
+function inferArrayType(arr) {
+	return {
+		type: "array",
+		items: arr.length > 0 ? inferType(arr[0]) : {}
+	};
 }
-function requestResponseMessage(ep, msg, transfers) {
-	return new Promise((resolve) => {
-		const id = generateUUID();
-		ep.addEventListener("message", function l(ev) {
-			if (!ev.data || !ev.data.id || ev.data.id !== id) return;
-			ep.removeEventListener("message", l);
-			resolve(ev.data);
-		});
-		if (ep.start) ep.start();
-		ep.postMessage(Object.assign({ id }, msg), transfers);
+function inferObjectType(obj) {
+	const properties = {};
+	Object.entries(obj).forEach(([key, value]) => {
+		properties[key] = inferType(value);
 	});
+	return {
+		type: "object",
+		properties
+	};
 }
-function generateUUID() {
-	return new Array(4).fill(0).map(() => Math.floor(Math.random() * Number.MAX_SAFE_INTEGER).toString(16)).join("-");
-}
-const runDataWorker = wrap(new Worker(new URL(
-	/* @vite-ignore */
-	"/%7B%7BBASE_PATH%7D%7D/assets/worker-CIvWfg3a.js",
-	"" + import.meta.url
-), { type: "module" }));
-const usePushConnectionStore = defineStore(STORES.PUSH, () => {
+const useSchemaPreviewStore = defineStore("schemaPreview", () => {
+	const schemaPreviews = reactive(/* @__PURE__ */ new Map());
 	const rootStore = useRootStore();
-	const settingsStore = useSettingsStore();
-	const isRunDataWorkerEnabled = useLocalStorage(LOCAL_STORAGE_RUN_DATA_WORKER, false);
-	const outgoingQueue = ref([]);
-	const isConnectionRequested = ref(false);
-	const onMessageReceivedHandlers = ref([]);
-	const addEventListener = (handler) => {
-		onMessageReceivedHandlers.value.push(handler);
-		return () => {
-			const index = onMessageReceivedHandlers.value.indexOf(handler);
-			if (index !== -1) onMessageReceivedHandlers.value.splice(index, 1);
-		};
-	};
-	const useWebSockets = computed(() => settingsStore.pushBackend === "websocket");
-	const getConnectionUrl = () => {
-		const restUrl = rootStore.restUrl;
-		const url$1 = `/push?pushRef=${rootStore.pushRef}`;
-		if (useWebSockets.value) {
-			const { protocol, host } = window.location;
-			return `${restUrl.startsWith("http") ? restUrl.replace(/^http/, "ws") : `${protocol === "https:" ? "wss" : "ws"}://${host + restUrl}`}${url$1}`;
-		} else return `${restUrl}${url$1}`;
-	};
-	async function onMessage(data) {
-		if (data instanceof ArrayBuffer) if (isRunDataWorkerEnabled.value) {
-			await runDataWorker.onNodeExecuteAfterData(data);
-			return;
-		} else data = new TextDecoder("utf-8").decode(new Uint8Array(data));
-		let parsedData;
+	const telemetry = useTelemetry();
+	const workflowsStore = useWorkflowsStore();
+	function getSchemaPreviewKey({ nodeType, version, operation, resource }) {
+		return `${nodeType}_${version}_${resource?.toString() ?? "all"}_${operation?.toString() ?? "all"}`;
+	}
+	async function getSchemaPreview$1(options) {
+		const key = getSchemaPreviewKey(options);
+		const cached = schemaPreviews.get(key);
+		if (cached) return cached;
 		try {
-			parsedData = JSON.parse(data);
+			const result = createResultOk(await getSchemaPreview(rootStore.baseUrl, options));
+			schemaPreviews.set(key, result);
+			return result;
 		} catch (error) {
-			return;
+			const result = createResultError(error);
+			schemaPreviews.set(key, result);
+			return result;
 		}
-		onMessageReceivedHandlers.value.forEach((handler) => handler(parsedData));
 	}
-	const url = getConnectionUrl();
-	const client = computed(() => useWebSockets.value ? useWebSocketClient({
-		url,
-		onMessage
-	}) : useEventSourceClient({
-		url,
-		onMessage
-	}));
-	function serializeAndSend(message) {
-		if (client.value.isConnected.value) client.value.sendMessage(JSON.stringify(message));
-		else outgoingQueue.value.push(message);
+	async function trackSchemaPreviewExecution(pushEvent) {
+		if (schemaPreviews.size === 0 || pushEvent.data.executionStatus !== "success") return;
+		const node = workflowsStore.getNodeByName(pushEvent.nodeName);
+		if (!node) return;
+		const { id, type, typeVersion, parameters: { resource, operation } } = node;
+		const result = schemaPreviews.get(getSchemaPreviewKey({
+			nodeType: type,
+			version: typeVersion,
+			resource,
+			operation
+		}));
+		if (!result?.ok) return;
+		telemetry.track("User executed node with schema preview", {
+			node_id: id,
+			node_type: type,
+			node_version: typeVersion,
+			node_resource: resource,
+			node_operation: operation,
+			schema_preview: JSON.stringify(result.result),
+			output_schema: JSON.stringify(generateJsonSchema(pushEvent.data.data?.main?.[0]?.[0]?.json)),
+			workflow_id: workflowsStore.workflowId
+		});
 	}
-	const pushConnect = () => {
-		isConnectionRequested.value = true;
-		client.value.connect();
-	};
-	const pushDisconnect = () => {
-		isConnectionRequested.value = false;
-		client.value.disconnect();
-	};
-	watch(() => client.value.isConnected.value, (didConnect) => {
-		if (!didConnect) return;
-		if (outgoingQueue.value.length) {
-			for (const message of outgoingQueue.value) serializeAndSend(message);
-			outgoingQueue.value = [];
-		}
-	});
-	const clearQueue = () => {
-		outgoingQueue.value = [];
-	};
 	return {
-		isConnected: computed(() => client.value.isConnected.value),
-		isConnectionRequested,
-		onMessageReceivedHandlers,
-		addEventListener,
-		pushConnect,
-		pushDisconnect,
-		send: serializeAndSend,
-		clearQueue
+		getSchemaPreview: getSchemaPreview$1,
+		trackSchemaPreviewExecution
 	};
 });
 function shouldCommandMarkDirty(command, nodeName, siblingCommands, getIncomingConnections, getOutgoingConnectors) {
@@ -614,11 +233,11 @@ const useAgentRequestStore = defineStore("agentRequest", () => {
 		if (typeof query === "string") return;
 		return query?.[paramName];
 	};
-	const setAgentRequestForNode = (workflowId, nodeId, request) => {
+	const setAgentRequestForNode = (workflowId, nodeId, request$1) => {
 		ensureWorkflowAndNodeExist(workflowId, nodeId);
 		agentRequests.value[workflowId][nodeId] = {
-			...request,
-			query: typeof request.query === "string" ? request.query : { ...request.query }
+			...request$1,
+			query: typeof request$1.query === "string" ? request$1.query : { ...request$1.query }
 		};
 	};
 	const clearAgentRequests = (workflowId, nodeId) => {
@@ -641,7 +260,7 @@ const useAgentRequestStore = defineStore("agentRequest", () => {
 		getAgentRequest
 	};
 });
-var import_get = /* @__PURE__ */ __toESM(require_get());
+var import_get = /* @__PURE__ */ __toESM(require_get(), 1);
 function useRunWorkflow(useRunWorkflowOpts) {
 	const workflowHelpers = useWorkflowHelpers();
 	const i18n = useI18n();
@@ -828,6 +447,7 @@ function useRunWorkflow(useRunWorkflowOpts) {
 			});
 			return runWorkflowApiResponse;
 		} catch (error) {
+			console.error(error);
 			workflowState.setWorkflowExecutionData(null);
 			useDocumentTitle().setDocumentTitle(workflowObject.value.name, "ERROR");
 			toast.showError(error, i18n.baseText("workflowRun.showError.title"));
@@ -928,4 +548,4 @@ function useRunWorkflow(useRunWorkflowOpts) {
 		sortNodesByYPosition
 	};
 }
-export { proxy as a, usePushConnectionStore as i, useAgentRequestStore as n, wrap as o, useNodeDirtiness as r, useRunWorkflow as t };
+export { useSchemaPreviewStore as i, useAgentRequestStore as n, useNodeDirtiness as r, useRunWorkflow as t };

package/dist/assets/{useSettingsItems-CNv2tIdk.js → useSettingsItems-DDLH7vvJ.js}

@@ -1,8 +1,8 @@
-import { C as computed } from "./vue.runtime.esm-bundler-tP5dCd7J.js";
-import { _t as useI18n } from "./_MapCache-ficiegRb.js";
-import { y as useRouter } from "./truncate-B1HVeveJ.js";
-import { gs as useSettingsStore, oa as useUIStore, vr as hasPermission } from "./builder.store-D6GyopzN.js";
-import { Bo as VIEWS } from "./constants-DRIItkNt.js";
+import { C as computed } from "./vue.runtime.esm-bundler-XtMkEjzB.js";
+import { _t as useI18n } from "./_MapCache-DkLivSSb.js";
+import { y as useRouter } from "./truncate-BrM_9cme.js";
+import { ls as useSettingsStore, r as useUIStore, rr as hasPermission } from "./users.store-Dh2O3NbU.js";
+import { zo as VIEWS } from "./constants-D48cSFnx.js";
 function useUserHelpers(router) {
 	const canUserAccessRouteByName = (name) => {
 		return canUserAccessRoute(router.resolve({ name }));

package/dist/assets/{useTelemetryContext-B3sCbxNK.js → useTelemetryContext-s869bjx6.js}

@@ -1,6 +1,6 @@
-import { D as createElementBlock, P as defineComponent, et as openBlock, nt as provide, st as resolveDirective, vn as normalizeClass, xt as withDirectives, z as inject } from "./vue.runtime.esm-bundler-tP5dCd7J.js";
-import { t as __plugin_vue_export_helper_default } from "./_plugin-vue_export-helper-BwBpWJRZ.js";
-import { ic as TelemetryContextSymbol } from "./constants-DRIItkNt.js";
+import { D as createElementBlock, P as defineComponent, et as openBlock, nt as provide, st as resolveDirective, vn as normalizeClass, xt as withDirectives, z as inject } from "./vue.runtime.esm-bundler-XtMkEjzB.js";
+import { t as __plugin_vue_export_helper_default } from "./_plugin-vue_export-helper-fRq25RGE.js";
+import { nc as TelemetryContextSymbol } from "./constants-D48cSFnx.js";
 var MappingPill_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
 	__name: "MappingPill",
 	props: {
@@ -13,7 +13,7 @@ var MappingPill_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ de
 	setup(__props) {
 		return (_ctx, _cache) => {
 			const _directive_n8n_html = resolveDirective("n8n-html");
-			return withDirectives((openBlock(), createElementBlock("div", { class: normalizeClass([_ctx.$style.dragPill, _ctx.canDrop ? _ctx.$style.droppablePill : _ctx.$style.defaultPill]) }, null, 2)), [[_directive_n8n_html, _ctx.html]]);
+			return withDirectives((openBlock(), createElementBlock("div", { class: normalizeClass([_ctx.$style.dragPill, __props.canDrop ? _ctx.$style.droppablePill : _ctx.$style.defaultPill]) }, null, 2)), [[_directive_n8n_html, __props.html]]);
 		};
 	}
 });