fix(Think Tool Node): Use dynamic tool name based on node name (#17364)

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

@@ -1,6 +1,7 @@
 import { DynamicTool } from 'langchain/tools';
 import {
 	NodeConnectionTypes,
+	nodeNameToToolName,
 	type INodeType,
 	type INodeTypeDescription,
 	type ISupplyDataFunctions,
@@ -22,7 +23,7 @@ export class ToolThink implements INodeType {
 		icon: 'fa:brain',
 		iconColor: 'black',
 		group: ['transform'],
-		version: 1,
+		version: [1, 1.1],
 		description: 'Invite the AI agent to do some thinking',
 		defaults: {
 			name: 'Think',
@@ -62,9 +63,14 @@ export class ToolThink implements INodeType {
 	};
 
 	async supplyData(this: ISupplyDataFunctions, itemIndex: number): Promise<SupplyData> {
+		const node = this.getNode();
+		const { typeVersion } = node;
+
+		const name = typeVersion === 1 ? 'thinking_tool' : nodeNameToToolName(node);
 		const description = this.getNodeParameter('description', itemIndex) as string;
+
 		const tool = new DynamicTool({
-			name: 'thinking_tool',
+			name,
 			description,
 			func: async (subject: string) => {
 				return subject;

packages/@n8n/nodes-langchain/nodes/tools/ToolThink/test/ToolThink.node.test.ts

@@ -1,27 +1,34 @@
 import { mock } from 'jest-mock-extended';
 import { DynamicTool } from 'langchain/tools';
-import type { ISupplyDataFunctions } from 'n8n-workflow';
+import type { ISupplyDataFunctions, INode } from 'n8n-workflow';
 
 import { ToolThink } from '../ToolThink.node';
 
 describe('ToolThink', () => {
 	const thinkTool = new ToolThink();
 	const helpers = mock<ISupplyDataFunctions['helpers']>();
-	const executeFunctions = mock<ISupplyDataFunctions>({
+
-		helpers,
+	const createExecuteFunctions = (node: Partial<INode> = { typeVersion: 1 }) => {
-	});
+		const executeFunctions = mock<ISupplyDataFunctions>({
-	executeFunctions.addInputData.mockReturnValue({ index: 0 });
+			helpers,
-	executeFunctions.getNodeParameter.mockImplementation((paramName: string) => {
+		});
-		switch (paramName) {
+		executeFunctions.addInputData.mockReturnValue({ index: 0 });
-			case 'description':
+		executeFunctions.getNodeParameter.mockImplementation((paramName: string) => {
-				return 'Tool description';
+			switch (paramName) {
-			default:
+				case 'description':
-				return undefined;
+					return 'Tool description';
-		}
+				default:
-	});
+					return undefined;
+			}
+		});
+		executeFunctions.getNode.mockReturnValue(mock<INode>(node));
+		return executeFunctions;
+	};
 
 	describe('Tool response', () => {
 		it('should return the same text as response when receiving a text input', async () => {
+			const executeFunctions = createExecuteFunctions();
+
 			const { response } = (await thinkTool.supplyData.call(executeFunctions, 0)) as {
 				response: DynamicTool;
 			};
@@ -30,5 +37,26 @@ describe('ToolThink', () => {
 			const res = (await response.invoke('foo')) as string;
 			expect(res).toEqual('foo');
 		});
+
+		it('should use hardcoded name for version 1', async () => {
+			const executeFunctions = createExecuteFunctions({ typeVersion: 1 });
+
+			const { response } = (await thinkTool.supplyData.call(executeFunctions, 0)) as {
+				response: DynamicTool;
+			};
+			expect(response.name).toEqual('thinking_tool');
+		});
+
+		it('should use dynamic name from node for version 1.1', async () => {
+			const executeFunctions = createExecuteFunctions({
+				typeVersion: 1.1,
+				name: 'My Thinking Tool',
+			});
+
+			const { response } = (await thinkTool.supplyData.call(executeFunctions, 0)) as {
+				response: DynamicTool;
+			};
+			expect(response.name).toEqual('My_Thinking_Tool');
+		});
 	});
 });