@n8n/n8n-nodes-langchain 2.5.1 → 2.6.0

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

@@ -1,396 +1,341 @@
 "use strict";
-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");
+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");
 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"
-      },
-      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/"
-            }
-          ]
-        }
-      },
-      // Replaced by a `usableAsTool` version of the standalone HttpRequest node
-      hidden: true,
-      inputs: [],
-      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"
+    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',
             },
-            {
-              name: "GET",
-              value: "GET"
+            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: "PATCH",
-              value: "PATCH"
-            },
-            {
-              name: "POST",
-              value: "POST"
+            hidden: true,
+            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: "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}"
-        },
-        ...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]
-            }
-          }
-        },
-        {
-          ...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]
+            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',
+                });
             }
-          }
-        },
-        {
-          ...import_descriptions.parametersCollection,
-          displayName: "Body Parameters",
-          name: "parametersBody",
-          displayOptions: {
-            show: {
-              sendBody: [true],
-              specifyBody: ["keypair"]
+        }
+        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);
             }
-          }
-        },
-        {
-          ...import_descriptions.jsonInput,
-          name: "jsonBody",
-          displayOptions: {
-            show: {
-              sendBody: [true],
-              specifyBody: ["json"]
+            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.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 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 });
+        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,
+        };
     }
-    return {
-      response: tool
-    };
-  }
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  ToolHttpRequest
-});
+exports.ToolHttpRequest = ToolHttpRequest;
 //# sourceMappingURL=ToolHttpRequest.node.js.map