@n8n/n8n-nodes-langchain 2.5.1 → 2.6.0

package/dist/nodes/trigger/ChatTrigger/ChatTrigger.node.js

@@ -1,249 +1,254 @@
 "use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var ChatTrigger_node_exports = {};
-__export(ChatTrigger_node_exports, {
-  ChatTrigger: () => ChatTrigger
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
 });
-module.exports = __toCommonJS(ChatTrigger_node_exports);
-var import_pick = __toESM(require("lodash/pick"));
-var import_n8n_workflow = require("n8n-workflow");
-var a = __toESM(require("node:assert"));
-var import_constants = require("./constants");
-var import_GenericFunctions = require("./GenericFunctions");
-var import_templates = require("./templates");
-var import_types = require("./types");
-const CHAT_TRIGGER_PATH_IDENTIFIER = "chat";
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChatTrigger = void 0;
+const pick_1 = __importDefault(require("lodash/pick"));
+const n8n_workflow_1 = require("n8n-workflow");
+const a = __importStar(require("node:assert"));
+const constants_1 = require("./constants");
+const GenericFunctions_1 = require("./GenericFunctions");
+const templates_1 = require("./templates");
+const types_1 = require("./types");
+const CHAT_TRIGGER_PATH_IDENTIFIER = 'chat';
 const allowFileUploadsOption = {
-  displayName: "Allow File Uploads",
-  name: "allowFileUploads",
-  type: "boolean",
-  default: false,
-  description: "Whether to allow file uploads in the chat"
+    displayName: 'Allow File Uploads',
+    name: 'allowFileUploads',
+    type: 'boolean',
+    default: false,
+    description: 'Whether to allow file uploads in the chat',
 };
 const allowedFileMimeTypeOption = {
-  displayName: "Allowed File Mime Types",
-  name: "allowedFilesMimeTypes",
-  type: "string",
-  default: "*",
-  placeholder: "e.g. image/*, text/*, application/pdf",
-  description: 'Allowed file types for upload. Comma-separated list of <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types/Common_types" target="_blank">MIME types</a>.'
+    displayName: 'Allowed File Mime Types',
+    name: 'allowedFilesMimeTypes',
+    type: 'string',
+    default: '*',
+    placeholder: 'e.g. image/*, text/*, application/pdf',
+    description: 'Allowed file types for upload. Comma-separated list of <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types/Common_types" target="_blank">MIME types</a>.',
 };
 const respondToWebhookResponseMode = {
-  name: "Using 'Respond to Webhook' Node",
-  value: "responseNode",
-  description: "Response defined in that node"
+    name: "Using 'Respond to Webhook' Node",
+    value: 'responseNode',
+    description: 'Response defined in that node',
 };
 const lastNodeResponseMode = {
-  name: "When Last Node Finishes",
-  value: "lastNode",
-  description: "Returns data of the last-executed node"
+    name: 'When Last Node Finishes',
+    value: 'lastNode',
+    description: 'Returns data of the last-executed node',
 };
 const streamingResponseMode = {
-  name: "Streaming",
-  value: "streaming",
-  description: "Streaming response from specified nodes (e.g. Agents)"
+    name: 'Streaming',
+    value: 'streaming',
+    description: 'Streaming response from specified nodes (e.g. Agents)',
 };
 const respondNodesResponseMode = {
-  name: "Using Response Nodes",
-  value: "responseNodes",
-  description: "Send responses to the chat by using one or more Chat nodes"
+    name: 'Using Response Nodes',
+    value: 'responseNodes',
+    description: 'Send responses to the chat by using one or more Chat nodes',
 };
 const commonOptionsFields = [
-  // CORS parameters are only valid for when chat is used in hosted or webhook mode
-  {
-    displayName: "Allowed Origins (CORS)",
-    name: "allowedOrigins",
-    type: "string",
-    default: "*",
-    description: "Comma-separated list of URLs allowed for cross-origin non-preflight requests. Use * (default) to allow all origins.",
-    displayOptions: {
-      show: {
-        "/mode": ["hostedChat", "webhook"]
-      }
-    }
-  },
-  {
-    ...allowFileUploadsOption,
-    displayOptions: {
-      show: {
-        "/mode": ["hostedChat"]
-      }
-    }
-  },
-  {
-    ...allowedFileMimeTypeOption,
-    displayOptions: {
-      show: {
-        "/mode": ["hostedChat"]
-      }
-    }
-  },
-  {
-    displayName: "Input Placeholder",
-    name: "inputPlaceholder",
-    type: "string",
-    displayOptions: {
-      show: {
-        "/mode": ["hostedChat"]
-      }
+    {
+        displayName: 'Allowed Origins (CORS)',
+        name: 'allowedOrigins',
+        type: 'string',
+        default: '*',
+        description: 'Comma-separated list of URLs allowed for cross-origin non-preflight requests. Use * (default) to allow all origins.',
+        displayOptions: {
+            show: {
+                '/mode': ['hostedChat', 'webhook'],
+            },
+        },
     },
-    default: "Type your question..",
-    placeholder: "e.g. Type your message here",
-    description: "Shown as placeholder text in the chat input field"
-  },
-  {
-    displayName: "Load Previous Session",
-    name: "loadPreviousSession",
-    type: "options",
-    options: [
-      {
-        name: "Off",
-        value: "notSupported",
-        description: "Loading messages of previous session is turned off"
-      },
-      {
-        name: "From Memory",
-        value: "memory",
-        description: "Load session messages from memory"
-      },
-      {
-        name: "Manually",
-        value: "manually",
-        description: "Manually return messages of session"
-      }
-    ],
-    default: "notSupported",
-    description: "If loading messages of a previous session should be enabled"
-  },
-  {
-    displayName: "Require Button Click to Start Chat",
-    name: "showWelcomeScreen",
-    type: "boolean",
-    displayOptions: {
-      show: {
-        "/mode": ["hostedChat"]
-      }
+    {
+        ...allowFileUploadsOption,
+        displayOptions: {
+            show: {
+                '/mode': ['hostedChat'],
+            },
+        },
     },
-    default: false,
-    description: "Whether to show the welcome screen at the start of the chat"
-  },
-  {
-    displayName: "Start Conversation Button Text",
-    name: "getStarted",
-    type: "string",
-    displayOptions: {
-      show: {
-        showWelcomeScreen: [true],
-        "/mode": ["hostedChat"]
-      }
+    {
+        ...allowedFileMimeTypeOption,
+        displayOptions: {
+            show: {
+                '/mode': ['hostedChat'],
+            },
+        },
+    },
+    {
+        displayName: 'Input Placeholder',
+        name: 'inputPlaceholder',
+        type: 'string',
+        displayOptions: {
+            show: {
+                '/mode': ['hostedChat'],
+            },
+        },
+        default: 'Type your question..',
+        placeholder: 'e.g. Type your message here',
+        description: 'Shown as placeholder text in the chat input field',
+    },
+    {
+        displayName: 'Load Previous Session',
+        name: 'loadPreviousSession',
+        type: 'options',
+        options: [
+            {
+                name: 'Off',
+                value: 'notSupported',
+                description: 'Loading messages of previous session is turned off',
+            },
+            {
+                name: 'From Memory',
+                value: 'memory',
+                description: 'Load session messages from memory',
+            },
+            {
+                name: 'Manually',
+                value: 'manually',
+                description: 'Manually return messages of session',
+            },
+        ],
+        default: 'notSupported',
+        description: 'If loading messages of a previous session should be enabled',
     },
-    default: "New Conversation",
-    placeholder: "e.g. New Conversation",
-    description: "Shown as part of the welcome screen, in the middle of the chat window"
-  },
-  {
-    displayName: "Subtitle",
-    name: "subtitle",
-    type: "string",
-    displayOptions: {
-      show: {
-        "/mode": ["hostedChat"]
-      }
+    {
+        displayName: 'Require Button Click to Start Chat',
+        name: 'showWelcomeScreen',
+        type: 'boolean',
+        displayOptions: {
+            show: {
+                '/mode': ['hostedChat'],
+            },
+        },
+        default: false,
+        description: 'Whether to show the welcome screen at the start of the chat',
     },
-    default: "Start a chat. We're here to help you 24/7.",
-    placeholder: "e.g. We're here for you",
-    description: "Shown at the top of the chat, under the title"
-  },
-  {
-    displayName: "Title",
-    name: "title",
-    type: "string",
-    displayOptions: {
-      show: {
-        "/mode": ["hostedChat"]
-      }
+    {
+        displayName: 'Start Conversation Button Text',
+        name: 'getStarted',
+        type: 'string',
+        displayOptions: {
+            show: {
+                showWelcomeScreen: [true],
+                '/mode': ['hostedChat'],
+            },
+        },
+        default: 'New Conversation',
+        placeholder: 'e.g. New Conversation',
+        description: 'Shown as part of the welcome screen, in the middle of the chat window',
     },
-    default: "Hi there! \u{1F44B}",
-    placeholder: "e.g. Welcome",
-    description: "Shown at the top of the chat"
-  },
-  {
-    displayName: "Custom Chat Styling",
-    name: "customCss",
-    type: "string",
-    typeOptions: {
-      rows: 10,
-      editor: "cssEditor"
+    {
+        displayName: 'Subtitle',
+        name: 'subtitle',
+        type: 'string',
+        displayOptions: {
+            show: {
+                '/mode': ['hostedChat'],
+            },
+        },
+        default: "Start a chat. We're here to help you 24/7.",
+        placeholder: "e.g. We're here for you",
+        description: 'Shown at the top of the chat, under the title',
     },
-    displayOptions: {
-      show: {
-        "/mode": ["hostedChat"]
-      }
+    {
+        displayName: 'Title',
+        name: 'title',
+        type: 'string',
+        displayOptions: {
+            show: {
+                '/mode': ['hostedChat'],
+            },
+        },
+        default: 'Hi there! 👋',
+        placeholder: 'e.g. Welcome',
+        description: 'Shown at the top of the chat',
     },
-    default: `
-${import_constants.cssVariables}
+    {
+        displayName: 'Custom Chat Styling',
+        name: 'customCss',
+        type: 'string',
+        typeOptions: {
+            rows: 10,
+            editor: 'cssEditor',
+        },
+        displayOptions: {
+            show: {
+                '/mode': ['hostedChat'],
+            },
+        },
+        default: `
+${constants_1.cssVariables}
 
 /* You can override any class styles, too. Right-click inspect in Chat UI to find class to override. */
 .chat-message {
 	max-width: 50%;
 }
 `.trim(),
-    description: "Override default styling of the public chat interface with CSS"
-  }
+        description: 'Override default styling of the public chat interface with CSS',
+    },
 ];
-class ChatTrigger extends import_n8n_workflow.Node {
-  constructor() {
-    super(...arguments);
-    this.description = {
-      displayName: "Chat Trigger",
-      name: "chatTrigger",
-      icon: "fa:comments",
-      iconColor: "black",
-      group: ["trigger"],
-      version: [1, 1.1, 1.2, 1.3, 1.4],
-      defaultVersion: 1.4,
-      description: "Runs the workflow when an n8n generated webchat is submitted",
-      defaults: {
-        name: "When chat message received"
-      },
-      codex: {
-        categories: ["Core Nodes"],
-        resources: {
-          primaryDocumentation: [
-            {
-              url: "https://docs.n8n.io/integrations/builtin/core-nodes/n8n-nodes-langchain.chattrigger/"
-            }
-          ]
-        }
-      },
-      maxNodes: 1,
-      inputs: `={{ (() => {
+class ChatTrigger extends n8n_workflow_1.Node {
+    constructor() {
+        super(...arguments);
+        this.description = {
+            displayName: 'Chat Trigger',
+            name: 'chatTrigger',
+            icon: 'fa:comments',
+            iconColor: 'black',
+            group: ['trigger'],
+            version: [1, 1.1, 1.2, 1.3, 1.4],
+            defaultVersion: 1.4,
+            description: 'Runs the workflow when an n8n generated webchat is submitted',
+            defaults: {
+                name: 'When chat message received',
+            },
+            codex: {
+                categories: ['Core Nodes'],
+                resources: {
+                    primaryDocumentation: [
+                        {
+                            url: 'https://docs.n8n.io/integrations/builtin/core-nodes/n8n-nodes-langchain.chattrigger/',
+                        },
+                    ],
+                },
+            },
+            maxNodes: 1,
+            inputs: `={{ (() => {
 			if (!['hostedChat', 'webhook'].includes($parameter.mode)) {
 				return [];
 			}
@@ -255,582 +260,572 @@ class ChatTrigger extends import_n8n_workflow.Node {
 				{
 					displayName: 'Memory',
 					maxConnections: 1,
-					type: '${import_n8n_workflow.NodeConnectionTypes.AiMemory}',
+					type: '${n8n_workflow_1.NodeConnectionTypes.AiMemory}',
 					required: true,
 				}
 			];
 		 })() }}`,
-      outputs: [import_n8n_workflow.NodeConnectionTypes.Main],
-      credentials: [
-        {
-          // eslint-disable-next-line n8n-nodes-base/node-class-description-credentials-name-unsuffixed
-          name: "httpBasicAuth",
-          required: true,
-          displayOptions: {
-            show: {
-              authentication: ["basicAuth"]
+            outputs: [n8n_workflow_1.NodeConnectionTypes.Main],
+            credentials: [
+                {
+                    name: 'httpBasicAuth',
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            authentication: ['basicAuth'],
+                        },
+                    },
+                },
+            ],
+            webhooks: [
+                {
+                    name: 'setup',
+                    httpMethod: 'GET',
+                    responseMode: 'onReceived',
+                    path: CHAT_TRIGGER_PATH_IDENTIFIER,
+                    ndvHideUrl: true,
+                },
+                {
+                    name: 'default',
+                    httpMethod: 'POST',
+                    responseMode: '={{$parameter.options?.["responseMode"] ?? ($parameter.availableInChat ? "streaming" : "lastNode") }}',
+                    path: CHAT_TRIGGER_PATH_IDENTIFIER,
+                    ndvHideMethod: true,
+                    ndvHideUrl: '={{ !$parameter.public }}',
+                },
+            ],
+            eventTriggerDescription: 'Waiting for you to submit the chat',
+            activationMessage: 'You can now make calls to your production chat URL.',
+            triggerPanel: false,
+            properties: [
+                {
+                    displayName: 'Make Chat Publicly Available',
+                    name: 'public',
+                    type: 'boolean',
+                    default: false,
+                    description: 'Whether the chat should be publicly available or only accessible through the manual chat interface',
+                },
+                {
+                    displayName: 'Mode',
+                    name: 'mode',
+                    type: 'options',
+                    options: [
+                        {
+                            name: 'Hosted Chat',
+                            value: 'hostedChat',
+                            description: 'Chat on a page served by n8n',
+                        },
+                        {
+                            name: 'Embedded Chat',
+                            value: 'webhook',
+                            description: 'Chat through a widget embedded in another page, or by calling a webhook',
+                        },
+                    ],
+                    default: 'hostedChat',
+                    displayOptions: {
+                        show: {
+                            public: [true],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Chat will be live at the URL above once this workflow is published. Live executions will show up in the ‘executions’ tab',
+                    name: 'hostedChatNotice',
+                    type: 'notice',
+                    displayOptions: {
+                        show: {
+                            mode: ['hostedChat'],
+                            public: [true],
+                        },
+                    },
+                    default: '',
+                },
+                {
+                    displayName: 'Follow the instructions <a href="https://www.npmjs.com/package/@n8n/chat" target="_blank">here</a> to embed chat in a webpage (or just call the webhook URL at the top of this section). Chat will be live once you publish this workflow',
+                    name: 'embeddedChatNotice',
+                    type: 'notice',
+                    displayOptions: {
+                        show: {
+                            mode: ['webhook'],
+                            public: [true],
+                        },
+                    },
+                    default: '',
+                },
+                {
+                    displayName: 'Authentication',
+                    name: 'authentication',
+                    type: 'options',
+                    displayOptions: {
+                        show: {
+                            public: [true],
+                        },
+                    },
+                    options: [
+                        {
+                            name: 'Basic Auth',
+                            value: 'basicAuth',
+                            description: 'Simple username and password (the same one for all users)',
+                        },
+                        {
+                            name: 'n8n User Auth',
+                            value: 'n8nUserAuth',
+                            description: 'Require user to be logged in with their n8n account',
+                        },
+                        {
+                            name: 'None',
+                            value: 'none',
+                        },
+                    ],
+                    default: 'none',
+                    description: 'The way to authenticate',
+                },
+                {
+                    displayName: 'Initial Message(s)',
+                    name: 'initialMessages',
+                    type: 'string',
+                    displayOptions: {
+                        show: {
+                            mode: ['hostedChat'],
+                            public: [true],
+                        },
+                    },
+                    typeOptions: {
+                        rows: 3,
+                    },
+                    default: 'Hi there! 👋\nMy name is Nathan. How can I assist you today?',
+                    description: 'Default messages shown at the start of the chat, one per line',
+                },
+                {
+                    displayName: 'Make Available in n8n Chat Hub',
+                    name: 'availableInChat',
+                    type: 'boolean',
+                    default: false,
+                    noDataExpression: true,
+                    description: 'Whether to make the agent available in n8n Chat Hub for n8n instance users to chat with',
+                },
+                {
+                    displayName: 'Your Chat Trigger node is out of date. To update, delete this node and insert a new Chat Trigger node.',
+                    name: 'availableInChatNotice',
+                    type: 'notice',
+                    displayOptions: {
+                        show: {
+                            availableInChat: [true],
+                            '@version': [{ _cnd: { lt: 1.2 } }],
+                        },
+                    },
+                    default: '',
+                },
+                {
+                    displayName: 'Your n8n users will be able to use this agent in <a href="/home/chat/" target="_blank">Chat</a> once this workflow is published. Make sure to share this workflow with at least Project Chat User access to all users who should use it.',
+                    name: 'availableInChatNotice',
+                    type: 'notice',
+                    displayOptions: {
+                        show: {
+                            availableInChat: [true],
+                            '@version': [{ _cnd: { gte: 1.2 } }],
+                        },
+                    },
+                    default: '',
+                },
+                {
+                    displayName: 'Agent Icon',
+                    name: 'agentIcon',
+                    type: 'icon',
+                    default: { type: 'icon', value: 'bot' },
+                    noDataExpression: true,
+                    description: 'The icon of the agent on n8n Chat',
+                    displayOptions: {
+                        show: {
+                            availableInChat: [true],
+                            '@version': [{ _cnd: { gte: 1.2 } }],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Agent Name',
+                    name: 'agentName',
+                    type: 'string',
+                    default: '',
+                    noDataExpression: true,
+                    description: 'The name of the agent on n8n Chat. Name of the workflow is used if left empty.',
+                    displayOptions: {
+                        show: {
+                            availableInChat: [true],
+                            '@version': [{ _cnd: { gte: 1.2 } }],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Agent Description',
+                    name: 'agentDescription',
+                    type: 'string',
+                    typeOptions: {
+                        rows: 2,
+                    },
+                    default: '',
+                    noDataExpression: true,
+                    description: 'The description of the agent on n8n Chat',
+                    displayOptions: {
+                        show: {
+                            availableInChat: [true],
+                            '@version': [{ _cnd: { gte: 1.2 } }],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Options',
+                    name: 'options',
+                    type: 'collection',
+                    displayOptions: {
+                        show: {
+                            public: [false],
+                            '@version': [1, 1.1],
+                        },
+                    },
+                    placeholder: 'Add Field',
+                    default: {},
+                    options: [allowFileUploadsOption, allowedFileMimeTypeOption],
+                },
+                {
+                    displayName: 'Options',
+                    name: 'options',
+                    type: 'collection',
+                    displayOptions: {
+                        show: {
+                            mode: ['hostedChat', 'webhook'],
+                            public: [true],
+                            '@version': [1, 1.1],
+                        },
+                    },
+                    placeholder: 'Add Field',
+                    default: {},
+                    options: [
+                        ...commonOptionsFields,
+                        {
+                            displayName: 'Response Mode',
+                            name: 'responseMode',
+                            type: 'options',
+                            options: [lastNodeResponseMode, respondToWebhookResponseMode],
+                            default: 'lastNode',
+                            description: 'When and how to respond to the webhook',
+                        },
+                    ],
+                },
+                {
+                    displayName: 'Options',
+                    name: 'options',
+                    type: 'collection',
+                    displayOptions: {
+                        show: {
+                            mode: ['hostedChat', 'webhook'],
+                            public: [true],
+                            '@version': [1.2],
+                        },
+                    },
+                    placeholder: 'Add Field',
+                    default: {},
+                    options: [
+                        ...commonOptionsFields,
+                        {
+                            displayName: 'Response Mode',
+                            name: 'responseMode',
+                            type: 'options',
+                            options: [lastNodeResponseMode, respondToWebhookResponseMode, streamingResponseMode],
+                            default: 'lastNode',
+                            description: 'When and how to respond to the webhook',
+                            displayOptions: { show: { '/availableInChat': [false] } },
+                        },
+                        {
+                            displayName: 'Response Mode',
+                            name: 'responseMode',
+                            type: 'options',
+                            options: [streamingResponseMode, lastNodeResponseMode],
+                            default: 'streaming',
+                            description: 'When and how to respond to the webhook',
+                            displayOptions: { show: { '/availableInChat': [true] } },
+                        },
+                    ],
+                },
+                {
+                    displayName: 'Options',
+                    name: 'options',
+                    type: 'collection',
+                    displayOptions: {
+                        show: {
+                            public: [false],
+                            '@version': [{ _cnd: { gte: 1.3 } }],
+                        },
+                    },
+                    placeholder: 'Add Field',
+                    default: {},
+                    options: [
+                        allowFileUploadsOption,
+                        allowedFileMimeTypeOption,
+                        {
+                            displayName: 'Response Mode',
+                            name: 'responseMode',
+                            type: 'options',
+                            options: [lastNodeResponseMode, respondNodesResponseMode, streamingResponseMode],
+                            default: 'lastNode',
+                            description: 'When and how to respond to the chat',
+                            displayOptions: { show: { '/availableInChat': [false] } },
+                        },
+                        {
+                            displayName: 'Response Mode',
+                            name: 'responseMode',
+                            type: 'options',
+                            options: [streamingResponseMode, lastNodeResponseMode, respondNodesResponseMode],
+                            default: 'streaming',
+                            description: 'When and how to respond to the chat',
+                            displayOptions: { show: { '/availableInChat': [true] } },
+                        },
+                    ],
+                },
+                {
+                    displayName: 'Options',
+                    name: 'options',
+                    type: 'collection',
+                    displayOptions: {
+                        show: {
+                            mode: ['hostedChat', 'webhook'],
+                            public: [true],
+                            '@version': [{ _cnd: { gte: 1.3 } }],
+                        },
+                    },
+                    placeholder: 'Add Field',
+                    default: {},
+                    options: [
+                        ...commonOptionsFields,
+                        {
+                            displayName: 'Response Mode',
+                            name: 'responseMode',
+                            type: 'options',
+                            options: [lastNodeResponseMode, streamingResponseMode, respondToWebhookResponseMode],
+                            default: 'lastNode',
+                            description: 'When and how to respond to the chat',
+                            displayOptions: { show: { '/mode': ['webhook'], '/availableInChat': [false] } },
+                        },
+                        {
+                            displayName: 'Response Mode',
+                            name: 'responseMode',
+                            type: 'options',
+                            options: [streamingResponseMode, lastNodeResponseMode],
+                            default: 'streaming',
+                            description: 'When and how to respond to the chat',
+                            displayOptions: { show: { '/mode': ['webhook'], '/availableInChat': [true] } },
+                        },
+                        {
+                            displayName: 'Response Mode',
+                            name: 'responseMode',
+                            type: 'options',
+                            options: [lastNodeResponseMode, streamingResponseMode, respondNodesResponseMode],
+                            default: 'lastNode',
+                            description: 'When and how to respond to the chat',
+                            displayOptions: { show: { '/mode': ['hostedChat'], '/availableInChat': [false] } },
+                        },
+                        {
+                            displayName: 'Response Mode',
+                            name: 'responseMode',
+                            type: 'options',
+                            options: [streamingResponseMode, lastNodeResponseMode, respondNodesResponseMode],
+                            default: 'streaming',
+                            description: 'When and how to respond to the chat',
+                            displayOptions: { show: { '/mode': ['hostedChat'], '/availableInChat': [true] } },
+                        },
+                    ],
+                },
+            ],
+        };
+    }
+    async handleFormData(context) {
+        const req = context.getRequestObject();
+        a.ok(req.contentType === 'multipart/form-data', 'Expected multipart/form-data');
+        const options = context.getNodeParameter('options', {});
+        const { data, files } = req.body;
+        const returnItem = {
+            json: data,
+        };
+        if (files && Object.keys(files).length) {
+            returnItem.json.files = [];
+            returnItem.binary = {};
+            const count = 0;
+            for (const fileKey of Object.keys(files)) {
+                const processedFiles = [];
+                if (Array.isArray(files[fileKey])) {
+                    processedFiles.push(...files[fileKey]);
+                }
+                else {
+                    processedFiles.push(files[fileKey]);
+                }
+                let fileIndex = 0;
+                for (const file of processedFiles) {
+                    let binaryPropertyName = 'data';
+                    if (binaryPropertyName.endsWith('[]')) {
+                        binaryPropertyName = binaryPropertyName.slice(0, -2);
+                    }
+                    if (options.binaryPropertyName) {
+                        binaryPropertyName = `${options.binaryPropertyName.toString()}${count}`;
+                    }
+                    const binaryFile = await context.nodeHelpers.copyBinaryFile(file.filepath, file.originalFilename ?? file.newFilename, file.mimetype);
+                    const binaryKey = `${binaryPropertyName}${fileIndex}`;
+                    const binaryInfo = {
+                        ...(0, pick_1.default)(binaryFile, ['fileName', 'fileSize', 'fileType', 'mimeType', 'fileExtension']),
+                        binaryKey,
+                    };
+                    returnItem.binary = Object.assign(returnItem.binary ?? {}, {
+                        [`${binaryKey}`]: binaryFile,
+                    });
+                    returnItem.json.files = [
+                        ...returnItem.json.files,
+                        binaryInfo,
+                    ];
+                    fileIndex += 1;
+                }
             }
-          }
         }
-      ],
-      webhooks: [
-        {
-          name: "setup",
-          httpMethod: "GET",
-          responseMode: "onReceived",
-          path: CHAT_TRIGGER_PATH_IDENTIFIER,
-          ndvHideUrl: true
-        },
-        {
-          name: "default",
-          httpMethod: "POST",
-          responseMode: '={{$parameter.options?.["responseMode"] ?? ($parameter.availableInChat ? "streaming" : "lastNode") }}',
-          path: CHAT_TRIGGER_PATH_IDENTIFIER,
-          ndvHideMethod: true,
-          ndvHideUrl: "={{ !$parameter.public }}"
+        return returnItem;
+    }
+    async webhook(ctx) {
+        const res = ctx.getResponseObject();
+        const isPublic = ctx.getNodeParameter('public', false);
+        (0, n8n_workflow_1.assertParamIsBoolean)('public', isPublic, ctx.getNode());
+        const nodeMode = ctx.getNodeParameter('mode', 'hostedChat');
+        (0, n8n_workflow_1.assertParamIsString)('mode', nodeMode, ctx.getNode());
+        if (!isPublic) {
+            res.status(404).end();
+            return {
+                noWebhookResponse: true,
+            };
         }
-      ],
-      eventTriggerDescription: "Waiting for you to submit the chat",
-      activationMessage: "You can now make calls to your production chat URL.",
-      triggerPanel: false,
-      properties: [
-        /**
-         * @note If we change this property, also update it in ChatEmbedModal.vue
-         */
-        {
-          displayName: "Make Chat Publicly Available",
-          name: "public",
-          type: "boolean",
-          default: false,
-          description: "Whether the chat should be publicly available or only accessible through the manual chat interface"
-        },
-        {
-          displayName: "Mode",
-          name: "mode",
-          type: "options",
-          options: [
-            {
-              name: "Hosted Chat",
-              value: "hostedChat",
-              description: "Chat on a page served by n8n"
-            },
-            {
-              name: "Embedded Chat",
-              value: "webhook",
-              description: "Chat through a widget embedded in another page, or by calling a webhook"
-            }
-          ],
-          default: "hostedChat",
-          displayOptions: {
-            show: {
-              public: [true]
-            }
-          }
-        },
-        {
-          displayName: "Chat will be live at the URL above once this workflow is published. Live executions will show up in the \u2018executions\u2019 tab",
-          name: "hostedChatNotice",
-          type: "notice",
-          displayOptions: {
-            show: {
-              mode: ["hostedChat"],
-              public: [true]
-            }
-          },
-          default: ""
-        },
-        {
-          displayName: 'Follow the instructions <a href="https://www.npmjs.com/package/@n8n/chat" target="_blank">here</a> to embed chat in a webpage (or just call the webhook URL at the top of this section). Chat will be live once you publish this workflow',
-          name: "embeddedChatNotice",
-          type: "notice",
-          displayOptions: {
-            show: {
-              mode: ["webhook"],
-              public: [true]
-            }
-          },
-          default: ""
-        },
-        {
-          displayName: "Authentication",
-          name: "authentication",
-          type: "options",
-          displayOptions: {
-            show: {
-              public: [true]
-            }
-          },
-          options: [
-            {
-              name: "Basic Auth",
-              value: "basicAuth",
-              description: "Simple username and password (the same one for all users)"
-            },
-            {
-              // eslint-disable-next-line n8n-nodes-base/node-param-display-name-miscased
-              name: "n8n User Auth",
-              value: "n8nUserAuth",
-              description: "Require user to be logged in with their n8n account"
-            },
-            {
-              name: "None",
-              value: "none"
-            }
-          ],
-          default: "none",
-          description: "The way to authenticate"
-        },
-        {
-          displayName: "Initial Message(s)",
-          name: "initialMessages",
-          type: "string",
-          displayOptions: {
-            show: {
-              mode: ["hostedChat"],
-              public: [true]
-            }
-          },
-          typeOptions: {
-            rows: 3
-          },
-          default: "Hi there! \u{1F44B}\nMy name is Nathan. How can I assist you today?",
-          description: "Default messages shown at the start of the chat, one per line"
-        },
-        {
-          // eslint-disable-next-line n8n-nodes-base/node-param-display-name-miscased
-          displayName: "Make Available in n8n Chat",
-          name: "availableInChat",
-          type: "boolean",
-          default: false,
-          noDataExpression: true,
-          description: "Whether to make the agent available in n8n Chat"
-        },
-        {
-          displayName: "Your Chat Trigger node is out of date. To update, delete this node and insert a new Chat Trigger node.",
-          name: "availableInChatNotice",
-          type: "notice",
-          displayOptions: {
-            show: {
-              availableInChat: [true],
-              "@version": [{ _cnd: { lt: 1.2 } }]
-            }
-          },
-          default: ""
-        },
-        {
-          displayName: 'Your n8n users will be able to use this agent in <a href="/home/chat/" target="_blank">Chat</a> once this workflow is published. Make sure to share this workflow with at least Project Chat User access to all users who should use it.',
-          name: "availableInChatNotice",
-          type: "notice",
-          displayOptions: {
-            show: {
-              availableInChat: [true],
-              "@version": [{ _cnd: { gte: 1.2 } }]
-            }
-          },
-          default: ""
-        },
-        {
-          displayName: "Agent Icon",
-          name: "agentIcon",
-          type: "icon",
-          default: { type: "icon", value: "bot" },
-          noDataExpression: true,
-          description: "The icon of the agent on n8n Chat",
-          displayOptions: {
-            show: {
-              availableInChat: [true],
-              "@version": [{ _cnd: { gte: 1.2 } }]
-            }
-          }
-        },
-        {
-          displayName: "Agent Name",
-          name: "agentName",
-          type: "string",
-          default: "",
-          noDataExpression: true,
-          description: "The name of the agent on n8n Chat. Name of the workflow is used if left empty.",
-          displayOptions: {
-            show: {
-              availableInChat: [true],
-              "@version": [{ _cnd: { gte: 1.2 } }]
-            }
-          }
-        },
-        {
-          displayName: "Agent Description",
-          name: "agentDescription",
-          type: "string",
-          typeOptions: {
-            rows: 2
-          },
-          default: "",
-          noDataExpression: true,
-          description: "The description of the agent on n8n Chat",
-          displayOptions: {
-            show: {
-              availableInChat: [true],
-              "@version": [{ _cnd: { gte: 1.2 } }]
-            }
-          }
-        },
-        {
-          displayName: "Options",
-          name: "options",
-          type: "collection",
-          displayOptions: {
-            show: {
-              public: [false],
-              "@version": [1, 1.1]
-            }
-          },
-          placeholder: "Add Field",
-          default: {},
-          options: [allowFileUploadsOption, allowedFileMimeTypeOption]
-        },
-        // Options for versions 1.0 and 1.1 (without streaming)
-        {
-          displayName: "Options",
-          name: "options",
-          type: "collection",
-          displayOptions: {
-            show: {
-              mode: ["hostedChat", "webhook"],
-              public: [true],
-              "@version": [1, 1.1]
-            }
-          },
-          placeholder: "Add Field",
-          default: {},
-          options: [
-            ...commonOptionsFields,
-            {
-              displayName: "Response Mode",
-              name: "responseMode",
-              type: "options",
-              options: [lastNodeResponseMode, respondToWebhookResponseMode],
-              default: "lastNode",
-              description: "When and how to respond to the webhook"
-            }
-          ]
-        },
-        // Options for version 1.2 (with streaming)
-        {
-          displayName: "Options",
-          name: "options",
-          type: "collection",
-          displayOptions: {
-            show: {
-              mode: ["hostedChat", "webhook"],
-              public: [true],
-              "@version": [1.2]
+        const availableInChat = ctx.getNodeParameter('availableInChat', false);
+        const options = ctx.getNodeParameter('options', {});
+        (0, n8n_workflow_1.validateNodeParameters)(options, {
+            getStarted: { type: 'string' },
+            inputPlaceholder: { type: 'string' },
+            loadPreviousSession: { type: 'string' },
+            showWelcomeScreen: { type: 'boolean' },
+            subtitle: { type: 'string' },
+            title: { type: 'string' },
+            allowFileUploads: { type: 'boolean' },
+            allowedFilesMimeTypes: { type: 'string' },
+            customCss: { type: 'string' },
+            responseMode: { type: 'string' },
+        }, ctx.getNode());
+        const loadPreviousSession = options.loadPreviousSession;
+        (0, types_1.assertValidLoadPreviousSessionOption)(loadPreviousSession, ctx.getNode());
+        const enableStreaming = availableInChat
+            ? !options.responseMode || options.responseMode === 'streaming'
+            : options.responseMode === 'streaming';
+        const req = ctx.getRequestObject();
+        const webhookName = ctx.getWebhookName();
+        const mode = ctx.getMode() === 'manual' ? 'test' : 'production';
+        const bodyData = ctx.getBodyData() ?? {};
+        try {
+            await (0, GenericFunctions_1.validateAuth)(ctx);
+        }
+        catch (error) {
+            if (error) {
+                res.writeHead(error.responseCode, {
+                    'www-authenticate': 'Basic realm="Webhook"',
+                });
+                res.end(error.message);
+                return { noWebhookResponse: true };
             }
-          },
-          placeholder: "Add Field",
-          default: {},
-          options: [
-            ...commonOptionsFields,
-            {
-              displayName: "Response Mode",
-              name: "responseMode",
-              type: "options",
-              options: [lastNodeResponseMode, respondToWebhookResponseMode, streamingResponseMode],
-              default: "lastNode",
-              description: "When and how to respond to the webhook",
-              displayOptions: { show: { "/availableInChat": [false] } }
-            },
-            {
-              displayName: "Response Mode",
-              name: "responseMode",
-              type: "options",
-              options: [streamingResponseMode, lastNodeResponseMode],
-              default: "streaming",
-              description: "When and how to respond to the webhook",
-              displayOptions: { show: { "/availableInChat": [true] } }
+            throw error;
+        }
+        if (nodeMode === 'hostedChat') {
+            if (webhookName === 'setup') {
+                const webhookUrlRaw = ctx.getNodeWebhookUrl('default');
+                if (!webhookUrlRaw) {
+                    throw new n8n_workflow_1.NodeOperationError(ctx.getNode(), 'Default webhook url not set');
+                }
+                const webhookUrl = mode === 'test' ? webhookUrlRaw.replace('/webhook', '/webhook-test') : webhookUrlRaw;
+                const authentication = ctx.getNodeParameter('authentication');
+                const initialMessagesRaw = ctx.getNodeParameter('initialMessages', '');
+                (0, n8n_workflow_1.assertParamIsString)('initialMessage', initialMessagesRaw, ctx.getNode());
+                const instanceId = ctx.getInstanceId();
+                const i18nConfig = {};
+                const keys = ['getStarted', 'inputPlaceholder', 'subtitle', 'title'];
+                for (const key of keys) {
+                    if (options[key] !== undefined) {
+                        i18nConfig[key] = options[key];
+                    }
+                }
+                const page = (0, templates_1.createPage)({
+                    i18n: {
+                        en: i18nConfig,
+                    },
+                    showWelcomeScreen: options.showWelcomeScreen,
+                    loadPreviousSession,
+                    initialMessages: initialMessagesRaw,
+                    webhookUrl,
+                    mode,
+                    instanceId,
+                    authentication,
+                    allowFileUploads: options.allowFileUploads,
+                    allowedFilesMimeTypes: options.allowedFilesMimeTypes,
+                    customCss: options.customCss,
+                    enableStreaming,
+                });
+                res.status(200).send(page).end();
+                return {
+                    noWebhookResponse: true,
+                };
             }
-          ]
-        },
-        {
-          displayName: "Options",
-          name: "options",
-          type: "collection",
-          displayOptions: {
-            show: {
-              public: [false],
-              "@version": [{ _cnd: { gte: 1.3 } }]
+        }
+        if (bodyData.action === 'loadPreviousSession') {
+            if (options?.loadPreviousSession === 'memory') {
+                const memory = (await ctx.getInputConnectionData(n8n_workflow_1.NodeConnectionTypes.AiMemory, 0));
+                const messages = ((await memory?.chatHistory.getMessages()) ?? [])
+                    .filter((message) => !message?.additional_kwargs?.hideFromUI)
+                    .map((message) => message?.toJSON());
+                return {
+                    webhookResponse: { data: messages },
+                };
             }
-          },
-          placeholder: "Add Field",
-          default: {},
-          options: [
-            allowFileUploadsOption,
-            allowedFileMimeTypeOption,
-            {
-              displayName: "Response Mode",
-              name: "responseMode",
-              type: "options",
-              options: [lastNodeResponseMode, respondNodesResponseMode, streamingResponseMode],
-              default: "lastNode",
-              description: "When and how to respond to the chat",
-              displayOptions: { show: { "/availableInChat": [false] } }
-            },
-            {
-              displayName: "Response Mode",
-              name: "responseMode",
-              type: "options",
-              options: [streamingResponseMode, lastNodeResponseMode, respondNodesResponseMode],
-              default: "streaming",
-              description: "When and how to respond to the chat",
-              displayOptions: { show: { "/availableInChat": [true] } }
+            else if (!options?.loadPreviousSession || options?.loadPreviousSession === 'notSupported') {
+                return {
+                    webhookResponse: { data: [] },
+                };
             }
-          ]
-        },
-        {
-          displayName: "Options",
-          name: "options",
-          type: "collection",
-          displayOptions: {
-            show: {
-              mode: ["hostedChat", "webhook"],
-              public: [true],
-              "@version": [{ _cnd: { gte: 1.3 } }]
+        }
+        let returnData;
+        const webhookResponse = { status: 200 };
+        if (enableStreaming) {
+            res.writeHead(200, {
+                'Content-Type': 'application/json; charset=utf-8',
+                'Transfer-Encoding': 'chunked',
+                'Cache-Control': 'no-cache',
+                Connection: 'keep-alive',
+            });
+            res.flushHeaders();
+            if (req.contentType === 'multipart/form-data') {
+                returnData = [await this.handleFormData(ctx)];
             }
-          },
-          placeholder: "Add Field",
-          default: {},
-          options: [
-            ...commonOptionsFields,
-            {
-              displayName: "Response Mode",
-              name: "responseMode",
-              type: "options",
-              options: [lastNodeResponseMode, streamingResponseMode, respondToWebhookResponseMode],
-              default: "lastNode",
-              description: "When and how to respond to the chat",
-              displayOptions: { show: { "/mode": ["webhook"], "/availableInChat": [false] } }
-            },
-            {
-              displayName: "Response Mode",
-              name: "responseMode",
-              type: "options",
-              options: [streamingResponseMode, lastNodeResponseMode],
-              default: "streaming",
-              description: "When and how to respond to the chat",
-              displayOptions: { show: { "/mode": ["webhook"], "/availableInChat": [true] } }
-            },
-            {
-              displayName: "Response Mode",
-              name: "responseMode",
-              type: "options",
-              options: [lastNodeResponseMode, streamingResponseMode, respondNodesResponseMode],
-              default: "lastNode",
-              description: "When and how to respond to the chat",
-              displayOptions: { show: { "/mode": ["hostedChat"], "/availableInChat": [false] } }
-            },
-            {
-              displayName: "Response Mode",
-              name: "responseMode",
-              type: "options",
-              options: [streamingResponseMode, lastNodeResponseMode, respondNodesResponseMode],
-              default: "streaming",
-              description: "When and how to respond to the chat",
-              displayOptions: { show: { "/mode": ["hostedChat"], "/availableInChat": [true] } }
+            else {
+                returnData = [{ json: bodyData }];
             }
-          ]
-        }
-      ]
-    };
-  }
-  async handleFormData(context) {
-    const req = context.getRequestObject();
-    a.ok(req.contentType === "multipart/form-data", "Expected multipart/form-data");
-    const options = context.getNodeParameter("options", {});
-    const { data, files } = req.body;
-    const returnItem = {
-      json: data
-    };
-    if (files && Object.keys(files).length) {
-      returnItem.json.files = [];
-      returnItem.binary = {};
-      const count = 0;
-      for (const fileKey of Object.keys(files)) {
-        const processedFiles = [];
-        if (Array.isArray(files[fileKey])) {
-          processedFiles.push(...files[fileKey]);
-        } else {
-          processedFiles.push(files[fileKey]);
+            return {
+                workflowData: [ctx.helpers.returnJsonArray(returnData)],
+                noWebhookResponse: true,
+            };
         }
-        let fileIndex = 0;
-        for (const file of processedFiles) {
-          let binaryPropertyName = "data";
-          if (binaryPropertyName.endsWith("[]")) {
-            binaryPropertyName = binaryPropertyName.slice(0, -2);
-          }
-          if (options.binaryPropertyName) {
-            binaryPropertyName = `${options.binaryPropertyName.toString()}${count}`;
-          }
-          const binaryFile = await context.nodeHelpers.copyBinaryFile(
-            file.filepath,
-            file.originalFilename ?? file.newFilename,
-            file.mimetype
-          );
-          const binaryKey = `${binaryPropertyName}${fileIndex}`;
-          const binaryInfo = {
-            ...(0, import_pick.default)(binaryFile, ["fileName", "fileSize", "fileType", "mimeType", "fileExtension"]),
-            binaryKey
-          };
-          returnItem.binary = Object.assign(returnItem.binary ?? {}, {
-            [`${binaryKey}`]: binaryFile
-          });
-          returnItem.json.files = [
-            ...returnItem.json.files,
-            binaryInfo
-          ];
-          fileIndex += 1;
-        }
-      }
-    }
-    return returnItem;
-  }
-  async webhook(ctx) {
-    const res = ctx.getResponseObject();
-    const isPublic = ctx.getNodeParameter("public", false);
-    (0, import_n8n_workflow.assertParamIsBoolean)("public", isPublic, ctx.getNode());
-    const nodeMode = ctx.getNodeParameter("mode", "hostedChat");
-    (0, import_n8n_workflow.assertParamIsString)("mode", nodeMode, ctx.getNode());
-    if (!isPublic) {
-      res.status(404).end();
-      return {
-        noWebhookResponse: true
-      };
-    }
-    const availableInChat = ctx.getNodeParameter("availableInChat", false);
-    const options = ctx.getNodeParameter("options", {});
-    (0, import_n8n_workflow.validateNodeParameters)(
-      options,
-      {
-        getStarted: { type: "string" },
-        inputPlaceholder: { type: "string" },
-        loadPreviousSession: { type: "string" },
-        showWelcomeScreen: { type: "boolean" },
-        subtitle: { type: "string" },
-        title: { type: "string" },
-        allowFileUploads: { type: "boolean" },
-        allowedFilesMimeTypes: { type: "string" },
-        customCss: { type: "string" },
-        responseMode: { type: "string" }
-      },
-      ctx.getNode()
-    );
-    const loadPreviousSession = options.loadPreviousSession;
-    (0, import_types.assertValidLoadPreviousSessionOption)(loadPreviousSession, ctx.getNode());
-    const enableStreaming = availableInChat ? !options.responseMode || options.responseMode === "streaming" : options.responseMode === "streaming";
-    const req = ctx.getRequestObject();
-    const webhookName = ctx.getWebhookName();
-    const mode = ctx.getMode() === "manual" ? "test" : "production";
-    const bodyData = ctx.getBodyData() ?? {};
-    try {
-      await (0, import_GenericFunctions.validateAuth)(ctx);
-    } catch (error) {
-      if (error) {
-        res.writeHead(error.responseCode, {
-          "www-authenticate": 'Basic realm="Webhook"'
-        });
-        res.end(error.message);
-        return { noWebhookResponse: true };
-      }
-      throw error;
-    }
-    if (nodeMode === "hostedChat") {
-      if (webhookName === "setup") {
-        const webhookUrlRaw = ctx.getNodeWebhookUrl("default");
-        if (!webhookUrlRaw) {
-          throw new import_n8n_workflow.NodeOperationError(ctx.getNode(), "Default webhook url not set");
+        if (req.contentType === 'multipart/form-data') {
+            returnData = [await this.handleFormData(ctx)];
+            return {
+                webhookResponse,
+                workflowData: [returnData],
+            };
         }
-        const webhookUrl = mode === "test" ? webhookUrlRaw.replace("/webhook", "/webhook-test") : webhookUrlRaw;
-        const authentication = ctx.getNodeParameter("authentication");
-        const initialMessagesRaw = ctx.getNodeParameter("initialMessages", "");
-        (0, import_n8n_workflow.assertParamIsString)("initialMessage", initialMessagesRaw, ctx.getNode());
-        const instanceId = ctx.getInstanceId();
-        const i18nConfig = {};
-        const keys = ["getStarted", "inputPlaceholder", "subtitle", "title"];
-        for (const key of keys) {
-          if (options[key] !== void 0) {
-            i18nConfig[key] = options[key];
-          }
+        else {
+            returnData = [{ json: bodyData }];
         }
-        const page = (0, import_templates.createPage)({
-          i18n: {
-            en: i18nConfig
-          },
-          showWelcomeScreen: options.showWelcomeScreen,
-          loadPreviousSession,
-          initialMessages: initialMessagesRaw,
-          webhookUrl,
-          mode,
-          instanceId,
-          authentication,
-          allowFileUploads: options.allowFileUploads,
-          allowedFilesMimeTypes: options.allowedFilesMimeTypes,
-          customCss: options.customCss,
-          enableStreaming
-        });
-        res.status(200).send(page).end();
         return {
-          noWebhookResponse: true
+            webhookResponse,
+            workflowData: [ctx.helpers.returnJsonArray(returnData)],
         };
-      }
     }
-    if (bodyData.action === "loadPreviousSession") {
-      if (options?.loadPreviousSession === "memory") {
-        const memory = await ctx.getInputConnectionData(import_n8n_workflow.NodeConnectionTypes.AiMemory, 0);
-        const messages = (await memory?.chatHistory.getMessages() ?? []).filter((message) => !message?.additional_kwargs?.hideFromUI).map((message) => message?.toJSON());
-        return {
-          webhookResponse: { data: messages }
-        };
-      } else if (!options?.loadPreviousSession || options?.loadPreviousSession === "notSupported") {
-        return {
-          webhookResponse: { data: [] }
-        };
-      }
-    }
-    let returnData;
-    const webhookResponse = { status: 200 };
-    if (enableStreaming) {
-      res.writeHead(200, {
-        "Content-Type": "application/json; charset=utf-8",
-        "Transfer-Encoding": "chunked",
-        "Cache-Control": "no-cache",
-        Connection: "keep-alive"
-      });
-      res.flushHeaders();
-      if (req.contentType === "multipart/form-data") {
-        returnData = [await this.handleFormData(ctx)];
-      } else {
-        returnData = [{ json: bodyData }];
-      }
-      return {
-        workflowData: [ctx.helpers.returnJsonArray(returnData)],
-        noWebhookResponse: true
-      };
-    }
-    if (req.contentType === "multipart/form-data") {
-      returnData = [await this.handleFormData(ctx)];
-      return {
-        webhookResponse,
-        workflowData: [returnData]
-      };
-    } else {
-      returnData = [{ json: bodyData }];
-    }
-    return {
-      webhookResponse,
-      workflowData: [ctx.helpers.returnJsonArray(returnData)]
-    };
-  }
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  ChatTrigger
-});
+exports.ChatTrigger = ChatTrigger;
 //# sourceMappingURL=ChatTrigger.node.js.map