@n8n/n8n-nodes-langchain 1.120.2 → 1.121.1

package/dist/nodes/agents/Agent/agents/ToolsAgent/V3/helpers/buildExecutionContext.js

@@ -0,0 +1,74 @@
+"use strict";
+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 buildExecutionContext_exports = {};
+__export(buildExecutionContext_exports, {
+  buildToolsAgentExecutionContext: () => buildToolsAgentExecutionContext
+});
+module.exports = __toCommonJS(buildExecutionContext_exports);
+var import_n8n_workflow = require("n8n-workflow");
+var import_node_assert = __toESM(require("node:assert"));
+var import_common = require("../../common");
+async function buildToolsAgentExecutionContext(ctx) {
+  const items = ctx.getInputData();
+  const batchSize = ctx.getNodeParameter("options.batching.batchSize", 0, 1);
+  const delayBetweenBatches = ctx.getNodeParameter(
+    "options.batching.delayBetweenBatches",
+    0,
+    0
+  );
+  const needsFallback = ctx.getNodeParameter("needsFallback", 0, false);
+  const memory = await (0, import_common.getOptionalMemory)(ctx);
+  const model = await (0, import_common.getChatModel)(ctx, 0);
+  (0, import_node_assert.default)(model, "Please connect a model to the Chat Model input");
+  let fallbackModel = null;
+  if (needsFallback) {
+    const maybeFallbackModel = await (0, import_common.getChatModel)(ctx, 1);
+    if (!maybeFallbackModel) {
+      throw new import_n8n_workflow.NodeOperationError(
+        ctx.getNode(),
+        "Please connect a model to the Fallback Model input or disable the fallback option"
+      );
+    }
+    fallbackModel = maybeFallbackModel;
+  }
+  return {
+    items,
+    batchSize,
+    delayBetweenBatches,
+    needsFallback,
+    model,
+    fallbackModel,
+    memory
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildToolsAgentExecutionContext
+});
+//# sourceMappingURL=buildExecutionContext.js.map

package/dist/nodes/agents/Agent/agents/ToolsAgent/V3/helpers/buildExecutionContext.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../nodes/agents/Agent/agents/ToolsAgent/V3/helpers/buildExecutionContext.ts"],"sourcesContent":["import type { BaseChatModel } from '@langchain/core/language_models/chat_models';\nimport type { BaseChatMemory } from 'langchain/memory';\nimport { NodeOperationError } from 'n8n-workflow';\nimport type { IExecuteFunctions, ISupplyDataFunctions, INodeExecutionData } from 'n8n-workflow';\nimport assert from 'node:assert';\n\nimport { getChatModel, getOptionalMemory } from '../../common';\n\n/**\n * Execution context that contains shared configuration needed across all items\n */\nexport type ToolsAgentExecutionContext = {\n\titems: INodeExecutionData[];\n\tbatchSize: number;\n\tdelayBetweenBatches: number;\n\tneedsFallback: boolean;\n\tmodel: BaseChatModel;\n\tfallbackModel: BaseChatModel | null;\n\tmemory: BaseChatMemory | undefined;\n};\n\n/**\n * Builds the execution context by collecting shared configuration\n * such as models, memory, batching settings, and streaming flags.\n *\n * @param ctx - The execution context (IExecuteFunctions or ISupplyDataFunctions)\n * @returns ExecutionContext containing all shared configuration\n */\nexport async function buildToolsAgentExecutionContext(\n\tctx: IExecuteFunctions | ISupplyDataFunctions,\n): Promise<ToolsAgentExecutionContext> {\n\tconst items = ctx.getInputData();\n\tconst batchSize = ctx.getNodeParameter('options.batching.batchSize', 0, 1) as number;\n\tconst delayBetweenBatches = ctx.getNodeParameter(\n\t\t'options.batching.delayBetweenBatches',\n\t\t0,\n\t\t0,\n\t) as number;\n\tconst needsFallback = ctx.getNodeParameter('needsFallback', 0, false) as boolean;\n\n\tconst memory = await getOptionalMemory(ctx);\n\tconst model = await getChatModel(ctx, 0);\n\tassert(model, 'Please connect a model to the Chat Model input');\n\n\tlet fallbackModel: BaseChatModel | null = null;\n\tif (needsFallback) {\n\t\tconst maybeFallbackModel = await getChatModel(ctx, 1);\n\t\tif (!maybeFallbackModel) {\n\t\t\tthrow new NodeOperationError(\n\t\t\t\tctx.getNode(),\n\t\t\t\t'Please connect a model to the Fallback Model input or disable the fallback option',\n\t\t\t);\n\t\t}\n\t\tfallbackModel = maybeFallbackModel;\n\t}\n\n\treturn {\n\t\titems,\n\t\tbatchSize,\n\t\tdelayBetweenBatches,\n\t\tneedsFallback,\n\t\tmodel,\n\t\tfallbackModel,\n\t\tmemory,\n\t};\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAEA,0BAAmC;AAEnC,yBAAmB;AAEnB,oBAAgD;AAsBhD,eAAsB,gCACrB,KACsC;AACtC,QAAM,QAAQ,IAAI,aAAa;AAC/B,QAAM,YAAY,IAAI,iBAAiB,8BAA8B,GAAG,CAAC;AACzE,QAAM,sBAAsB,IAAI;AAAA,IAC/B;AAAA,IACA;AAAA,IACA;AAAA,EACD;AACA,QAAM,gBAAgB,IAAI,iBAAiB,iBAAiB,GAAG,KAAK;AAEpE,QAAM,SAAS,UAAM,iCAAkB,GAAG;AAC1C,QAAM,QAAQ,UAAM,4BAAa,KAAK,CAAC;AACvC,yBAAAA,SAAO,OAAO,gDAAgD;AAE9D,MAAI,gBAAsC;AAC1C,MAAI,eAAe;AAClB,UAAM,qBAAqB,UAAM,4BAAa,KAAK,CAAC;AACpD,QAAI,CAAC,oBAAoB;AACxB,YAAM,IAAI;AAAA,QACT,IAAI,QAAQ;AAAA,QACZ;AAAA,MACD;AAAA,IACD;AACA,oBAAgB;AAAA,EACjB;AAEA,SAAO;AAAA,IACN;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACD;AACD;","names":["assert"]}

package/dist/nodes/agents/Agent/agents/ToolsAgent/V3/helpers/buildResponseMetadata.js

@@ -0,0 +1,37 @@
+"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 buildResponseMetadata_exports = {};
+__export(buildResponseMetadata_exports, {
+  buildResponseMetadata: () => buildResponseMetadata
+});
+module.exports = __toCommonJS(buildResponseMetadata_exports);
+var import_agent_execution = require("../../../../../../../utils/agent-execution");
+function buildResponseMetadata(response, itemIndex) {
+  const currentIterationCount = response?.metadata?.iterationCount ?? 0;
+  return {
+    previousRequests: (0, import_agent_execution.buildSteps)(response, itemIndex),
+    itemIndex,
+    iterationCount: currentIterationCount + 1
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildResponseMetadata
+});
+//# sourceMappingURL=buildResponseMetadata.js.map

package/dist/nodes/agents/Agent/agents/ToolsAgent/V3/helpers/buildResponseMetadata.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../nodes/agents/Agent/agents/ToolsAgent/V3/helpers/buildResponseMetadata.ts"],"sourcesContent":["import type { EngineResponse } from 'n8n-workflow';\n\nimport { buildSteps } from '@utils/agent-execution';\n\nimport type { RequestResponseMetadata } from '../types';\n\n/**\n * Builds metadata for an engine request, tracking iteration count and previous requests.\n *\n * This helper centralizes the logic for incrementing iteration count and building\n * the request history, which is used to enforce max iterations and maintain context.\n *\n * @param response - The optional engine response from previous tool execution\n * @param itemIndex - The current item index being processed\n * @returns Metadata object with previousRequests and iterationCount\n *\n */\nexport function buildResponseMetadata(\n\tresponse: EngineResponse<RequestResponseMetadata> | undefined,\n\titemIndex: number,\n): RequestResponseMetadata {\n\tconst currentIterationCount = response?.metadata?.iterationCount ?? 0;\n\n\treturn {\n\t\tpreviousRequests: buildSteps(response, itemIndex),\n\t\titemIndex,\n\t\titerationCount: currentIterationCount + 1,\n\t};\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAEA,6BAA2B;AAepB,SAAS,sBACf,UACA,WAC0B;AAC1B,QAAM,wBAAwB,UAAU,UAAU,kBAAkB;AAEpE,SAAO;AAAA,IACN,sBAAkB,mCAAW,UAAU,SAAS;AAAA,IAChD;AAAA,IACA,gBAAgB,wBAAwB;AAAA,EACzC;AACD;","names":[]}

package/dist/nodes/agents/Agent/agents/ToolsAgent/V3/helpers/checkMaxIterations.js

@@ -0,0 +1,40 @@
+"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 checkMaxIterations_exports = {};
+__export(checkMaxIterations_exports, {
+  checkMaxIterations: () => checkMaxIterations
+});
+module.exports = __toCommonJS(checkMaxIterations_exports);
+var import_n8n_workflow = require("n8n-workflow");
+function checkMaxIterations(response, maxIterations, node) {
+  if (response?.metadata?.iterationCount === void 0) {
+    return;
+  }
+  if (response.metadata.iterationCount >= maxIterations) {
+    throw new import_n8n_workflow.NodeOperationError(
+      node,
+      `Max iterations (${maxIterations}) reached. The agent could not complete the task within the allowed number of iterations.`
+    );
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  checkMaxIterations
+});
+//# sourceMappingURL=checkMaxIterations.js.map

package/dist/nodes/agents/Agent/agents/ToolsAgent/V3/helpers/checkMaxIterations.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../nodes/agents/Agent/agents/ToolsAgent/V3/helpers/checkMaxIterations.ts"],"sourcesContent":["import { NodeOperationError } from 'n8n-workflow';\nimport type { INode, EngineResponse } from 'n8n-workflow';\n\nimport type { RequestResponseMetadata } from '../types';\n\n/**\n * Checks if the maximum iteration limit has been reached and throws an error if so.\n *\n * This function is called at the start of each agent execution to enforce\n * the maximum number of tool call iterations allowed.\n *\n * @param response - The engine response containing iteration metadata (if this is a continuation)\n * @param maxIterations - The maximum number of iterations allowed\n * @param node - The current node (for error context)\n * @throws {NodeOperationError} When the iteration count reaches or exceeds maxIterations\n *\n * @example\n * ```typescript\n * const response: EngineResponse<RequestResponseMetadata> = {\n *   // ... response data\n *   metadata: { iterationCount: 3 }\n * };\n *\n * // This will throw if iterationCount >= maxIterations\n * checkMaxIterations(response, 2, node);\n * ```\n */\nexport function checkMaxIterations(\n\tresponse: EngineResponse<RequestResponseMetadata> | undefined,\n\tmaxIterations: number,\n\tnode: INode,\n): void {\n\t// Only check if this is a continuation (response has iteration count)\n\tif (response?.metadata?.iterationCount === undefined) {\n\t\treturn;\n\t}\n\n\tif (response.metadata.iterationCount >= maxIterations) {\n\t\tthrow new NodeOperationError(\n\t\t\tnode,\n\t\t\t`Max iterations (${maxIterations}) reached. The agent could not complete the task within the allowed number of iterations.`,\n\t\t);\n\t}\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,0BAAmC;AA2B5B,SAAS,mBACf,UACA,eACA,MACO;AAEP,MAAI,UAAU,UAAU,mBAAmB,QAAW;AACrD;AAAA,EACD;AAEA,MAAI,SAAS,SAAS,kBAAkB,eAAe;AACtD,UAAM,IAAI;AAAA,MACT;AAAA,MACA,mBAAmB,aAAa;AAAA,IACjC;AAAA,EACD;AACD;","names":[]}

package/dist/nodes/agents/Agent/agents/ToolsAgent/V3/helpers/createAgentSequence.js

@@ -0,0 +1,61 @@
+"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 createAgentSequence_exports = {};
+__export(createAgentSequence_exports, {
+  createAgentSequence: () => createAgentSequence
+});
+module.exports = __toCommonJS(createAgentSequence_exports);
+var import_runnables = require("@langchain/core/runnables");
+var import_agents = require("langchain/agents");
+var import_common = require("../../common");
+function createAgentSequence(model, tools, prompt, _options, outputParser, memory, fallbackModel) {
+  const agent = (0, import_agents.createToolCallingAgent)({
+    llm: model,
+    tools: getAllTools(model, tools),
+    prompt,
+    streamRunnable: false
+  });
+  let fallbackAgent;
+  if (fallbackModel) {
+    fallbackAgent = (0, import_agents.createToolCallingAgent)({
+      llm: fallbackModel,
+      tools: getAllTools(fallbackModel, tools),
+      prompt,
+      streamRunnable: false
+    });
+  }
+  const runnableAgent = import_runnables.RunnableSequence.from([
+    fallbackAgent ? agent.withFallbacks([fallbackAgent]) : agent,
+    (0, import_common.getAgentStepsParser)(outputParser, memory),
+    import_common.fixEmptyContentMessage
+  ]);
+  runnableAgent.singleAction = true;
+  runnableAgent.streamRunnable = false;
+  return runnableAgent;
+}
+function getAllTools(model, tools) {
+  const modelTools = model.metadata?.tools ?? [];
+  const allTools = [...tools, ...modelTools];
+  return allTools;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createAgentSequence
+});
+//# sourceMappingURL=createAgentSequence.js.map

package/dist/nodes/agents/Agent/agents/ToolsAgent/V3/helpers/createAgentSequence.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../nodes/agents/Agent/agents/ToolsAgent/V3/helpers/createAgentSequence.ts"],"sourcesContent":["import type { BaseChatModel } from '@langchain/core/language_models/chat_models';\nimport type { ChatPromptTemplate } from '@langchain/core/prompts';\nimport { RunnableSequence } from '@langchain/core/runnables';\nimport { type AgentRunnableSequence, createToolCallingAgent } from 'langchain/agents';\nimport type { BaseChatMemory } from 'langchain/memory';\nimport type { DynamicStructuredTool, Tool } from 'langchain/tools';\n\nimport type { N8nOutputParser } from '@utils/output_parsers/N8nOutputParser';\n\nimport { fixEmptyContentMessage, getAgentStepsParser } from '../../common';\n\n/**\n * Creates an agent sequence with the given configuration.\n * The sequence includes the agent, output parser, and fallback logic.\n *\n * @param model - The primary chat model\n * @param tools - Array of tools available to the agent\n * @param prompt - The prompt template\n * @param _options - Additional options (maxIterations, returnIntermediateSteps)\n * @param outputParser - Optional output parser for structured responses\n * @param memory - Optional memory for conversation context\n * @param fallbackModel - Optional fallback model if primary fails\n * @returns AgentRunnableSequence ready for execution\n */\nexport function createAgentSequence(\n\tmodel: BaseChatModel,\n\ttools: Array<DynamicStructuredTool | Tool>,\n\tprompt: ChatPromptTemplate,\n\t_options: { maxIterations?: number; returnIntermediateSteps?: boolean },\n\toutputParser?: N8nOutputParser,\n\tmemory?: BaseChatMemory,\n\tfallbackModel?: BaseChatModel | null,\n) {\n\tconst agent = createToolCallingAgent({\n\t\tllm: model,\n\t\ttools: getAllTools(model, tools),\n\t\tprompt,\n\t\tstreamRunnable: false,\n\t});\n\n\tlet fallbackAgent: AgentRunnableSequence | undefined;\n\tif (fallbackModel) {\n\t\tfallbackAgent = createToolCallingAgent({\n\t\t\tllm: fallbackModel,\n\t\t\ttools: getAllTools(fallbackModel, tools),\n\t\t\tprompt,\n\t\t\tstreamRunnable: false,\n\t\t});\n\t}\n\tconst runnableAgent = RunnableSequence.from([\n\t\tfallbackAgent ? agent.withFallbacks([fallbackAgent]) : agent,\n\t\tgetAgentStepsParser(outputParser, memory),\n\t\tfixEmptyContentMessage,\n\t]) as AgentRunnableSequence;\n\n\trunnableAgent.singleAction = true;\n\trunnableAgent.streamRunnable = false;\n\n\treturn runnableAgent;\n}\n\n/**\n * Uses provided tools and tried to get tools from model metadata\n * Some chat model nodes can define built-in tools in their metadata\n */\nfunction getAllTools(model: BaseChatModel, tools: Array<DynamicStructuredTool | Tool>) {\n\tconst modelTools = (model.metadata?.tools as Tool[]) ?? [];\n\tconst allTools = [...tools, ...modelTools];\n\treturn allTools;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAEA,uBAAiC;AACjC,oBAAmE;AAMnE,oBAA4D;AAerD,SAAS,oBACf,OACA,OACA,QACA,UACA,cACA,QACA,eACC;AACD,QAAM,YAAQ,sCAAuB;AAAA,IACpC,KAAK;AAAA,IACL,OAAO,YAAY,OAAO,KAAK;AAAA,IAC/B;AAAA,IACA,gBAAgB;AAAA,EACjB,CAAC;AAED,MAAI;AACJ,MAAI,eAAe;AAClB,wBAAgB,sCAAuB;AAAA,MACtC,KAAK;AAAA,MACL,OAAO,YAAY,eAAe,KAAK;AAAA,MACvC;AAAA,MACA,gBAAgB;AAAA,IACjB,CAAC;AAAA,EACF;AACA,QAAM,gBAAgB,kCAAiB,KAAK;AAAA,IAC3C,gBAAgB,MAAM,cAAc,CAAC,aAAa,CAAC,IAAI;AAAA,QACvD,mCAAoB,cAAc,MAAM;AAAA,IACxC;AAAA,EACD,CAAC;AAED,gBAAc,eAAe;AAC7B,gBAAc,iBAAiB;AAE/B,SAAO;AACR;AAMA,SAAS,YAAY,OAAsB,OAA4C;AACtF,QAAM,aAAc,MAAM,UAAU,SAAoB,CAAC;AACzD,QAAM,WAAW,CAAC,GAAG,OAAO,GAAG,UAAU;AACzC,SAAO;AACR;","names":[]}

package/dist/nodes/agents/Agent/agents/ToolsAgent/V3/helpers/executeBatch.js

@@ -0,0 +1,88 @@
+"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 executeBatch_exports = {};
+__export(executeBatch_exports, {
+  executeBatch: () => executeBatch
+});
+module.exports = __toCommonJS(executeBatch_exports);
+var import_n8n_workflow = require("n8n-workflow");
+var import_N8nOutputParser = require("../../../../../../../utils/output_parsers/N8nOutputParser");
+var import_createAgentSequence = require("./createAgentSequence");
+var import_finalizeResult = require("./finalizeResult");
+var import_prepareItemContext = require("./prepareItemContext");
+var import_runAgent = require("./runAgent");
+async function executeBatch(ctx, batch, startIndex, model, fallbackModel, memory, response) {
+  const returnData = [];
+  let request = void 0;
+  const batchPromises = batch.map(async (_item, batchItemIndex) => {
+    const itemIndex = startIndex + batchItemIndex;
+    const itemContext = await (0, import_prepareItemContext.prepareItemContext)(ctx, itemIndex, response);
+    const { tools, prompt, options, outputParser: outputParser2 } = itemContext;
+    const executor = (0, import_createAgentSequence.createAgentSequence)(
+      model,
+      tools,
+      prompt,
+      options,
+      outputParser2,
+      memory,
+      fallbackModel
+    );
+    return await (0, import_runAgent.runAgent)(ctx, executor, itemContext, model, memory, response);
+  });
+  const batchResults = await Promise.allSettled(batchPromises);
+  const outputParser = await (0, import_N8nOutputParser.getOptionalOutputParser)(ctx, 0);
+  batchResults.forEach((result, index) => {
+    const itemIndex = startIndex + index;
+    if (result.status === "rejected") {
+      const error = result.reason;
+      if (ctx.continueOnFail()) {
+        returnData.push({
+          json: { error: error.message },
+          pairedItem: { item: itemIndex }
+        });
+        return;
+      } else {
+        throw new import_n8n_workflow.NodeOperationError(ctx.getNode(), error);
+      }
+    }
+    const batchResult = result.value;
+    if (!batchResult) {
+      return;
+    }
+    if ("actions" in batchResult) {
+      if (!request) {
+        request = {
+          actions: batchResult.actions,
+          metadata: batchResult.metadata
+        };
+      } else {
+        request.actions.push.apply(request.actions, batchResult.actions);
+      }
+      return;
+    }
+    const itemResult = (0, import_finalizeResult.finalizeResult)(batchResult, itemIndex, memory, outputParser);
+    returnData.push(itemResult);
+  });
+  return { returnData, request };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  executeBatch
+});
+//# sourceMappingURL=executeBatch.js.map

package/dist/nodes/agents/Agent/agents/ToolsAgent/V3/helpers/executeBatch.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../nodes/agents/Agent/agents/ToolsAgent/V3/helpers/executeBatch.ts"],"sourcesContent":["import type { BaseChatModel } from '@langchain/core/language_models/chat_models';\nimport type { AgentRunnableSequence } from 'langchain/agents';\nimport type { BaseChatMemory } from 'langchain/memory';\nimport { NodeOperationError } from 'n8n-workflow';\nimport type {\n\tIExecuteFunctions,\n\tISupplyDataFunctions,\n\tINodeExecutionData,\n\tEngineResponse,\n\tEngineRequest,\n} from 'n8n-workflow';\n\nimport { getOptionalOutputParser } from '@utils/output_parsers/N8nOutputParser';\n\nimport type { RequestResponseMetadata, AgentResult } from '../types';\nimport { createAgentSequence } from './createAgentSequence';\nimport { finalizeResult } from './finalizeResult';\nimport { prepareItemContext } from './prepareItemContext';\nimport { runAgent } from './runAgent';\n\ntype BatchResult = AgentResult | EngineRequest<RequestResponseMetadata>;\n/**\n * Executes a batch of items, handling both successful execution and errors.\n * Applies continue-on-fail logic when errors occur.\n *\n * @param ctx - The execution context\n * @param batch - Array of items to process in this batch\n * @param startIndex - Starting index of the batch in the original items array (used to calculate itemIndex)\n * @param model - Primary chat model\n * @param fallbackModel - Optional fallback model\n * @param memory - Optional memory for conversation context\n * @param response - Optional engine response with previous tool calls\n * @returns Object containing execution data and optional requests\n */\nexport async function executeBatch(\n\tctx: IExecuteFunctions | ISupplyDataFunctions,\n\tbatch: INodeExecutionData[],\n\tstartIndex: number,\n\tmodel: BaseChatModel,\n\tfallbackModel: BaseChatModel | null,\n\tmemory: BaseChatMemory | undefined,\n\tresponse?: EngineResponse<RequestResponseMetadata>,\n): Promise<{\n\treturnData: INodeExecutionData[];\n\trequest: EngineRequest<RequestResponseMetadata> | undefined;\n}> {\n\tconst returnData: INodeExecutionData[] = [];\n\tlet request: EngineRequest<RequestResponseMetadata> | undefined = undefined;\n\n\tconst batchPromises = batch.map(async (_item, batchItemIndex) => {\n\t\tconst itemIndex = startIndex + batchItemIndex;\n\n\t\tconst itemContext = await prepareItemContext(ctx, itemIndex, response);\n\n\t\tconst { tools, prompt, options, outputParser } = itemContext;\n\n\t\t// Create executors for primary and fallback models\n\t\tconst executor: AgentRunnableSequence = createAgentSequence(\n\t\t\tmodel,\n\t\t\ttools,\n\t\t\tprompt,\n\t\t\toptions,\n\t\t\toutputParser,\n\t\t\tmemory,\n\t\t\tfallbackModel,\n\t\t);\n\n\t\t// Run the agent\n\t\treturn await runAgent(ctx, executor, itemContext, model, memory, response);\n\t});\n\n\tconst batchResults = await Promise.allSettled(batchPromises);\n\t// This is only used to check if the output parser is connected\n\t// so we can parse the output if needed. Actual output parsing is done in the loop above\n\tconst outputParser = await getOptionalOutputParser(ctx, 0);\n\n\tbatchResults.forEach((result, index) => {\n\t\tconst itemIndex = startIndex + index;\n\t\tif (result.status === 'rejected') {\n\t\t\tconst error = result.reason as Error;\n\t\t\tif (ctx.continueOnFail()) {\n\t\t\t\treturnData.push({\n\t\t\t\t\tjson: { error: error.message },\n\t\t\t\t\tpairedItem: { item: itemIndex },\n\t\t\t\t} as INodeExecutionData);\n\t\t\t\treturn;\n\t\t\t} else {\n\t\t\t\tthrow new NodeOperationError(ctx.getNode(), error);\n\t\t\t}\n\t\t}\n\t\tconst batchResult = result.value as BatchResult;\n\n\t\tif (!batchResult) {\n\t\t\treturn;\n\t\t}\n\n\t\tif ('actions' in batchResult) {\n\t\t\tif (!request) {\n\t\t\t\trequest = {\n\t\t\t\t\tactions: batchResult.actions,\n\t\t\t\t\tmetadata: batchResult.metadata,\n\t\t\t\t};\n\t\t\t} else {\n\t\t\t\trequest.actions.push.apply(request.actions, batchResult.actions);\n\t\t\t}\n\t\t\treturn;\n\t\t}\n\n\t\t// Finalize the result\n\t\tconst itemResult = finalizeResult(batchResult, itemIndex, memory, outputParser);\n\t\treturnData.push(itemResult);\n\t});\n\n\treturn { returnData, request };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAGA,0BAAmC;AASnC,6BAAwC;AAGxC,iCAAoC;AACpC,4BAA+B;AAC/B,gCAAmC;AACnC,sBAAyB;AAgBzB,eAAsB,aACrB,KACA,OACA,YACA,OACA,eACA,QACA,UAIE;AACF,QAAM,aAAmC,CAAC;AAC1C,MAAI,UAA8D;AAElE,QAAM,gBAAgB,MAAM,IAAI,OAAO,OAAO,mBAAmB;AAChE,UAAM,YAAY,aAAa;AAE/B,UAAM,cAAc,UAAM,8CAAmB,KAAK,WAAW,QAAQ;AAErE,UAAM,EAAE,OAAO,QAAQ,SAAS,cAAAA,cAAa,IAAI;AAGjD,UAAM,eAAkC;AAAA,MACvC;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACAA;AAAA,MACA;AAAA,MACA;AAAA,IACD;AAGA,WAAO,UAAM,0BAAS,KAAK,UAAU,aAAa,OAAO,QAAQ,QAAQ;AAAA,EAC1E,CAAC;AAED,QAAM,eAAe,MAAM,QAAQ,WAAW,aAAa;AAG3D,QAAM,eAAe,UAAM,gDAAwB,KAAK,CAAC;AAEzD,eAAa,QAAQ,CAAC,QAAQ,UAAU;AACvC,UAAM,YAAY,aAAa;AAC/B,QAAI,OAAO,WAAW,YAAY;AACjC,YAAM,QAAQ,OAAO;AACrB,UAAI,IAAI,eAAe,GAAG;AACzB,mBAAW,KAAK;AAAA,UACf,MAAM,EAAE,OAAO,MAAM,QAAQ;AAAA,UAC7B,YAAY,EAAE,MAAM,UAAU;AAAA,QAC/B,CAAuB;AACvB;AAAA,MACD,OAAO;AACN,cAAM,IAAI,uCAAmB,IAAI,QAAQ,GAAG,KAAK;AAAA,MAClD;AAAA,IACD;AACA,UAAM,cAAc,OAAO;AAE3B,QAAI,CAAC,aAAa;AACjB;AAAA,IACD;AAEA,QAAI,aAAa,aAAa;AAC7B,UAAI,CAAC,SAAS;AACb,kBAAU;AAAA,UACT,SAAS,YAAY;AAAA,UACrB,UAAU,YAAY;AAAA,QACvB;AAAA,MACD,OAAO;AACN,gBAAQ,QAAQ,KAAK,MAAM,QAAQ,SAAS,YAAY,OAAO;AAAA,MAChE;AACA;AAAA,IACD;AAGA,UAAM,iBAAa,sCAAe,aAAa,WAAW,QAAQ,YAAY;AAC9E,eAAW,KAAK,UAAU;AAAA,EAC3B,CAAC;AAED,SAAO,EAAE,YAAY,QAAQ;AAC9B;","names":["outputParser"]}

package/dist/nodes/agents/Agent/agents/ToolsAgent/V3/helpers/finalizeResult.js

@@ -0,0 +1,58 @@
+"use strict";
+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 finalizeResult_exports = {};
+__export(finalizeResult_exports, {
+  finalizeResult: () => finalizeResult
+});
+module.exports = __toCommonJS(finalizeResult_exports);
+var import_omit = __toESM(require("lodash/omit"));
+var import_n8n_workflow = require("n8n-workflow");
+function finalizeResult(result, itemIndex, memory, outputParser) {
+  if (memory && outputParser) {
+    const parsedOutput = (0, import_n8n_workflow.jsonParse)(result.output);
+    result.output = parsedOutput?.output ?? parsedOutput;
+  }
+  const itemResult = {
+    json: (0, import_omit.default)(
+      result,
+      "system_message",
+      "formatting_instructions",
+      "input",
+      "chat_history",
+      "agent_scratchpad"
+    ),
+    pairedItem: { item: itemIndex }
+  };
+  return itemResult;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  finalizeResult
+});
+//# sourceMappingURL=finalizeResult.js.map

package/dist/nodes/agents/Agent/agents/ToolsAgent/V3/helpers/finalizeResult.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../nodes/agents/Agent/agents/ToolsAgent/V3/helpers/finalizeResult.ts"],"sourcesContent":["import type { BaseChatMemory } from 'langchain/memory';\nimport omit from 'lodash/omit';\nimport { jsonParse } from 'n8n-workflow';\nimport type { INodeExecutionData } from 'n8n-workflow';\n\nimport type { N8nOutputParser } from '@utils/output_parsers/N8nOutputParser';\n\nimport type { AgentResult } from '../types';\n\n/**\n * Finalizes the result by parsing output and preparing execution data.\n * Handles output parser integration and memory-based parsing.\n *\n * @param result - The agent result to finalize\n * @param itemIndex - The current item index\n * @param memory - Optional memory for parsing context\n * @param outputParser - Optional output parser for structured responses\n * @returns INodeExecutionData ready for output\n */\nexport function finalizeResult(\n\tresult: AgentResult,\n\titemIndex: number,\n\tmemory: BaseChatMemory | undefined,\n\toutputParser: N8nOutputParser | undefined,\n): INodeExecutionData {\n\t// If memory and outputParser are connected, parse the output.\n\tif (memory && outputParser) {\n\t\tconst parsedOutput = jsonParse<{ output: Record<string, unknown> }>(result.output);\n\t\t// Type assertion needed because parsedOutput can be various types\n\t\tresult.output = (parsedOutput?.output ?? parsedOutput) as unknown as string;\n\t}\n\n\t// Omit internal keys before returning the result.\n\tconst itemResult: INodeExecutionData = {\n\t\tjson: omit(\n\t\t\tresult,\n\t\t\t'system_message',\n\t\t\t'formatting_instructions',\n\t\t\t'input',\n\t\t\t'chat_history',\n\t\t\t'agent_scratchpad',\n\t\t),\n\t\tpairedItem: { item: itemIndex },\n\t};\n\n\treturn itemResult;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,kBAAiB;AACjB,0BAA0B;AAiBnB,SAAS,eACf,QACA,WACA,QACA,cACqB;AAErB,MAAI,UAAU,cAAc;AAC3B,UAAM,mBAAe,+BAA+C,OAAO,MAAM;AAEjF,WAAO,SAAU,cAAc,UAAU;AAAA,EAC1C;AAGA,QAAM,aAAiC;AAAA,IACtC,UAAM,YAAAA;AAAA,MACL;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IACD;AAAA,IACA,YAAY,EAAE,MAAM,UAAU;AAAA,EAC/B;AAEA,SAAO;AACR;","names":["omit"]}

package/dist/nodes/agents/Agent/agents/ToolsAgent/V3/helpers/index.js

@@ -0,0 +1,50 @@
+"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 helpers_exports = {};
+__export(helpers_exports, {
+  buildExecutionContext: () => import_buildExecutionContext.buildToolsAgentExecutionContext,
+  buildResponseMetadata: () => import_buildResponseMetadata.buildResponseMetadata,
+  checkMaxIterations: () => import_checkMaxIterations.checkMaxIterations,
+  createAgentSequence: () => import_createAgentSequence.createAgentSequence,
+  executeBatch: () => import_executeBatch.executeBatch,
+  finalizeResult: () => import_finalizeResult.finalizeResult,
+  prepareItemContext: () => import_prepareItemContext.prepareItemContext,
+  runAgent: () => import_runAgent.runAgent
+});
+module.exports = __toCommonJS(helpers_exports);
+var import_buildExecutionContext = require("./buildExecutionContext");
+var import_createAgentSequence = require("./createAgentSequence");
+var import_prepareItemContext = require("./prepareItemContext");
+var import_runAgent = require("./runAgent");
+var import_finalizeResult = require("./finalizeResult");
+var import_executeBatch = require("./executeBatch");
+var import_checkMaxIterations = require("./checkMaxIterations");
+var import_buildResponseMetadata = require("./buildResponseMetadata");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildExecutionContext,
+  buildResponseMetadata,
+  checkMaxIterations,
+  createAgentSequence,
+  executeBatch,
+  finalizeResult,
+  prepareItemContext,
+  runAgent
+});
+//# sourceMappingURL=index.js.map

package/dist/nodes/agents/Agent/agents/ToolsAgent/V3/helpers/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../nodes/agents/Agent/agents/ToolsAgent/V3/helpers/index.ts"],"sourcesContent":["export { buildToolsAgentExecutionContext as buildExecutionContext } from './buildExecutionContext';\nexport type { ToolsAgentExecutionContext as ExecutionContext } from './buildExecutionContext';\n\nexport { createAgentSequence } from './createAgentSequence';\n\nexport { prepareItemContext } from './prepareItemContext';\nexport type { ItemContext } from './prepareItemContext';\n\nexport { runAgent } from './runAgent';\n\nexport { finalizeResult } from './finalizeResult';\n\nexport { executeBatch } from './executeBatch';\n\nexport { checkMaxIterations } from './checkMaxIterations';\n\nexport { buildResponseMetadata } from './buildResponseMetadata';\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mCAAyE;AAGzE,iCAAoC;AAEpC,gCAAmC;AAGnC,sBAAyB;AAEzB,4BAA+B;AAE/B,0BAA6B;AAE7B,gCAAmC;AAEnC,mCAAsC;","names":[]}

package/dist/nodes/agents/Agent/agents/ToolsAgent/V3/helpers/prepareItemContext.js

@@ -0,0 +1,66 @@
+"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 prepareItemContext_exports = {};
+__export(prepareItemContext_exports, {
+  prepareItemContext: () => prepareItemContext
+});
+module.exports = __toCommonJS(prepareItemContext_exports);
+var import_n8n_workflow = require("n8n-workflow");
+var import_agent_execution = require("../../../../../../../utils/agent-execution");
+var import_helpers = require("../../../../../../../utils/helpers");
+var import_N8nOutputParser = require("../../../../../../../utils/output_parsers/N8nOutputParser");
+var import_common = require("../../common");
+async function prepareItemContext(ctx, itemIndex, response) {
+  const steps = (0, import_agent_execution.buildSteps)(response, itemIndex);
+  const input = (0, import_helpers.getPromptInputByType)({
+    ctx,
+    i: itemIndex,
+    inputKey: "text",
+    promptTypeKey: "promptType"
+  });
+  if (input === void 0) {
+    throw new import_n8n_workflow.NodeOperationError(ctx.getNode(), 'The "text" parameter is empty.');
+  }
+  const outputParser = await (0, import_N8nOutputParser.getOptionalOutputParser)(ctx, itemIndex);
+  const tools = await (0, import_common.getTools)(ctx, outputParser);
+  const options = ctx.getNodeParameter("options", itemIndex);
+  if (options.enableStreaming === void 0) {
+    options.enableStreaming = true;
+  }
+  const messages = await (0, import_common.prepareMessages)(ctx, itemIndex, {
+    systemMessage: options.systemMessage,
+    passthroughBinaryImages: options.passthroughBinaryImages ?? true,
+    outputParser
+  });
+  const prompt = (0, import_common.preparePrompt)(messages);
+  return {
+    itemIndex,
+    input,
+    steps,
+    tools,
+    prompt,
+    options,
+    outputParser
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  prepareItemContext
+});
+//# sourceMappingURL=prepareItemContext.js.map

package/dist/nodes/agents/Agent/agents/ToolsAgent/V3/helpers/prepareItemContext.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../nodes/agents/Agent/agents/ToolsAgent/V3/helpers/prepareItemContext.ts"],"sourcesContent":["import type { ChatPromptTemplate } from '@langchain/core/prompts';\nimport type { DynamicStructuredTool, Tool } from 'langchain/tools';\nimport { NodeOperationError } from 'n8n-workflow';\nimport type { IExecuteFunctions, ISupplyDataFunctions, EngineResponse } from 'n8n-workflow';\n\nimport { buildSteps, type ToolCallData } from '@utils/agent-execution';\nimport { getPromptInputByType } from '@utils/helpers';\nimport { getOptionalOutputParser } from '@utils/output_parsers/N8nOutputParser';\nimport type { N8nOutputParser } from '@utils/output_parsers/N8nOutputParser';\n\nimport { getTools, prepareMessages, preparePrompt } from '../../common';\nimport type { AgentOptions, RequestResponseMetadata } from '../types';\n\n/**\n * Context specific to a single item's processing\n */\nexport type ItemContext = {\n\titemIndex: number;\n\tinput: string;\n\tsteps: ToolCallData[];\n\ttools: Array<DynamicStructuredTool | Tool>;\n\tprompt: ChatPromptTemplate;\n\toptions: AgentOptions;\n\toutputParser: N8nOutputParser | undefined;\n};\n\n/**\n * Prepares the context for processing a single item.\n * This includes loading steps, input, tools, prompt, and options.\n *\n * @param ctx - The execution context\n * @param itemIndex - The index of the item to process\n * @param response - Optional engine response with previous tool calls\n * @returns ItemContext containing all item-specific state\n */\nexport async function prepareItemContext(\n\tctx: IExecuteFunctions | ISupplyDataFunctions,\n\titemIndex: number,\n\tresponse?: EngineResponse<RequestResponseMetadata>,\n): Promise<ItemContext> {\n\tconst steps = buildSteps(response, itemIndex);\n\n\tconst input = getPromptInputByType({\n\t\tctx,\n\t\ti: itemIndex,\n\t\tinputKey: 'text',\n\t\tpromptTypeKey: 'promptType',\n\t});\n\tif (input === undefined) {\n\t\tthrow new NodeOperationError(ctx.getNode(), 'The \"text\" parameter is empty.');\n\t}\n\n\tconst outputParser = await getOptionalOutputParser(ctx, itemIndex);\n\tconst tools = await getTools(ctx, outputParser);\n\tconst options = ctx.getNodeParameter('options', itemIndex) as AgentOptions;\n\n\tif (options.enableStreaming === undefined) {\n\t\toptions.enableStreaming = true;\n\t}\n\n\t// Prepare the prompt messages and prompt template.\n\tconst messages = await prepareMessages(ctx, itemIndex, {\n\t\tsystemMessage: options.systemMessage,\n\t\tpassthroughBinaryImages: options.passthroughBinaryImages ?? true,\n\t\toutputParser,\n\t});\n\tconst prompt: ChatPromptTemplate = preparePrompt(messages);\n\n\treturn {\n\t\titemIndex,\n\t\tinput,\n\t\tsteps,\n\t\ttools,\n\t\tprompt,\n\t\toptions,\n\t\toutputParser,\n\t};\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAEA,0BAAmC;AAGnC,6BAA8C;AAC9C,qBAAqC;AACrC,6BAAwC;AAGxC,oBAAyD;AAyBzD,eAAsB,mBACrB,KACA,WACA,UACuB;AACvB,QAAM,YAAQ,mCAAW,UAAU,SAAS;AAE5C,QAAM,YAAQ,qCAAqB;AAAA,IAClC;AAAA,IACA,GAAG;AAAA,IACH,UAAU;AAAA,IACV,eAAe;AAAA,EAChB,CAAC;AACD,MAAI,UAAU,QAAW;AACxB,UAAM,IAAI,uCAAmB,IAAI,QAAQ,GAAG,gCAAgC;AAAA,EAC7E;AAEA,QAAM,eAAe,UAAM,gDAAwB,KAAK,SAAS;AACjE,QAAM,QAAQ,UAAM,wBAAS,KAAK,YAAY;AAC9C,QAAM,UAAU,IAAI,iBAAiB,WAAW,SAAS;AAEzD,MAAI,QAAQ,oBAAoB,QAAW;AAC1C,YAAQ,kBAAkB;AAAA,EAC3B;AAGA,QAAM,WAAW,UAAM,+BAAgB,KAAK,WAAW;AAAA,IACtD,eAAe,QAAQ;AAAA,IACvB,yBAAyB,QAAQ,2BAA2B;AAAA,IAC5D;AAAA,EACD,CAAC;AACD,QAAM,aAA6B,6BAAc,QAAQ;AAEzD,SAAO;AAAA,IACN;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACD;AACD;","names":[]}

package/dist/nodes/agents/Agent/agents/ToolsAgent/V3/helpers/runAgent.js

@@ -0,0 +1,99 @@
+"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 runAgent_exports = {};
+__export(runAgent_exports, {
+  runAgent: () => runAgent
+});
+module.exports = __toCommonJS(runAgent_exports);
+var import_agent_execution = require("../../../../../../../utils/agent-execution");
+var import_prompt = require("../../prompt");
+var import_buildResponseMetadata = require("./buildResponseMetadata");
+async function runAgent(ctx, executor, itemContext, model, memory, response) {
+  const { itemIndex, input, steps, tools, options } = itemContext;
+  const invokeParams = {
+    steps,
+    input,
+    system_message: options.systemMessage ?? import_prompt.SYSTEM_MESSAGE,
+    formatting_instructions: "IMPORTANT: For your response to user, you MUST use the `format_final_json_response` tool with your complete answer formatted according to the required schema. Do not attempt to format the JSON manually - always use this tool. Your response will be rejected if it is not properly formatted through this tool. Only use this tool once you are ready to provide your final answer."
+  };
+  const executeOptions = { signal: ctx.getExecutionCancelSignal() };
+  const isStreamingAvailable = "isStreaming" in ctx ? ctx.isStreaming?.() : void 0;
+  if ("isStreaming" in ctx && options.enableStreaming && isStreamingAvailable && ctx.getNode().typeVersion >= 2.1) {
+    const chatHistory = await (0, import_agent_execution.loadMemory)(memory, model, options.maxTokensFromMemory);
+    const eventStream = executor.streamEvents(
+      {
+        ...invokeParams,
+        chat_history: chatHistory
+      },
+      {
+        version: "v2",
+        ...executeOptions
+      }
+    );
+    const result = await (0, import_agent_execution.processEventStream)(
+      ctx,
+      eventStream,
+      itemIndex,
+      options.returnIntermediateSteps,
+      memory,
+      input
+    );
+    if (result.toolCalls && result.toolCalls.length > 0) {
+      const actions = await (0, import_agent_execution.createEngineRequests)(result.toolCalls, itemIndex, tools);
+      return {
+        actions,
+        metadata: (0, import_buildResponseMetadata.buildResponseMetadata)(response, itemIndex)
+      };
+    }
+    return result;
+  } else {
+    const chatHistory = await (0, import_agent_execution.loadMemory)(memory, model, options.maxTokensFromMemory);
+    const modelResponse = await executor.invoke({
+      ...invokeParams,
+      chat_history: chatHistory
+    });
+    if ("returnValues" in modelResponse) {
+      if (memory && input && modelResponse.returnValues.output) {
+        let fullOutput = modelResponse.returnValues.output;
+        if (steps.length > 0) {
+          const toolContext = steps.map(
+            (step) => `Tool: ${step.action.tool}, Input: ${JSON.stringify(step.action.toolInput)}, Result: ${step.observation}`
+          ).join("; ");
+          fullOutput = `[Used tools: ${toolContext}] ${fullOutput}`;
+        }
+        await (0, import_agent_execution.saveToMemory)(input, fullOutput, memory);
+      }
+      const result = { ...modelResponse.returnValues };
+      if (options.returnIntermediateSteps && steps.length > 0) {
+        result.intermediateSteps = steps;
+      }
+      return result;
+    }
+    const actions = await (0, import_agent_execution.createEngineRequests)(modelResponse, itemIndex, tools);
+    return {
+      actions,
+      metadata: (0, import_buildResponseMetadata.buildResponseMetadata)(response, itemIndex)
+    };
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  runAgent
+});
+//# sourceMappingURL=runAgent.js.map