feat: HTTP request tool

packages/@n8n/nodes-langchain/nodes/tools/ToolHttpRequest/ToolHttpRequest.node.ts

@@ -0,0 +1,398 @@
+/* eslint-disable n8n-nodes-base/node-dirname-against-convention */
+import type {
+ IExecuteFunctions,
+ INodeType,
+ INodeTypeDescription,
+ SupplyData,
+ ExecutionError,
+ IDataObject,
+ IHttpRequestOptions,
+ IHttpRequestMethods,
+} from 'n8n-workflow';
+import { NodeConnectionType, NodeOperationError, jsonParse } from 'n8n-workflow';
+
+import { getConnectionHintNoticeField } from '../../../utils/sharedFields';
+
+import { DynamicTool } from '@langchain/core/tools';
+
+import {
+ type ToolParameter,
+ configureHttpRequestFunction,
+ prettifyToolName,
+ configureResponseOptimizer,
+} from './utils';
+
+import {
+ authenticationProperties,
+ optimizeResponseProperties,
+ parametersCollection,
+} from './descriptions';
+
+export class ToolHttpRequest implements INodeType {
+ description: INodeTypeDescription = {
+ displayName: 'HTTP Request Tool',
+ name: 'toolHttpRequest',
+ icon: 'file:httprequest.svg',
+ group: ['output'],
+ version: 1,
+ description: 'Makes an HTTP request and returns the response data',
+ subtitle: `={{(${prettifyToolName})($parameter.name)}}`,
+ defaults: {
+ name: 'HTTP Request',
+ },
+ credentials: [],
+ codex: {
+ categories: ['AI'],
+ subcategories: {
+ AI: ['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: [NodeConnectionType.AiTool],
+ outputNames: ['Tool'],
+ properties: [
+ getConnectionHintNoticeField([NodeConnectionType.AiAgent]),
+ {
+ displayName: 'Name',
+ name: 'name',
+ type: 'string',
+ default: '',
+ placeholder: 'e.g. get_current_weather',
+ validateType: 'string-alphanumeric',
+ description:
+ 'The name of the function to be called, could contain letters, numbers, and underscores only',
+ },
+ {
+ 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: 'URL',
+ name: 'url',
+ type: 'string',
+ default: '',
+ placeholder: 'e.g. https://wikipedia.org/api',
+ validateType: 'url',
+ },
+ ...authenticationProperties,
+ {
+ displayName: 'Define Path',
+ name: 'sendInPath',
+ type: 'boolean',
+ default: false,
+ noDataExpression: true,
+ description: 'Whether the LLM should provide path parameters',
+ },
+ {
+ displayName: 'Path',
+ name: 'path',
+ type: 'string',
+ default: '',
+ required: true,
+ placeholder: 'e.g. /weather/{latitude}/{longitude}',
+ hint: "Use {parameter_name} to indicate where the parameter's value should be inserted",
+ displayOptions: {
+ show: {
+ sendInPath: [true],
+ },
+ },
+ },
+ {
+ ...parametersCollection,
+ name: 'pathParameters',
+ displayOptions: {
+ show: {
+ sendInPath: [true],
+ },
+ },
+ },
+ {
+ displayName: 'Define Query',
+ name: 'sendInQuery',
+ type: 'boolean',
+ default: false,
+ noDataExpression: true,
+ description: 'Whether the LLM should provide query parameters',
+ },
+ {
+ ...parametersCollection,
+ name: 'queryParameters',
+ displayOptions: {
+ show: {
+ sendInQuery: [true],
+ },
+ },
+ },
+ {
+ displayName: 'Define Body',
+ name: 'sendInBody',
+ type: 'boolean',
+ default: false,
+ noDataExpression: true,
+ description: 'Whether the LLM should provide body parameters',
+ },
+ {
+ ...parametersCollection,
+ name: 'bodyParameters',
+ displayOptions: {
+ show: {
+ sendInBody: [true],
+ },
+ },
+ },
+ ...optimizeResponseProperties,
+ {
+ displayName: 'Options',
+ name: 'options',
+ placeholder: 'Add Option',
+ description: 'Data to send in the request in addition to data provided by LLM',
+ type: 'collection',
+ default: {},
+ options: [
+ {
+ displayName: 'Headers',
+ name: 'headers',
+ type: 'json',
+ typeOptions: {
+ rows: 2,
+ },
+ default: '{\n "Authorization": "Bearer my_token"\n}\n',
+ validateType: 'object',
+ },
+ {
+ displayName: 'Extra Body Parameters',
+ name: 'bodyParameters',
+ type: 'json',
+ typeOptions: {
+ rows: 2,
+ },
+ default: '{\n "id": "some id"\n}\n',
+ validateType: 'object',
+ },
+ {
+ displayName: 'Extra Query Parameters',
+ name: 'queryParameters',
+ type: 'json',
+ typeOptions: {
+ rows: 2,
+ },
+ default: '{\n "limit": 20\n}\n',
+ validateType: 'object',
+ },
+ ],
+ },
+ ],
+ };
+
+ async supplyData(this: IExecuteFunctions, itemIndex: number): Promise<SupplyData> {
+ const name = this.getNodeParameter('name', itemIndex) as string;
+ const toolDescription = this.getNodeParameter('toolDescription', itemIndex) as string;
+ const method = this.getNodeParameter('method', itemIndex, 'GET') as IHttpRequestMethods;
+ const url = this.getNodeParameter('url', itemIndex) as string;
+ const authentication = this.getNodeParameter('authentication', itemIndex, 'none') as
+ | 'predefinedCredentialType'
+ | 'genericCredentialType'
+ | 'none';
+ const options = this.getNodeParameter('options', itemIndex, {});
+
+ let headers = (options?.headers as IDataObject) ?? {};
+ let body = (options?.bodyParameters as IDataObject) ?? {};
+ let qs = (options?.queryParameters as IDataObject) ?? {};
+
+ if (typeof headers === 'string') {
+ headers = jsonParse<IDataObject>(headers, {
+ errorMessage: 'Invalid JSON in "Extra Request Options -> Headers" field',
+ });
+ }
+
+ if (typeof body === 'string') {
+ body = jsonParse<IDataObject>(body, {
+ errorMessage: 'Invalid JSON in "Extra Request Options -> Body Parameters" field',
+ });
+ }
+
+ if (typeof qs === 'string') {
+ qs = jsonParse<IDataObject>(qs, {
+ errorMessage: 'Invalid JSON in "Extra Request Options -> Query Parameters" field',
+ });
+ }
+
+ const httpRequest = await configureHttpRequestFunction(this, authentication, itemIndex);
+ const optimizeResponse = configureResponseOptimizer(this, itemIndex);
+
+ let path = this.getNodeParameter('path', itemIndex, '') as string;
+ if (path && path[0] !== '/') {
+ path = '/' + path;
+ }
+ const pathParameters = this.getNodeParameter(
+ 'pathParameters.values',
+ itemIndex,
+ [],
+ ) as ToolParameter[];
+ const queryParameters = this.getNodeParameter(
+ 'queryParameters.values',
+ itemIndex,
+ [],
+ ) as ToolParameter[];
+ const bodyParameters = this.getNodeParameter(
+ 'bodyParameters.values',
+ itemIndex,
+ [],
+ ) as ToolParameter[];
+
+ if (pathParameters.length) {
+ for (const parameter of pathParameters) {
+ if (path.indexOf(`{${parameter.name}}`) === -1) {
+ throw new NodeOperationError(
+ this.getNode(),
+ `'Path' does not contain parameter '${parameter.name}', remove it from 'Path Parameters' or include in 'Path' as {${parameter.name}}`,
+ );
+ }
+ }
+ }
+
+ const parameters = [...pathParameters, ...queryParameters, ...bodyParameters];
+
+ let description = toolDescription;
+ if (parameters.length) {
+ description +=
+ ` extract from prompt ${parameters.map((parameter) => `${parameter.name}(description: ${parameter.description}, type: ${parameter.type})`).join(', ')}` +
+ 'send as JSON';
+ }
+
+ return {
+ response: new DynamicTool({
+ name,
+ description,
+ func: async (query: string): Promise<string> => {
+ const { index } = this.addInputData(NodeConnectionType.AiTool, [[{ json: { query } }]]);
+
+ let response: string = '';
+ let executionError: Error | undefined = undefined;
+
+ try {
+ let toolParameters: IDataObject = {};
+ try {
+ toolParameters = jsonParse<IDataObject>(query);
+ } catch (error) {
+ if (parameters.length === 1) {
+ toolParameters = { [parameters[0].name]: query };
+ }
+ }
+
+ const requestOptions: IHttpRequestOptions = {
+ method,
+ url,
+ };
+
+ if (pathParameters.length) {
+ for (const parameter of pathParameters) {
+ const parameterName = parameter.name;
+ const parameterValue = encodeURIComponent(String(toolParameters[parameterName]));
+ path = path.replace(`{${parameterName}}`, parameterValue);
+ }
+ }
+
+ if (queryParameters.length) {
+ for (const parameter of queryParameters) {
+ const parameterName = parameter.name;
+ const parameterValue = toolParameters[parameterName];
+ qs[parameterName] = parameterValue;
+ }
+ }
+
+ if (bodyParameters.length) {
+ for (const parameter of bodyParameters) {
+ const parameterName = parameter.name;
+ const parameterValue = toolParameters[parameterName];
+ body[parameterName] = parameterValue;
+ }
+ }
+
+ requestOptions.url += path;
+
+ if (Object.keys(headers).length) {
+ requestOptions.headers = headers;
+ }
+
+ if (Object.keys(qs).length) {
+ requestOptions.qs = qs;
+ }
+
+ if (Object.keys(body)) {
+ requestOptions.body = body;
+ }
+
+ response = optimizeResponse(await httpRequest(requestOptions));
+ } catch (error) {
+ executionError = error;
+ response = `There was an error: "${error.message}"`;
+ }
+
+ if (typeof response !== 'string') {
+ executionError = new NodeOperationError(this.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 (executionError) {
+ void this.addOutputData(
+ NodeConnectionType.AiTool,
+ index,
+ executionError as ExecutionError,
+ );
+ } else {
+ void this.addOutputData(NodeConnectionType.AiTool, index, [[{ json: { response } }]]);
+ }
+ return response;
+ },
+ }),
+ };
+ }
+}