@n8n/n8n-nodes-langchain 2.5.2 → 2.6.0

package/dist/utils/logWrapper.js

@@ -1,376 +1,331 @@
 "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 logWrapper_exports = {};
-__export(logWrapper_exports, {
-  callMethodAsync: () => callMethodAsync,
-  callMethodSync: () => callMethodSync,
-  logWrapper: () => logWrapper
-});
-module.exports = __toCommonJS(logWrapper_exports);
-var import_embeddings = require("@langchain/core/embeddings");
-var import_retrievers = require("@langchain/core/retrievers");
-var import_document_compressors = require("@langchain/core/retrievers/document_compressors");
-var import_vectorstores = require("@langchain/core/vectorstores");
-var import_textsplitters = require("@langchain/textsplitters");
-var import_openai = require("@langchain/openai");
-var import_n8n_workflow = require("n8n-workflow");
-var import_embeddingInputValidation = require("./embeddings/embeddingInputValidation");
-var import_helpers = require("./helpers");
-var import_N8nBinaryLoader = require("./N8nBinaryLoader");
-var import_N8nJsonLoader = require("./N8nJsonLoader");
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.callMethodAsync = callMethodAsync;
+exports.callMethodSync = callMethodSync;
+exports.logWrapper = logWrapper;
+const embeddings_1 = require("@langchain/core/embeddings");
+const retrievers_1 = require("@langchain/core/retrievers");
+const document_compressors_1 = require("@langchain/core/retrievers/document_compressors");
+const vectorstores_1 = require("@langchain/core/vectorstores");
+const textsplitters_1 = require("@langchain/textsplitters");
+const openai_1 = require("@langchain/openai");
+const n8n_workflow_1 = require("n8n-workflow");
+const embeddingInputValidation_1 = require("./embeddings/embeddingInputValidation");
+const helpers_1 = require("./helpers");
+const N8nBinaryLoader_1 = require("./N8nBinaryLoader");
+const N8nJsonLoader_1 = require("./N8nJsonLoader");
 async function callMethodAsync(parameters) {
-  try {
-    return await parameters.method.call(this, ...parameters.arguments);
-  } catch (e) {
-    const connectedNode = parameters.executeFunctions.getNode();
-    const error = new import_n8n_workflow.NodeOperationError(connectedNode, e, {
-      functionality: "configuration-node"
-    });
-    const metadata = (0, import_n8n_workflow.parseErrorMetadata)(error);
-    parameters.executeFunctions.addOutputData(
-      parameters.connectionType,
-      parameters.currentNodeRunIndex,
-      error,
-      metadata
-    );
-    if (error.message) {
-      if (!error.description) {
-        error.description = error.message;
-      }
-      throw error;
+    try {
+        return await parameters.method.call(this, ...parameters.arguments);
+    }
+    catch (e) {
+        const connectedNode = parameters.executeFunctions.getNode();
+        const error = new n8n_workflow_1.NodeOperationError(connectedNode, e, {
+            functionality: 'configuration-node',
+        });
+        const metadata = (0, n8n_workflow_1.parseErrorMetadata)(error);
+        parameters.executeFunctions.addOutputData(parameters.connectionType, parameters.currentNodeRunIndex, error, metadata);
+        if (error.message) {
+            if (!error.description) {
+                error.description = error.message;
+            }
+            throw error;
+        }
+        throw new n8n_workflow_1.NodeOperationError(connectedNode, `Error on node "${connectedNode.name}" which is connected via input "${parameters.connectionType}"`, { functionality: 'configuration-node' });
     }
-    throw new import_n8n_workflow.NodeOperationError(
-      connectedNode,
-      `Error on node "${connectedNode.name}" which is connected via input "${parameters.connectionType}"`,
-      { functionality: "configuration-node" }
-    );
-  }
 }
 function callMethodSync(parameters) {
-  try {
-    return parameters.method.call(this, ...parameters.arguments);
-  } catch (e) {
-    const connectedNode = parameters.executeFunctions.getNode();
-    const error = new import_n8n_workflow.NodeOperationError(connectedNode, e);
-    parameters.executeFunctions.addOutputData(
-      parameters.connectionType,
-      parameters.currentNodeRunIndex,
-      error
-    );
-    throw new import_n8n_workflow.NodeOperationError(
-      connectedNode,
-      `Error on node "${connectedNode.name}" which is connected via input "${parameters.connectionType}"`,
-      { functionality: "configuration-node" }
-    );
-  }
+    try {
+        return parameters.method.call(this, ...parameters.arguments);
+    }
+    catch (e) {
+        const connectedNode = parameters.executeFunctions.getNode();
+        const error = new n8n_workflow_1.NodeOperationError(connectedNode, e);
+        parameters.executeFunctions.addOutputData(parameters.connectionType, parameters.currentNodeRunIndex, error);
+        throw new n8n_workflow_1.NodeOperationError(connectedNode, `Error on node "${connectedNode.name}" which is connected via input "${parameters.connectionType}"`, { functionality: 'configuration-node' });
+    }
 }
 function logWrapper(originalInstance, executeFunctions) {
-  return new Proxy(originalInstance, {
-    get: (target, prop) => {
-      let connectionType;
-      if ((0, import_helpers.isBaseChatMemory)(originalInstance)) {
-        if (prop === "loadMemoryVariables" && "loadMemoryVariables" in target) {
-          return async (values) => {
-            connectionType = import_n8n_workflow.NodeConnectionTypes.AiMemory;
-            const { index } = executeFunctions.addInputData(connectionType, [
-              [{ json: { action: "loadMemoryVariables", values } }]
-            ]);
-            const response = await callMethodAsync.call(target, {
-              executeFunctions,
-              connectionType,
-              currentNodeRunIndex: index,
-              method: target[prop],
-              arguments: [values]
-            });
-            const chatHistory = response?.chat_history ?? response;
-            executeFunctions.addOutputData(connectionType, index, [
-              [{ json: { action: "loadMemoryVariables", chatHistory } }]
-            ]);
-            return response;
-          };
-        } else if (prop === "saveContext" && "saveContext" in target) {
-          return async (input, output) => {
-            connectionType = import_n8n_workflow.NodeConnectionTypes.AiMemory;
-            const { index } = executeFunctions.addInputData(connectionType, [
-              [{ json: { action: "saveContext", input, output } }]
-            ]);
-            const response = await callMethodAsync.call(target, {
-              executeFunctions,
-              connectionType,
-              currentNodeRunIndex: index,
-              method: target[prop],
-              arguments: [input, output]
-            });
-            const chatHistory = await target.chatHistory.getMessages();
-            executeFunctions.addOutputData(connectionType, index, [
-              [{ json: { action: "saveContext", chatHistory } }]
-            ]);
-            return response;
-          };
-        }
-      }
-      if ((0, import_helpers.isBaseChatMessageHistory)(originalInstance)) {
-        if (prop === "getMessages" && "getMessages" in target) {
-          return async () => {
-            connectionType = import_n8n_workflow.NodeConnectionTypes.AiMemory;
-            const { index } = executeFunctions.addInputData(connectionType, [
-              [{ json: { action: "getMessages" } }]
-            ]);
-            const response = await callMethodAsync.call(target, {
-              executeFunctions,
-              connectionType,
-              currentNodeRunIndex: index,
-              method: target[prop],
-              arguments: []
-            });
-            const payload = { action: "getMessages", response };
-            executeFunctions.addOutputData(connectionType, index, [[{ json: payload }]]);
-            (0, import_helpers.logAiEvent)(executeFunctions, "ai-messages-retrieved-from-memory", { response });
-            return response;
-          };
-        } else if (prop === "addMessage" && "addMessage" in target) {
-          return async (message) => {
-            connectionType = import_n8n_workflow.NodeConnectionTypes.AiMemory;
-            const payload = { action: "addMessage", message };
-            const { index } = executeFunctions.addInputData(connectionType, [[{ json: payload }]]);
-            await callMethodAsync.call(target, {
-              executeFunctions,
-              connectionType,
-              currentNodeRunIndex: index,
-              method: target[prop],
-              arguments: [message]
-            });
-            (0, import_helpers.logAiEvent)(executeFunctions, "ai-message-added-to-memory", { message });
-            executeFunctions.addOutputData(connectionType, index, [[{ json: payload }]]);
-          };
-        }
-      }
-      if (originalInstance instanceof import_retrievers.BaseRetriever) {
-        if (prop === "getRelevantDocuments" && "getRelevantDocuments" in target) {
-          return async (query, config) => {
-            connectionType = import_n8n_workflow.NodeConnectionTypes.AiRetriever;
-            const { index } = executeFunctions.addInputData(connectionType, [
-              [{ json: { query, config } }]
-            ]);
-            const response = await callMethodAsync.call(target, {
-              executeFunctions,
-              connectionType,
-              currentNodeRunIndex: index,
-              method: target[prop],
-              arguments: [query, config]
-            });
-            const executionId = response[0]?.metadata?.executionId;
-            const workflowId = response[0]?.metadata?.workflowId;
-            const metadata = {};
-            if (executionId && workflowId) {
-              metadata.subExecution = {
-                executionId,
-                workflowId
-              };
+    return new Proxy(originalInstance, {
+        get: (target, prop) => {
+            let connectionType;
+            if ((0, helpers_1.isBaseChatMemory)(originalInstance)) {
+                if (prop === 'loadMemoryVariables' && 'loadMemoryVariables' in target) {
+                    return async (values) => {
+                        connectionType = n8n_workflow_1.NodeConnectionTypes.AiMemory;
+                        const { index } = executeFunctions.addInputData(connectionType, [
+                            [{ json: { action: 'loadMemoryVariables', values } }],
+                        ]);
+                        const response = (await callMethodAsync.call(target, {
+                            executeFunctions,
+                            connectionType,
+                            currentNodeRunIndex: index,
+                            method: target[prop],
+                            arguments: [values],
+                        }));
+                        const chatHistory = response?.chat_history ?? response;
+                        executeFunctions.addOutputData(connectionType, index, [
+                            [{ json: { action: 'loadMemoryVariables', chatHistory } }],
+                        ]);
+                        return response;
+                    };
+                }
+                else if (prop === 'saveContext' && 'saveContext' in target) {
+                    return async (input, output) => {
+                        connectionType = n8n_workflow_1.NodeConnectionTypes.AiMemory;
+                        const { index } = executeFunctions.addInputData(connectionType, [
+                            [{ json: { action: 'saveContext', input, output } }],
+                        ]);
+                        const response = (await callMethodAsync.call(target, {
+                            executeFunctions,
+                            connectionType,
+                            currentNodeRunIndex: index,
+                            method: target[prop],
+                            arguments: [input, output],
+                        }));
+                        const chatHistory = await target.chatHistory.getMessages();
+                        executeFunctions.addOutputData(connectionType, index, [
+                            [{ json: { action: 'saveContext', chatHistory } }],
+                        ]);
+                        return response;
+                    };
+                }
             }
-            (0, import_helpers.logAiEvent)(executeFunctions, "ai-documents-retrieved", { query });
-            executeFunctions.addOutputData(
-              connectionType,
-              index,
-              [[{ json: { response } }]],
-              metadata
-            );
-            return response;
-          };
-        }
-      }
-      if (originalInstance instanceof import_embeddings.Embeddings || originalInstance instanceof import_openai.OpenAIEmbeddings || originalInstance instanceof import_openai.AzureOpenAIEmbeddings) {
-        if (prop === "embedDocuments" && "embedDocuments" in target) {
-          return async (documents) => {
-            const validatedDocuments = (0, import_embeddingInputValidation.validateEmbedDocumentsInput)(
-              documents,
-              executeFunctions.getNode()
-            );
-            connectionType = import_n8n_workflow.NodeConnectionTypes.AiEmbedding;
-            const { index } = executeFunctions.addInputData(connectionType, [
-              [{ json: { documents: validatedDocuments } }]
-            ]);
-            const response = await callMethodAsync.call(target, {
-              executeFunctions,
-              connectionType,
-              currentNodeRunIndex: index,
-              method: target[prop],
-              arguments: [validatedDocuments]
-            });
-            (0, import_helpers.logAiEvent)(executeFunctions, "ai-document-embedded");
-            executeFunctions.addOutputData(connectionType, index, [[{ json: { response } }]]);
-            return response;
-          };
-        }
-        if (prop === "embedQuery" && "embedQuery" in target) {
-          return async (query) => {
-            const validatedQuery = (0, import_embeddingInputValidation.validateEmbedQueryInput)(query, executeFunctions.getNode());
-            connectionType = import_n8n_workflow.NodeConnectionTypes.AiEmbedding;
-            const { index } = executeFunctions.addInputData(connectionType, [
-              [{ json: { query: validatedQuery } }]
-            ]);
-            const response = await callMethodAsync.call(target, {
-              executeFunctions,
-              connectionType,
-              currentNodeRunIndex: index,
-              method: target[prop],
-              arguments: [validatedQuery]
-            });
-            (0, import_helpers.logAiEvent)(executeFunctions, "ai-query-embedded");
-            executeFunctions.addOutputData(connectionType, index, [[{ json: { response } }]]);
-            return response;
-          };
-        }
-      }
-      if (originalInstance instanceof import_document_compressors.BaseDocumentCompressor) {
-        if (prop === "compressDocuments" && "compressDocuments" in target) {
-          return async (documents, query) => {
-            connectionType = import_n8n_workflow.NodeConnectionTypes.AiReranker;
-            const { index } = executeFunctions.addInputData(connectionType, [
-              [{ json: { query, documents } }]
-            ]);
-            const response = await callMethodAsync.call(target, {
-              executeFunctions,
-              connectionType,
-              currentNodeRunIndex: index,
-              method: target[prop],
-              // compressDocuments mutates the original object
-              // messing up the input data logging
-              arguments: [(0, import_n8n_workflow.deepCopy)(documents), query]
-            });
-            (0, import_helpers.logAiEvent)(executeFunctions, "ai-document-reranked", { query });
-            executeFunctions.addOutputData(connectionType, index, [[{ json: { response } }]]);
-            return response;
-          };
-        }
-      }
-      if (originalInstance instanceof import_N8nJsonLoader.N8nJsonLoader || originalInstance instanceof import_N8nBinaryLoader.N8nBinaryLoader) {
-        if (prop === "processAll" && "processAll" in target) {
-          return async (items) => {
-            connectionType = import_n8n_workflow.NodeConnectionTypes.AiDocument;
-            const { index } = executeFunctions.addInputData(connectionType, [items]);
-            const response = await callMethodAsync.call(target, {
-              executeFunctions,
-              connectionType,
-              currentNodeRunIndex: index,
-              method: target[prop],
-              arguments: [items]
-            });
-            executeFunctions.addOutputData(connectionType, index, [[{ json: { response } }]]);
-            return response;
-          };
-        }
-        if (prop === "processItem" && "processItem" in target) {
-          return async (item, itemIndex) => {
-            connectionType = import_n8n_workflow.NodeConnectionTypes.AiDocument;
-            const { index } = executeFunctions.addInputData(connectionType, [[item]]);
-            const response = await callMethodAsync.call(target, {
-              executeFunctions,
-              connectionType,
-              currentNodeRunIndex: index,
-              method: target[prop],
-              arguments: [item, itemIndex]
-            });
-            (0, import_helpers.logAiEvent)(executeFunctions, "ai-document-processed");
-            executeFunctions.addOutputData(connectionType, index, [
-              [{ json: { response }, pairedItem: { item: itemIndex } }]
-            ]);
-            return response;
-          };
-        }
-      }
-      if (originalInstance instanceof import_textsplitters.TextSplitter) {
-        if (prop === "splitText" && "splitText" in target) {
-          return async (text) => {
-            connectionType = import_n8n_workflow.NodeConnectionTypes.AiTextSplitter;
-            const { index } = executeFunctions.addInputData(connectionType, [
-              [{ json: { textSplitter: text } }]
-            ]);
-            const response = await callMethodAsync.call(target, {
-              executeFunctions,
-              connectionType,
-              currentNodeRunIndex: index,
-              method: target[prop],
-              arguments: [text]
-            });
-            (0, import_helpers.logAiEvent)(executeFunctions, "ai-text-split");
-            executeFunctions.addOutputData(connectionType, index, [[{ json: { response } }]]);
-            return response;
-          };
-        }
-      }
-      if ((0, import_helpers.isToolsInstance)(originalInstance)) {
-        if (prop === "_call" && "_call" in target) {
-          return async (query) => {
-            connectionType = import_n8n_workflow.NodeConnectionTypes.AiTool;
-            const inputData = { query };
-            if (target.metadata?.isFromToolkit) {
-              inputData.tool = {
-                name: target.name,
-                description: target.description
-              };
+            if ((0, helpers_1.isBaseChatMessageHistory)(originalInstance)) {
+                if (prop === 'getMessages' && 'getMessages' in target) {
+                    return async () => {
+                        connectionType = n8n_workflow_1.NodeConnectionTypes.AiMemory;
+                        const { index } = executeFunctions.addInputData(connectionType, [
+                            [{ json: { action: 'getMessages' } }],
+                        ]);
+                        const response = (await callMethodAsync.call(target, {
+                            executeFunctions,
+                            connectionType,
+                            currentNodeRunIndex: index,
+                            method: target[prop],
+                            arguments: [],
+                        }));
+                        const payload = { action: 'getMessages', response };
+                        executeFunctions.addOutputData(connectionType, index, [[{ json: payload }]]);
+                        (0, helpers_1.logAiEvent)(executeFunctions, 'ai-messages-retrieved-from-memory', { response });
+                        return response;
+                    };
+                }
+                else if (prop === 'addMessage' && 'addMessage' in target) {
+                    return async (message) => {
+                        connectionType = n8n_workflow_1.NodeConnectionTypes.AiMemory;
+                        const payload = { action: 'addMessage', message };
+                        const { index } = executeFunctions.addInputData(connectionType, [[{ json: payload }]]);
+                        await callMethodAsync.call(target, {
+                            executeFunctions,
+                            connectionType,
+                            currentNodeRunIndex: index,
+                            method: target[prop],
+                            arguments: [message],
+                        });
+                        (0, helpers_1.logAiEvent)(executeFunctions, 'ai-message-added-to-memory', { message });
+                        executeFunctions.addOutputData(connectionType, index, [[{ json: payload }]]);
+                    };
+                }
             }
-            const { index } = executeFunctions.addInputData(connectionType, [
-              [{ json: inputData }]
-            ]);
-            const response = await callMethodAsync.call(target, {
-              executeFunctions,
-              connectionType,
-              currentNodeRunIndex: index,
-              method: target[prop],
-              arguments: [query]
-            });
-            (0, import_helpers.logAiEvent)(executeFunctions, "ai-tool-called", { ...inputData, response });
-            executeFunctions.addOutputData(connectionType, index, [[{ json: { response } }]]);
-            if (typeof response === "string") return response;
-            return JSON.stringify(response);
-          };
-        }
-      }
-      if (originalInstance instanceof import_vectorstores.VectorStore) {
-        if (prop === "similaritySearch" && "similaritySearch" in target) {
-          return async (query, k, filter, _callbacks) => {
-            connectionType = import_n8n_workflow.NodeConnectionTypes.AiVectorStore;
-            const { index } = executeFunctions.addInputData(connectionType, [
-              [{ json: { query, k, filter } }]
-            ]);
-            const response = await callMethodAsync.call(target, {
-              executeFunctions,
-              connectionType,
-              currentNodeRunIndex: index,
-              method: target[prop],
-              arguments: [query, k, filter, _callbacks]
-            });
-            (0, import_helpers.logAiEvent)(executeFunctions, "ai-vector-store-searched", { query });
-            executeFunctions.addOutputData(connectionType, index, [[{ json: { response } }]]);
-            return response;
-          };
-        }
-      }
-      return target[prop];
-    }
-  });
+            if (originalInstance instanceof retrievers_1.BaseRetriever) {
+                if (prop === 'getRelevantDocuments' && 'getRelevantDocuments' in target) {
+                    return async (query, config) => {
+                        connectionType = n8n_workflow_1.NodeConnectionTypes.AiRetriever;
+                        const { index } = executeFunctions.addInputData(connectionType, [
+                            [{ json: { query, config } }],
+                        ]);
+                        const response = (await callMethodAsync.call(target, {
+                            executeFunctions,
+                            connectionType,
+                            currentNodeRunIndex: index,
+                            method: target[prop],
+                            arguments: [query, config],
+                        }));
+                        const executionId = response[0]?.metadata?.executionId;
+                        const workflowId = response[0]?.metadata?.workflowId;
+                        const metadata = {};
+                        if (executionId && workflowId) {
+                            metadata.subExecution = {
+                                executionId,
+                                workflowId,
+                            };
+                        }
+                        (0, helpers_1.logAiEvent)(executeFunctions, 'ai-documents-retrieved', { query });
+                        executeFunctions.addOutputData(connectionType, index, [[{ json: { response } }]], metadata);
+                        return response;
+                    };
+                }
+            }
+            if (originalInstance instanceof embeddings_1.Embeddings ||
+                originalInstance instanceof openai_1.OpenAIEmbeddings ||
+                originalInstance instanceof openai_1.AzureOpenAIEmbeddings) {
+                if (prop === 'embedDocuments' && 'embedDocuments' in target) {
+                    return async (documents) => {
+                        const validatedDocuments = (0, embeddingInputValidation_1.validateEmbedDocumentsInput)(documents, executeFunctions.getNode());
+                        connectionType = n8n_workflow_1.NodeConnectionTypes.AiEmbedding;
+                        const { index } = executeFunctions.addInputData(connectionType, [
+                            [{ json: { documents: validatedDocuments } }],
+                        ]);
+                        const response = (await callMethodAsync.call(target, {
+                            executeFunctions,
+                            connectionType,
+                            currentNodeRunIndex: index,
+                            method: target[prop],
+                            arguments: [validatedDocuments],
+                        }));
+                        (0, helpers_1.logAiEvent)(executeFunctions, 'ai-document-embedded');
+                        executeFunctions.addOutputData(connectionType, index, [[{ json: { response } }]]);
+                        return response;
+                    };
+                }
+                if (prop === 'embedQuery' && 'embedQuery' in target) {
+                    return async (query) => {
+                        const validatedQuery = (0, embeddingInputValidation_1.validateEmbedQueryInput)(query, executeFunctions.getNode());
+                        connectionType = n8n_workflow_1.NodeConnectionTypes.AiEmbedding;
+                        const { index } = executeFunctions.addInputData(connectionType, [
+                            [{ json: { query: validatedQuery } }],
+                        ]);
+                        const response = (await callMethodAsync.call(target, {
+                            executeFunctions,
+                            connectionType,
+                            currentNodeRunIndex: index,
+                            method: target[prop],
+                            arguments: [validatedQuery],
+                        }));
+                        (0, helpers_1.logAiEvent)(executeFunctions, 'ai-query-embedded');
+                        executeFunctions.addOutputData(connectionType, index, [[{ json: { response } }]]);
+                        return response;
+                    };
+                }
+            }
+            if (originalInstance instanceof document_compressors_1.BaseDocumentCompressor) {
+                if (prop === 'compressDocuments' && 'compressDocuments' in target) {
+                    return async (documents, query) => {
+                        connectionType = n8n_workflow_1.NodeConnectionTypes.AiReranker;
+                        const { index } = executeFunctions.addInputData(connectionType, [
+                            [{ json: { query, documents } }],
+                        ]);
+                        const response = (await callMethodAsync.call(target, {
+                            executeFunctions,
+                            connectionType,
+                            currentNodeRunIndex: index,
+                            method: target[prop],
+                            arguments: [(0, n8n_workflow_1.deepCopy)(documents), query],
+                        }));
+                        (0, helpers_1.logAiEvent)(executeFunctions, 'ai-document-reranked', { query });
+                        executeFunctions.addOutputData(connectionType, index, [[{ json: { response } }]]);
+                        return response;
+                    };
+                }
+            }
+            if (originalInstance instanceof N8nJsonLoader_1.N8nJsonLoader ||
+                originalInstance instanceof N8nBinaryLoader_1.N8nBinaryLoader) {
+                if (prop === 'processAll' && 'processAll' in target) {
+                    return async (items) => {
+                        connectionType = n8n_workflow_1.NodeConnectionTypes.AiDocument;
+                        const { index } = executeFunctions.addInputData(connectionType, [items]);
+                        const response = (await callMethodAsync.call(target, {
+                            executeFunctions,
+                            connectionType,
+                            currentNodeRunIndex: index,
+                            method: target[prop],
+                            arguments: [items],
+                        }));
+                        executeFunctions.addOutputData(connectionType, index, [[{ json: { response } }]]);
+                        return response;
+                    };
+                }
+                if (prop === 'processItem' && 'processItem' in target) {
+                    return async (item, itemIndex) => {
+                        connectionType = n8n_workflow_1.NodeConnectionTypes.AiDocument;
+                        const { index } = executeFunctions.addInputData(connectionType, [[item]]);
+                        const response = (await callMethodAsync.call(target, {
+                            executeFunctions,
+                            connectionType,
+                            currentNodeRunIndex: index,
+                            method: target[prop],
+                            arguments: [item, itemIndex],
+                        }));
+                        (0, helpers_1.logAiEvent)(executeFunctions, 'ai-document-processed');
+                        executeFunctions.addOutputData(connectionType, index, [
+                            [{ json: { response }, pairedItem: { item: itemIndex } }],
+                        ]);
+                        return response;
+                    };
+                }
+            }
+            if (originalInstance instanceof textsplitters_1.TextSplitter) {
+                if (prop === 'splitText' && 'splitText' in target) {
+                    return async (text) => {
+                        connectionType = n8n_workflow_1.NodeConnectionTypes.AiTextSplitter;
+                        const { index } = executeFunctions.addInputData(connectionType, [
+                            [{ json: { textSplitter: text } }],
+                        ]);
+                        const response = (await callMethodAsync.call(target, {
+                            executeFunctions,
+                            connectionType,
+                            currentNodeRunIndex: index,
+                            method: target[prop],
+                            arguments: [text],
+                        }));
+                        (0, helpers_1.logAiEvent)(executeFunctions, 'ai-text-split');
+                        executeFunctions.addOutputData(connectionType, index, [[{ json: { response } }]]);
+                        return response;
+                    };
+                }
+            }
+            if ((0, helpers_1.isToolsInstance)(originalInstance)) {
+                if (prop === '_call' && '_call' in target) {
+                    return async (query) => {
+                        connectionType = n8n_workflow_1.NodeConnectionTypes.AiTool;
+                        const inputData = { query };
+                        if (target.metadata?.isFromToolkit) {
+                            inputData.tool = {
+                                name: target.name,
+                                description: target.description,
+                            };
+                        }
+                        const { index } = executeFunctions.addInputData(connectionType, [
+                            [{ json: inputData }],
+                        ]);
+                        const response = (await callMethodAsync.call(target, {
+                            executeFunctions,
+                            connectionType,
+                            currentNodeRunIndex: index,
+                            method: target[prop],
+                            arguments: [query],
+                        }));
+                        (0, helpers_1.logAiEvent)(executeFunctions, 'ai-tool-called', { ...inputData, response });
+                        executeFunctions.addOutputData(connectionType, index, [[{ json: { response } }]]);
+                        if (typeof response === 'string')
+                            return response;
+                        return JSON.stringify(response);
+                    };
+                }
+            }
+            if (originalInstance instanceof vectorstores_1.VectorStore) {
+                if (prop === 'similaritySearch' && 'similaritySearch' in target) {
+                    return async (query, k, filter, _callbacks) => {
+                        connectionType = n8n_workflow_1.NodeConnectionTypes.AiVectorStore;
+                        const { index } = executeFunctions.addInputData(connectionType, [
+                            [{ json: { query, k, filter } }],
+                        ]);
+                        const response = (await callMethodAsync.call(target, {
+                            executeFunctions,
+                            connectionType,
+                            currentNodeRunIndex: index,
+                            method: target[prop],
+                            arguments: [query, k, filter, _callbacks],
+                        }));
+                        (0, helpers_1.logAiEvent)(executeFunctions, 'ai-vector-store-searched', { query });
+                        executeFunctions.addOutputData(connectionType, index, [[{ json: { response } }]]);
+                        return response;
+                    };
+                }
+            }
+            return target[prop];
+        },
+    });
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  callMethodAsync,
-  callMethodSync,
-  logWrapper
-});
 //# sourceMappingURL=logWrapper.js.map