@n8n/n8n-nodes-langchain 1.85.3 → 1.87.0

package/dist/nodes/tools/ToolHttpRequest/utils.js

@@ -1,621 +1,657 @@
 "use strict";
-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;
+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 utils_exports = {};
+__export(utils_exports, {
+  configureHttpRequestFunction: () => configureHttpRequestFunction,
+  configureResponseOptimizer: () => configureResponseOptimizer,
+  configureToolFunction: () => configureToolFunction,
+  extractParametersFromText: () => extractParametersFromText,
+  makeToolInputSchema: () => makeToolInputSchema,
+  prepareToolDescription: () => prepareToolDescription,
+  updateParametersAndOptions: () => updateParametersAndOptions
 });
-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);
+module.exports = __toCommonJS(utils_exports);
+var import_readability = require("@mozilla/readability");
+var cheerio = __toESM(require("cheerio"));
+var import_html_to_text = require("html-to-text");
+var import_jsdom = require("jsdom");
+var import_get = __toESM(require("lodash/get"));
+var import_set = __toESM(require("lodash/set"));
+var import_unset = __toESM(require("lodash/unset"));
+var import_GenericFunctions = require("n8n-nodes-base/dist/nodes/HttpRequest/GenericFunctions");
+var import_n8n_workflow = require("n8n-workflow");
+var import_zod = require("zod");
+const genericCredentialRequest = async (ctx, itemIndex) => {
+  const genericType = ctx.getNodeParameter("genericAuthType", itemIndex);
+  if (genericType === "httpBasicAuth" || genericType === "httpDigestAuth") {
+    const basicAuth = await ctx.getCredentials("httpBasicAuth", itemIndex);
+    const sendImmediately = genericType === "httpDigestAuth" ? false : void 0;
+    return async (options) => {
+      options.auth = {
+        username: basicAuth.user,
+        password: basicAuth.password,
+        sendImmediately
+      };
+      return await ctx.helpers.httpRequest(options);
     };
-    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;
+  }
+  if (genericType === "httpHeaderAuth") {
+    const headerAuth = await ctx.getCredentials("httpHeaderAuth", itemIndex);
+    return async (options) => {
+      if (!options.headers) options.headers = {};
+      options.headers[headerAuth.name] = headerAuth.value;
+      return await ctx.helpers.httpRequest(options);
     };
-})();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.configureToolFunction = exports.prepareToolDescription = exports.updateParametersAndOptions = exports.extractParametersFromText = exports.configureResponseOptimizer = exports.configureHttpRequestFunction = void 0;
-exports.makeToolInputSchema = makeToolInputSchema;
-const readability_1 = require("@mozilla/readability");
-const cheerio = __importStar(require("cheerio"));
-const html_to_text_1 = require("html-to-text");
-const jsdom_1 = require("jsdom");
-const get_1 = __importDefault(require("lodash/get"));
-const set_1 = __importDefault(require("lodash/set"));
-const unset_1 = __importDefault(require("lodash/unset"));
-const GenericFunctions_1 = require("n8n-nodes-base/dist/nodes/HttpRequest/GenericFunctions");
-const n8n_workflow_1 = require("n8n-workflow");
-const zod_1 = require("zod");
-const genericCredentialRequest = async (ctx, itemIndex) => {
-    const genericType = ctx.getNodeParameter('genericAuthType', itemIndex);
-    if (genericType === 'httpBasicAuth' || genericType === 'httpDigestAuth') {
-        const basicAuth = await ctx.getCredentials('httpBasicAuth', itemIndex);
-        const sendImmediately = genericType === 'httpDigestAuth' ? false : undefined;
-        return async (options) => {
-            options.auth = {
-                username: basicAuth.user,
-                password: basicAuth.password,
-                sendImmediately,
-            };
-            return await ctx.helpers.httpRequest(options);
-        };
-    }
-    if (genericType === 'httpHeaderAuth') {
-        const headerAuth = await ctx.getCredentials('httpHeaderAuth', itemIndex);
-        return async (options) => {
-            if (!options.headers)
-                options.headers = {};
-            options.headers[headerAuth.name] = headerAuth.value;
-            return await ctx.helpers.httpRequest(options);
-        };
-    }
-    if (genericType === 'httpQueryAuth') {
-        const queryAuth = await ctx.getCredentials('httpQueryAuth', itemIndex);
-        return async (options) => {
-            if (!options.qs)
-                options.qs = {};
-            options.qs[queryAuth.name] = queryAuth.value;
-            return await ctx.helpers.httpRequest(options);
-        };
-    }
-    if (genericType === 'httpCustomAuth') {
-        const customAuth = await ctx.getCredentials('httpCustomAuth', itemIndex);
-        return async (options) => {
-            const auth = (0, n8n_workflow_1.jsonParse)(customAuth.json || '{}', {
-                errorMessage: 'Invalid Custom Auth JSON',
-            });
-            if (auth.headers) {
-                options.headers = { ...options.headers, ...auth.headers };
-            }
-            if (auth.body) {
-                options.body = { ...options.body, ...auth.body };
-            }
-            if (auth.qs) {
-                options.qs = { ...options.qs, ...auth.qs };
-            }
-            return await ctx.helpers.httpRequest(options);
-        };
-    }
-    if (genericType === 'oAuth1Api') {
-        return async (options) => {
-            return await ctx.helpers.requestOAuth1.call(ctx, 'oAuth1Api', options);
-        };
-    }
-    if (genericType === 'oAuth2Api') {
-        return async (options) => {
-            return await ctx.helpers.requestOAuth2.call(ctx, 'oAuth1Api', options, {
-                tokenType: 'Bearer',
-            });
-        };
-    }
-    throw new n8n_workflow_1.NodeOperationError(ctx.getNode(), `The type ${genericType} is not supported`, {
-        itemIndex,
-    });
-};
-const predefinedCredentialRequest = async (ctx, itemIndex) => {
-    const predefinedType = ctx.getNodeParameter('nodeCredentialType', itemIndex);
-    const additionalOptions = (0, GenericFunctions_1.getOAuth2AdditionalParameters)(predefinedType);
+  }
+  if (genericType === "httpQueryAuth") {
+    const queryAuth = await ctx.getCredentials("httpQueryAuth", itemIndex);
+    return async (options) => {
+      if (!options.qs) options.qs = {};
+      options.qs[queryAuth.name] = queryAuth.value;
+      return await ctx.helpers.httpRequest(options);
+    };
+  }
+  if (genericType === "httpCustomAuth") {
+    const customAuth = await ctx.getCredentials("httpCustomAuth", itemIndex);
+    return async (options) => {
+      const auth = (0, import_n8n_workflow.jsonParse)(customAuth.json || "{}", {
+        errorMessage: "Invalid Custom Auth JSON"
+      });
+      if (auth.headers) {
+        options.headers = { ...options.headers, ...auth.headers };
+      }
+      if (auth.body) {
+        options.body = { ...options.body, ...auth.body };
+      }
+      if (auth.qs) {
+        options.qs = { ...options.qs, ...auth.qs };
+      }
+      return await ctx.helpers.httpRequest(options);
+    };
+  }
+  if (genericType === "oAuth1Api") {
+    return async (options) => {
+      return await ctx.helpers.requestOAuth1.call(ctx, "oAuth1Api", options);
+    };
+  }
+  if (genericType === "oAuth2Api") {
     return async (options) => {
-        return await ctx.helpers.httpRequestWithAuthentication.call(ctx, predefinedType, options, additionalOptions && { oauth2: additionalOptions });
+      return await ctx.helpers.requestOAuth2.call(ctx, "oAuth2Api", options, {
+        tokenType: "Bearer"
+      });
     };
+  }
+  throw new import_n8n_workflow.NodeOperationError(ctx.getNode(), `The type ${genericType} is not supported`, {
+    itemIndex
+  });
+};
+const predefinedCredentialRequest = async (ctx, itemIndex) => {
+  const predefinedType = ctx.getNodeParameter("nodeCredentialType", itemIndex);
+  const additionalOptions = (0, import_GenericFunctions.getOAuth2AdditionalParameters)(predefinedType);
+  return async (options) => {
+    return await ctx.helpers.httpRequestWithAuthentication.call(
+      ctx,
+      predefinedType,
+      options,
+      additionalOptions && { oauth2: additionalOptions }
+    );
+  };
 };
 const configureHttpRequestFunction = async (ctx, credentialsType, itemIndex) => {
-    switch (credentialsType) {
-        case 'genericCredentialType':
-            return await genericCredentialRequest(ctx, itemIndex);
-        case 'predefinedCredentialType':
-            return await predefinedCredentialRequest(ctx, itemIndex);
-        default:
-            return async (options) => {
-                return await ctx.helpers.httpRequest(options);
-            };
-    }
+  switch (credentialsType) {
+    case "genericCredentialType":
+      return await genericCredentialRequest(ctx, itemIndex);
+    case "predefinedCredentialType":
+      return await predefinedCredentialRequest(ctx, itemIndex);
+    default:
+      return async (options) => {
+        return await ctx.helpers.httpRequest(options);
+      };
+  }
 };
-exports.configureHttpRequestFunction = configureHttpRequestFunction;
 const defaultOptimizer = (response) => {
-    if (typeof response === 'string') {
-        return response;
-    }
-    if (typeof response === 'object') {
-        return JSON.stringify(response, null, 2);
-    }
-    return String(response);
+  if (typeof response === "string") {
+    return response;
+  }
+  if (typeof response === "object") {
+    return JSON.stringify(response, null, 2);
+  }
+  return String(response);
 };
 function isBinary(data) {
-    if (Buffer.isBuffer(data)) {
-        return true;
-    }
-    if (typeof data === 'string') {
-        if (data.includes('\0')) {
-            return true;
-        }
-        return false;
+  if (Buffer.isBuffer(data)) {
+    return true;
+  }
+  if (typeof data === "string") {
+    if (data.includes("\0")) {
+      return true;
     }
     return false;
+  }
+  return false;
 }
 const htmlOptimizer = (ctx, itemIndex, maxLength) => {
-    const cssSelector = ctx.getNodeParameter('cssSelector', itemIndex, '');
-    const onlyContent = ctx.getNodeParameter('onlyContent', itemIndex, false);
-    let elementsToOmit = [];
-    if (onlyContent) {
-        const elementsToOmitUi = ctx.getNodeParameter('elementsToOmit', itemIndex, '');
-        if (typeof elementsToOmitUi === 'string') {
-            elementsToOmit = elementsToOmitUi
-                .split(',')
-                .filter((s) => s)
-                .map((s) => s.trim());
-        }
+  const cssSelector = ctx.getNodeParameter("cssSelector", itemIndex, "");
+  const onlyContent = ctx.getNodeParameter("onlyContent", itemIndex, false);
+  let elementsToOmit = [];
+  if (onlyContent) {
+    const elementsToOmitUi = ctx.getNodeParameter("elementsToOmit", itemIndex, "");
+    if (typeof elementsToOmitUi === "string") {
+      elementsToOmit = elementsToOmitUi.split(",").filter((s) => s).map((s) => s.trim());
     }
-    return (response) => {
-        if (typeof response !== 'string') {
-            throw new n8n_workflow_1.NodeOperationError(ctx.getNode(), `The response type must be a string. Received: ${typeof response}`, { itemIndex });
-        }
-        const returnData = [];
-        const html = cheerio.load(response);
-        const htmlElements = html(cssSelector);
-        htmlElements.each((_, el) => {
-            let value = html(el).html() || '';
-            if (onlyContent) {
-                let htmlToTextOptions;
-                if (elementsToOmit?.length) {
-                    htmlToTextOptions = {
-                        selectors: elementsToOmit.map((selector) => ({
-                            selector,
-                            format: 'skip',
-                        })),
-                    };
-                }
-                value = (0, html_to_text_1.convert)(value, htmlToTextOptions);
-            }
-            value = value
-                .trim()
-                .replace(/^\s+|\s+$/g, '')
-                .replace(/(\r\n|\n|\r)/gm, '')
-                .replace(/\s+/g, ' ');
-            returnData.push(value);
-        });
-        const text = JSON.stringify(returnData, null, 2);
-        if (maxLength > 0 && text.length > maxLength) {
-            return text.substring(0, maxLength);
+  }
+  return (response) => {
+    if (typeof response !== "string") {
+      throw new import_n8n_workflow.NodeOperationError(
+        ctx.getNode(),
+        `The response type must be a string. Received: ${typeof response}`,
+        { itemIndex }
+      );
+    }
+    const returnData = [];
+    const html = cheerio.load(response);
+    const htmlElements = html(cssSelector);
+    htmlElements.each((_, el) => {
+      let value = html(el).html() || "";
+      if (onlyContent) {
+        let htmlToTextOptions;
+        if (elementsToOmit?.length) {
+          htmlToTextOptions = {
+            selectors: elementsToOmit.map((selector) => ({
+              selector,
+              format: "skip"
+            }))
+          };
         }
-        return text;
-    };
+        value = (0, import_html_to_text.convert)(value, htmlToTextOptions);
+      }
+      value = value.trim().replace(/^\s+|\s+$/g, "").replace(/(\r\n|\n|\r)/gm, "").replace(/\s+/g, " ");
+      returnData.push(value);
+    });
+    const text = JSON.stringify(returnData, null, 2);
+    if (maxLength > 0 && text.length > maxLength) {
+      return text.substring(0, maxLength);
+    }
+    return text;
+  };
 };
 const textOptimizer = (ctx, itemIndex, maxLength) => {
-    return (response) => {
-        if (typeof response === 'object') {
-            try {
-                response = JSON.stringify(response, null, 2);
-            }
-            catch (error) { }
-        }
-        if (typeof response !== 'string') {
-            throw new n8n_workflow_1.NodeOperationError(ctx.getNode(), `The response type must be a string. Received: ${typeof response}`, { itemIndex });
-        }
-        const dom = new jsdom_1.JSDOM(response);
-        const article = new readability_1.Readability(dom.window.document, {
-            keepClasses: true,
-        }).parse();
-        const text = article?.textContent || '';
-        if (maxLength > 0 && text.length > maxLength) {
-            return text.substring(0, maxLength);
-        }
-        return text;
-    };
+  return (response) => {
+    if (typeof response === "object") {
+      try {
+        response = JSON.stringify(response, null, 2);
+      } catch (error) {
+      }
+    }
+    if (typeof response !== "string") {
+      throw new import_n8n_workflow.NodeOperationError(
+        ctx.getNode(),
+        `The response type must be a string. Received: ${typeof response}`,
+        { itemIndex }
+      );
+    }
+    const dom = new import_jsdom.JSDOM(response);
+    const article = new import_readability.Readability(dom.window.document, {
+      keepClasses: true
+    }).parse();
+    const text = article?.textContent || "";
+    if (maxLength > 0 && text.length > maxLength) {
+      return text.substring(0, maxLength);
+    }
+    return text;
+  };
 };
 const jsonOptimizer = (ctx, itemIndex) => {
-    return (response) => {
-        let responseData = response;
-        if (typeof responseData === 'string') {
-            responseData = (0, n8n_workflow_1.jsonParse)(response);
-        }
-        if (typeof responseData !== 'object' || !responseData) {
-            throw new n8n_workflow_1.NodeOperationError(ctx.getNode(), 'The response type must be an object or an array of objects', { itemIndex });
-        }
-        const dataField = ctx.getNodeParameter('dataField', itemIndex, '');
-        let returnData = [];
-        if (!Array.isArray(responseData)) {
-            if (dataField) {
-                const data = responseData[dataField];
-                if (Array.isArray(data)) {
-                    responseData = data;
-                }
-                else {
-                    responseData = [data];
-                }
-            }
-            else {
-                responseData = [responseData];
-            }
-        }
-        else {
-            if (dataField) {
-                responseData = responseData.map((data) => data[dataField]);
-            }
-        }
-        const fieldsToInclude = ctx.getNodeParameter('fieldsToInclude', itemIndex, 'all');
-        let fields = [];
-        if (fieldsToInclude !== 'all') {
-            fields = ctx.getNodeParameter('fields', itemIndex, []);
-            if (typeof fields === 'string') {
-                fields = fields.split(',').map((field) => field.trim());
-            }
-        }
-        else {
-            returnData = responseData;
+  return (response) => {
+    let responseData = response;
+    if (typeof responseData === "string") {
+      responseData = (0, import_n8n_workflow.jsonParse)(response);
+    }
+    if (typeof responseData !== "object" || !responseData) {
+      throw new import_n8n_workflow.NodeOperationError(
+        ctx.getNode(),
+        "The response type must be an object or an array of objects",
+        { itemIndex }
+      );
+    }
+    const dataField = ctx.getNodeParameter("dataField", itemIndex, "");
+    let returnData = [];
+    if (!Array.isArray(responseData)) {
+      if (dataField) {
+        const data = responseData[dataField];
+        if (Array.isArray(data)) {
+          responseData = data;
+        } else {
+          responseData = [data];
         }
-        if (fieldsToInclude === 'selected') {
-            for (const item of responseData) {
-                const newItem = {};
-                for (const field of fields) {
-                    (0, set_1.default)(newItem, field, (0, get_1.default)(item, field));
-                }
-                returnData.push(newItem);
-            }
+      } else {
+        responseData = [responseData];
+      }
+    } else {
+      if (dataField) {
+        responseData = responseData.map((data) => data[dataField]);
+      }
+    }
+    const fieldsToInclude = ctx.getNodeParameter("fieldsToInclude", itemIndex, "all");
+    let fields = [];
+    if (fieldsToInclude !== "all") {
+      fields = ctx.getNodeParameter("fields", itemIndex, []);
+      if (typeof fields === "string") {
+        fields = fields.split(",").map((field) => field.trim());
+      }
+    } else {
+      returnData = responseData;
+    }
+    if (fieldsToInclude === "selected") {
+      for (const item of responseData) {
+        const newItem = {};
+        for (const field of fields) {
+          (0, import_set.default)(newItem, field, (0, import_get.default)(item, field));
         }
-        if (fieldsToInclude === 'except') {
-            for (const item of responseData) {
-                for (const field of fields) {
-                    (0, unset_1.default)(item, field);
-                }
-                returnData.push(item);
-            }
+        returnData.push(newItem);
+      }
+    }
+    if (fieldsToInclude === "except") {
+      for (const item of responseData) {
+        for (const field of fields) {
+          (0, import_unset.default)(item, field);
         }
-        return JSON.stringify(returnData, null, 2);
-    };
+        returnData.push(item);
+      }
+    }
+    return JSON.stringify(returnData, null, 2);
+  };
 };
 const configureResponseOptimizer = (ctx, itemIndex) => {
-    const optimizeResponse = ctx.getNodeParameter('optimizeResponse', itemIndex, false);
-    if (optimizeResponse) {
-        const responseType = ctx.getNodeParameter('responseType', itemIndex);
-        let maxLength = 0;
-        const truncateResponse = ctx.getNodeParameter('truncateResponse', itemIndex, false);
-        if (truncateResponse) {
-            maxLength = ctx.getNodeParameter('maxLength', itemIndex, 0);
-        }
-        switch (responseType) {
-            case 'html':
-                return htmlOptimizer(ctx, itemIndex, maxLength);
-            case 'text':
-                return textOptimizer(ctx, itemIndex, maxLength);
-            case 'json':
-                return jsonOptimizer(ctx, itemIndex);
-        }
+  const optimizeResponse = ctx.getNodeParameter("optimizeResponse", itemIndex, false);
+  if (optimizeResponse) {
+    const responseType = ctx.getNodeParameter("responseType", itemIndex);
+    let maxLength = 0;
+    const truncateResponse = ctx.getNodeParameter("truncateResponse", itemIndex, false);
+    if (truncateResponse) {
+      maxLength = ctx.getNodeParameter("maxLength", itemIndex, 0);
     }
-    return defaultOptimizer;
+    switch (responseType) {
+      case "html":
+        return htmlOptimizer(ctx, itemIndex, maxLength);
+      case "text":
+        return textOptimizer(ctx, itemIndex, maxLength);
+      case "json":
+        return jsonOptimizer(ctx, itemIndex);
+    }
+  }
+  return defaultOptimizer;
 };
-exports.configureResponseOptimizer = configureResponseOptimizer;
 const extractPlaceholders = (text) => {
-    const placeholder = /(\{[a-zA-Z0-9_-]+\})/g;
-    const returnData = [];
-    const matches = text.matchAll(placeholder);
-    for (const match of matches) {
-        returnData.push(match[0].replace(/{|}/g, ''));
-    }
-    return returnData;
+  const placeholder = /(\{[a-zA-Z0-9_-]+\})/g;
+  const returnData = [];
+  const matches = text.matchAll(placeholder);
+  for (const match of matches) {
+    returnData.push(match[0].replace(/{|}/g, ""));
+  }
+  return returnData;
 };
 const extractParametersFromText = (placeholders, text, sendIn, key) => {
-    if (typeof text !== 'string')
-        return [];
-    const parameters = extractPlaceholders(text);
-    if (parameters.length) {
-        const inputParameters = prepareParameters(parameters.map((name) => ({
-            name,
-            valueProvider: 'modelRequired',
-        })), placeholders, 'keypair', sendIn, '');
-        return key
-            ? inputParameters.parameters.map((p) => ({ ...p, key }))
-            : inputParameters.parameters;
-    }
-    return [];
+  if (typeof text !== "string") return [];
+  const parameters = extractPlaceholders(text);
+  if (parameters.length) {
+    const inputParameters = prepareParameters(
+      parameters.map((name) => ({
+        name,
+        valueProvider: "modelRequired"
+      })),
+      placeholders,
+      "keypair",
+      sendIn,
+      ""
+    );
+    return key ? inputParameters.parameters.map((p) => ({ ...p, key })) : inputParameters.parameters;
+  }
+  return [];
 };
-exports.extractParametersFromText = extractParametersFromText;
 function prepareParameters(rawParameters, placeholders, parametersInputType, sendIn, modelInputDescription, jsonWithPlaceholders) {
-    const parameters = [];
-    const values = {};
-    if (parametersInputType === 'model') {
-        return {
-            parameters: [
-                {
-                    name: sendIn,
-                    required: true,
-                    type: 'json',
-                    description: modelInputDescription,
-                    sendIn,
-                },
-            ],
-            values: {},
+  const parameters = [];
+  const values = {};
+  if (parametersInputType === "model") {
+    return {
+      parameters: [
+        {
+          name: sendIn,
+          required: true,
+          type: "json",
+          description: modelInputDescription,
+          sendIn
+        }
+      ],
+      values: {}
+    };
+  }
+  if (parametersInputType === "keypair") {
+    for (const entry of rawParameters) {
+      if (entry.valueProvider.includes("model")) {
+        const placeholder = placeholders.find((p) => p.name === entry.name);
+        const parameter = {
+          name: entry.name,
+          required: entry.valueProvider === "modelRequired",
+          sendIn
         };
-    }
-    if (parametersInputType === 'keypair') {
-        for (const entry of rawParameters) {
-            if (entry.valueProvider.includes('model')) {
-                const placeholder = placeholders.find((p) => p.name === entry.name);
-                const parameter = {
-                    name: entry.name,
-                    required: entry.valueProvider === 'modelRequired',
-                    sendIn,
-                };
-                if (placeholder) {
-                    parameter.type = placeholder.type;
-                    parameter.description = placeholder.description;
-                }
-                parameters.push(parameter);
-            }
-            else if (entry.value) {
-                parameters.push(...(0, exports.extractParametersFromText)(placeholders, entry.value, sendIn, entry.name));
-                values[entry.name] = entry.value;
-            }
+        if (placeholder) {
+          parameter.type = placeholder.type;
+          parameter.description = placeholder.description;
         }
+        parameters.push(parameter);
+      } else if (entry.value) {
+        parameters.push(
+          ...extractParametersFromText(placeholders, entry.value, sendIn, entry.name)
+        );
+        values[entry.name] = entry.value;
+      }
     }
-    if (parametersInputType === 'json' && jsonWithPlaceholders) {
-        parameters.push(...(0, exports.extractParametersFromText)(placeholders, jsonWithPlaceholders, sendIn, `${sendIn + 'Raw'}`));
-    }
-    return {
-        parameters,
-        values,
-    };
+  }
+  if (parametersInputType === "json" && jsonWithPlaceholders) {
+    parameters.push(
+      ...extractParametersFromText(placeholders, jsonWithPlaceholders, sendIn, `${sendIn + "Raw"}`)
+    );
+  }
+  return {
+    parameters,
+    values
+  };
 }
 const MODEL_INPUT_DESCRIPTION = {
-    qs: 'Query parameters for request as key value pairs',
-    headers: 'Headers parameters for request as key value pairs',
-    body: 'Body parameters for request as key value pairs',
+  qs: "Query parameters for request as key value pairs",
+  headers: "Headers parameters for request as key value pairs",
+  body: "Body parameters for request as key value pairs"
 };
 const updateParametersAndOptions = (options) => {
-    const { ctx, itemIndex, toolParameters, placeholdersDefinitions, requestOptions, rawRequestOptions, requestOptionsProperty, inputTypePropertyName, jsonPropertyName, parametersPropertyName, } = options;
-    const inputType = ctx.getNodeParameter(inputTypePropertyName, itemIndex, 'keypair');
-    let parametersValues = [];
-    if (inputType === 'json') {
-        rawRequestOptions[requestOptionsProperty] = ctx.getNodeParameter(jsonPropertyName, itemIndex, '');
-    }
-    else {
-        parametersValues = ctx.getNodeParameter(parametersPropertyName, itemIndex, []);
-    }
-    const inputParameters = prepareParameters(parametersValues, placeholdersDefinitions, inputType, requestOptionsProperty, MODEL_INPUT_DESCRIPTION[requestOptionsProperty], rawRequestOptions[requestOptionsProperty]);
-    toolParameters.push(...inputParameters.parameters);
-    requestOptions[requestOptionsProperty] = {
-        ...requestOptions[requestOptionsProperty],
-        ...inputParameters.values,
-    };
+  const {
+    ctx,
+    itemIndex,
+    toolParameters,
+    placeholdersDefinitions,
+    requestOptions,
+    rawRequestOptions,
+    requestOptionsProperty,
+    inputTypePropertyName,
+    jsonPropertyName,
+    parametersPropertyName
+  } = options;
+  const inputType = ctx.getNodeParameter(
+    inputTypePropertyName,
+    itemIndex,
+    "keypair"
+  );
+  let parametersValues = [];
+  if (inputType === "json") {
+    rawRequestOptions[requestOptionsProperty] = ctx.getNodeParameter(
+      jsonPropertyName,
+      itemIndex,
+      ""
+    );
+  } else {
+    parametersValues = ctx.getNodeParameter(
+      parametersPropertyName,
+      itemIndex,
+      []
+    );
+  }
+  const inputParameters = prepareParameters(
+    parametersValues,
+    placeholdersDefinitions,
+    inputType,
+    requestOptionsProperty,
+    MODEL_INPUT_DESCRIPTION[requestOptionsProperty],
+    rawRequestOptions[requestOptionsProperty]
+  );
+  toolParameters.push(...inputParameters.parameters);
+  requestOptions[requestOptionsProperty] = {
+    ...requestOptions[requestOptionsProperty],
+    ...inputParameters.values
+  };
 };
-exports.updateParametersAndOptions = updateParametersAndOptions;
-const getParametersDescription = (parameters) => parameters
-    .map((p) => `${p.name}: (description: ${p.description ?? ''}, type: ${p.type ?? 'string'}, required: ${!!p.required})`)
-    .join(',\n ');
+const getParametersDescription = (parameters) => parameters.map(
+  (p) => `${p.name}: (description: ${p.description ?? ""}, type: ${p.type ?? "string"}, required: ${!!p.required})`
+).join(",\n ");
 const prepareToolDescription = (toolDescription, toolParameters) => {
-    let description = `${toolDescription}`;
-    if (toolParameters.length) {
-        description += `
+  let description = `${toolDescription}`;
+  if (toolParameters.length) {
+    description += `
 	Tool expects valid stringified JSON object with ${toolParameters.length} properties.
 	Property names with description, type and required status:
 	${getParametersDescription(toolParameters)}
 	ALL parameters marked as required must be provided`;
-    }
-    return description;
+  }
+  return description;
 };
-exports.prepareToolDescription = prepareToolDescription;
 const configureToolFunction = (ctx, itemIndex, toolParameters, requestOptions, rawRequestOptions, httpRequest, optimizeResponse) => {
-    return async (query) => {
-        const { index } = ctx.addInputData(n8n_workflow_1.NodeConnectionTypes.AiTool, [[{ json: { query } }]]);
-        const options = structuredClone(requestOptions);
-        const clonedRawRequestOptions = structuredClone(rawRequestOptions);
-        let fullResponse;
-        let response = '';
-        let executionError = undefined;
-        if (!toolParameters.length) {
-            query = '{}';
+  return async (query) => {
+    const { index } = ctx.addInputData(import_n8n_workflow.NodeConnectionTypes.AiTool, [[{ json: { query } }]]);
+    const options = structuredClone(requestOptions);
+    const clonedRawRequestOptions = structuredClone(rawRequestOptions);
+    let fullResponse;
+    let response = "";
+    let executionError = void 0;
+    if (!toolParameters.length) {
+      query = "{}";
+    }
+    try {
+      if (query) {
+        let dataFromModel;
+        if (typeof query === "string") {
+          try {
+            dataFromModel = (0, import_n8n_workflow.jsonParse)(query);
+          } catch (error) {
+            if (toolParameters.length === 1) {
+              dataFromModel = { [toolParameters[0].name]: query };
+            } else {
+              throw new import_n8n_workflow.NodeOperationError(
+                ctx.getNode(),
+                `Input is not a valid JSON: ${error.message}`,
+                { itemIndex }
+              );
+            }
+          }
+        } else {
+          dataFromModel = query;
         }
-        try {
-            if (query) {
-                let dataFromModel;
-                if (typeof query === 'string') {
-                    try {
-                        dataFromModel = (0, n8n_workflow_1.jsonParse)(query);
-                    }
-                    catch (error) {
-                        if (toolParameters.length === 1) {
-                            dataFromModel = { [toolParameters[0].name]: query };
-                        }
-                        else {
-                            throw new n8n_workflow_1.NodeOperationError(ctx.getNode(), `Input is not a valid JSON: ${error.message}`, { itemIndex });
-                        }
-                    }
-                }
-                else {
-                    dataFromModel = query;
-                }
-                for (const parameter of toolParameters) {
-                    if (parameter.required &&
-                        (dataFromModel[parameter.name] === undefined || dataFromModel[parameter.name] === null)) {
-                        throw new n8n_workflow_1.NodeOperationError(ctx.getNode(), `Model did not provide parameter '${parameter.name}' which is required and must be present in the input`, { itemIndex });
-                    }
-                }
-                for (const parameter of toolParameters) {
-                    let argument = dataFromModel[parameter.name];
-                    if (argument &&
-                        parameter.type === 'json' &&
-                        !['qsRaw', 'headersRaw', 'bodyRaw'].includes(parameter.key ?? '') &&
-                        typeof argument !== 'object') {
-                        try {
-                            argument = (0, n8n_workflow_1.jsonParse)(String(argument));
-                        }
-                        catch (error) {
-                            throw new n8n_workflow_1.NodeOperationError(ctx.getNode(), `Parameter ${parameter.name} is not a valid JSON: ${error.message}`, {
-                                itemIndex,
-                            });
-                        }
-                    }
-                    if (parameter.sendIn === 'path') {
-                        argument = String(argument);
-                        argument = argument.replace(/^['"]+|['"]+$/g, '');
-                        options.url = options.url.replace(`{${parameter.name}}`, argument);
-                        continue;
-                    }
-                    if (parameter.sendIn === parameter.name) {
-                        (0, set_1.default)(options, [parameter.sendIn], argument);
-                        continue;
-                    }
-                    if (['qsRaw', 'headersRaw', 'bodyRaw'].includes(parameter.key ?? '')) {
-                        if (parameter.type === 'string') {
-                            argument = String(argument);
-                            if (!argument.startsWith('"') &&
-                                !clonedRawRequestOptions[parameter.sendIn].includes(`"{${parameter.name}}"`)) {
-                                argument = `"${argument}"`;
-                            }
-                        }
-                        if (typeof argument === 'object') {
-                            argument = JSON.stringify(argument);
-                        }
-                        clonedRawRequestOptions[parameter.sendIn] = clonedRawRequestOptions[parameter.sendIn].replace(`{${parameter.name}}`, String(argument));
-                        continue;
-                    }
-                    if (parameter.key) {
-                        let requestOptionsValue = (0, get_1.default)(options, [parameter.sendIn, parameter.key]);
-                        if (typeof requestOptionsValue === 'string') {
-                            requestOptionsValue = requestOptionsValue.replace(`{${parameter.name}}`, String(argument));
-                        }
-                        (0, set_1.default)(options, [parameter.sendIn, parameter.key], requestOptionsValue);
-                        continue;
-                    }
-                    (0, set_1.default)(options, [parameter.sendIn, parameter.name], argument);
-                }
-                for (const [key, value] of Object.entries(clonedRawRequestOptions)) {
-                    if (value) {
-                        let parsedValue;
-                        try {
-                            parsedValue = (0, n8n_workflow_1.jsonParse)(value);
-                        }
-                        catch (error) {
-                            let recoveredData = '';
-                            try {
-                                recoveredData = value
-                                    .replace(/'/g, '"')
-                                    .replace(/(['"])?([a-zA-Z0-9_]+)(['"])?:/g, '"$2":')
-                                    .replace(/,\s*([\]}])/g, '$1')
-                                    .replace(/,+$/, '');
-                                parsedValue = (0, n8n_workflow_1.jsonParse)(recoveredData);
-                            }
-                            catch (err) {
-                                throw new n8n_workflow_1.NodeOperationError(ctx.getNode(), `Could not replace placeholders in ${key}: ${error.message}`);
-                            }
-                        }
-                        options[key] = parsedValue;
-                    }
+        for (const parameter of toolParameters) {
+          if (parameter.required && (dataFromModel[parameter.name] === void 0 || dataFromModel[parameter.name] === null)) {
+            throw new import_n8n_workflow.NodeOperationError(
+              ctx.getNode(),
+              `Model did not provide parameter '${parameter.name}' which is required and must be present in the input`,
+              { itemIndex }
+            );
+          }
+        }
+        for (const parameter of toolParameters) {
+          let argument = dataFromModel[parameter.name];
+          if (argument && parameter.type === "json" && !["qsRaw", "headersRaw", "bodyRaw"].includes(parameter.key ?? "") && typeof argument !== "object") {
+            try {
+              argument = (0, import_n8n_workflow.jsonParse)(String(argument));
+            } catch (error) {
+              throw new import_n8n_workflow.NodeOperationError(
+                ctx.getNode(),
+                `Parameter ${parameter.name} is not a valid JSON: ${error.message}`,
+                {
+                  itemIndex
                 }
+              );
             }
-            if (options) {
-                options.url = encodeURI(options.url);
-                if (options.headers && !Object.keys(options.headers).length) {
-                    delete options.headers;
-                }
-                if (options.qs && !Object.keys(options.qs).length) {
-                    delete options.qs;
-                }
-                if (options.body && !Object.keys(options.body).length) {
-                    delete options.body;
-                }
+          }
+          if (parameter.sendIn === "path") {
+            argument = String(argument);
+            argument = argument.replace(/^['"]+|['"]+$/g, "");
+            options.url = options.url.replace(`{${parameter.name}}`, argument);
+            continue;
+          }
+          if (parameter.sendIn === parameter.name) {
+            (0, import_set.default)(options, [parameter.sendIn], argument);
+            continue;
+          }
+          if (["qsRaw", "headersRaw", "bodyRaw"].includes(parameter.key ?? "")) {
+            if (parameter.type === "string") {
+              argument = String(argument);
+              if (!argument.startsWith('"') && !clonedRawRequestOptions[parameter.sendIn].includes(`"{${parameter.name}}"`)) {
+                argument = `"${argument}"`;
+              }
             }
-        }
-        catch (error) {
-            const errorMessage = 'Input provided by model is not valid';
-            if (error instanceof n8n_workflow_1.NodeOperationError) {
-                executionError = error;
+            if (typeof argument === "object") {
+              argument = JSON.stringify(argument);
             }
-            else {
-                executionError = new n8n_workflow_1.NodeOperationError(ctx.getNode(), errorMessage, {
-                    itemIndex,
-                });
+            clonedRawRequestOptions[parameter.sendIn] = clonedRawRequestOptions[parameter.sendIn].replace(`{${parameter.name}}`, String(argument));
+            continue;
+          }
+          if (parameter.key) {
+            let requestOptionsValue = (0, import_get.default)(options, [parameter.sendIn, parameter.key]);
+            if (typeof requestOptionsValue === "string") {
+              requestOptionsValue = requestOptionsValue.replace(
+                `{${parameter.name}}`,
+                String(argument)
+              );
             }
-            response = errorMessage;
+            (0, import_set.default)(options, [parameter.sendIn, parameter.key], requestOptionsValue);
+            continue;
+          }
+          (0, import_set.default)(options, [parameter.sendIn, parameter.name], argument);
         }
-        if (options) {
+        for (const [key, value] of Object.entries(clonedRawRequestOptions)) {
+          if (value) {
+            let parsedValue;
             try {
-                fullResponse = await httpRequest(options);
-            }
-            catch (error) {
-                const httpCode = error.httpCode;
-                response = `${httpCode ? `HTTP ${httpCode} ` : ''}There was an error: "${error.message}"`;
-            }
-            if (!response) {
-                try {
-                    if (fullResponse.body && isBinary(fullResponse.body)) {
-                        throw new n8n_workflow_1.NodeOperationError(ctx.getNode(), 'Binary data is not supported');
-                    }
-                    response = optimizeResponse(fullResponse.body);
-                }
-                catch (error) {
-                    response = `There was an error: "${error.message}"`;
-                }
+              parsedValue = (0, import_n8n_workflow.jsonParse)(value);
+            } catch (error) {
+              let recoveredData = "";
+              try {
+                recoveredData = value.replace(/'/g, '"').replace(/(['"])?([a-zA-Z0-9_]+)(['"])?:/g, '"$2":').replace(/,\s*([\]}])/g, "$1").replace(/,+$/, "");
+                parsedValue = (0, import_n8n_workflow.jsonParse)(recoveredData);
+              } catch (err) {
+                throw new import_n8n_workflow.NodeOperationError(
+                  ctx.getNode(),
+                  `Could not replace placeholders in ${key}: ${error.message}`
+                );
+              }
             }
+            options[key] = parsedValue;
+          }
         }
-        if (typeof response !== 'string') {
-            executionError = new n8n_workflow_1.NodeOperationError(ctx.getNode(), 'Wrong output type returned', {
-                description: `The response property should be a string, but it is an ${typeof response}`,
-            });
-            response = `There was an error: "${executionError.message}"`;
+      }
+      if (options) {
+        options.url = encodeURI(options.url);
+        if (options.headers && !Object.keys(options.headers).length) {
+          delete options.headers;
         }
-        if (executionError) {
-            void ctx.addOutputData(n8n_workflow_1.NodeConnectionTypes.AiTool, index, executionError);
+        if (options.qs && !Object.keys(options.qs).length) {
+          delete options.qs;
         }
-        else {
-            void ctx.addOutputData(n8n_workflow_1.NodeConnectionTypes.AiTool, index, [[{ json: { response } }]]);
+        if (options.body && !Object.keys(options.body).length) {
+          delete options.body;
         }
-        return response;
-    };
-};
-exports.configureToolFunction = configureToolFunction;
-function makeParameterZodSchema(parameter) {
-    let schema;
-    if (parameter.type === 'string') {
-        schema = zod_1.z.string();
-    }
-    else if (parameter.type === 'number') {
-        schema = zod_1.z.number();
-    }
-    else if (parameter.type === 'boolean') {
-        schema = zod_1.z.boolean();
-    }
-    else if (parameter.type === 'json') {
-        schema = zod_1.z.record(zod_1.z.any());
+      }
+    } catch (error) {
+      const errorMessage = "Input provided by model is not valid";
+      if (error instanceof import_n8n_workflow.NodeOperationError) {
+        executionError = error;
+      } else {
+        executionError = new import_n8n_workflow.NodeOperationError(ctx.getNode(), errorMessage, {
+          itemIndex
+        });
+      }
+      response = errorMessage;
     }
-    else {
-        schema = zod_1.z.string();
+    if (options) {
+      try {
+        fullResponse = await httpRequest(options);
+      } catch (error) {
+        const httpCode = error.httpCode;
+        response = `${httpCode ? `HTTP ${httpCode} ` : ""}There was an error: "${error.message}"`;
+      }
+      if (!response) {
+        try {
+          if (fullResponse.body && isBinary(fullResponse.body)) {
+            throw new import_n8n_workflow.NodeOperationError(ctx.getNode(), "Binary data is not supported");
+          }
+          response = optimizeResponse(fullResponse.body ?? fullResponse);
+        } catch (error) {
+          response = `There was an error: "${error.message}"`;
+        }
+      }
     }
-    if (!parameter.required) {
-        schema = schema.optional();
+    if (typeof response !== "string") {
+      executionError = new import_n8n_workflow.NodeOperationError(ctx.getNode(), "Wrong output type returned", {
+        description: `The response property should be a string, but it is an ${typeof response}`
+      });
+      response = `There was an error: "${executionError.message}"`;
     }
-    if (parameter.description) {
-        schema = schema.describe(parameter.description);
+    if (executionError) {
+      void ctx.addOutputData(import_n8n_workflow.NodeConnectionTypes.AiTool, index, executionError);
+    } else {
+      void ctx.addOutputData(import_n8n_workflow.NodeConnectionTypes.AiTool, index, [[{ json: { response } }]]);
     }
-    return schema;
+    return response;
+  };
+};
+function makeParameterZodSchema(parameter) {
+  let schema;
+  if (parameter.type === "string") {
+    schema = import_zod.z.string();
+  } else if (parameter.type === "number") {
+    schema = import_zod.z.number();
+  } else if (parameter.type === "boolean") {
+    schema = import_zod.z.boolean();
+  } else if (parameter.type === "json") {
+    schema = import_zod.z.record(import_zod.z.any());
+  } else {
+    schema = import_zod.z.string();
+  }
+  if (!parameter.required) {
+    schema = schema.optional();
+  }
+  if (parameter.description) {
+    schema = schema.describe(parameter.description);
+  }
+  return schema;
 }
 function makeToolInputSchema(parameters) {
-    const schemaEntries = parameters.map((parameter) => [
-        parameter.name,
-        makeParameterZodSchema(parameter),
-    ]);
-    return zod_1.z.object(Object.fromEntries(schemaEntries));
+  const schemaEntries = parameters.map((parameter) => [
+    parameter.name,
+    makeParameterZodSchema(parameter)
+  ]);
+  return import_zod.z.object(Object.fromEntries(schemaEntries));
 }
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  configureHttpRequestFunction,
+  configureResponseOptimizer,
+  configureToolFunction,
+  extractParametersFromText,
+  makeToolInputSchema,
+  prepareToolDescription,
+  updateParametersAndOptions
+});
 //# sourceMappingURL=utils.js.map