@n8n/n8n-nodes-langchain 1.85.2 → 1.86.0

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

@@ -1,340 +1,395 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ToolHttpRequest = void 0;
-const tools_1 = require("@langchain/core/tools");
-const n8n_workflow_1 = require("n8n-workflow");
-const N8nTool_1 = require("../../../utils/N8nTool");
-const sharedFields_1 = require("../../../utils/sharedFields");
-const descriptions_1 = require("./descriptions");
-const utils_1 = require("./utils");
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ToolHttpRequest_node_exports = {};
+__export(ToolHttpRequest_node_exports, {
+  ToolHttpRequest: () => ToolHttpRequest
+});
+module.exports = __toCommonJS(ToolHttpRequest_node_exports);
+var import_tools = require("@langchain/core/tools");
+var import_n8n_workflow = require("n8n-workflow");
+var import_N8nTool = require("../../../utils/N8nTool");
+var import_sharedFields = require("../../../utils/sharedFields");
+var import_descriptions = require("./descriptions");
+var import_utils = require("./utils");
 class ToolHttpRequest {
-    constructor() {
-        this.description = {
-            displayName: 'HTTP Request Tool',
-            name: 'toolHttpRequest',
-            icon: { light: 'file:httprequest.svg', dark: 'file:httprequest.dark.svg' },
-            group: ['output'],
-            version: [1, 1.1],
-            description: 'Makes an HTTP request and returns the response data',
-            subtitle: '={{ $parameter.toolDescription }}',
-            defaults: {
-                name: 'HTTP Request',
+  constructor() {
+    this.description = {
+      displayName: "HTTP Request Tool",
+      name: "toolHttpRequest",
+      icon: { light: "file:httprequest.svg", dark: "file:httprequest.dark.svg" },
+      group: ["output"],
+      version: [1, 1.1],
+      description: "Makes an HTTP request and returns the response data",
+      subtitle: "={{ $parameter.toolDescription }}",
+      defaults: {
+        name: "HTTP Request"
+      },
+      credentials: [],
+      codex: {
+        categories: ["AI"],
+        subcategories: {
+          AI: ["Tools"],
+          Tools: ["Recommended Tools"]
+        },
+        resources: {
+          primaryDocumentation: [
+            {
+              url: "https://docs.n8n.io/integrations/builtin/cluster-nodes/sub-nodes/n8n-nodes-langchain.toolhttprequest/"
+            }
+          ]
+        }
+      },
+      // eslint-disable-next-line n8n-nodes-base/node-class-description-inputs-wrong-regular-node
+      inputs: [],
+      // eslint-disable-next-line n8n-nodes-base/node-class-description-outputs-wrong
+      outputs: [import_n8n_workflow.NodeConnectionTypes.AiTool],
+      outputNames: ["Tool"],
+      properties: [
+        (0, import_sharedFields.getConnectionHintNoticeField)([import_n8n_workflow.NodeConnectionTypes.AiAgent]),
+        {
+          displayName: "Description",
+          name: "toolDescription",
+          type: "string",
+          description: "Explain to LLM what this tool does, better description would allow LLM to produce expected result",
+          placeholder: "e.g. Get the current weather in the requested city",
+          default: "",
+          typeOptions: {
+            rows: 3
+          }
+        },
+        {
+          displayName: "Method",
+          name: "method",
+          type: "options",
+          options: [
+            {
+              name: "DELETE",
+              value: "DELETE"
             },
-            credentials: [],
-            codex: {
-                categories: ['AI'],
-                subcategories: {
-                    AI: ['Tools'],
-                    Tools: ['Recommended Tools'],
-                },
-                resources: {
-                    primaryDocumentation: [
-                        {
-                            url: 'https://docs.n8n.io/integrations/builtin/cluster-nodes/sub-nodes/n8n-nodes-langchain.toolhttprequest/',
-                        },
-                    ],
-                },
+            {
+              name: "GET",
+              value: "GET"
             },
-            inputs: [],
-            outputs: [n8n_workflow_1.NodeConnectionTypes.AiTool],
-            outputNames: ['Tool'],
-            properties: [
-                (0, sharedFields_1.getConnectionHintNoticeField)([n8n_workflow_1.NodeConnectionTypes.AiAgent]),
-                {
-                    displayName: 'Description',
-                    name: 'toolDescription',
-                    type: 'string',
-                    description: 'Explain to LLM what this tool does, better description would allow LLM to produce expected result',
-                    placeholder: 'e.g. Get the current weather in the requested city',
-                    default: '',
-                    typeOptions: {
-                        rows: 3,
-                    },
-                },
-                {
-                    displayName: 'Method',
-                    name: 'method',
-                    type: 'options',
-                    options: [
-                        {
-                            name: 'DELETE',
-                            value: 'DELETE',
-                        },
-                        {
-                            name: 'GET',
-                            value: 'GET',
-                        },
-                        {
-                            name: 'PATCH',
-                            value: 'PATCH',
-                        },
-                        {
-                            name: 'POST',
-                            value: 'POST',
-                        },
-                        {
-                            name: 'PUT',
-                            value: 'PUT',
-                        },
-                    ],
-                    default: 'GET',
-                },
-                {
-                    displayName: 'Tip: You can use a {placeholder} for any part of the request to be filled by the model. Provide more context about them in the placeholders section',
-                    name: 'placeholderNotice',
-                    type: 'notice',
-                    default: '',
-                },
-                {
-                    displayName: 'URL',
-                    name: 'url',
-                    type: 'string',
-                    default: '',
-                    required: true,
-                    placeholder: 'e.g. http://www.example.com/{path}',
-                },
-                ...descriptions_1.authenticationProperties,
-                {
-                    displayName: 'Send Query Parameters',
-                    name: 'sendQuery',
-                    type: 'boolean',
-                    default: false,
-                    noDataExpression: true,
-                    description: 'Whether the request has query params or not',
-                },
-                {
-                    ...descriptions_1.specifyBySelector,
-                    displayName: 'Specify Query Parameters',
-                    name: 'specifyQuery',
-                    displayOptions: {
-                        show: {
-                            sendQuery: [true],
-                        },
-                    },
-                },
-                {
-                    ...descriptions_1.parametersCollection,
-                    displayName: 'Query Parameters',
-                    name: 'parametersQuery',
-                    displayOptions: {
-                        show: {
-                            sendQuery: [true],
-                            specifyQuery: ['keypair'],
-                        },
-                    },
-                },
-                {
-                    ...descriptions_1.jsonInput,
-                    name: 'jsonQuery',
-                    displayOptions: {
-                        show: {
-                            sendQuery: [true],
-                            specifyQuery: ['json'],
-                        },
-                    },
-                },
-                {
-                    displayName: 'Send Headers',
-                    name: 'sendHeaders',
-                    type: 'boolean',
-                    default: false,
-                    noDataExpression: true,
-                    description: 'Whether the request has headers or not',
-                },
-                {
-                    ...descriptions_1.specifyBySelector,
-                    displayName: 'Specify Headers',
-                    name: 'specifyHeaders',
-                    displayOptions: {
-                        show: {
-                            sendHeaders: [true],
-                        },
-                    },
-                },
-                {
-                    ...descriptions_1.parametersCollection,
-                    displayName: 'Header Parameters',
-                    name: 'parametersHeaders',
-                    displayOptions: {
-                        show: {
-                            sendHeaders: [true],
-                            specifyHeaders: ['keypair'],
-                        },
-                    },
-                },
-                {
-                    ...descriptions_1.jsonInput,
-                    name: 'jsonHeaders',
-                    displayOptions: {
-                        show: {
-                            sendHeaders: [true],
-                            specifyHeaders: ['json'],
-                        },
-                    },
-                },
-                {
-                    displayName: 'Send Body',
-                    name: 'sendBody',
-                    type: 'boolean',
-                    default: false,
-                    noDataExpression: true,
-                    description: 'Whether the request has body or not',
-                },
-                {
-                    ...descriptions_1.specifyBySelector,
-                    displayName: 'Specify Body',
-                    name: 'specifyBody',
-                    displayOptions: {
-                        show: {
-                            sendBody: [true],
-                        },
-                    },
-                },
-                {
-                    ...descriptions_1.parametersCollection,
-                    displayName: 'Body Parameters',
-                    name: 'parametersBody',
-                    displayOptions: {
-                        show: {
-                            sendBody: [true],
-                            specifyBody: ['keypair'],
-                        },
-                    },
-                },
-                {
-                    ...descriptions_1.jsonInput,
-                    name: 'jsonBody',
-                    displayOptions: {
-                        show: {
-                            sendBody: [true],
-                            specifyBody: ['json'],
-                        },
-                    },
-                },
-                descriptions_1.placeholderDefinitionsCollection,
-                ...descriptions_1.optimizeResponseProperties,
-            ],
-        };
-    }
-    async supplyData(itemIndex) {
-        const name = this.getNode().name.replace(/ /g, '_');
-        try {
-            (0, n8n_workflow_1.tryToParseAlphanumericString)(name);
-        }
-        catch (error) {
-            throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'The name of this tool is not a valid alphanumeric string', {
-                itemIndex,
-                description: "Only alphanumeric characters and underscores are allowed in the tool's name, and the name cannot start with a number",
-            });
-        }
-        const toolDescription = this.getNodeParameter('toolDescription', itemIndex);
-        const sendQuery = this.getNodeParameter('sendQuery', itemIndex, false);
-        const sendHeaders = this.getNodeParameter('sendHeaders', itemIndex, false);
-        const sendBody = this.getNodeParameter('sendBody', itemIndex, false);
-        const requestOptions = {
-            method: this.getNodeParameter('method', itemIndex, 'GET'),
-            url: this.getNodeParameter('url', itemIndex),
-            qs: {},
-            headers: {
-                'User-Agent': undefined,
+            {
+              name: "PATCH",
+              value: "PATCH"
+            },
+            {
+              name: "POST",
+              value: "POST"
             },
-            body: {},
-            returnFullResponse: true,
-        };
-        const authentication = this.getNodeParameter('authentication', itemIndex, 'none');
-        if (authentication !== 'none') {
-            const domain = new URL(requestOptions.url).hostname;
-            if (domain.includes('{') && domain.includes('}')) {
-                throw new n8n_workflow_1.NodeOperationError(this.getNode(), "Can't use a placeholder for the domain when using authentication", {
-                    itemIndex,
-                    description: 'This is for security reasons, to prevent the model accidentally sending your credentials to an unauthorized domain',
-                });
+            {
+              name: "PUT",
+              value: "PUT"
             }
-        }
-        const httpRequest = await (0, utils_1.configureHttpRequestFunction)(this, authentication, itemIndex);
-        const optimizeResponse = (0, utils_1.configureResponseOptimizer)(this, itemIndex);
-        const rawRequestOptions = {
-            qs: '',
-            headers: '',
-            body: '',
-        };
-        const placeholdersDefinitions = this.getNodeParameter('placeholderDefinitions.values', itemIndex, []).map((p) => {
-            if (p.name.startsWith('{') && p.name.endsWith('}')) {
-                p.name = p.name.slice(1, -1);
+          ],
+          default: "GET"
+        },
+        {
+          displayName: "Tip: You can use a {placeholder} for any part of the request to be filled by the model. Provide more context about them in the placeholders section",
+          name: "placeholderNotice",
+          type: "notice",
+          default: ""
+        },
+        {
+          displayName: "URL",
+          name: "url",
+          type: "string",
+          default: "",
+          required: true,
+          placeholder: "e.g. http://www.example.com/{path}"
+        },
+        ...import_descriptions.authenticationProperties,
+        //----------------------------------------------------------------
+        {
+          displayName: "Send Query Parameters",
+          name: "sendQuery",
+          type: "boolean",
+          default: false,
+          noDataExpression: true,
+          description: "Whether the request has query params or not"
+        },
+        {
+          ...import_descriptions.specifyBySelector,
+          displayName: "Specify Query Parameters",
+          name: "specifyQuery",
+          displayOptions: {
+            show: {
+              sendQuery: [true]
             }
-            return p;
-        });
-        const toolParameters = [];
-        toolParameters.push(...(0, utils_1.extractParametersFromText)(placeholdersDefinitions, requestOptions.url, 'path'));
-        if (sendQuery) {
-            (0, utils_1.updateParametersAndOptions)({
-                ctx: this,
-                itemIndex,
-                toolParameters,
-                placeholdersDefinitions,
-                requestOptions,
-                rawRequestOptions,
-                requestOptionsProperty: 'qs',
-                inputTypePropertyName: 'specifyQuery',
-                jsonPropertyName: 'jsonQuery',
-                parametersPropertyName: 'parametersQuery.values',
-            });
-        }
-        if (sendHeaders) {
-            (0, utils_1.updateParametersAndOptions)({
-                ctx: this,
-                itemIndex,
-                toolParameters,
-                placeholdersDefinitions,
-                requestOptions,
-                rawRequestOptions,
-                requestOptionsProperty: 'headers',
-                inputTypePropertyName: 'specifyHeaders',
-                jsonPropertyName: 'jsonHeaders',
-                parametersPropertyName: 'parametersHeaders.values',
-            });
-        }
-        if (sendBody) {
-            (0, utils_1.updateParametersAndOptions)({
-                ctx: this,
-                itemIndex,
-                toolParameters,
-                placeholdersDefinitions,
-                requestOptions,
-                rawRequestOptions,
-                requestOptionsProperty: 'body',
-                inputTypePropertyName: 'specifyBody',
-                jsonPropertyName: 'jsonBody',
-                parametersPropertyName: 'parametersBody.values',
-            });
-        }
-        for (const placeholder of placeholdersDefinitions) {
-            if (!toolParameters.find((parameter) => parameter.name === placeholder.name)) {
-                throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Misconfigured placeholder '${placeholder.name}'`, {
-                    itemIndex,
-                    description: "This placeholder is defined in the 'Placeholder Definitions' but isn't used anywhere. Either remove the definition, or add the placeholder to a part of the request.",
-                });
+          }
+        },
+        {
+          ...import_descriptions.parametersCollection,
+          displayName: "Query Parameters",
+          name: "parametersQuery",
+          displayOptions: {
+            show: {
+              sendQuery: [true],
+              specifyQuery: ["keypair"]
             }
+          }
+        },
+        {
+          ...import_descriptions.jsonInput,
+          name: "jsonQuery",
+          displayOptions: {
+            show: {
+              sendQuery: [true],
+              specifyQuery: ["json"]
+            }
+          }
+        },
+        //----------------------------------------------------------------
+        {
+          displayName: "Send Headers",
+          name: "sendHeaders",
+          type: "boolean",
+          default: false,
+          noDataExpression: true,
+          description: "Whether the request has headers or not"
+        },
+        {
+          ...import_descriptions.specifyBySelector,
+          displayName: "Specify Headers",
+          name: "specifyHeaders",
+          displayOptions: {
+            show: {
+              sendHeaders: [true]
+            }
+          }
+        },
+        {
+          ...import_descriptions.parametersCollection,
+          displayName: "Header Parameters",
+          name: "parametersHeaders",
+          displayOptions: {
+            show: {
+              sendHeaders: [true],
+              specifyHeaders: ["keypair"]
+            }
+          }
+        },
+        {
+          ...import_descriptions.jsonInput,
+          name: "jsonHeaders",
+          displayOptions: {
+            show: {
+              sendHeaders: [true],
+              specifyHeaders: ["json"]
+            }
+          }
+        },
+        //----------------------------------------------------------------
+        {
+          displayName: "Send Body",
+          name: "sendBody",
+          type: "boolean",
+          default: false,
+          noDataExpression: true,
+          description: "Whether the request has body or not"
+        },
+        {
+          ...import_descriptions.specifyBySelector,
+          displayName: "Specify Body",
+          name: "specifyBody",
+          displayOptions: {
+            show: {
+              sendBody: [true]
+            }
+          }
+        },
+        {
+          ...import_descriptions.parametersCollection,
+          displayName: "Body Parameters",
+          name: "parametersBody",
+          displayOptions: {
+            show: {
+              sendBody: [true],
+              specifyBody: ["keypair"]
+            }
+          }
+        },
+        {
+          ...import_descriptions.jsonInput,
+          name: "jsonBody",
+          displayOptions: {
+            show: {
+              sendBody: [true],
+              specifyBody: ["json"]
+            }
+          }
+        },
+        //----------------------------------------------------------------
+        import_descriptions.placeholderDefinitionsCollection,
+        ...import_descriptions.optimizeResponseProperties
+      ]
+    };
+  }
+  async supplyData(itemIndex) {
+    const name = this.getNode().name.replace(/ /g, "_");
+    try {
+      (0, import_n8n_workflow.tryToParseAlphanumericString)(name);
+    } catch (error) {
+      throw new import_n8n_workflow.NodeOperationError(
+        this.getNode(),
+        "The name of this tool is not a valid alphanumeric string",
+        {
+          itemIndex,
+          description: "Only alphanumeric characters and underscores are allowed in the tool's name, and the name cannot start with a number"
         }
-        const func = (0, utils_1.configureToolFunction)(this, itemIndex, toolParameters, requestOptions, rawRequestOptions, httpRequest, optimizeResponse);
-        let tool;
-        if (this.getNode().typeVersion >= 1.1) {
-            const schema = (0, utils_1.makeToolInputSchema)(toolParameters);
-            tool = new N8nTool_1.N8nTool(this, {
-                name,
-                description: toolDescription,
-                func,
-                schema,
-            });
-        }
-        else {
-            const description = (0, utils_1.prepareToolDescription)(toolDescription, toolParameters);
-            tool = new tools_1.DynamicTool({ name, description, func });
-        }
-        return {
-            response: tool,
-        };
+      );
+    }
+    const toolDescription = this.getNodeParameter("toolDescription", itemIndex);
+    const sendQuery = this.getNodeParameter("sendQuery", itemIndex, false);
+    const sendHeaders = this.getNodeParameter("sendHeaders", itemIndex, false);
+    const sendBody = this.getNodeParameter("sendBody", itemIndex, false);
+    const requestOptions = {
+      method: this.getNodeParameter("method", itemIndex, "GET"),
+      url: this.getNodeParameter("url", itemIndex),
+      qs: {},
+      headers: {
+        // FIXME: This is a workaround to prevent the node from sending a default User-Agent (`n8n`) when the header is not set.
+        //  Needs to be replaced with a proper fix after NODE-1777 is resolved
+        "User-Agent": void 0
+      },
+      body: {},
+      // We will need a full response object later to extract the headers and check the response's content type.
+      returnFullResponse: true
+    };
+    const authentication = this.getNodeParameter("authentication", itemIndex, "none");
+    if (authentication !== "none") {
+      const domain = new URL(requestOptions.url).hostname;
+      if (domain.includes("{") && domain.includes("}")) {
+        throw new import_n8n_workflow.NodeOperationError(
+          this.getNode(),
+          "Can't use a placeholder for the domain when using authentication",
+          {
+            itemIndex,
+            description: "This is for security reasons, to prevent the model accidentally sending your credentials to an unauthorized domain"
+          }
+        );
+      }
+    }
+    const httpRequest = await (0, import_utils.configureHttpRequestFunction)(this, authentication, itemIndex);
+    const optimizeResponse = (0, import_utils.configureResponseOptimizer)(this, itemIndex);
+    const rawRequestOptions = {
+      qs: "",
+      headers: "",
+      body: ""
+    };
+    const placeholdersDefinitions = this.getNodeParameter(
+      "placeholderDefinitions.values",
+      itemIndex,
+      []
+    ).map((p) => {
+      if (p.name.startsWith("{") && p.name.endsWith("}")) {
+        p.name = p.name.slice(1, -1);
+      }
+      return p;
+    });
+    const toolParameters = [];
+    toolParameters.push(
+      ...(0, import_utils.extractParametersFromText)(placeholdersDefinitions, requestOptions.url, "path")
+    );
+    if (sendQuery) {
+      (0, import_utils.updateParametersAndOptions)({
+        ctx: this,
+        itemIndex,
+        toolParameters,
+        placeholdersDefinitions,
+        requestOptions,
+        rawRequestOptions,
+        requestOptionsProperty: "qs",
+        inputTypePropertyName: "specifyQuery",
+        jsonPropertyName: "jsonQuery",
+        parametersPropertyName: "parametersQuery.values"
+      });
+    }
+    if (sendHeaders) {
+      (0, import_utils.updateParametersAndOptions)({
+        ctx: this,
+        itemIndex,
+        toolParameters,
+        placeholdersDefinitions,
+        requestOptions,
+        rawRequestOptions,
+        requestOptionsProperty: "headers",
+        inputTypePropertyName: "specifyHeaders",
+        jsonPropertyName: "jsonHeaders",
+        parametersPropertyName: "parametersHeaders.values"
+      });
+    }
+    if (sendBody) {
+      (0, import_utils.updateParametersAndOptions)({
+        ctx: this,
+        itemIndex,
+        toolParameters,
+        placeholdersDefinitions,
+        requestOptions,
+        rawRequestOptions,
+        requestOptionsProperty: "body",
+        inputTypePropertyName: "specifyBody",
+        jsonPropertyName: "jsonBody",
+        parametersPropertyName: "parametersBody.values"
+      });
+    }
+    for (const placeholder of placeholdersDefinitions) {
+      if (!toolParameters.find((parameter) => parameter.name === placeholder.name)) {
+        throw new import_n8n_workflow.NodeOperationError(
+          this.getNode(),
+          `Misconfigured placeholder '${placeholder.name}'`,
+          {
+            itemIndex,
+            description: "This placeholder is defined in the 'Placeholder Definitions' but isn't used anywhere. Either remove the definition, or add the placeholder to a part of the request."
+          }
+        );
+      }
+    }
+    const func = (0, import_utils.configureToolFunction)(
+      this,
+      itemIndex,
+      toolParameters,
+      requestOptions,
+      rawRequestOptions,
+      httpRequest,
+      optimizeResponse
+    );
+    let tool;
+    if (this.getNode().typeVersion >= 1.1) {
+      const schema = (0, import_utils.makeToolInputSchema)(toolParameters);
+      tool = new import_N8nTool.N8nTool(this, {
+        name,
+        description: toolDescription,
+        func,
+        schema
+      });
+    } else {
+      const description = (0, import_utils.prepareToolDescription)(toolDescription, toolParameters);
+      tool = new import_tools.DynamicTool({ name, description, func });
     }
+    return {
+      response: tool
+    };
+  }
 }
-exports.ToolHttpRequest = ToolHttpRequest;
-//# sourceMappingURL=ToolHttpRequest.node.js.map
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ToolHttpRequest
+});