@n8n/n8n-nodes-langchain 1.85.2 → 1.86.0

package/dist/nodes/tools/ToolWorkflow/v2/utils/WorkflowToolService.js

@@ -1,221 +1,275 @@
 "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 WorkflowToolService_exports = {};
+__export(WorkflowToolService_exports, {
+  WorkflowToolService: () => WorkflowToolService
 });
-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);
-    };
-    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;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WorkflowToolService = void 0;
-const tools_1 = require("@langchain/core/tools");
-const lodash_1 = require("lodash");
-const manual = __importStar(require("n8n-nodes-base/dist/nodes/Set/v2/manual.mode"));
-const GenericFunctions_1 = require("n8n-nodes-base/dist/utils/workflowInputsResourceMapping/GenericFunctions");
-const n8n_workflow_1 = require("n8n-workflow");
-const zod_1 = require("zod");
+module.exports = __toCommonJS(WorkflowToolService_exports);
+var import_tools = require("@langchain/core/tools");
+var import_lodash = require("lodash");
+var manual = __toESM(require("n8n-nodes-base/dist/nodes/Set/v2/manual.mode"));
+var import_GenericFunctions = require("n8n-nodes-base/dist/utils/workflowInputsResourceMapping/GenericFunctions");
+var import_n8n_workflow = require("n8n-workflow");
+var import_zod = require("zod");
 function isNodeExecutionData(data) {
-    return (0, lodash_1.isArray)(data) && Boolean(data.length) && (0, lodash_1.isObject)(data[0]) && 'json' in data[0];
+  return (0, import_lodash.isArray)(data) && Boolean(data.length) && (0, import_lodash.isObject)(data[0]) && "json" in data[0];
 }
 class WorkflowToolService {
-    constructor(baseContext, options) {
-        this.baseContext = baseContext;
-        this.returnAllItems = false;
-        const subWorkflowInputs = this.baseContext.getNode().parameters
-            .workflowInputs;
-        this.useSchema = (subWorkflowInputs?.schema ?? []).length > 0;
-        this.returnAllItems = options?.returnAllItems ?? false;
-    }
-    async createTool({ name, description, itemIndex, }) {
-        let runIndex = 0;
-        const toolHandler = async (query, runManager) => {
-            const localRunIndex = runIndex++;
-            const context = this.baseContext.cloneWith({
-                runIndex: localRunIndex,
-                inputData: [[{ json: { query } }]],
-            });
-            try {
-                const response = await this.runFunction(context, query, itemIndex, runManager);
-                const processedResponse = this.handleToolResponse(response);
-                let responseData;
-                if (isNodeExecutionData(response)) {
-                    responseData = response;
-                }
-                else {
-                    const reParsedData = (0, n8n_workflow_1.jsonParse)(processedResponse, {
-                        fallbackValue: { response: processedResponse },
-                    });
-                    responseData = [{ json: reParsedData }];
-                }
-                let metadata;
-                if (this.subExecutionId && this.subWorkflowId) {
-                    metadata = {
-                        subExecution: {
-                            executionId: this.subExecutionId,
-                            workflowId: this.subWorkflowId,
-                        },
-                    };
-                }
-                void context.addOutputData(n8n_workflow_1.NodeConnectionTypes.AiTool, localRunIndex, [responseData], metadata);
-                return processedResponse;
-            }
-            catch (error) {
-                const executionError = error;
-                const errorResponse = `There was an error: "${executionError.message}"`;
-                const metadata = (0, n8n_workflow_1.parseErrorMetadata)(error);
-                void context.addOutputData(n8n_workflow_1.NodeConnectionTypes.AiTool, localRunIndex, executionError, metadata);
-                return errorResponse;
-            }
-        };
-        return this.useSchema
-            ? await this.createStructuredTool(name, description, toolHandler)
-            : new tools_1.DynamicTool({ name, description, func: toolHandler });
-    }
-    handleToolResponse(response) {
-        if (typeof response === 'number') {
-            return response.toString();
-        }
+  constructor(baseContext, options) {
+    this.baseContext = baseContext;
+    this.returnAllItems = false;
+    const subWorkflowInputs = this.baseContext.getNode().parameters.workflowInputs;
+    this.useSchema = (subWorkflowInputs?.schema ?? []).length > 0;
+    this.returnAllItems = options?.returnAllItems ?? false;
+  }
+  // Creates the tool based on the provided parameters
+  async createTool({
+    name,
+    description,
+    itemIndex
+  }) {
+    let runIndex = 0;
+    const toolHandler = async (query, runManager) => {
+      const localRunIndex = runIndex++;
+      const context = this.baseContext.cloneWith({
+        runIndex: localRunIndex,
+        inputData: [[{ json: { query } }]]
+      });
+      try {
+        const response = await this.runFunction(context, query, itemIndex, runManager);
+        const processedResponse = this.handleToolResponse(response);
+        let responseData;
         if (isNodeExecutionData(response)) {
-            return JSON.stringify(response.map((item) => item.json), null, 2);
-        }
-        if ((0, lodash_1.isObject)(response)) {
-            return JSON.stringify(response, null, 2);
+          responseData = response;
+        } else {
+          const reParsedData = (0, import_n8n_workflow.jsonParse)(processedResponse, {
+            fallbackValue: { response: processedResponse }
+          });
+          responseData = [{ json: reParsedData }];
         }
-        if (typeof response !== 'string') {
-            throw new n8n_workflow_1.NodeOperationError(this.baseContext.getNode(), 'Wrong output type returned', {
-                description: `The response property should be a string, but it is an ${typeof response}`,
-            });
+        let metadata;
+        if (this.subExecutionId && this.subWorkflowId) {
+          metadata = {
+            subExecution: {
+              executionId: this.subExecutionId,
+              workflowId: this.subWorkflowId
+            }
+          };
         }
-        return response;
+        void context.addOutputData(
+          import_n8n_workflow.NodeConnectionTypes.AiTool,
+          localRunIndex,
+          [responseData],
+          metadata
+        );
+        return processedResponse;
+      } catch (error) {
+        const executionError = error;
+        const errorResponse = `There was an error: "${executionError.message}"`;
+        const metadata = (0, import_n8n_workflow.parseErrorMetadata)(error);
+        void context.addOutputData(
+          import_n8n_workflow.NodeConnectionTypes.AiTool,
+          localRunIndex,
+          executionError,
+          metadata
+        );
+        return errorResponse;
+      }
+    };
+    return this.useSchema ? await this.createStructuredTool(name, description, toolHandler) : new import_tools.DynamicTool({ name, description, func: toolHandler });
+  }
+  handleToolResponse(response) {
+    if (typeof response === "number") {
+      return response.toString();
     }
-    async executeSubWorkflow(context, workflowInfo, items, workflowProxy, runManager) {
-        let receivedData;
-        try {
-            receivedData = await context.executeWorkflow(workflowInfo, items, runManager?.getChild(), {
-                parentExecution: {
-                    executionId: workflowProxy.$execution.id,
-                    workflowId: workflowProxy.$workflow.id,
-                },
-            });
-            this.subExecutionId = receivedData.executionId;
-        }
-        catch (error) {
-            throw new n8n_workflow_1.NodeOperationError(context.getNode(), error);
-        }
-        let response;
-        if (this.returnAllItems) {
-            response = receivedData?.data?.[0]?.length ? receivedData.data[0] : undefined;
-        }
-        else {
-            response = receivedData?.data?.[0]?.[0]?.json;
-        }
-        if (response === undefined) {
-            throw new n8n_workflow_1.NodeOperationError(context.getNode(), 'There was an error: "The workflow did not return a response"');
-        }
-        return { response, subExecutionId: receivedData.executionId };
+    if (isNodeExecutionData(response)) {
+      return JSON.stringify(
+        response.map((item) => item.json),
+        null,
+        2
+      );
     }
-    async runFunction(context, query, itemIndex, runManager) {
-        const source = context.getNodeParameter('source', itemIndex);
-        const workflowProxy = context.getWorkflowDataProxy(0);
-        const { workflowInfo } = await this.getSubWorkflowInfo(context, source, itemIndex, workflowProxy);
-        const rawData = this.prepareRawData(context, query, itemIndex);
-        const items = await this.prepareWorkflowItems(context, query, itemIndex, rawData);
-        this.subWorkflowId = workflowInfo.id;
-        const { response } = await this.executeSubWorkflow(context, workflowInfo, items, workflowProxy, runManager);
-        return response;
+    if ((0, import_lodash.isObject)(response)) {
+      return JSON.stringify(response, null, 2);
     }
-    async getSubWorkflowInfo(context, source, itemIndex, workflowProxy) {
-        const workflowInfo = {};
-        let subWorkflowId;
-        if (source === 'database') {
-            const { value } = context.getNodeParameter('workflowId', itemIndex, {});
-            workflowInfo.id = value;
-            subWorkflowId = workflowInfo.id;
-        }
-        else if (source === 'parameter') {
-            const workflowJson = context.getNodeParameter('workflowJson', itemIndex);
-            try {
-                workflowInfo.code = JSON.parse(workflowJson);
-                subWorkflowId = workflowProxy.$workflow.id;
-            }
-            catch (error) {
-                throw new n8n_workflow_1.NodeOperationError(context.getNode(), `The provided workflow is not valid JSON: "${error.message}"`, { itemIndex });
-            }
-        }
-        return { workflowInfo, subWorkflowId: subWorkflowId };
+    if (typeof response !== "string") {
+      throw new import_n8n_workflow.NodeOperationError(this.baseContext.getNode(), "Wrong output type returned", {
+        description: `The response property should be a string, but it is an ${typeof response}`
+      });
     }
-    prepareRawData(context, query, itemIndex) {
-        const rawData = { query };
-        const workflowFieldsJson = context.getNodeParameter('fields.values', itemIndex, [], {
-            rawExpressions: true,
-        });
-        for (const entry of workflowFieldsJson) {
-            if (entry.type === 'objectValue' && entry.objectValue.startsWith('=')) {
-                rawData[entry.name] = entry.objectValue.replace(/^=+/, '');
-            }
+    return response;
+  }
+  /**
+   * Executes specified sub-workflow with provided inputs
+   */
+  async executeSubWorkflow(context, workflowInfo, items, workflowProxy, runManager) {
+    let receivedData;
+    try {
+      receivedData = await context.executeWorkflow(workflowInfo, items, runManager?.getChild(), {
+        parentExecution: {
+          executionId: workflowProxy.$execution.id,
+          workflowId: workflowProxy.$workflow.id
         }
-        return rawData;
+      });
+      this.subExecutionId = receivedData.executionId;
+    } catch (error) {
+      throw new import_n8n_workflow.NodeOperationError(context.getNode(), error);
     }
-    async prepareWorkflowItems(context, query, itemIndex, rawData) {
-        const options = { include: 'all' };
-        let jsonData = typeof query === 'object' ? query : { query };
-        if (this.useSchema) {
-            const currentWorkflowInputs = GenericFunctions_1.getCurrentWorkflowInputData.call(context);
-            jsonData = currentWorkflowInputs[itemIndex].json;
-        }
-        const newItem = await manual.execute.call(context, { json: jsonData }, itemIndex, options, rawData, context.getNode());
-        return [newItem];
+    let response;
+    if (this.returnAllItems) {
+      response = receivedData?.data?.[0]?.length ? receivedData.data[0] : void 0;
+    } else {
+      response = receivedData?.data?.[0]?.[0]?.json;
     }
-    async createStructuredTool(name, description, func) {
-        const collectedArguments = await this.extractFromAIParameters();
-        if (collectedArguments.length === 0) {
-            return new tools_1.DynamicTool({ name, description, func });
-        }
-        const schema = this.createZodSchema(collectedArguments);
-        return new tools_1.DynamicStructuredTool({ schema, name, description, func });
+    if (response === void 0) {
+      throw new import_n8n_workflow.NodeOperationError(
+        context.getNode(),
+        'There was an error: "The workflow did not return a response"'
+      );
     }
-    async extractFromAIParameters() {
-        const collectedArguments = [];
-        (0, n8n_workflow_1.traverseNodeParameters)(this.baseContext.getNode().parameters, collectedArguments);
-        const uniqueArgsMap = new Map();
-        for (const arg of collectedArguments) {
-            uniqueArgsMap.set(arg.key, arg);
-        }
-        return Array.from(uniqueArgsMap.values());
+    return { response, subExecutionId: receivedData.executionId };
+  }
+  /**
+   * Gets the sub-workflow info based on the source and executes it.
+   * This function will be called as part of the tool execution (from the toolHandler)
+   */
+  async runFunction(context, query, itemIndex, runManager) {
+    const source = context.getNodeParameter("source", itemIndex);
+    const workflowProxy = context.getWorkflowDataProxy(0);
+    const { workflowInfo } = await this.getSubWorkflowInfo(
+      context,
+      source,
+      itemIndex,
+      workflowProxy
+    );
+    const rawData = this.prepareRawData(context, query, itemIndex);
+    const items = await this.prepareWorkflowItems(context, query, itemIndex, rawData);
+    this.subWorkflowId = workflowInfo.id;
+    const { response } = await this.executeSubWorkflow(
+      context,
+      workflowInfo,
+      items,
+      workflowProxy,
+      runManager
+    );
+    return response;
+  }
+  /**
+   * Gets the sub-workflow info based on the source (database or parameter)
+   */
+  async getSubWorkflowInfo(context, source, itemIndex, workflowProxy) {
+    const workflowInfo = {};
+    let subWorkflowId;
+    if (source === "database") {
+      const { value } = context.getNodeParameter(
+        "workflowId",
+        itemIndex,
+        {}
+      );
+      workflowInfo.id = value;
+      subWorkflowId = workflowInfo.id;
+    } else if (source === "parameter") {
+      const workflowJson = context.getNodeParameter("workflowJson", itemIndex);
+      try {
+        workflowInfo.code = JSON.parse(workflowJson);
+        subWorkflowId = workflowProxy.$workflow.id;
+      } catch (error) {
+        throw new import_n8n_workflow.NodeOperationError(
+          context.getNode(),
+          `The provided workflow is not valid JSON: "${error.message}"`,
+          { itemIndex }
+        );
+      }
+    }
+    return { workflowInfo, subWorkflowId };
+  }
+  prepareRawData(context, query, itemIndex) {
+    const rawData = { query };
+    const workflowFieldsJson = context.getNodeParameter("fields.values", itemIndex, [], {
+      rawExpressions: true
+    });
+    for (const entry of workflowFieldsJson) {
+      if (entry.type === "objectValue" && entry.objectValue.startsWith("=")) {
+        rawData[entry.name] = entry.objectValue.replace(/^=+/, "");
+      }
     }
-    createZodSchema(args) {
-        const schemaObj = args.reduce((acc, placeholder) => {
-            acc[placeholder.key] = (0, n8n_workflow_1.generateZodSchema)(placeholder);
-            return acc;
-        }, {});
-        return zod_1.z.object(schemaObj).required();
+    return rawData;
+  }
+  /**
+   * Prepares the sub-workflow items for execution
+   */
+  async prepareWorkflowItems(context, query, itemIndex, rawData) {
+    const options = { include: "all" };
+    let jsonData = typeof query === "object" ? query : { query };
+    if (this.useSchema) {
+      const currentWorkflowInputs = import_GenericFunctions.getCurrentWorkflowInputData.call(context);
+      jsonData = currentWorkflowInputs[itemIndex].json;
     }
+    const newItem = await manual.execute.call(
+      context,
+      { json: jsonData },
+      itemIndex,
+      options,
+      rawData,
+      context.getNode()
+    );
+    return [newItem];
+  }
+  /**
+   *  Create structured tool by parsing the sub-workflow input schema
+   */
+  async createStructuredTool(name, description, func) {
+    const collectedArguments = await this.extractFromAIParameters();
+    if (collectedArguments.length === 0) {
+      return new import_tools.DynamicTool({ name, description, func });
+    }
+    const schema = this.createZodSchema(collectedArguments);
+    return new import_tools.DynamicStructuredTool({ schema, name, description, func });
+  }
+  async extractFromAIParameters() {
+    const collectedArguments = [];
+    (0, import_n8n_workflow.traverseNodeParameters)(this.baseContext.getNode().parameters, collectedArguments);
+    const uniqueArgsMap = /* @__PURE__ */ new Map();
+    for (const arg of collectedArguments) {
+      uniqueArgsMap.set(arg.key, arg);
+    }
+    return Array.from(uniqueArgsMap.values());
+  }
+  createZodSchema(args) {
+    const schemaObj = args.reduce((acc, placeholder) => {
+      acc[placeholder.key] = (0, import_n8n_workflow.generateZodSchema)(placeholder);
+      return acc;
+    }, {});
+    return import_zod.z.object(schemaObj).required();
+  }
 }
-exports.WorkflowToolService = WorkflowToolService;
-//# sourceMappingURL=WorkflowToolService.js.map
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  WorkflowToolService
+});