@codemation/core-nodes 0.0.14 → 0.0.16

package/dist/index.js

@@ -1,6 +1,6 @@
-import { AgentConfigInspector, ConnectionInvocationIdFactory, ConnectionNodeIdFactory, CoreTokens, ItemsInputNormalizer, RetryPolicy, WorkflowBuilder, chatModel, inject, node } from "@codemation/core";
+import { AgentConfigInspector, AgentGuardrailDefaults, AgentMessageConfigNormalizer, ConnectionInvocationIdFactory, ConnectionNodeIdFactory, CoreTokens, ItemsInputNormalizer, NodeBackedToolConfig, RetryPolicy, WorkflowBuilder, chatModel, inject, injectable, node } from "@codemation/core";
 import { ChatOpenAI } from "@langchain/openai";
-import { HumanMessage, SystemMessage, ToolMessage } from "@langchain/core/messages";
+import { AIMessage, HumanMessage, SystemMessage, ToolMessage } from "@langchain/core/messages";
 import { DynamicStructuredTool } from "@langchain/core/tools";
 import { CredentialResolverFactory } from "@codemation/core/bootstrap";
 
@@ -68,12 +68,18 @@ const openAiChatModelPresets = new OpenAiChatModelPresets();
 //#endregion
 //#region src/nodes/AgentMessageFactory.ts
 var AgentMessageFactory = class {
+	static createPromptMessages(messages) {
+		return messages.map((message) => this.createPromptMessage(message));
+	}
 	static createSystemPrompt(systemMessage) {
 		return new SystemMessage(systemMessage);
 	}
 	static createUserPrompt(prompt) {
 		return new HumanMessage(prompt);
 	}
+	static createAssistantPrompt(prompt) {
+		return new AIMessage(prompt);
+	}
 	static createToolMessage(toolCallId, content) {
 		return new ToolMessage({
 			tool_call_id: toolCallId,
@@ -105,6 +111,11 @@ var AgentMessageFactory = class {
 	static isRecord(value) {
 		return typeof value === "object" && value !== null;
 	}
+	static createPromptMessage(message) {
+		if (message.role === "system") return this.createSystemPrompt(message.content);
+		if (message.role === "assistant") return this.createAssistantPrompt(message.content);
+		return this.createUserPrompt(message.content);
+	}
 };
 
 //#endregion
@@ -160,12 +171,31 @@ var ConnectionCredentialExecutionContextFactory = class {
 };
 
 //#endregion
-//#region src/nodes/aiAgentSupport.types.ts
-var AgentItemPortMap = class {
-	static fromItem(item) {
-		return { in: [item] };
+//#region src/nodes/AIAgentExecutionHelpersFactory.ts
+let AIAgentExecutionHelpersFactory = class AIAgentExecutionHelpersFactory$1 {
+	createConnectionCredentialExecutionContextFactory(credentialSessions) {
+		return new ConnectionCredentialExecutionContextFactory(credentialSessions);
+	}
+	createDynamicStructuredTool(entry, toolCredentialContext, item, itemIndex, items) {
+		return new DynamicStructuredTool({
+			name: entry.config.name,
+			description: entry.config.description ?? entry.runtime.defaultDescription,
+			schema: entry.runtime.inputSchema,
+			func: async (input) => {
+				const result = await entry.runtime.execute({
+					config: entry.config,
+					input,
+					ctx: toolCredentialContext,
+					item,
+					itemIndex,
+					items
+				});
+				return JSON.stringify(result);
+			}
+		});
 	}
 };
+AIAgentExecutionHelpersFactory = __decorate([injectable()], AIAgentExecutionHelpersFactory);
 
 //#endregion
 //#region \0@oxc-project+runtime@0.95.0/helpers/decorateMetadata.js
@@ -182,55 +212,164 @@ function __decorateParam(paramIndex, decorator) {
 }
 
 //#endregion
-//#region src/nodes/AIAgentNodeFactory.ts
+//#region src/nodes/NodeBackedToolRuntime.ts
+let NodeBackedToolRuntime = class NodeBackedToolRuntime$1 {
+	constructor(nodeResolver) {
+		this.nodeResolver = nodeResolver;
+	}
+	async execute(config, args) {
+		const nodeInput = config.toNodeItem({
+			input: args.input,
+			item: args.item,
+			itemIndex: args.itemIndex,
+			items: args.items,
+			ctx: args.ctx,
+			node: config.node
+		});
+		const nodeCtx = {
+			...args.ctx,
+			config: config.node
+		};
+		const resolvedNode = this.nodeResolver.resolve(config.node.type);
+		const outputs = await this.executeResolvedNode(resolvedNode, nodeInput, nodeCtx);
+		return config.toToolOutput({
+			input: args.input,
+			item: args.item,
+			itemIndex: args.itemIndex,
+			items: args.items,
+			ctx: args.ctx,
+			node: config.node,
+			outputs
+		});
+	}
+	async executeResolvedNode(resolvedNode, nodeInput, ctx) {
+		if (this.isMultiInputNode(resolvedNode)) return await resolvedNode.executeMulti({ in: [nodeInput] }, ctx);
+		if (this.isNode(resolvedNode)) return await resolvedNode.execute([nodeInput], ctx);
+		throw new Error(`Node-backed tool expected a runnable node instance for "${ctx.config.name ?? ctx.nodeId}".`);
+	}
+	isNode(value) {
+		return typeof value === "object" && value !== null && "execute" in value;
+	}
+	isMultiInputNode(value) {
+		return typeof value === "object" && value !== null && "executeMulti" in value;
+	}
+};
+NodeBackedToolRuntime = __decorate([
+	injectable(),
+	__decorateParam(0, inject(CoreTokens.NodeResolver)),
+	__decorateMetadata("design:paramtypes", [Object])
+], NodeBackedToolRuntime);
+
+//#endregion
+//#region src/nodes/aiAgentSupport.types.ts
+var AgentItemPortMap = class {
+	static fromItem(item) {
+		return { in: [item] };
+	}
+};
+
+//#endregion
+//#region src/nodes/AIAgentNode.ts
+var _ref, _ref2;
 let AIAgentNode = class AIAgentNode$1 {
 	kind = "node";
 	outputPorts = ["main"];
 	connectionCredentialExecutionContextFactory;
-	constructor(nodeResolver, credentialSessions) {
+	constructor(nodeResolver, credentialSessions, nodeBackedToolRuntime, executionHelpers) {
 		this.nodeResolver = nodeResolver;
-		this.connectionCredentialExecutionContextFactory = new ConnectionCredentialExecutionContextFactory(credentialSessions);
+		this.nodeBackedToolRuntime = nodeBackedToolRuntime;
+		this.executionHelpers = executionHelpers;
+		this.connectionCredentialExecutionContextFactory = this.executionHelpers.createConnectionCredentialExecutionContextFactory(credentialSessions);
 	}
 	async execute(items, ctx) {
+		const prepared = await this.prepareExecution(ctx);
+		const out = [];
+		for (let i = 0; i < items.length; i++) out.push(await this.runAgentForItem(prepared, items[i], i, items));
+		return { main: out };
+	}
+	/**
+	* Resolves the chat model and tools once, then returns shared state for every item in the batch.
+	*/
+	async prepareExecution(ctx) {
 		const chatModelFactory = this.nodeResolver.resolve(ctx.config.chatModel.type);
 		const languageModelCredentialContext = this.connectionCredentialExecutionContextFactory.forConnectionNode(ctx, {
 			connectionNodeId: ConnectionNodeIdFactory.languageModelConnectionNodeId(ctx.nodeId),
 			getCredentialRequirements: () => ctx.config.chatModel.getCredentialRequirements?.() ?? []
 		});
-		const model = await Promise.resolve(chatModelFactory.create({
-			config: ctx.config.chatModel,
-			ctx: languageModelCredentialContext
-		}));
-		const resolvedTools = this.resolveTools(ctx.config.tools ?? []);
-		const out = [];
-		for (let i = 0; i < items.length; i++) {
-			const item = items[i];
-			const prompt = ctx.config.userMessageFormatter(item, i, items, ctx);
-			const itemInputsByPort = AgentItemPortMap.fromItem(item);
-			const itemScopedTools = this.createItemScopedTools(resolvedTools, ctx, item, i, items);
-			const firstResponse = await this.invokeModel(itemScopedTools.length > 0 && model.bindTools ? model.bindTools(itemScopedTools.map((entry) => entry.langChainTool)) : model, ConnectionNodeIdFactory.languageModelConnectionNodeId(ctx.nodeId), [AgentMessageFactory.createSystemPrompt(ctx.config.systemMessage), AgentMessageFactory.createUserPrompt(prompt)], ctx, itemInputsByPort);
-			const toolCalls = AgentMessageFactory.extractToolCalls(firstResponse);
-			if (toolCalls.length === 0) {
-				out.push(AgentOutputFactory.replaceJson(item, AgentOutputFactory.fromAgentContent(AgentMessageFactory.extractContent(firstResponse))));
-				continue;
+		return {
+			ctx,
+			model: await Promise.resolve(chatModelFactory.create({
+				config: ctx.config.chatModel,
+				ctx: languageModelCredentialContext
+			})),
+			resolvedTools: this.resolveTools(ctx.config.tools ?? []),
+			guardrails: this.resolveGuardrails(ctx.config.guardrails),
+			languageModelConnectionNodeId: ConnectionNodeIdFactory.languageModelConnectionNodeId(ctx.nodeId)
+		};
+	}
+	/**
+	* One item: build prompts, optionally bind tools, run the multi-turn loop, map the final model message to workflow JSON.
+	*/
+	async runAgentForItem(prepared, item, itemIndex, items) {
+		const { ctx } = prepared;
+		const itemInputsByPort = AgentItemPortMap.fromItem(item);
+		const itemScopedTools = this.createItemScopedTools(prepared.resolvedTools, ctx, item, itemIndex, items);
+		const conversation = [...this.createPromptMessages(item, itemIndex, items, ctx)];
+		const modelWithTools = this.bindToolsToModel(prepared.model, itemScopedTools);
+		const finalResponse = await this.runTurnLoopUntilFinalAnswer({
+			prepared,
+			itemInputsByPort,
+			itemScopedTools,
+			conversation,
+			modelWithTools
+		});
+		return this.buildOutputItem(item, finalResponse);
+	}
+	/**
+	* Repeatedly invokes the model until it returns without tool calls, or guardrails end the loop.
+	*/
+	async runTurnLoopUntilFinalAnswer(args) {
+		const { prepared, itemInputsByPort, itemScopedTools, conversation, modelWithTools } = args;
+		const { ctx, guardrails, languageModelConnectionNodeId } = prepared;
+		let finalResponse;
+		for (let turn = 1; turn <= guardrails.maxTurns; turn++) {
+			const response = await this.invokeModel(modelWithTools, languageModelConnectionNodeId, conversation, ctx, itemInputsByPort, guardrails.modelInvocationOptions);
+			finalResponse = response;
+			const toolCalls = AgentMessageFactory.extractToolCalls(response);
+			if (toolCalls.length === 0) break;
+			if (this.cannotExecuteAnotherToolRound(turn, guardrails)) {
+				this.finishOrThrowWhenTurnCapHitWithToolCalls(ctx, guardrails);
+				break;
 			}
 			const plannedToolCalls = this.planToolCalls(itemScopedTools, toolCalls, ctx.nodeId);
 			await this.markQueuedTools(plannedToolCalls, ctx);
 			const executedToolCalls = await this.executeToolCalls(plannedToolCalls, ctx);
-			const finalResponse = await this.invokeModel(itemScopedTools.length > 0 && model.bindTools ? model.bindTools(itemScopedTools.map((entry) => entry.langChainTool)) : model, ConnectionNodeIdFactory.languageModelConnectionNodeId(ctx.nodeId), [
-				AgentMessageFactory.createSystemPrompt(ctx.config.systemMessage),
-				AgentMessageFactory.createUserPrompt(prompt),
-				firstResponse,
-				...executedToolCalls.map((toolCall) => AgentMessageFactory.createToolMessage(toolCall.toolCallId, toolCall.serialized))
-			], ctx, itemInputsByPort);
-			out.push(AgentOutputFactory.replaceJson(item, AgentOutputFactory.fromAgentContent(AgentMessageFactory.extractContent(finalResponse))));
+			this.appendAssistantAndToolMessages(conversation, response, executedToolCalls);
 		}
-		return { main: out };
+		if (!finalResponse) throw new Error(`AIAgent "${ctx.config.name ?? ctx.nodeId}" did not produce a model response.`);
+		return finalResponse;
+	}
+	cannotExecuteAnotherToolRound(turn, guardrails) {
+		return turn >= guardrails.maxTurns;
+	}
+	finishOrThrowWhenTurnCapHitWithToolCalls(ctx, guardrails) {
+		if (guardrails.onTurnLimitReached === "respondWithLastMessage") return;
+		throw new Error(`AIAgent "${ctx.config.name ?? ctx.nodeId}" reached maxTurns=${guardrails.maxTurns} before producing a final response.`);
+	}
+	appendAssistantAndToolMessages(conversation, assistantMessage, executedToolCalls) {
+		conversation.push(assistantMessage, ...executedToolCalls.map((toolCall) => AgentMessageFactory.createToolMessage(toolCall.toolCallId, toolCall.serialized)));
+	}
+	buildOutputItem(item, finalResponse) {
+		return AgentOutputFactory.replaceJson(item, AgentOutputFactory.fromAgentContent(AgentMessageFactory.extractContent(finalResponse)));
+	}
+	bindToolsToModel(model, itemScopedTools) {
+		if (itemScopedTools.length === 0 || !model.bindTools) return model;
+		return model.bindTools(itemScopedTools.map((entry) => entry.langChainTool));
 	}
 	resolveTools(toolConfigs) {
 		const resolvedTools = toolConfigs.map((config) => ({
 			config,
-			tool: this.nodeResolver.resolve(config.type)
+			runtime: this.resolveToolRuntime(config)
 		}));
 		const names = /* @__PURE__ */ new Set();
 		for (const entry of resolvedTools) {
@@ -245,29 +384,14 @@ let AIAgentNode = class AIAgentNode$1 {
 				connectionNodeId: ConnectionNodeIdFactory.toolConnectionNodeId(ctx.nodeId, entry.config.name),
 				getCredentialRequirements: () => entry.config.getCredentialRequirements?.() ?? []
 			});
-			const langChainTool = new DynamicStructuredTool({
-				name: entry.config.name,
-				description: entry.config.description ?? entry.tool.defaultDescription,
-				schema: entry.tool.inputSchema,
-				func: async (input) => {
-					const result = await entry.tool.execute({
-						config: entry.config,
-						input,
-						ctx: toolCredentialContext,
-						item,
-						itemIndex,
-						items
-					});
-					return JSON.stringify(result);
-				}
-			});
+			const langChainTool = this.executionHelpers.createDynamicStructuredTool(entry, toolCredentialContext, item, itemIndex, items);
 			return {
 				config: entry.config,
 				langChainTool
 			};
 		});
 	}
-	async invokeModel(model, nodeId, messages, ctx, inputsByPort) {
+	async invokeModel(model, nodeId, messages, ctx, inputsByPort, options) {
 		await ctx.nodeState?.markQueued({
 			nodeId,
 			activationId: ctx.activationId,
@@ -279,7 +403,7 @@ let AIAgentNode = class AIAgentNode$1 {
 			inputsByPort
 		});
 		try {
-			const response = await model.invoke(messages);
+			const response = await model.invoke(messages, options);
 			await ctx.nodeState?.markCompleted({
 				nodeId,
 				activationId: ctx.activationId,
@@ -413,12 +537,49 @@ let AIAgentNode = class AIAgentNode$1 {
 		const json = JSON.stringify(value);
 		return JSON.parse(json);
 	}
+	createPromptMessages(item, itemIndex, items, ctx) {
+		return AgentMessageFactory.createPromptMessages(AgentMessageConfigNormalizer.normalize(ctx.config, {
+			item,
+			itemIndex,
+			items,
+			ctx
+		}));
+	}
+	resolveToolRuntime(config) {
+		if (config instanceof NodeBackedToolConfig) return {
+			defaultDescription: `Run workflow node "${config.node.name ?? config.name}" as an AI tool.`,
+			inputSchema: config.getInputSchema(),
+			execute: async (args) => await this.nodeBackedToolRuntime.execute(config, args)
+		};
+		const tool = this.nodeResolver.resolve(config.type);
+		return {
+			defaultDescription: tool.defaultDescription,
+			inputSchema: tool.inputSchema,
+			execute: async (args) => await Promise.resolve(tool.execute(args))
+		};
+	}
+	resolveGuardrails(guardrails) {
+		const maxTurns = guardrails?.maxTurns ?? AgentGuardrailDefaults.maxTurns;
+		if (!Number.isInteger(maxTurns) || maxTurns < 1) throw new Error(`AIAgent maxTurns must be a positive integer. Received: ${String(maxTurns)}`);
+		return {
+			maxTurns,
+			onTurnLimitReached: guardrails?.onTurnLimitReached ?? AgentGuardrailDefaults.onTurnLimitReached,
+			modelInvocationOptions: guardrails?.modelInvocationOptions
+		};
+	}
 };
 AIAgentNode = __decorate([
 	node({ packageName: "@codemation/core-nodes" }),
 	__decorateParam(0, inject(CoreTokens.NodeResolver)),
 	__decorateParam(1, inject(CoreTokens.CredentialSessionService)),
-	__decorateMetadata("design:paramtypes", [Object, Object])
+	__decorateParam(2, inject(NodeBackedToolRuntime)),
+	__decorateParam(3, inject(AIAgentExecutionHelpersFactory)),
+	__decorateMetadata("design:paramtypes", [
+		Object,
+		Object,
+		typeof (_ref = typeof NodeBackedToolRuntime !== "undefined" && NodeBackedToolRuntime) === "function" ? _ref : Object,
+		typeof (_ref2 = typeof AIAgentExecutionHelpersFactory !== "undefined" && AIAgentExecutionHelpersFactory) === "function" ? _ref2 : Object
+	])
 ], AIAgentNode);
 
 //#endregion
@@ -432,14 +593,21 @@ var AIAgent = class {
 	type = AIAgentNode;
 	execution = { hint: "local" };
 	icon = "lucide:bot";
-	constructor(name, systemMessage, userMessageFormatter, chatModel$1, tools = [], id, retryPolicy = RetryPolicy.defaultForAiAgent) {
-		this.name = name;
-		this.systemMessage = systemMessage;
-		this.userMessageFormatter = userMessageFormatter;
-		this.chatModel = chatModel$1;
-		this.tools = tools;
-		this.id = id;
-		this.retryPolicy = retryPolicy;
+	name;
+	messages;
+	chatModel;
+	tools;
+	id;
+	retryPolicy;
+	guardrails;
+	constructor(options) {
+		this.name = options.name;
+		this.messages = options.messages;
+		this.chatModel = options.chatModel;
+		this.tools = options.tools ?? [];
+		this.id = options.id;
+		this.retryPolicy = options.retryPolicy ?? RetryPolicy.defaultForAiAgent;
+		this.guardrails = options.guardrails;
 	}
 };
 
@@ -1113,5 +1281,5 @@ var ConnectionCredentialNodeConfigFactory = class {
 };
 
 //#endregion
-export { AIAgent, AIAgentConnectionWorkflowExpander, AIAgentNode, AgentItemPortMap, AgentMessageFactory, AgentOutputFactory, AgentToolCallPortMap, Callback, CallbackNode, CallbackResultNormalizer, ConnectionCredentialExecutionContextFactory, ConnectionCredentialNode, ConnectionCredentialNodeConfig, ConnectionCredentialNodeConfigFactory, HttpRequest, HttpRequestNode, If, IfNode, ManualTrigger, ManualTriggerNode, MapData, MapDataNode, Merge, MergeNode, NoOp, NoOpNode, OpenAIChatModelConfig, OpenAIChatModelFactory, OpenAiChatModelPresets, SubWorkflow, SubWorkflowNode, Wait, WaitDuration, WaitNode, WebhookRespondNowAndContinueError, WebhookRespondNowError, WebhookTrigger, WebhookTriggerNode, createWorkflowBuilder, openAiChatModelPresets, registerCoreNodes };
+export { AIAgent, AIAgentConnectionWorkflowExpander, AIAgentExecutionHelpersFactory, AIAgentNode, AgentItemPortMap, AgentMessageFactory, AgentOutputFactory, AgentToolCallPortMap, Callback, CallbackNode, CallbackResultNormalizer, ConnectionCredentialExecutionContextFactory, ConnectionCredentialNode, ConnectionCredentialNodeConfig, ConnectionCredentialNodeConfigFactory, HttpRequest, HttpRequestNode, If, IfNode, ManualTrigger, ManualTriggerNode, MapData, MapDataNode, Merge, MergeNode, NoOp, NoOpNode, OpenAIChatModelConfig, OpenAIChatModelFactory, OpenAiChatModelPresets, SubWorkflow, SubWorkflowNode, Wait, WaitDuration, WaitNode, WebhookRespondNowAndContinueError, WebhookRespondNowError, WebhookTrigger, WebhookTriggerNode, createWorkflowBuilder, openAiChatModelPresets, registerCoreNodes };
 //# sourceMappingURL=index.js.map