@invect/core 0.0.1

package/dist/nodes/agent-executor.js

@@ -0,0 +1,877 @@
+import { NodeExecutionStatus } from "../types/base.js";
+import { BatchProvider } from "../services/ai/ai-types.js";
+import "../services/ai/base-client.js";
+import { GraphNodeType } from "../types/graph-node-types.js";
+import "../types-fresh.js";
+import { detectProviderFromCredential } from "../utils/provider-detection.js";
+import { BaseNodeExecutor } from "./base-node.js";
+import { APPROX_TOKENS_PER_CHAR, DEFAULT_MAX_CONVERSATION_TOKENS, DEFAULT_TOOL_TIMEOUT_MS } from "../types/agent-tool.types.js";
+import { AgentToolRegistry } from "../services/agent-tools/agent-tool-registry.js";
+import { createOutputSchema } from "../types/node-output-schemas.js";
+import z$1 from "zod/v4";
+//#region src/nodes/agent-executor.ts
+/**
+* AI Agent Node Executor
+*
+* Executes an LLM agent loop with tool use capabilities.
+* The agent can use configured tools to accomplish a task.
+*
+* Features:
+* - Parallel tool execution (executes multiple tool calls concurrently)
+* - Tool execution timeout (configurable, prevents hung tools)
+* - Conversation truncation (manages token budget for long conversations)
+* - Error handling with retry via LLM (tool errors returned to LLM for recovery)
+*/
+/**
+* Zod schema for an added tool instance
+*/
+const addedToolInstanceSchema = z$1.object({
+	instanceId: z$1.string(),
+	toolId: z$1.string(),
+	name: z$1.string(),
+	description: z$1.string(),
+	params: z$1.record(z$1.string(), z$1.unknown())
+});
+/**
+* Zod schema for Agent node parameters
+* This provides runtime validation and type inference
+*/
+const agentNodeParamsSchema = z$1.object({
+	credentialId: z$1.string().min(1, "Credential is required"),
+	model: z$1.string().min(1, "Model is required"),
+	taskPrompt: z$1.string().min(1, "Task prompt is required"),
+	systemPrompt: z$1.string().optional().default(""),
+	provider: z$1.string().optional(),
+	enabledTools: z$1.array(z$1.string()).optional().default([]),
+	addedTools: z$1.array(addedToolInstanceSchema).optional().default([]),
+	maxIterations: z$1.number().int().min(1).max(50).optional().default(10),
+	stopCondition: z$1.enum([
+		"explicit_stop",
+		"tool_result",
+		"max_iterations"
+	]).optional().default("explicit_stop"),
+	temperature: z$1.number().min(0).max(2).optional().default(.7),
+	maxTokens: z$1.number().positive().optional(),
+	toolTimeoutMs: z$1.number().positive().optional().default(DEFAULT_TOOL_TIMEOUT_MS),
+	maxConversationTokens: z$1.number().positive().optional().default(DEFAULT_MAX_CONVERSATION_TOKENS),
+	enableParallelTools: z$1.boolean().optional().default(true),
+	useBatchProcessing: z$1.boolean().optional().default(false)
+});
+/**
+* Zod schema for Agent node output
+*/
+const agentNodeOutputSchema = createOutputSchema(GraphNodeType.AGENT, z$1.object({ output: z$1.object({
+	value: z$1.object({
+		finalResponse: z$1.string(),
+		toolResults: z$1.array(z$1.object({
+			toolId: z$1.string(),
+			toolName: z$1.string(),
+			input: z$1.record(z$1.string(), z$1.unknown()),
+			output: z$1.unknown().optional(),
+			error: z$1.string().optional(),
+			success: z$1.boolean(),
+			iteration: z$1.number(),
+			executionTimeMs: z$1.number()
+		})),
+		iterations: z$1.number(),
+		finishReason: z$1.enum([
+			"completed",
+			"max_iterations",
+			"tool_result",
+			"error"
+		])
+	}),
+	type: z$1.literal("object")
+}) }), z$1.object({
+	model: z$1.string().optional(),
+	provider: z$1.nativeEnum(BatchProvider).optional(),
+	toolsUsed: z$1.array(z$1.string()).optional(),
+	totalIterations: z$1.number().optional(),
+	tokenUsage: z$1.object({
+		conversationTokensEstimate: z$1.number(),
+		truncationOccurred: z$1.boolean()
+	}).optional()
+}).optional());
+/**
+* AI Agent Node Executor
+* Runs an agent loop that can use tools to accomplish tasks
+*/
+var AgentNodeExecutor = class extends BaseNodeExecutor {
+	toolRegistry;
+	/**
+	* Zod schema for validating agent node parameters
+	*/
+	paramsSchema = agentNodeParamsSchema;
+	outputSchema = agentNodeOutputSchema;
+	constructor(toolRegistry) {
+		super(GraphNodeType.AGENT);
+		this.toolRegistry = toolRegistry || new AgentToolRegistry();
+	}
+	/**
+	* Set the tool registry (called after initialization)
+	*/
+	setToolRegistry(registry) {
+		this.toolRegistry = registry;
+	}
+	getDefinition() {
+		return {
+			type: GraphNodeType.AGENT,
+			label: "AI Agent",
+			description: "LLM agent that can use tools to accomplish tasks",
+			category: "AI",
+			icon: "Bot",
+			input: {
+				id: "input",
+				label: "Incoming Data",
+				type: "object",
+				description: "Context data available to the agent"
+			},
+			outputs: [{
+				id: "output",
+				label: "Agent Output",
+				type: "object"
+			}],
+			paramFields: [
+				{
+					name: "credentialId",
+					label: "Credential",
+					type: "credential",
+					required: true,
+					description: "API credential for the LLM provider",
+					defaultValue: ""
+				},
+				{
+					name: "model",
+					label: "Model",
+					type: "select",
+					required: true,
+					defaultValue: "",
+					options: [],
+					placeholder: "Select a model",
+					description: "LLM model to use for the agent"
+				},
+				{
+					name: "taskPrompt",
+					label: "Task / Goal",
+					type: "textarea",
+					required: true,
+					defaultValue: "",
+					placeholder: "Describe what the agent should accomplish...",
+					description: "The main task or goal for the agent. Supports Nunjucks templating."
+				},
+				{
+					name: "systemPrompt",
+					label: "System Prompt",
+					type: "textarea",
+					required: false,
+					defaultValue: "",
+					placeholder: "Optional: Additional context or behavior instructions...",
+					description: "System-level instructions for the agent's behavior."
+				},
+				{
+					name: "enabledTools",
+					label: "Available Tools",
+					type: "json",
+					required: false,
+					defaultValue: [],
+					description: "Array of tool IDs the agent can use. Example: [\"jq_query\", \"http_request\", \"math_eval\"]"
+				},
+				{
+					name: "maxIterations",
+					label: "Max Iterations",
+					type: "number",
+					defaultValue: 10,
+					description: "Maximum number of agent iterations (1-50)",
+					extended: true
+				},
+				{
+					name: "stopCondition",
+					label: "Stop Condition",
+					type: "select",
+					defaultValue: "explicit_stop",
+					options: [
+						{
+							label: "Agent decides to stop",
+							value: "explicit_stop"
+						},
+						{
+							label: "After first tool result",
+							value: "tool_result"
+						},
+						{
+							label: "Max iterations only",
+							value: "max_iterations"
+						}
+					],
+					description: "When the agent should stop executing",
+					extended: true
+				},
+				{
+					name: "temperature",
+					label: "Temperature",
+					type: "number",
+					defaultValue: .7,
+					description: "Controls randomness (0.0 to 2.0)",
+					extended: true
+				},
+				{
+					name: "maxTokens",
+					label: "Max Tokens",
+					type: "number",
+					description: "Maximum tokens per LLM call",
+					extended: true
+				},
+				{
+					name: "toolTimeoutMs",
+					label: "Tool Timeout (ms)",
+					type: "number",
+					defaultValue: 3e4,
+					description: "Maximum time in milliseconds for each tool execution (default: 30000)",
+					extended: true
+				},
+				{
+					name: "maxConversationTokens",
+					label: "Max Conversation Tokens",
+					type: "number",
+					defaultValue: 1e5,
+					description: "Token budget for conversation history before truncation (default: 100000)",
+					extended: true
+				},
+				{
+					name: "enableParallelTools",
+					label: "Enable Parallel Tools",
+					type: "boolean",
+					defaultValue: true,
+					description: "Execute multiple tool calls in parallel when the LLM requests them",
+					extended: true
+				},
+				{
+					name: "useBatchProcessing",
+					label: "Batch Processing",
+					type: "boolean",
+					defaultValue: false,
+					description: "When enabled, the initial prompt is submitted via the provider's batch API for asynchronous processing. The flow will pause until the batch completes.",
+					extended: true,
+					hidden: true
+				}
+			],
+			defaultParams: {
+				credentialId: "",
+				model: "",
+				taskPrompt: "",
+				systemPrompt: "",
+				enabledTools: [],
+				maxIterations: 10,
+				stopCondition: "explicit_stop",
+				temperature: .7,
+				toolTimeoutMs: 3e4,
+				maxConversationTokens: 1e5,
+				enableParallelTools: true,
+				useBatchProcessing: false
+			}
+		};
+	}
+	async handleConfigUpdate(event, context) {
+		const params = event.params ?? {};
+		const credentialId = typeof params.credentialId === "string" ? params.credentialId : "";
+		const providerFromParams = !(event.change?.field === "credentialId") && typeof params.provider === "string" ? params.provider : void 0;
+		if (!credentialId && !providerFromParams) return {
+			definition: this.getDefinition(),
+			params
+		};
+		try {
+			let provider = providerFromParams;
+			if (!provider && credentialId) provider = detectProviderFromCredential(await context.services.credentials.get(credentialId)) ?? void 0;
+			if (!provider) return {
+				definition: this.getDefinition(),
+				params,
+				warnings: ["Unable to detect provider from credential"]
+			};
+			const { models, defaultModel } = await context.services.baseAIClient.listModelsForProvider(provider);
+			const definition = this.hydrateModelOptions(this.getDefinition(), provider, models);
+			const nextParams = {
+				...params,
+				provider
+			};
+			const currentModelId = typeof nextParams["model"] === "string" ? nextParams["model"] : "";
+			if (!models.some((model) => model.id === currentModelId)) {
+				const fallback = models.find((model) => model.id === defaultModel) ?? models[0];
+				nextParams["model"] = fallback ? fallback.id : "";
+			}
+			return {
+				definition,
+				params: nextParams
+			};
+		} catch (error) {
+			context.logger.error("Agent node config update failed", {
+				error: error instanceof Error ? error.message : String(error),
+				nodeId: event.nodeId
+			});
+			return {
+				definition: this.getDefinition(),
+				params,
+				errors: [error instanceof Error ? error.message : String(error)]
+			};
+		}
+	}
+	hydrateModelOptions(baseDefinition, provider, models) {
+		const providerLabel = provider === BatchProvider.OPENAI ? "OpenAI" : "Anthropic";
+		const supportsBatch = provider === BatchProvider.OPENAI || provider === BatchProvider.ANTHROPIC;
+		return {
+			...baseDefinition,
+			paramFields: baseDefinition.paramFields.map((field) => {
+				if (field.name === "useBatchProcessing") return {
+					...field,
+					hidden: !supportsBatch
+				};
+				if (field.name !== "model") return field;
+				return {
+					...field,
+					options: models.map((model) => ({
+						label: model.name ?? model.id,
+						value: model.id
+					})),
+					placeholder: models.length ? `Select a ${providerLabel} model` : `No ${providerLabel} models available`,
+					disabled: models.length === 0
+				};
+			})
+		};
+	}
+	/**
+	* Build configured tool definitions from added tool instances.
+	*
+	* For each instance:
+	* - Look up the base tool definition from the registry
+	* - Apply instance customizations (name, description)
+	* - Filter inputSchema to only include AI-chosen params
+	* - Track static params for injection during execution
+	*
+	* @returns Array of configured tool definitions and a map of instanceId -> static params
+	*/
+	buildConfiguredTools(addedTools, logger) {
+		const tools = [];
+		const staticParamsMap = /* @__PURE__ */ new Map();
+		logger?.debug("Building configured tools from addedTools", {
+			addedToolCount: addedTools.length,
+			addedToolIds: addedTools.map((t) => ({
+				instanceId: t.instanceId,
+				toolId: t.toolId,
+				name: t.name
+			}))
+		});
+		for (const instance of addedTools) {
+			const baseDef = this.toolRegistry.get(instance.toolId)?.definition;
+			if (!baseDef) {
+				logger?.debug("Skipping unknown tool", { toolId: instance.toolId });
+				continue;
+			}
+			const aiChosenModes = instance.params._aiChosenModes ?? {};
+			const staticParams = {};
+			if (instance.params.credentialId !== void 0) staticParams.credentialId = instance.params.credentialId;
+			logger?.debug("Processing tool instance", {
+				instanceId: instance.instanceId,
+				toolId: instance.toolId,
+				name: instance.name,
+				paramKeys: Object.keys(instance.params),
+				aiChosenModes
+			});
+			const baseSchema = baseDef.inputSchema;
+			let filteredSchema = { ...baseDef.inputSchema };
+			if (baseSchema.properties) {
+				const filteredProperties = {};
+				for (const [paramName, paramSchema] of Object.entries(baseSchema.properties)) {
+					if (paramName === "credentialId") continue;
+					if (aiChosenModes[paramName] ?? true) filteredProperties[paramName] = paramSchema;
+					else if (instance.params[paramName] !== void 0) staticParams[paramName] = instance.params[paramName];
+				}
+				const filteredRequired = baseSchema.required?.filter((name) => {
+					if (name === "credentialId") return false;
+					return aiChosenModes[name] ?? true;
+				});
+				filteredSchema = {
+					...baseSchema,
+					properties: filteredProperties,
+					required: filteredRequired && filteredRequired.length > 0 ? filteredRequired : void 0
+				};
+			}
+			logger?.debug("Tool static params extracted", {
+				instanceId: instance.instanceId,
+				staticParamKeys: Object.keys(staticParams),
+				staticParamValues: staticParams,
+				hasCredentialId: "credentialId" in staticParams
+			});
+			const configuredTool = {
+				...baseDef,
+				id: instance.instanceId,
+				name: instance.name,
+				description: instance.description,
+				inputSchema: filteredSchema,
+				instanceId: instance.instanceId,
+				staticParams,
+				baseToolId: instance.toolId
+			};
+			tools.push(configuredTool);
+			staticParamsMap.set(instance.instanceId, staticParams);
+		}
+		return {
+			tools,
+			staticParamsMap
+		};
+	}
+	/**
+	* Execute the agent loop
+	*/
+	async execute(inputs, node, context) {
+		this.logExecutionStart(context);
+		try {
+			const paramsResult = this.parseParams(node.params);
+			if (!paramsResult.success) return this.createErrorResult([`Invalid agent node parameters: ${paramsResult.error}`]);
+			const params = paramsResult.data;
+			if (!context.functions.submitAgentPrompt) return this.createErrorResult(["Agent prompt function not available in execution context"]);
+			let provider = params.provider;
+			if (!provider) {
+				if (!context.functions.getCredential) return this.createErrorResult(["Credential lookup function not available in execution context"]);
+				const credential = await context.functions.getCredential(params.credentialId);
+				if (!credential) return this.createErrorResult(["Selected credential was not found or is inaccessible"]);
+				provider = detectProviderFromCredential(credential) || void 0;
+				if (!provider) return this.createErrorResult(["Unable to detect provider from credential."]);
+			}
+			context.logger.debug(`Agent ${context.nodeId} - Tool configuration`, {
+				addedToolsCount: params.addedTools?.length ?? 0,
+				enabledToolsCount: params.enabledTools?.length ?? 0,
+				addedTools: params.addedTools ? JSON.stringify(params.addedTools).substring(0, 500) : "undefined"
+			});
+			let configuredTools = [];
+			let staticParamsMap = /* @__PURE__ */ new Map();
+			if (params.addedTools && params.addedTools.length > 0) {
+				const result = this.buildConfiguredTools(params.addedTools, context.logger);
+				configuredTools = result.tools;
+				staticParamsMap = result.staticParamsMap;
+			} else if (params.enabledTools && params.enabledTools.length > 0) configuredTools = this.toolRegistry.getDefinitionsForIds(params.enabledTools).map((def) => ({
+				...def,
+				instanceId: def.id,
+				staticParams: {},
+				baseToolId: def.id
+			}));
+			context.logger.debug(`Agent ${context.nodeId} - Starting agent loop`, {
+				taskPrompt: params.taskPrompt.substring(0, 100),
+				model: params.model,
+				configuredToolCount: configuredTools.length,
+				maxIterations: params.maxIterations,
+				stopCondition: params.stopCondition
+			});
+			const agentResult = await this.runAgentLoop({
+				taskPrompt: params.taskPrompt,
+				systemPrompt: params.systemPrompt || void 0,
+				model: params.model,
+				maxIterations: params.maxIterations,
+				stopCondition: params.stopCondition,
+				temperature: params.temperature,
+				maxTokens: params.maxTokens,
+				credentialId: params.credentialId,
+				useBatchProcessing: params.useBatchProcessing
+			}, configuredTools, staticParamsMap, provider, context, {
+				toolTimeoutMs: params.toolTimeoutMs,
+				maxConversationTokens: params.maxConversationTokens,
+				enableParallelTools: params.enableParallelTools
+			});
+			if ("state" in agentResult && agentResult.state === NodeExecutionStatus.PENDING) return agentResult;
+			const agentOutput = agentResult;
+			const executionResult = this.createSuccessResult({
+				nodeType: GraphNodeType.AGENT,
+				data: {
+					variables: { output: {
+						value: agentOutput,
+						type: "object"
+					} },
+					metadata: {
+						model: params.model,
+						provider,
+						toolsUsed: agentOutput.toolResults.map((r) => r.toolId),
+						totalIterations: agentOutput.iterations,
+						tokenUsage: agentOutput.tokenUsage
+					}
+				}
+			}, {
+				model: params.model,
+				provider,
+				iterations: agentOutput.iterations,
+				finishReason: agentOutput.finishReason,
+				toolsUsed: agentOutput.toolResults.map((r) => r.toolId),
+				executedAt: (/* @__PURE__ */ new Date()).toISOString(),
+				tokenUsage: agentOutput.tokenUsage
+			});
+			this.logExecutionComplete(context, executionResult);
+			return executionResult;
+		} catch (error) {
+			const errorMessage = error instanceof Error ? error.message : String(error);
+			context.logger.error(`Agent ${context.nodeId} - Execution failed:`, { error: errorMessage });
+			return this.createErrorResult([`Agent execution failed: ${errorMessage}`]);
+		}
+	}
+	/**
+	* Run the agent loop with support for:
+	* - Parallel tool execution
+	* - Tool execution timeouts
+	* - Conversation truncation for token management
+	* - Static parameter injection for configured tools
+	*/
+	async runAgentLoop(params, tools, staticParamsMap, provider, context, config) {
+		const maxIterations = params.maxIterations ?? 10;
+		const stopCondition = params.stopCondition ?? "explicit_stop";
+		const systemPromptWithTools = this.buildSystemPromptWithTools(params.systemPrompt, tools);
+		const messages = [{
+			role: "user",
+			content: params.taskPrompt
+		}];
+		const toolResults = [];
+		let iteration = 0;
+		let agentFinished = false;
+		let finishReason = "max_iterations";
+		let finalResponse = "";
+		let truncationOccurred = false;
+		while (!agentFinished && iteration < maxIterations) {
+			iteration++;
+			const truncationResult = this.truncateConversationIfNeeded(messages, config.maxConversationTokens, context);
+			if (truncationResult.truncated) truncationOccurred = true;
+			context.logger.debug(`Agent ${context.nodeId} - Iteration ${iteration}`, {
+				messageCount: messages.length,
+				toolResultCount: toolResults.length,
+				estimatedTokens: truncationResult.estimatedTokens
+			});
+			const useBatch = iteration === 1 && params.useBatchProcessing === true;
+			const response = await context.functions.submitAgentPrompt({
+				model: params.model,
+				messages,
+				tools,
+				systemPrompt: systemPromptWithTools,
+				temperature: params.temperature,
+				maxTokens: params.maxTokens,
+				provider,
+				credentialId: params.credentialId,
+				parallelToolCalls: config.enableParallelTools,
+				...useBatch ? {
+					useBatchProcessing: true,
+					nodeId: context.nodeId,
+					flowRunId: context.flowRunId
+				} : {}
+			});
+			if ("type" in response && response.type === "batch_submitted") {
+				const batchResult = response;
+				return {
+					state: NodeExecutionStatus.PENDING,
+					type: "batch_submitted",
+					batchJobId: batchResult.batchJobId,
+					nodeId: batchResult.nodeId,
+					executionId: batchResult.flowRunId
+				};
+			}
+			const allToolCalls = response.toolCalls ?? [];
+			context.logger.debug(`Agent ${context.nodeId} - LLM response`, {
+				type: response.type,
+				toolCallCount: allToolCalls.length,
+				contentLength: response.content?.length ?? 0
+			});
+			if (response.type === "tool_use" && allToolCalls.length > 0) {
+				const iterationToolResults = config.enableParallelTools && allToolCalls.length > 1 ? await this.executeToolsInParallel(allToolCalls, tools, staticParamsMap, context, iteration, maxIterations, config.toolTimeoutMs) : await this.executeToolsSequentially(allToolCalls, tools, staticParamsMap, context, iteration, maxIterations, config.toolTimeoutMs);
+				toolResults.push(...iterationToolResults);
+				messages.push({
+					role: "assistant",
+					content: response.content || "",
+					toolCalls: allToolCalls
+				});
+				for (let i = 0; i < allToolCalls.length; i++) {
+					const toolCall = allToolCalls[i];
+					const toolRecord = iterationToolResults[i];
+					messages.push({
+						role: "tool",
+						toolCallId: toolCall.id,
+						content: toolRecord.success ? JSON.stringify(toolRecord.output) : `Error: ${toolRecord.error}`
+					});
+				}
+				if (stopCondition === "tool_result") {
+					agentFinished = true;
+					finishReason = "tool_result";
+					const lastResult = iterationToolResults[iterationToolResults.length - 1];
+					finalResponse = lastResult.success ? JSON.stringify(lastResult.output) : `Tool execution failed: ${lastResult.error}`;
+				}
+			} else {
+				agentFinished = true;
+				finishReason = "completed";
+				finalResponse = response.content || "";
+				messages.push({
+					role: "assistant",
+					content: finalResponse
+				});
+			}
+		}
+		if (!agentFinished) {
+			finishReason = "max_iterations";
+			finalResponse = messages[messages.length - 1]?.content || "Agent reached maximum iterations without completing.";
+		}
+		const finalTokenEstimate = this.estimateConversationTokens(messages);
+		return {
+			finalResponse,
+			toolResults,
+			iterations: iteration,
+			finishReason,
+			conversationHistory: messages,
+			tokenUsage: {
+				conversationTokensEstimate: finalTokenEstimate,
+				truncationOccurred
+			}
+		};
+	}
+	/**
+	* Execute multiple tools in parallel with timeout
+	*/
+	async executeToolsInParallel(toolCalls, configuredTools, staticParamsMap, context, iteration, maxIterations, timeoutMs) {
+		context.logger.debug(`Agent ${context.nodeId} - Executing ${toolCalls.length} tools in parallel`);
+		const promises = toolCalls.map((toolCall) => this.executeToolWithTimeout(toolCall, configuredTools, staticParamsMap, context, iteration, maxIterations, timeoutMs));
+		return Promise.all(promises);
+	}
+	/**
+	* Execute multiple tools sequentially with timeout
+	*/
+	async executeToolsSequentially(toolCalls, configuredTools, staticParamsMap, context, iteration, maxIterations, timeoutMs) {
+		const results = [];
+		for (const toolCall of toolCalls) {
+			const result = await this.executeToolWithTimeout(toolCall, configuredTools, staticParamsMap, context, iteration, maxIterations, timeoutMs);
+			results.push(result);
+		}
+		return results;
+	}
+	/**
+	* Execute a single tool with timeout
+	*/
+	async executeToolWithTimeout(toolCall, configuredTools, staticParamsMap, context, iteration, maxIterations, timeoutMs) {
+		const startTime = Date.now();
+		const timeoutPromise = new Promise((_, reject) => {
+			setTimeout(() => {
+				reject(/* @__PURE__ */ new Error(`Tool execution timed out after ${timeoutMs}ms`));
+			}, timeoutMs);
+		});
+		try {
+			return await Promise.race([this.executeTool(toolCall, configuredTools, staticParamsMap, context, iteration, maxIterations), timeoutPromise]);
+		} catch (error) {
+			const errorMessage = error instanceof Error ? error.message : String(error);
+			const isTimeout = errorMessage.includes("timed out");
+			context.logger.warn(`Agent ${context.nodeId} - Tool ${isTimeout ? "timed out" : "failed"}`, {
+				toolId: toolCall.toolId,
+				error: errorMessage,
+				timeoutMs
+			});
+			const configuredTool = configuredTools.find((t) => t.id === toolCall.toolId);
+			const registeredTool = configuredTool ? this.toolRegistry.get(configuredTool.baseToolId) : this.toolRegistry.get(toolCall.toolId);
+			return {
+				toolId: toolCall.toolId,
+				toolName: configuredTool?.name ?? registeredTool?.definition.name ?? toolCall.toolId,
+				input: toolCall.input,
+				error: errorMessage,
+				success: false,
+				iteration,
+				executionTimeMs: Date.now() - startTime
+			};
+		}
+	}
+	/**
+	* Estimate the number of tokens in the conversation
+	*/
+	estimateConversationTokens(messages) {
+		let totalChars = 0;
+		for (const message of messages) {
+			totalChars += (message.content ?? "").length;
+			if (message.toolCalls) totalChars += JSON.stringify(message.toolCalls).length;
+		}
+		return Math.ceil(totalChars * APPROX_TOKENS_PER_CHAR);
+	}
+	/**
+	* Truncate conversation history if it exceeds the token budget
+	* Preserves the first message (task prompt) and recent messages
+	*/
+	truncateConversationIfNeeded(messages, maxTokens, context) {
+		const estimatedTokens = this.estimateConversationTokens(messages);
+		if (estimatedTokens <= maxTokens || messages.length <= 2) return {
+			truncated: false,
+			estimatedTokens
+		};
+		context.logger.info(`Agent ${context.nodeId} - Truncating conversation`, {
+			currentTokens: estimatedTokens,
+			maxTokens,
+			messageCount: messages.length
+		});
+		const firstMessage = messages[0];
+		const remainingMessages = messages.slice(1);
+		while (remainingMessages.length > 1) {
+			const testMessages = [firstMessage, ...remainingMessages];
+			if (this.estimateConversationTokens(testMessages) <= maxTokens * .9) break;
+			const removedMessage = remainingMessages.shift();
+			if (removedMessage?.toolCalls && removedMessage.toolCalls.length > 0) {
+				const toolCallIds = new Set(removedMessage.toolCalls.map((tc) => tc.id));
+				while (remainingMessages.length > 0 && remainingMessages[0].role === "tool" && remainingMessages[0].toolCallId && toolCallIds.has(remainingMessages[0].toolCallId)) remainingMessages.shift();
+			}
+		}
+		const truncationNotice = {
+			role: "user",
+			content: "[Note: Earlier conversation history has been truncated to stay within token limits. The conversation continues from here.]"
+		};
+		messages.length = 0;
+		messages.push(firstMessage, truncationNotice, ...remainingMessages);
+		const newEstimatedTokens = this.estimateConversationTokens(messages);
+		context.logger.info(`Agent ${context.nodeId} - Conversation truncated`, {
+			newTokens: newEstimatedTokens,
+			newMessageCount: messages.length
+		});
+		return {
+			truncated: true,
+			estimatedTokens: newEstimatedTokens
+		};
+	}
+	/**
+	* Build system prompt with tool descriptions
+	*/
+	buildSystemPromptWithTools(baseSystemPrompt, tools) {
+		let systemPrompt = baseSystemPrompt || "";
+		if (tools.length > 0) {
+			const toolInstructions = `
+You have access to the following tools:
+
+${tools.map((tool) => `- ${tool.name} (${tool.id}): ${tool.description}`).join("\n")}
+
+To use a tool, respond with a tool call in the appropriate format for your API.
+Only use tools when necessary to accomplish the task.
+When you have completed the task or have a final answer, respond with text only (no tool call).
+`;
+			systemPrompt = systemPrompt ? `${systemPrompt}\n\n${toolInstructions}` : toolInstructions;
+		}
+		return systemPrompt;
+	}
+	/**
+	* Execute a tool call
+	*
+	* The toolCall.toolId may be an instanceId (for configured tools) or a base tool ID (legacy).
+	* We look up the configured tool to:
+	* 1. Find the base tool ID for the actual executor
+	* 2. Merge static params with the AI-provided input
+	* 3. Record the tool execution to the database
+	*/
+	async executeTool(toolCall, configuredTools, staticParamsMap, context, iteration, maxIterations) {
+		const startTime = Date.now();
+		const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+		const configuredTool = configuredTools.find((t) => t.id === toolCall.toolId);
+		const baseToolId = configuredTool?.baseToolId ?? toolCall.toolId;
+		const registeredTool = this.toolRegistry.get(baseToolId);
+		if (!registeredTool) {
+			const result = {
+				toolId: toolCall.toolId,
+				toolName: configuredTool?.name ?? toolCall.toolId,
+				input: toolCall.input,
+				error: `Tool '${baseToolId}' not found in registry`,
+				success: false,
+				iteration,
+				executionTimeMs: Date.now() - startTime
+			};
+			await this.recordToolExecutionToDb(context, result, startedAt);
+			return result;
+		}
+		const staticParams = staticParamsMap.get(toolCall.toolId) ?? {};
+		const mergedInput = {
+			...toolCall.input,
+			...staticParams
+		};
+		const toolContext = {
+			logger: context.logger,
+			iteration,
+			maxIterations,
+			nodeContext: context,
+			staticParams
+		};
+		try {
+			context.logger.debug(`Agent ${context.nodeId} - Executing tool`, {
+				toolId: toolCall.toolId,
+				baseToolId,
+				hasStaticParams: Object.keys(staticParams).length > 0,
+				staticParamKeys: Object.keys(staticParams),
+				credentialIdInStaticParams: staticParams.credentialId ?? "NOT SET",
+				input: JSON.stringify(mergedInput).substring(0, 200)
+			});
+			const executorResult = await registeredTool.executor(mergedInput, toolContext);
+			const result = {
+				toolId: toolCall.toolId,
+				toolName: configuredTool?.name ?? registeredTool.definition.name,
+				input: mergedInput,
+				output: executorResult.output,
+				error: executorResult.error,
+				success: executorResult.success,
+				iteration,
+				executionTimeMs: Date.now() - startTime
+			};
+			await this.recordToolExecutionToDb(context, result, startedAt);
+			return result;
+		} catch (error) {
+			const errorMessage = error instanceof Error ? error.message : String(error);
+			context.logger.error(`Agent ${context.nodeId} - Tool execution failed`, {
+				toolId: toolCall.toolId,
+				baseToolId,
+				error: errorMessage
+			});
+			const result = {
+				toolId: toolCall.toolId,
+				toolName: configuredTool?.name ?? registeredTool.definition.name,
+				input: mergedInput,
+				error: errorMessage,
+				success: false,
+				iteration,
+				executionTimeMs: Date.now() - startTime
+			};
+			await this.recordToolExecutionToDb(context, result, startedAt);
+			return result;
+		}
+	}
+	/**
+	* Record a tool execution to the database via the context function.
+	* This is a best-effort operation - failures are logged but don't affect the agent loop.
+	*/
+	async recordToolExecutionToDb(context, result, startedAt) {
+		const { recordToolExecution } = context.functions;
+		if (!recordToolExecution) {
+			context.logger.debug("recordToolExecution not available, skipping database recording");
+			return;
+		}
+		const nodeExecutionId = context.traceId;
+		if (!nodeExecutionId) {
+			context.logger.warn("traceId (nodeExecutionId) not available, skipping database recording");
+			return;
+		}
+		try {
+			await recordToolExecution({
+				nodeExecutionId,
+				flowRunId: context.flowRunId,
+				toolId: result.toolId,
+				toolName: result.toolName,
+				iteration: result.iteration,
+				input: result.input,
+				output: result.output,
+				error: result.error,
+				success: result.success,
+				startedAt,
+				completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+				duration: result.executionTimeMs
+			});
+			context.logger.debug("Tool execution recorded to database", {
+				toolId: result.toolId,
+				iteration: result.iteration,
+				success: result.success
+			});
+		} catch (error) {
+			context.logger.warn("Failed to record tool execution to database", {
+				toolId: result.toolId,
+				error: error instanceof Error ? error.message : String(error)
+			});
+		}
+	}
+};
+//#endregion
+export { AgentNodeExecutor, agentNodeOutputSchema, agentNodeParamsSchema };
+
+//# sourceMappingURL=agent-executor.js.map