@n8n/n8n-nodes-langchain 1.85.2 → 1.86.0

package/dist/nodes/chains/ChainSummarization/V2/ChainSummarizationV2.node.js

@@ -1,357 +1,401 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ChainSummarizationV2 = void 0;
-const textsplitters_1 = require("@langchain/textsplitters");
-const chains_1 = require("langchain/chains");
-const n8n_workflow_1 = require("n8n-workflow");
-const N8nBinaryLoader_1 = require("../../../../utils/N8nBinaryLoader");
-const N8nJsonLoader_1 = require("../../../../utils/N8nJsonLoader");
-const sharedFields_1 = require("../../../../utils/sharedFields");
-const tracing_1 = require("../../../../utils/tracing");
-const helpers_1 = require("../helpers");
-const prompt_1 = require("../prompt");
+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 ChainSummarizationV2_node_exports = {};
+__export(ChainSummarizationV2_node_exports, {
+  ChainSummarizationV2: () => ChainSummarizationV2
+});
+module.exports = __toCommonJS(ChainSummarizationV2_node_exports);
+var import_textsplitters = require("@langchain/textsplitters");
+var import_chains = require("langchain/chains");
+var import_n8n_workflow = require("n8n-workflow");
+var import_N8nBinaryLoader = require("../../../../utils/N8nBinaryLoader");
+var import_N8nJsonLoader = require("../../../../utils/N8nJsonLoader");
+var import_sharedFields = require("../../../../utils/sharedFields");
+var import_tracing = require("../../../../utils/tracing");
+var import_helpers = require("../helpers");
+var import_prompt = require("../prompt");
 function getInputs(parameters) {
-    const chunkingMode = parameters?.chunkingMode;
-    const operationMode = parameters?.operationMode;
-    const inputs = [
-        { displayName: '', type: 'main' },
-        {
-            displayName: 'Model',
-            maxConnections: 1,
-            type: 'ai_languageModel',
-            required: true,
-        },
-    ];
-    if (operationMode === 'documentLoader') {
-        inputs.push({
-            displayName: 'Document',
-            type: 'ai_document',
-            required: true,
-            maxConnections: 1,
-        });
-        return inputs;
-    }
-    if (chunkingMode === 'advanced') {
-        inputs.push({
-            displayName: 'Text Splitter',
-            type: 'ai_textSplitter',
-            required: false,
-            maxConnections: 1,
-        });
-        return inputs;
+  const chunkingMode = parameters?.chunkingMode;
+  const operationMode = parameters?.operationMode;
+  const inputs = [
+    { displayName: "", type: "main" },
+    {
+      displayName: "Model",
+      maxConnections: 1,
+      type: "ai_languageModel",
+      required: true
     }
+  ];
+  if (operationMode === "documentLoader") {
+    inputs.push({
+      displayName: "Document",
+      type: "ai_document",
+      required: true,
+      maxConnections: 1
+    });
+    return inputs;
+  }
+  if (chunkingMode === "advanced") {
+    inputs.push({
+      displayName: "Text Splitter",
+      type: "ai_textSplitter",
+      required: false,
+      maxConnections: 1
+    });
     return inputs;
+  }
+  return inputs;
 }
 class ChainSummarizationV2 {
-    constructor(baseDescription) {
-        this.description = {
-            ...baseDescription,
-            version: [2],
-            defaults: {
-                name: 'Summarization Chain',
-                color: '#909298',
+  constructor(baseDescription) {
+    this.description = {
+      ...baseDescription,
+      version: [2],
+      defaults: {
+        name: "Summarization Chain",
+        color: "#909298"
+      },
+      // eslint-disable-next-line n8n-nodes-base/node-class-description-inputs-wrong-regular-node
+      inputs: `={{ ((parameter) => { ${getInputs.toString()}; return getInputs(parameter) })($parameter) }}`,
+      outputs: [import_n8n_workflow.NodeConnectionTypes.Main],
+      credentials: [],
+      properties: [
+        (0, import_sharedFields.getTemplateNoticeField)(1951),
+        {
+          displayName: "Data to Summarize",
+          name: "operationMode",
+          noDataExpression: true,
+          type: "options",
+          description: "How to pass data into the summarization chain",
+          default: "nodeInputJson",
+          options: [
+            {
+              name: "Use Node Input (JSON)",
+              value: "nodeInputJson",
+              description: "Summarize the JSON data coming into this node from the previous one"
+            },
+            {
+              name: "Use Node Input (Binary)",
+              value: "nodeInputBinary",
+              description: "Summarize the binary data coming into this node from the previous one"
+            },
+            {
+              name: "Use Document Loader",
+              value: "documentLoader",
+              description: "Use a loader sub-node with more configuration options"
+            }
+          ]
+        },
+        {
+          displayName: "Chunking Strategy",
+          name: "chunkingMode",
+          noDataExpression: true,
+          type: "options",
+          description: "Chunk splitting strategy",
+          default: "simple",
+          options: [
+            {
+              name: "Simple (Define Below)",
+              value: "simple"
+            },
+            {
+              name: "Advanced",
+              value: "advanced",
+              description: "Use a splitter sub-node with more configuration options"
+            }
+          ],
+          displayOptions: {
+            show: {
+              "/operationMode": ["nodeInputJson", "nodeInputBinary"]
+            }
+          }
+        },
+        {
+          displayName: "Characters Per Chunk",
+          name: "chunkSize",
+          description: "Controls the max size (in terms of number of characters) of the final document chunk",
+          type: "number",
+          default: 1e3,
+          displayOptions: {
+            show: {
+              "/chunkingMode": ["simple"]
+            }
+          }
+        },
+        {
+          displayName: "Chunk Overlap (Characters)",
+          name: "chunkOverlap",
+          type: "number",
+          description: "Specifies how much characters overlap there should be between chunks",
+          default: 200,
+          displayOptions: {
+            show: {
+              "/chunkingMode": ["simple"]
+            }
+          }
+        },
+        {
+          displayName: "Options",
+          name: "options",
+          type: "collection",
+          default: {},
+          placeholder: "Add Option",
+          options: [
+            {
+              displayName: "Input Data Field Name",
+              name: "binaryDataKey",
+              type: "string",
+              default: "data",
+              description: "The name of the field in the agent or chain\u2019s input that contains the binary file to be processed",
+              displayOptions: {
+                show: {
+                  "/operationMode": ["nodeInputBinary"]
+                }
+              }
             },
-            inputs: `={{ ((parameter) => { ${getInputs.toString()}; return getInputs(parameter) })($parameter) }}`,
-            outputs: [n8n_workflow_1.NodeConnectionTypes.Main],
-            credentials: [],
-            properties: [
-                (0, sharedFields_1.getTemplateNoticeField)(1951),
+            {
+              displayName: "Summarization Method and Prompts",
+              name: "summarizationMethodAndPrompts",
+              type: "fixedCollection",
+              default: {
+                values: {
+                  summarizationMethod: "map_reduce",
+                  prompt: import_prompt.DEFAULT_PROMPT_TEMPLATE,
+                  combineMapPrompt: import_prompt.DEFAULT_PROMPT_TEMPLATE
+                }
+              },
+              placeholder: "Add Option",
+              typeOptions: {},
+              options: [
                 {
-                    displayName: 'Data to Summarize',
-                    name: 'operationMode',
-                    noDataExpression: true,
-                    type: 'options',
-                    description: 'How to pass data into the summarization chain',
-                    default: 'nodeInputJson',
-                    options: [
+                  name: "values",
+                  displayName: "Values",
+                  values: [
+                    {
+                      displayName: "Summarization Method",
+                      name: "summarizationMethod",
+                      type: "options",
+                      description: "The type of summarization to run",
+                      default: "map_reduce",
+                      options: [
                         {
-                            name: 'Use Node Input (JSON)',
-                            value: 'nodeInputJson',
-                            description: 'Summarize the JSON data coming into this node from the previous one',
+                          name: "Map Reduce (Recommended)",
+                          value: "map_reduce",
+                          description: "Summarize each document (or chunk) individually, then summarize those summaries"
                         },
                         {
-                            name: 'Use Node Input (Binary)',
-                            value: 'nodeInputBinary',
-                            description: 'Summarize the binary data coming into this node from the previous one',
+                          name: "Refine",
+                          value: "refine",
+                          description: "Summarize the first document (or chunk). Then update that summary based on the next document (or chunk), and repeat."
                         },
                         {
-                            name: 'Use Document Loader',
-                            value: 'documentLoader',
-                            description: 'Use a loader sub-node with more configuration options',
-                        },
-                    ],
-                },
-                {
-                    displayName: 'Chunking Strategy',
-                    name: 'chunkingMode',
-                    noDataExpression: true,
-                    type: 'options',
-                    description: 'Chunk splitting strategy',
-                    default: 'simple',
-                    options: [
-                        {
-                            name: 'Simple (Define Below)',
-                            value: 'simple',
-                        },
-                        {
-                            name: 'Advanced',
-                            value: 'advanced',
-                            description: 'Use a splitter sub-node with more configuration options',
-                        },
-                    ],
-                    displayOptions: {
-                        show: {
-                            '/operationMode': ['nodeInputJson', 'nodeInputBinary'],
-                        },
+                          name: "Stuff",
+                          value: "stuff",
+                          description: "Pass all documents (or chunks) at once. Ideal for small datasets."
+                        }
+                      ]
                     },
-                },
-                {
-                    displayName: 'Characters Per Chunk',
-                    name: 'chunkSize',
-                    description: 'Controls the max size (in terms of number of characters) of the final document chunk',
-                    type: 'number',
-                    default: 1000,
-                    displayOptions: {
-                        show: {
-                            '/chunkingMode': ['simple'],
-                        },
+                    {
+                      displayName: "Individual Summary Prompt",
+                      name: "combineMapPrompt",
+                      type: "string",
+                      hint: "The prompt to summarize an individual document (or chunk)",
+                      displayOptions: {
+                        hide: {
+                          "/options.summarizationMethodAndPrompts.values.summarizationMethod": [
+                            "stuff",
+                            "refine"
+                          ]
+                        }
+                      },
+                      default: import_prompt.DEFAULT_PROMPT_TEMPLATE,
+                      typeOptions: {
+                        rows: 9
+                      }
                     },
-                },
-                {
-                    displayName: 'Chunk Overlap (Characters)',
-                    name: 'chunkOverlap',
-                    type: 'number',
-                    description: 'Specifies how much characters overlap there should be between chunks',
-                    default: 200,
-                    displayOptions: {
-                        show: {
-                            '/chunkingMode': ['simple'],
-                        },
+                    {
+                      displayName: "Final Prompt to Combine",
+                      name: "prompt",
+                      type: "string",
+                      default: import_prompt.DEFAULT_PROMPT_TEMPLATE,
+                      hint: "The prompt to combine individual summaries",
+                      displayOptions: {
+                        hide: {
+                          "/options.summarizationMethodAndPrompts.values.summarizationMethod": [
+                            "stuff",
+                            "refine"
+                          ]
+                        }
+                      },
+                      typeOptions: {
+                        rows: 9
+                      }
                     },
-                },
-                {
-                    displayName: 'Options',
-                    name: 'options',
-                    type: 'collection',
-                    default: {},
-                    placeholder: 'Add Option',
-                    options: [
-                        {
-                            displayName: 'Input Data Field Name',
-                            name: 'binaryDataKey',
-                            type: 'string',
-                            default: 'data',
-                            description: 'The name of the field in the agent or chain’s input that contains the binary file to be processed',
-                            displayOptions: {
-                                show: {
-                                    '/operationMode': ['nodeInputBinary'],
-                                },
-                            },
-                        },
-                        {
-                            displayName: 'Summarization Method and Prompts',
-                            name: 'summarizationMethodAndPrompts',
-                            type: 'fixedCollection',
-                            default: {
-                                values: {
-                                    summarizationMethod: 'map_reduce',
-                                    prompt: prompt_1.DEFAULT_PROMPT_TEMPLATE,
-                                    combineMapPrompt: prompt_1.DEFAULT_PROMPT_TEMPLATE,
-                                },
-                            },
-                            placeholder: 'Add Option',
-                            typeOptions: {},
-                            options: [
-                                {
-                                    name: 'values',
-                                    displayName: 'Values',
-                                    values: [
-                                        {
-                                            displayName: 'Summarization Method',
-                                            name: 'summarizationMethod',
-                                            type: 'options',
-                                            description: 'The type of summarization to run',
-                                            default: 'map_reduce',
-                                            options: [
-                                                {
-                                                    name: 'Map Reduce (Recommended)',
-                                                    value: 'map_reduce',
-                                                    description: 'Summarize each document (or chunk) individually, then summarize those summaries',
-                                                },
-                                                {
-                                                    name: 'Refine',
-                                                    value: 'refine',
-                                                    description: 'Summarize the first document (or chunk). Then update that summary based on the next document (or chunk), and repeat.',
-                                                },
-                                                {
-                                                    name: 'Stuff',
-                                                    value: 'stuff',
-                                                    description: 'Pass all documents (or chunks) at once. Ideal for small datasets.',
-                                                },
-                                            ],
-                                        },
-                                        {
-                                            displayName: 'Individual Summary Prompt',
-                                            name: 'combineMapPrompt',
-                                            type: 'string',
-                                            hint: 'The prompt to summarize an individual document (or chunk)',
-                                            displayOptions: {
-                                                hide: {
-                                                    '/options.summarizationMethodAndPrompts.values.summarizationMethod': [
-                                                        'stuff',
-                                                        'refine',
-                                                    ],
-                                                },
-                                            },
-                                            default: prompt_1.DEFAULT_PROMPT_TEMPLATE,
-                                            typeOptions: {
-                                                rows: 9,
-                                            },
-                                        },
-                                        {
-                                            displayName: 'Final Prompt to Combine',
-                                            name: 'prompt',
-                                            type: 'string',
-                                            default: prompt_1.DEFAULT_PROMPT_TEMPLATE,
-                                            hint: 'The prompt to combine individual summaries',
-                                            displayOptions: {
-                                                hide: {
-                                                    '/options.summarizationMethodAndPrompts.values.summarizationMethod': [
-                                                        'stuff',
-                                                        'refine',
-                                                    ],
-                                                },
-                                            },
-                                            typeOptions: {
-                                                rows: 9,
-                                            },
-                                        },
-                                        {
-                                            displayName: 'Prompt',
-                                            name: 'prompt',
-                                            type: 'string',
-                                            default: prompt_1.DEFAULT_PROMPT_TEMPLATE,
-                                            displayOptions: {
-                                                hide: {
-                                                    '/options.summarizationMethodAndPrompts.values.summarizationMethod': [
-                                                        'refine',
-                                                        'map_reduce',
-                                                    ],
-                                                },
-                                            },
-                                            typeOptions: {
-                                                rows: 9,
-                                            },
-                                        },
-                                        {
-                                            displayName: 'Subsequent (Refine) Prompt',
-                                            name: 'refinePrompt',
-                                            type: 'string',
-                                            displayOptions: {
-                                                hide: {
-                                                    '/options.summarizationMethodAndPrompts.values.summarizationMethod': [
-                                                        'stuff',
-                                                        'map_reduce',
-                                                    ],
-                                                },
-                                            },
-                                            default: prompt_1.REFINE_PROMPT_TEMPLATE,
-                                            hint: 'The prompt to refine the summary based on the next document (or chunk)',
-                                            typeOptions: {
-                                                rows: 9,
-                                            },
-                                        },
-                                        {
-                                            displayName: 'Initial Prompt',
-                                            name: 'refineQuestionPrompt',
-                                            type: 'string',
-                                            displayOptions: {
-                                                hide: {
-                                                    '/options.summarizationMethodAndPrompts.values.summarizationMethod': [
-                                                        'stuff',
-                                                        'map_reduce',
-                                                    ],
-                                                },
-                                            },
-                                            default: prompt_1.DEFAULT_PROMPT_TEMPLATE,
-                                            hint: 'The prompt for the first document (or chunk)',
-                                            typeOptions: {
-                                                rows: 9,
-                                            },
-                                        },
-                                    ],
-                                },
-                            ],
-                        },
-                    ],
-                },
-            ],
-        };
-    }
-    async execute() {
-        this.logger.debug('Executing Summarization Chain V2');
-        const operationMode = this.getNodeParameter('operationMode', 0, 'nodeInputJson');
-        const chunkingMode = this.getNodeParameter('chunkingMode', 0, 'simple');
-        const items = this.getInputData();
-        const returnData = [];
-        for (let itemIndex = 0; itemIndex < items.length; itemIndex++) {
-            try {
-                const model = (await this.getInputConnectionData(n8n_workflow_1.NodeConnectionTypes.AiLanguageModel, 0));
-                const summarizationMethodAndPrompts = this.getNodeParameter('options.summarizationMethodAndPrompts.values', itemIndex, {});
-                const chainArgs = (0, helpers_1.getChainPromptsArgs)(summarizationMethodAndPrompts.summarizationMethod ?? 'map_reduce', summarizationMethodAndPrompts);
-                const chain = (0, chains_1.loadSummarizationChain)(model, chainArgs);
-                const item = items[itemIndex];
-                let processedDocuments;
-                if (operationMode === 'documentLoader') {
-                    const documentInput = (await this.getInputConnectionData(n8n_workflow_1.NodeConnectionTypes.AiDocument, 0));
-                    const isN8nLoader = documentInput instanceof N8nJsonLoader_1.N8nJsonLoader || documentInput instanceof N8nBinaryLoader_1.N8nBinaryLoader;
-                    processedDocuments = isN8nLoader
-                        ? await documentInput.processItem(item, itemIndex)
-                        : documentInput;
-                    const response = await chain.withConfig((0, tracing_1.getTracingConfig)(this)).invoke({
-                        input_documents: processedDocuments,
-                    });
-                    returnData.push({ json: { response } });
-                }
-                if (['nodeInputJson', 'nodeInputBinary'].includes(operationMode)) {
-                    let textSplitter;
-                    switch (chunkingMode) {
-                        case 'simple':
-                            const chunkSize = this.getNodeParameter('chunkSize', itemIndex, 1000);
-                            const chunkOverlap = this.getNodeParameter('chunkOverlap', itemIndex, 200);
-                            textSplitter = new textsplitters_1.RecursiveCharacterTextSplitter({ chunkOverlap, chunkSize });
-                            break;
-                        case 'advanced':
-                            textSplitter = (await this.getInputConnectionData(n8n_workflow_1.NodeConnectionTypes.AiTextSplitter, 0));
-                            break;
-                        default:
-                            break;
-                    }
-                    let processor;
-                    if (operationMode === 'nodeInputBinary') {
-                        const binaryDataKey = this.getNodeParameter('options.binaryDataKey', itemIndex, 'data');
-                        processor = new N8nBinaryLoader_1.N8nBinaryLoader(this, 'options.', binaryDataKey, textSplitter);
-                    }
-                    else {
-                        processor = new N8nJsonLoader_1.N8nJsonLoader(this, 'options.', textSplitter);
+                    {
+                      displayName: "Prompt",
+                      name: "prompt",
+                      type: "string",
+                      default: import_prompt.DEFAULT_PROMPT_TEMPLATE,
+                      displayOptions: {
+                        hide: {
+                          "/options.summarizationMethodAndPrompts.values.summarizationMethod": [
+                            "refine",
+                            "map_reduce"
+                          ]
+                        }
+                      },
+                      typeOptions: {
+                        rows: 9
+                      }
+                    },
+                    {
+                      displayName: "Subsequent (Refine) Prompt",
+                      name: "refinePrompt",
+                      type: "string",
+                      displayOptions: {
+                        hide: {
+                          "/options.summarizationMethodAndPrompts.values.summarizationMethod": [
+                            "stuff",
+                            "map_reduce"
+                          ]
+                        }
+                      },
+                      default: import_prompt.REFINE_PROMPT_TEMPLATE,
+                      hint: "The prompt to refine the summary based on the next document (or chunk)",
+                      typeOptions: {
+                        rows: 9
+                      }
+                    },
+                    {
+                      displayName: "Initial Prompt",
+                      name: "refineQuestionPrompt",
+                      type: "string",
+                      displayOptions: {
+                        hide: {
+                          "/options.summarizationMethodAndPrompts.values.summarizationMethod": [
+                            "stuff",
+                            "map_reduce"
+                          ]
+                        }
+                      },
+                      default: import_prompt.DEFAULT_PROMPT_TEMPLATE,
+                      hint: "The prompt for the first document (or chunk)",
+                      typeOptions: {
+                        rows: 9
+                      }
                     }
-                    const processedItem = await processor.processItem(item, itemIndex);
-                    const response = await chain.invoke({
-                        input_documents: processedItem,
-                    }, { signal: this.getExecutionCancelSignal() });
-                    returnData.push({ json: { response } });
+                  ]
                 }
+              ]
             }
-            catch (error) {
-                if (this.continueOnFail()) {
-                    returnData.push({ json: { error: error.message }, pairedItem: { item: itemIndex } });
-                    continue;
-                }
-                throw error;
-            }
+          ]
+        }
+      ]
+    };
+  }
+  async execute() {
+    this.logger.debug("Executing Summarization Chain V2");
+    const operationMode = this.getNodeParameter("operationMode", 0, "nodeInputJson");
+    const chunkingMode = this.getNodeParameter("chunkingMode", 0, "simple");
+    const items = this.getInputData();
+    const returnData = [];
+    for (let itemIndex = 0; itemIndex < items.length; itemIndex++) {
+      try {
+        const model = await this.getInputConnectionData(
+          import_n8n_workflow.NodeConnectionTypes.AiLanguageModel,
+          0
+        );
+        const summarizationMethodAndPrompts = this.getNodeParameter(
+          "options.summarizationMethodAndPrompts.values",
+          itemIndex,
+          {}
+        );
+        const chainArgs = (0, import_helpers.getChainPromptsArgs)(
+          summarizationMethodAndPrompts.summarizationMethod ?? "map_reduce",
+          summarizationMethodAndPrompts
+        );
+        const chain = (0, import_chains.loadSummarizationChain)(model, chainArgs);
+        const item = items[itemIndex];
+        let processedDocuments;
+        if (operationMode === "documentLoader") {
+          const documentInput = await this.getInputConnectionData(
+            import_n8n_workflow.NodeConnectionTypes.AiDocument,
+            0
+          );
+          const isN8nLoader = documentInput instanceof import_N8nJsonLoader.N8nJsonLoader || documentInput instanceof import_N8nBinaryLoader.N8nBinaryLoader;
+          processedDocuments = isN8nLoader ? await documentInput.processItem(item, itemIndex) : documentInput;
+          const response = await chain.withConfig((0, import_tracing.getTracingConfig)(this)).invoke({
+            input_documents: processedDocuments
+          });
+          returnData.push({ json: { response } });
+        }
+        if (["nodeInputJson", "nodeInputBinary"].includes(operationMode)) {
+          let textSplitter;
+          switch (chunkingMode) {
+            // In simple mode we use recursive character splitter with default settings
+            case "simple":
+              const chunkSize = this.getNodeParameter("chunkSize", itemIndex, 1e3);
+              const chunkOverlap = this.getNodeParameter("chunkOverlap", itemIndex, 200);
+              textSplitter = new import_textsplitters.RecursiveCharacterTextSplitter({ chunkOverlap, chunkSize });
+              break;
+            // In advanced mode user can connect text splitter node so we just retrieve it
+            case "advanced":
+              textSplitter = await this.getInputConnectionData(
+                import_n8n_workflow.NodeConnectionTypes.AiTextSplitter,
+                0
+              );
+              break;
+            default:
+              break;
+          }
+          let processor;
+          if (operationMode === "nodeInputBinary") {
+            const binaryDataKey = this.getNodeParameter(
+              "options.binaryDataKey",
+              itemIndex,
+              "data"
+            );
+            processor = new import_N8nBinaryLoader.N8nBinaryLoader(this, "options.", binaryDataKey, textSplitter);
+          } else {
+            processor = new import_N8nJsonLoader.N8nJsonLoader(this, "options.", textSplitter);
+          }
+          const processedItem = await processor.processItem(item, itemIndex);
+          const response = await chain.invoke(
+            {
+              input_documents: processedItem
+            },
+            { signal: this.getExecutionCancelSignal() }
+          );
+          returnData.push({ json: { response } });
+        }
+      } catch (error) {
+        if (this.continueOnFail()) {
+          returnData.push({ json: { error: error.message }, pairedItem: { item: itemIndex } });
+          continue;
         }
-        return [returnData];
+        throw error;
+      }
     }
+    return [returnData];
+  }
 }
-exports.ChainSummarizationV2 = ChainSummarizationV2;
-//# sourceMappingURL=ChainSummarizationV2.node.js.map
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ChainSummarizationV2
+});