n8n-editor-ui 1.119.1 → 1.120.1

package/dist/assets/{uniqBy-BUNHbbw3.js → uniqBy-DAOmWpEt.js}

@@ -1,5 +1,5 @@
 import { t as __commonJSMin } from "./chunk-6z4oVpB-.js";
-import { Qr as require__baseUniq, Rr as require__baseIteratee } from "./constants-DvlTm3U4.js";
+import { Qr as require__baseUniq, Rr as require__baseIteratee } from "./constants-C5Tj3dXQ.js";
 var require_uniqBy = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	var baseIteratee = require__baseIteratee(), baseUniq = require__baseUniq();
 	function uniqBy(array, iteratee) {

package/dist/assets/uniqBy-legacy-8A5HU2la.js

@@ -0,0 +1,52 @@
+;
+(function () {
+  System.register(["./chunk-legacy-Re9CbdfL.js", "./constants-legacy-CLA25gM9.js"], function (_export, _context) {
+    "use strict";
+
+    var __commonJS, require__baseUniq, require__baseIteratee, require_uniqBy;
+    return {
+      setters: [function (_chunkLegacy001Js) {
+        __commonJS = _chunkLegacy001Js.t;
+      }, function (_constantsLegacy00NJs) {
+        require__baseUniq = _constantsLegacy00NJs.Qr;
+        require__baseIteratee = _constantsLegacy00NJs.Rr;
+      }],
+      execute: function () {
+        //#region ../../../node_modules/.pnpm/lodash@4.17.21/node_modules/lodash/uniqBy.js
+        _export("t", require_uniqBy = /* @__PURE__ */__commonJS({
+          "../../../node_modules/.pnpm/lodash@4.17.21/node_modules/lodash/uniqBy.js": (exports, module) => {
+            var baseIteratee = require__baseIteratee(),
+              baseUniq = require__baseUniq();
+            /**
+            * This method is like `_.uniq` except that it accepts `iteratee` which is
+            * invoked for each element in `array` to generate the criterion by which
+            * uniqueness is computed. The order of result values is determined by the
+            * order they occur in the array. The iteratee is invoked with one argument:
+            * (value).
+            *
+            * @static
+            * @memberOf _
+            * @since 4.0.0
+            * @category Array
+            * @param {Array} array The array to inspect.
+            * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
+            * @returns {Array} Returns the new duplicate free array.
+            * @example
+            *
+            * _.uniqBy([2.1, 1.2, 2.3], Math.floor);
+            * // => [2.1, 1.2]
+            *
+            * // The `_.property` iteratee shorthand.
+            * _.uniqBy([{ 'x': 1 }, { 'x': 2 }, { 'x': 1 }], 'x');
+            * // => [{ 'x': 1 }, { 'x': 2 }]
+            */
+            function uniqBy(array, iteratee) {
+              return array && array.length ? baseUniq(array, baseIteratee(iteratee, 2)) : [];
+            }
+            module.exports = uniqBy;
+          }
+        })); //#endregion
+      }
+    };
+  });
+})();

package/dist/assets/{usage.store-EBmhHKPv.js → usage.store-Xl7x6DGx.js}

@@ -1,5 +1,5 @@
 import { C as computed, Pt as reactive } from "./vue.runtime.esm-bundler-DDuXT-9r.js";
-import { Go as getLicense, Jo as requestLicenseTrial, Ko as registerCommunityEdition, Ro as useSettingsStore, Wo as activateLicenseKey, Ys as useRootStore, qo as renewLicense, vc as defineStore } from "./useTelemetry-EOV0Llso.js";
+import { Bo as useSettingsStore, Jo as getLicense, Qs as useRootStore, Xo as renewLicense, Yo as registerCommunityEdition, Zo as requestLicenseTrial, qo as activateLicenseKey, xc as defineStore } from "./useTelemetry-DedEakwK.js";
 var DEFAULT_PLAN_NAME = "Community";
 var DEFAULT_STATE = {
 	loading: true,

package/dist/assets/usage.store-legacy-CVF7gKOp.js

@@ -0,0 +1,126 @@
+;
+(function () {
+  System.register(["./vue.runtime.esm-bundler-legacy-Bq05oSFs.js", "./useTelemetry-legacy-Bu_8SoSm.js"], function (_export, _context) {
+    "use strict";
+
+    var computed, reactive, useSettingsStore, getLicense, useRootStore, renewLicense, registerCommunityEdition, requestLicenseTrial, activateLicenseKey, defineStore, DEFAULT_PLAN_NAME, DEFAULT_STATE, useUsageStore;
+    return {
+      setters: [function (_vueRuntimeEsmBundlerLegacy003Js) {
+        computed = _vueRuntimeEsmBundlerLegacy003Js.C;
+        reactive = _vueRuntimeEsmBundlerLegacy003Js.Pt;
+      }, function (_useTelemetryLegacy00FJs) {
+        useSettingsStore = _useTelemetryLegacy00FJs.Bo;
+        getLicense = _useTelemetryLegacy00FJs.Jo;
+        useRootStore = _useTelemetryLegacy00FJs.Qs;
+        renewLicense = _useTelemetryLegacy00FJs.Xo;
+        registerCommunityEdition = _useTelemetryLegacy00FJs.Yo;
+        requestLicenseTrial = _useTelemetryLegacy00FJs.Zo;
+        activateLicenseKey = _useTelemetryLegacy00FJs.qo;
+        defineStore = _useTelemetryLegacy00FJs.xc;
+      }],
+      execute: function () {
+        //#region src/features/settings/usage/usage.store.ts
+        DEFAULT_PLAN_NAME = "Community";
+        DEFAULT_STATE = {
+          loading: true,
+          data: {
+            usage: {
+              activeWorkflowTriggers: {
+                limit: -1,
+                value: 0,
+                warningThreshold: .8
+              },
+              workflowsHavingEvaluations: {
+                value: 0,
+                limit: 0
+              }
+            },
+            license: {
+              planId: "",
+              planName: DEFAULT_PLAN_NAME
+            }
+          }
+        };
+        _export("t", useUsageStore = defineStore("usage", () => {
+          const rootStore = useRootStore();
+          const settingsStore = useSettingsStore();
+          const state = reactive({
+            ...DEFAULT_STATE
+          });
+          const planName = computed(() => state.data.license.planName || DEFAULT_PLAN_NAME);
+          const planId = computed(() => state.data.license.planId);
+          const activeWorkflowTriggersLimit = computed(() => state.data.usage.activeWorkflowTriggers.limit);
+          const activeWorkflowTriggersCount = computed(() => state.data.usage.activeWorkflowTriggers.value);
+          const workflowsWithEvaluationsLimit = computed(() => state.data.usage.workflowsHavingEvaluations.limit);
+          const workflowsWithEvaluationsCount = computed(() => state.data.usage.workflowsHavingEvaluations.value);
+          const executionPercentage = computed(() => activeWorkflowTriggersCount.value / activeWorkflowTriggersLimit.value * 100);
+          const instanceId = computed(() => settingsStore.settings.instanceId);
+          const managementToken = computed(() => state.data.managementToken);
+          const appVersion = computed(() => settingsStore.settings.versionCli);
+          const commonSubscriptionAppUrlQueryParams = computed(() => `instanceid=${instanceId.value}&version=${appVersion.value}`);
+          const subscriptionAppUrl = computed(() => settingsStore.settings.license.environment === "production" ? "https://subscription.n8n.io" : "https://staging-subscription.n8n.io");
+          const setLoading = loading => {
+            state.loading = loading;
+          };
+          const setData = data => {
+            state.data = data;
+          };
+          const getLicenseInfo = async () => {
+            setData(await getLicense(rootStore.restApiContext));
+          };
+          const activateLicense = async (activationKey, eulaUri) => {
+            setData(await activateLicenseKey(rootStore.restApiContext, {
+              activationKey,
+              eulaUri
+            }));
+            await settingsStore.getSettings();
+            await settingsStore.getModuleSettings();
+          };
+          const refreshLicenseManagementToken = async () => {
+            try {
+              setData(await renewLicense(rootStore.restApiContext));
+            } catch (error) {
+              await getLicenseInfo();
+            }
+          };
+          const requestEnterpriseLicenseTrial = async () => {
+            await requestLicenseTrial(rootStore.restApiContext);
+          };
+          const registerCommunityEdition$1 = async email => await registerCommunityEdition(rootStore.restApiContext, {
+            email
+          });
+          return {
+            setLoading,
+            getLicenseInfo,
+            setData,
+            activateLicense,
+            refreshLicenseManagementToken,
+            requestEnterpriseLicenseTrial,
+            registerCommunityEdition: registerCommunityEdition$1,
+            planName,
+            planId,
+            activeWorkflowTriggersLimit,
+            activeWorkflowTriggersCount,
+            workflowsWithEvaluationsLimit,
+            workflowsWithEvaluationsCount,
+            executionPercentage,
+            instanceId,
+            managementToken,
+            appVersion,
+            isCloseToLimit: computed(() => state.data.usage.activeWorkflowTriggers.limit < 0 ? false : activeWorkflowTriggersCount.value / activeWorkflowTriggersLimit.value >= state.data.usage.activeWorkflowTriggers.warningThreshold),
+            viewPlansUrl: computed(() => `${subscriptionAppUrl.value}?${commonSubscriptionAppUrlQueryParams.value}`),
+            managePlanUrl: computed(() => `${subscriptionAppUrl.value}/manage?token=${managementToken.value}&${commonSubscriptionAppUrlQueryParams.value}`),
+            isLoading: computed(() => state.loading),
+            telemetryPayload: computed(() => ({
+              instance_id: instanceId.value,
+              action: "view_plans",
+              plan_name_current: planName.value,
+              usage: activeWorkflowTriggersCount.value,
+              quota: activeWorkflowTriggersLimit.value
+            }))
+          };
+        })); //#endregion
+      }
+    };
+  });
+})();

package/dist/assets/{useActions-CqdsN2GH.js → useActions-BeWbvBcf.js}

@@ -1,9 +1,9 @@
 import { C as computed } from "./vue.runtime.esm-bundler-DDuXT-9r.js";
-import { gt as useI18n } from "./_MapCache-Byd-DTfo.js";
-import { Ct as transformNodeType, Sn as injectWorkflowState, Un as useCanvasStore, o as useWorkflowsStore, rt as useNodeTypesStore, xt as sortNodeCreateElements } from "./useTelemetry-EOV0Llso.js";
-import { $t as OPEN_AI_NODE_TYPE, Fa as AI_CATEGORY_LANGUAGE_MODELS, Lt as MANUAL_TRIGGER_NODE_TYPE, On as WEBHOOK_NODE_TYPE, Q as CHAT_TRIGGER_NODE_TYPE, Qt as OPEN_AI_NODE_MESSAGE_ASSISTANT_TYPE, W as AGENT_NODE_TYPE, X as BASIC_CHAIN_NODE_TYPE, Xt as NO_OP_NODE_TYPE, Zt as OPEN_AI_ASSISTANT_NODE_TYPE, _n as SPLIT_IN_BATCHES_NODE_TYPE, ca as CHAIN_LLM_LANGCHAIN_NODE_TYPE, do as TRIGGER_NODE_CREATOR_VIEW, ea as NodeConnectionTypes, in as QA_CHAIN_NODE_TYPE, io as NODE_CREATOR_OPEN_SOURCES, ln as SCHEDULE_TRIGGER_NODE_TYPE, xn as STICKY_NODE_TYPE } from "./constants-DvlTm3U4.js";
-import { t as useExternalHooks } from "./useExternalHooks-SxBXYVNW.js";
-import { t as useNodeCreatorStore } from "./nodeCreator.store-DHz0Nc1Y.js";
+import { gt as useI18n } from "./_MapCache-Dw6Llo22.js";
+import { Ct as transformNodeType, Sn as injectWorkflowState, Un as useCanvasStore, o as useWorkflowsStore, rt as useNodeTypesStore, xt as sortNodeCreateElements } from "./useTelemetry-DedEakwK.js";
+import { $t as OPEN_AI_NODE_TYPE, Fa as AI_CATEGORY_LANGUAGE_MODELS, Lt as MANUAL_TRIGGER_NODE_TYPE, On as WEBHOOK_NODE_TYPE, Q as CHAT_TRIGGER_NODE_TYPE, Qt as OPEN_AI_NODE_MESSAGE_ASSISTANT_TYPE, W as AGENT_NODE_TYPE, X as BASIC_CHAIN_NODE_TYPE, Xt as NO_OP_NODE_TYPE, Zt as OPEN_AI_ASSISTANT_NODE_TYPE, _n as SPLIT_IN_BATCHES_NODE_TYPE, ca as CHAIN_LLM_LANGCHAIN_NODE_TYPE, do as TRIGGER_NODE_CREATOR_VIEW, ea as NodeConnectionTypes, in as QA_CHAIN_NODE_TYPE, io as NODE_CREATOR_OPEN_SOURCES, ln as SCHEDULE_TRIGGER_NODE_TYPE, xn as STICKY_NODE_TYPE } from "./constants-C5Tj3dXQ.js";
+import { t as useExternalHooks } from "./useExternalHooks-DSSTcvme.js";
+import { t as useNodeCreatorStore } from "./nodeCreator.store-C1GkQ_2N.js";
 const useActions = () => {
 	const workflowState = injectWorkflowState();
 	const nodeCreatorStore = useNodeCreatorStore();

package/dist/assets/useActions-legacy-B8B-O_ET.js

@@ -0,0 +1,330 @@
+;
+(function () {
+  System.register(["./vue.runtime.esm-bundler-legacy-Bq05oSFs.js", "./_MapCache-legacy-DcX1vy0l.js", "./useTelemetry-legacy-Bu_8SoSm.js", "./constants-legacy-CLA25gM9.js", "./useExternalHooks-legacy-DAJrb39U.js", "./nodeCreator.store-legacy-CjrGX9Lm.js"], function (_export, _context) {
+    "use strict";
+
+    var computed, useI18n, transformNodeType, injectWorkflowState, useCanvasStore, useWorkflowsStore, useNodeTypesStore, sortNodeCreateElements, OPEN_AI_NODE_TYPE, AI_CATEGORY_LANGUAGE_MODELS, MANUAL_TRIGGER_NODE_TYPE, WEBHOOK_NODE_TYPE, CHAT_TRIGGER_NODE_TYPE, OPEN_AI_NODE_MESSAGE_ASSISTANT_TYPE, AGENT_NODE_TYPE, BASIC_CHAIN_NODE_TYPE, NO_OP_NODE_TYPE, OPEN_AI_ASSISTANT_NODE_TYPE, SPLIT_IN_BATCHES_NODE_TYPE, CHAIN_LLM_LANGCHAIN_NODE_TYPE, TRIGGER_NODE_CREATOR_VIEW, NodeConnectionTypes, QA_CHAIN_NODE_TYPE, NODE_CREATOR_OPEN_SOURCES, SCHEDULE_TRIGGER_NODE_TYPE, STICKY_NODE_TYPE, useExternalHooks, useNodeCreatorStore, useActions;
+    return {
+      setters: [function (_vueRuntimeEsmBundlerLegacy003Js) {
+        computed = _vueRuntimeEsmBundlerLegacy003Js.C;
+      }, function (_MapCacheLegacy005Js) {
+        useI18n = _MapCacheLegacy005Js.gt;
+      }, function (_useTelemetryLegacy00FJs) {
+        transformNodeType = _useTelemetryLegacy00FJs.Ct;
+        injectWorkflowState = _useTelemetryLegacy00FJs.Sn;
+        useCanvasStore = _useTelemetryLegacy00FJs.Un;
+        useWorkflowsStore = _useTelemetryLegacy00FJs.o;
+        useNodeTypesStore = _useTelemetryLegacy00FJs.rt;
+        sortNodeCreateElements = _useTelemetryLegacy00FJs.xt;
+      }, function (_constantsLegacy00NJs) {
+        OPEN_AI_NODE_TYPE = _constantsLegacy00NJs.$t;
+        AI_CATEGORY_LANGUAGE_MODELS = _constantsLegacy00NJs.Fa;
+        MANUAL_TRIGGER_NODE_TYPE = _constantsLegacy00NJs.Lt;
+        WEBHOOK_NODE_TYPE = _constantsLegacy00NJs.On;
+        CHAT_TRIGGER_NODE_TYPE = _constantsLegacy00NJs.Q;
+        OPEN_AI_NODE_MESSAGE_ASSISTANT_TYPE = _constantsLegacy00NJs.Qt;
+        AGENT_NODE_TYPE = _constantsLegacy00NJs.W;
+        BASIC_CHAIN_NODE_TYPE = _constantsLegacy00NJs.X;
+        NO_OP_NODE_TYPE = _constantsLegacy00NJs.Xt;
+        OPEN_AI_ASSISTANT_NODE_TYPE = _constantsLegacy00NJs.Zt;
+        SPLIT_IN_BATCHES_NODE_TYPE = _constantsLegacy00NJs._n;
+        CHAIN_LLM_LANGCHAIN_NODE_TYPE = _constantsLegacy00NJs.ca;
+        TRIGGER_NODE_CREATOR_VIEW = _constantsLegacy00NJs.do;
+        NodeConnectionTypes = _constantsLegacy00NJs.ea;
+        QA_CHAIN_NODE_TYPE = _constantsLegacy00NJs.in;
+        NODE_CREATOR_OPEN_SOURCES = _constantsLegacy00NJs.io;
+        SCHEDULE_TRIGGER_NODE_TYPE = _constantsLegacy00NJs.ln;
+        STICKY_NODE_TYPE = _constantsLegacy00NJs.xn;
+      }, function (_useExternalHooksLegacy00XJs) {
+        useExternalHooks = _useExternalHooksLegacy00XJs.t;
+      }, function (_nodeCreatorStoreLegacy01jJs) {
+        useNodeCreatorStore = _nodeCreatorStoreLegacy01jJs.t;
+      }],
+      execute: function () {
+        //#region src/features/shared/nodeCreator/composables/useActions.ts
+        _export("t", useActions = () => {
+          const workflowState = injectWorkflowState();
+          const nodeCreatorStore = useNodeCreatorStore();
+          const nodeTypesStore = useNodeTypesStore();
+          const i18n = useI18n();
+          const singleNodeOpenSources = [NODE_CREATOR_OPEN_SOURCES.PLUS_ENDPOINT, NODE_CREATOR_OPEN_SOURCES.NODE_CONNECTION_ACTION, NODE_CREATOR_OPEN_SOURCES.NODE_CONNECTION_DROP];
+          const actionsCategoryLocales = computed(() => {
+            return {
+              actions: i18n.baseText("nodeCreator.actionsCategory.actions") ?? "",
+              triggers: i18n.baseText("nodeCreator.actionsCategory.triggers") ?? ""
+            };
+          });
+          function getPlaceholderTriggerActions(subcategory) {
+            const nodes = [WEBHOOK_NODE_TYPE, SCHEDULE_TRIGGER_NODE_TYPE];
+            return nodeCreatorStore.mergedNodes.filter(node => nodes.some(n => n === node.name)).map(node => {
+              const transformed = transformNodeType(node, subcategory, "action");
+              if (transformed.type === "action") {
+                const localeKey = `nodeCreator.actionsPlaceholderNode.${node.name.replace("n8n-nodes-base.", "")}`;
+                const overwriteLocale = i18n.baseText(localeKey);
+                if (overwriteLocale !== localeKey) transformed.properties.displayName = overwriteLocale;
+              }
+              return transformed;
+            });
+          }
+          function filterActionsCategory(items, category) {
+            return items.filter(item => item.type === "action" && item.properties.codex.categories.includes(category));
+          }
+          function injectActionsLabels(items) {
+            const extendedActions = sortNodeCreateElements([...items]);
+            const labelsSet = /* @__PURE__ */new Set();
+            for (const action of extendedActions) {
+              if (action.type !== "action") continue;
+              const label = action.properties?.codex?.label;
+              labelsSet.add(label);
+            }
+            if (labelsSet.size <= 1) return extendedActions;
+            const firstIndexMap = /* @__PURE__ */new Map();
+            for (let i = 0; i < extendedActions.length; i++) {
+              const action = extendedActions[i];
+              if (action.type !== "action") continue;
+              const label = action.properties?.codex?.label;
+              if (!firstIndexMap.has(label)) firstIndexMap.set(label, i);
+            }
+            let insertedLabels = 0;
+            for (const label of labelsSet) {
+              const newLabel = {
+                uuid: label,
+                type: "label",
+                key: label,
+                subcategory: extendedActions[0].key,
+                properties: {
+                  key: label
+                }
+              };
+              const insertIndex = firstIndexMap.get(label);
+              if (insertIndex !== void 0) {
+                extendedActions.splice(insertIndex + insertedLabels, 0, newLabel);
+                insertedLabels++;
+              }
+            }
+            return extendedActions;
+          }
+          function parseCategoryActions(actions, category, withLabels = true) {
+            const filteredActions = filterActionsCategory(actions, category);
+            if (withLabels) return injectActionsLabels(filteredActions);
+            return filteredActions;
+          }
+          function getActionData(actionItem) {
+            const displayOptions = actionItem.displayOptions;
+            const displayConditions = Object.keys(displayOptions?.show ?? {}).reduce((acc, showCondition) => {
+              acc[showCondition] = displayOptions?.show?.[showCondition]?.[0];
+              return acc;
+            }, {});
+            return {
+              name: actionItem.displayName,
+              key: actionItem.name,
+              value: {
+                ...actionItem.values,
+                ...displayConditions
+              }
+            };
+          }
+          function actionDataToNodeTypeSelectedPayload(actionData) {
+            const result = {
+              type: actionData.key,
+              actionName: actionData.name
+            };
+            if (typeof actionData.value.language === "string") {
+              result.parameters = {
+                language: actionData.value.language
+              };
+              return result;
+            }
+            if (typeof actionData.value.resource === "string" || typeof actionData.value.operation === "string") {
+              result.parameters = {};
+              if (typeof actionData.value.resource === "string") result.parameters.resource = actionData.value.resource;
+              if (typeof actionData.value.operation === "string") result.parameters.operation = actionData.value.operation;
+            }
+            return result;
+          }
+          function nodeCreateElementToNodeTypeSelectedPayload(actionData) {
+            const result = {
+              type: actionData.key
+            };
+            if (typeof actionData.resource === "string" || typeof actionData.operation === "string") {
+              result.parameters = {};
+              if (typeof actionData.resource === "string") result.parameters.resource = actionData.resource;
+              if (typeof actionData.operation === "string") result.parameters.operation = actionData.operation;
+            }
+            return result;
+          }
+          /**
+          * Checks if added nodes contain trigger followed by another node
+          * In this case, we should connect the trigger with the following node
+          */
+          function shouldConnectWithExistingTrigger(addedNodes) {
+            if (addedNodes.length === 2) return useNodeTypesStore().isTriggerNode(addedNodes[0].type);
+            return false;
+          }
+          function shouldPrependManualTrigger(addedNodes) {
+            const {
+              selectedView,
+              openSource
+            } = useNodeCreatorStore();
+            const {
+              workflowTriggerNodes
+            } = useWorkflowsStore();
+            const hasTrigger = addedNodes.some(node => useNodeTypesStore().isTriggerNode(node.type));
+            const workflowContainsTrigger = workflowTriggerNodes.length > 0;
+            const isTriggerPanel = selectedView === TRIGGER_NODE_CREATOR_VIEW;
+            const onlyStickyNodes = addedNodes.every(node => node.type === STICKY_NODE_TYPE);
+            return !singleNodeOpenSources.includes(openSource) && !hasTrigger && !workflowContainsTrigger && isTriggerPanel && !onlyStickyNodes;
+          }
+          function shouldPrependChatTrigger(addedNodes) {
+            const COMPATIBLE_CHAT_NODES = [QA_CHAIN_NODE_TYPE, AGENT_NODE_TYPE, BASIC_CHAIN_NODE_TYPE, OPEN_AI_ASSISTANT_NODE_TYPE, OPEN_AI_NODE_MESSAGE_ASSISTANT_TYPE];
+            if (!addedNodes.some(node => COMPATIBLE_CHAT_NODES.includes(node.type))) return false;
+            const {
+              allNodes
+            } = useWorkflowsStore();
+            return allNodes.filter(x => x.type !== MANUAL_TRIGGER_NODE_TYPE).length === 0;
+          }
+          function shouldPrependLLMChain(addedNodes) {
+            if (useCanvasStore().aiNodes.length > 0) return false;
+            return addedNodes.some(node => {
+              const nodeType = nodeTypesStore.getNodeType(node.type);
+              return Object.keys(nodeType?.codex?.subcategories ?? {}).includes(AI_CATEGORY_LANGUAGE_MODELS);
+            });
+          }
+          function getAddedNodesAndConnections(addedNodes) {
+            if (addedNodes.length === 0) return {
+              nodes: [],
+              connections: []
+            };
+            const nodes = [];
+            const connections = [];
+            const nodeToAutoOpen = addedNodes.find(node => node.type !== MANUAL_TRIGGER_NODE_TYPE);
+            if (nodeToAutoOpen) nodeToAutoOpen.openDetail = true;
+            if (shouldPrependLLMChain(addedNodes) || shouldPrependChatTrigger(addedNodes)) {
+              if (shouldPrependLLMChain(addedNodes)) {
+                addedNodes.unshift({
+                  type: CHAIN_LLM_LANGCHAIN_NODE_TYPE,
+                  isAutoAdd: true
+                });
+                connections.push({
+                  from: {
+                    nodeIndex: 2,
+                    type: NodeConnectionTypes.AiLanguageModel
+                  },
+                  to: {
+                    nodeIndex: 1
+                  }
+                });
+              }
+              addedNodes.unshift({
+                type: CHAT_TRIGGER_NODE_TYPE,
+                isAutoAdd: true
+              });
+              connections.push({
+                from: {
+                  nodeIndex: 0
+                },
+                to: {
+                  nodeIndex: 1
+                }
+              });
+            } else if (shouldPrependManualTrigger(addedNodes)) {
+              addedNodes.unshift({
+                type: MANUAL_TRIGGER_NODE_TYPE,
+                isAutoAdd: true
+              });
+              connections.push({
+                from: {
+                  nodeIndex: 0
+                },
+                to: {
+                  nodeIndex: 1
+                }
+              });
+            } else if (shouldConnectWithExistingTrigger(addedNodes)) connections.push({
+              from: {
+                nodeIndex: 0
+              },
+              to: {
+                nodeIndex: 1
+              }
+            });
+            addedNodes.forEach((node, index) => {
+              if (node.type === "@n8n/n8n-nodes-langchain.openAi.assistant.message") node.type = OPEN_AI_NODE_TYPE;
+              nodes.push(node);
+              switch (node.type) {
+                case SPLIT_IN_BATCHES_NODE_TYPE:
+                  {
+                    const splitInBatchesIndex = index;
+                    const noOpIndex = splitInBatchesIndex + 1;
+                    nodes.push({
+                      type: NO_OP_NODE_TYPE,
+                      isAutoAdd: true,
+                      name: i18n.baseText("nodeView.replaceMe")
+                    });
+                    connections.push({
+                      from: {
+                        nodeIndex: splitInBatchesIndex,
+                        outputIndex: 1
+                      },
+                      to: {
+                        nodeIndex: noOpIndex
+                      }
+                    }, {
+                      from: {
+                        nodeIndex: noOpIndex
+                      },
+                      to: {
+                        nodeIndex: splitInBatchesIndex
+                      }
+                    });
+                    break;
+                  }
+              }
+            });
+            return {
+              nodes,
+              connections
+            };
+          }
+          function setAddedNodeActionParameters(action, telemetry, rootView = "") {
+            const {
+              $onAction: onWorkflowStoreAction
+            } = useWorkflowsStore();
+            const storeWatcher = onWorkflowStoreAction(({
+              name,
+              after,
+              args
+            }) => {
+              if (name !== "addNode" || args[0].type !== action.key) return;
+              after(() => {
+                workflowState.setLastNodeParameters(action);
+                if (telemetry) trackActionSelected(action, telemetry, rootView);
+                storeWatcher();
+              });
+            });
+            return storeWatcher;
+          }
+          function trackActionSelected(action, _telemetry, rootView) {
+            const payload = {
+              node_type: action.key,
+              action: action.name,
+              source_mode: rootView.toLowerCase(),
+              resource: action.value.resource || ""
+            };
+            useExternalHooks().run("nodeCreateList.addAction", payload);
+          }
+          return {
+            actionsCategoryLocales,
+            actionDataToNodeTypeSelectedPayload,
+            nodeCreateElementToNodeTypeSelectedPayload,
+            getPlaceholderTriggerActions,
+            parseCategoryActions,
+            getAddedNodesAndConnections,
+            getActionData,
+            setAddedNodeActionParameters
+          };
+        }); //#endregion
+      }
+    };
+  });
+})();

package/dist/assets/{useAgent-BHJHCfap.js → useAgent-C1ldRVaA.js}

@@ -1,5 +1,5 @@
 import { C as computed, Ut as toValue } from "./vue.runtime.esm-bundler-DDuXT-9r.js";
-import { r as useChatStore } from "./useChatHubSidebarState-CM9tokIj.js";
+import { r as useChatStore } from "./useChatHubSidebarState-DpLl3Oap.js";
 function useAgent(model) {
 	const chatStore = useChatStore();
 	return computed(() => {

package/dist/assets/useAgent-legacy-BSTQ3a_e.js

@@ -0,0 +1,28 @@
+;
+(function () {
+  System.register(["./vue.runtime.esm-bundler-legacy-Bq05oSFs.js", "./useChatHubSidebarState-legacy-fa3EFauo.js"], function (_export, _context) {
+    "use strict";
+
+    var computed, toValue, useChatStore;
+    //#region src/features/ai/chatHub/composables/useAgent.ts
+    function useAgent(model) {
+      const chatStore = useChatStore();
+      return computed(() => {
+        const modelValue = toValue(model);
+        return modelValue ? chatStore.getAgent(modelValue) : void 0;
+      });
+    }
+
+    //#endregion
+    _export("t", useAgent);
+    return {
+      setters: [function (_vueRuntimeEsmBundlerLegacy003Js) {
+        computed = _vueRuntimeEsmBundlerLegacy003Js.C;
+        toValue = _vueRuntimeEsmBundlerLegacy003Js.Ut;
+      }, function (_useChatHubSidebarStateLegacy04FJs) {
+        useChatStore = _useChatHubSidebarStateLegacy04FJs.r;
+      }],
+      execute: function () {}
+    };
+  });
+})();

package/dist/assets/{useBeforeUnload-BPhnlPrH.js → useBeforeUnload-Dk9osL_V.js}

@@ -1,7 +1,7 @@
 import { C as computed, It as ref } from "./vue.runtime.esm-bundler-DDuXT-9r.js";
-import { gt as useI18n } from "./_MapCache-Byd-DTfo.js";
-import { Ni as useUIStore, Un as useCanvasStore } from "./useTelemetry-EOV0Llso.js";
-import { mo as VIEWS } from "./constants-DvlTm3U4.js";
+import { gt as useI18n } from "./_MapCache-Dw6Llo22.js";
+import { Ni as useUIStore, Un as useCanvasStore } from "./useTelemetry-DedEakwK.js";
+import { mo as VIEWS } from "./constants-C5Tj3dXQ.js";
 function useBeforeUnload({ route }) {
 	const uiStore = useUIStore();
 	const canvasStore = useCanvasStore();

package/dist/assets/useBeforeUnload-legacy-hCNmJWkt.js

@@ -0,0 +1,69 @@
+;
+(function () {
+  System.register(["./vue.runtime.esm-bundler-legacy-Bq05oSFs.js", "./_MapCache-legacy-DcX1vy0l.js", "./useTelemetry-legacy-Bu_8SoSm.js", "./constants-legacy-CLA25gM9.js"], function (_export, _context) {
+    "use strict";
+
+    var computed, ref, useI18n, useUIStore, useCanvasStore, VIEWS;
+    //#region src/app/composables/useBeforeUnload.ts
+    /**
+    * Composable to handle the beforeunload event in canvas views.
+    *
+    * This hook will prevent closing the tab and prompt the user if the ui state is dirty
+    * (workflow has changes) and the user tries to leave the page.
+    */
+    function useBeforeUnload({
+      route
+    }) {
+      const uiStore = useUIStore();
+      const canvasStore = useCanvasStore();
+      const i18n = useI18n();
+      const unloadTimeout = ref(null);
+      const isDemoRoute = computed(() => route.name === VIEWS.DEMO);
+      const handlers = [];
+      function onBeforeUnload(e) {
+        if (isDemoRoute.value || window.preventNodeViewBeforeUnload) return;
+        handlers.forEach(handler => handler());
+        if (uiStore.stateIsDirty) {
+          e.returnValue = true;
+          return true;
+        } else {
+          canvasStore.startLoading(i18n.baseText("nodeView.redirecting"));
+          return;
+        }
+      }
+      function addBeforeUnloadHandler(handler) {
+        handlers.push(handler);
+      }
+      function addBeforeUnloadEventBindings() {
+        window.addEventListener("beforeunload", onBeforeUnload);
+      }
+      function removeBeforeUnloadEventBindings() {
+        if (unloadTimeout.value) clearTimeout(unloadTimeout.value);
+        window.removeEventListener("beforeunload", onBeforeUnload);
+      }
+      return {
+        onBeforeUnload,
+        addBeforeUnloadEventBindings,
+        removeBeforeUnloadEventBindings,
+        addBeforeUnloadHandler
+      };
+    }
+
+    //#endregion
+    _export("t", useBeforeUnload);
+    return {
+      setters: [function (_vueRuntimeEsmBundlerLegacy003Js) {
+        computed = _vueRuntimeEsmBundlerLegacy003Js.C;
+        ref = _vueRuntimeEsmBundlerLegacy003Js.It;
+      }, function (_MapCacheLegacy005Js) {
+        useI18n = _MapCacheLegacy005Js.gt;
+      }, function (_useTelemetryLegacy00FJs) {
+        useUIStore = _useTelemetryLegacy00FJs.Ni;
+        useCanvasStore = _useTelemetryLegacy00FJs.Un;
+      }, function (_constantsLegacy00NJs) {
+        VIEWS = _constantsLegacy00NJs.mo;
+      }],
+      execute: function () {}
+    };
+  });
+})();