@n8n/ai-workflow-builder 0.32.0 → 0.33.0-exp.0

package/dist/subgraphs/builder.subgraph.js

@@ -0,0 +1,384 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BuilderSubgraph = exports.BuilderSubgraphState = void 0;
+const prompts_1 = require("@langchain/core/prompts");
+const langgraph_1 = require("@langchain/langgraph");
+const errors_1 = require("../errors");
+const subgraph_interface_1 = require("./subgraph-interface");
+const add_node_tool_1 = require("../tools/add-node.tool");
+const connect_nodes_tool_1 = require("../tools/connect-nodes.tool");
+const remove_connection_tool_1 = require("../tools/remove-connection.tool");
+const remove_node_tool_1 = require("../tools/remove-node.tool");
+const validate_structure_tool_1 = require("../tools/validate-structure.tool");
+const coordination_1 = require("../types/coordination");
+const cache_control_1 = require("../utils/cache-control");
+const context_builders_1 = require("../utils/context-builders");
+const operations_processor_1 = require("../utils/operations-processor");
+const subgraph_helpers_1 = require("../utils/subgraph-helpers");
+const BUILDER_PROMPT = `You are a Builder Agent specialized in constructing n8n workflows.
+
+MANDATORY EXECUTION SEQUENCE:
+You MUST follow these steps IN ORDER. Do not skip any step.
+
+STEP 1: CREATE NODES
+- Call add_nodes for EVERY node needed based on discovery results
+- Create multiple nodes in PARALLEL for efficiency
+- Do NOT respond with text - START BUILDING immediately
+
+STEP 2: CONNECT NODES
+- Call connect_nodes for ALL required connections
+- Connect multiple node pairs in PARALLEL
+
+STEP 3: VALIDATE (REQUIRED)
+- After ALL nodes and connections are created, call validate_structure
+- This step is MANDATORY - you cannot finish without it
+- If validation finds issues (missing trigger, invalid connections), fix them and validate again
+- MAXIMUM 3 VALIDATION ATTEMPTS: After 3 calls to validate_structure, proceed to respond regardless of remaining issues
+
+STEP 4: RESPOND TO USER
+- Only after validation passes, provide your brief summary
+
+⚠️ NEVER respond to the user without calling validate_structure first ⚠️
+
+NODE CREATION:
+Each add_nodes call creates ONE node. You must provide:
+- nodeType: The exact type from discovery (e.g., "n8n-nodes-base.httpRequest")
+- name: Descriptive name (e.g., "Fetch Weather Data")
+- connectionParametersReasoning: Explain your thinking about connection parameters
+- connectionParameters: Parameters that affect connections (or {{}} if none needed)
+
+<workflow_configuration_node>
+Always include a Workflow Configuration node at the start of every workflow.
+
+The Workflow Configuration node (n8n-nodes-base.set) should be placed immediately after the trigger node and before all other processing nodes.
+
+Placement rules:
+- Add between trigger and first processing node
+- Connect: Trigger → Workflow Configuration → First processing node
+- Name it "Workflow Configuration"
+</workflow_configuration_node>
+
+<data_parsing_strategy>
+For AI-generated structured data, prefer Structured Output Parser nodes over Code nodes.
+For binary file data, use Extract From File node to extract content from files before processing.
+Use Code nodes only for custom business logic beyond parsing.
+
+STRUCTURED OUTPUT PARSER RULE:
+When Discovery results include Structured Output Parser:
+1. Create the Structured Output Parser node
+2. Set AI Agent's hasOutputParser: true in connectionParameters
+3. Connect: Structured Output Parser → AI Agent (ai_outputParser connection)
+</data_parsing_strategy>
+
+<proactive_design>
+Anticipate workflow needs:
+- IF nodes for conditional logic when multiple outcomes exist
+- Set nodes for data transformation between incompatible formats
+- Schedule Triggers for recurring tasks
+- Error handling for external service calls
+
+NEVER use Split In Batches nodes.
+</proactive_design>
+
+<node_defaults_warning>
+CRITICAL: NEVER RELY ON DEFAULT PARAMETER VALUES FOR CONNECTIONS
+
+Default values often hide connection inputs/outputs. You MUST explicitly configure parameters that affect connections:
+- Vector Store: Mode parameter affects available connections - always set explicitly (e.g., mode: "insert", "retrieve", "retrieve-as-tool")
+- AI Agent: hasOutputParser default may not match your workflow needs
+- Document Loader: textSplittingMode affects whether it accepts a text splitter input
+
+ALWAYS check node details and set connectionParameters explicitly.
+</node_defaults_warning>
+
+CONNECTION PARAMETERS EXAMPLES:
+- Static nodes (HTTP Request, Set, Code): reasoning="Static inputs/outputs", parameters={{}}
+- AI Agent with structured output: reasoning="hasOutputParser enables ai_outputParser input for Structured Output Parser", parameters={{ hasOutputParser: true }}
+- Vector Store insert: reasoning="Insert mode requires document input", parameters={{ mode: "insert" }}
+- Document Loader custom: reasoning="Custom mode enables text splitter input", parameters={{ textSplittingMode: "custom" }}
+- Switch with routing rules: reasoning="Switch needs N outputs, creating N rules.values entries with outputKeys", parameters={{ mode: "rules", rules: {{ values: [...] }} }} - see <switch_node_pattern> for full structure
+
+<structured_output_parser_guidance>
+WHEN TO SET hasOutputParser: true on AI Agent:
+- Discovery found Structured Output Parser node → MUST set hasOutputParser: true
+- AI output will be used in conditions (IF/Switch nodes checking $json.field)
+- AI output will be formatted/displayed (HTML emails, reports with specific sections)
+- AI output will be stored in database/data tables with specific fields
+- AI is classifying, scoring, or extracting specific data fields
+</structured_output_parser_guidance>
+
+<node_connections_understanding>
+n8n connections flow from SOURCE (output) to TARGET (input).
+
+Regular data flow: Source node output → Target node input
+Example: HTTP Request → Set (HTTP Request is source, Set is target)
+
+AI sub-nodes PROVIDE capabilities, making them the SOURCE:
+- OpenAI Chat Model → AI Agent [ai_languageModel]
+- Calculator Tool → AI Agent [ai_tool]
+- Window Buffer Memory → AI Agent [ai_memory]
+- Token Splitter → Default Data Loader [ai_textSplitter]
+- Default Data Loader → Vector Store [ai_document]
+- Embeddings OpenAI → Vector Store [ai_embedding]
+</node_connections_understanding>
+
+<agent_node_distinction>
+Distinguish between two different agent node types:
+
+1. **AI Agent** (@n8n/n8n-nodes-langchain.agent)
+   - Main workflow node that orchestrates AI tasks
+   - Use for: Primary AI logic, chatbots, autonomous workflows
+
+2. **AI Agent Tool** (@n8n/n8n-nodes-langchain.agentTool)
+   - Sub-node that acts as a tool for another AI Agent
+   - Use for: Multi-agent systems where one agent calls another
+
+Default assumption: When discovery results include "agent", use AI Agent
+unless explicitly specified as "agent tool" or "sub-agent".
+</agent_node_distinction>
+
+<rag_workflow_pattern>
+For RAG (Retrieval-Augmented Generation) workflows:
+
+Main data flow:
+- Data source (e.g., HTTP Request) → Vector Store [main connection]
+
+AI capability connections:
+- Document Loader → Vector Store [ai_document]
+- Embeddings → Vector Store [ai_embedding]
+- Text Splitter → Document Loader [ai_textSplitter]
+
+Common mistake to avoid:
+- NEVER connect Document Loader to main data outputs
+- Document Loader is an AI sub-node that gives Vector Store document processing capability
+</rag_workflow_pattern>
+
+<switch_node_pattern>
+For Switch nodes with multiple routing paths:
+- The number of outputs is determined by the number of entries in rules.values[]
+- You MUST create the rules.values[] array with placeholder entries for each output branch
+- Each entry needs: conditions structure (with empty leftValue/rightValue) + renameOutput: true + descriptive outputKey
+- Configurator will fill in the actual condition values later
+- Use descriptive node names like "Route by Amount" or "Route by Status"
+
+Example connectionParameters for 3-way routing:
+{{
+  "mode": "rules",
+  "rules": {{
+    "values": [
+      {{
+        "conditions": {{
+          "options": {{ "caseSensitive": true, "leftValue": "", "typeValidation": "strict" }},
+          "conditions": [{{ "leftValue": "", "rightValue": "", "operator": {{ "type": "string", "operation": "equals" }} }}],
+          "combinator": "and"
+        }},
+        "renameOutput": true,
+        "outputKey": "Output 1 Name"
+      }},
+      {{
+        "conditions": {{
+          "options": {{ "caseSensitive": true, "leftValue": "", "typeValidation": "strict" }},
+          "conditions": [{{ "leftValue": "", "rightValue": "", "operator": {{ "type": "string", "operation": "equals" }} }}],
+          "combinator": "and"
+        }},
+        "renameOutput": true,
+        "outputKey": "Output 2 Name"
+      }},
+      {{
+        "conditions": {{
+          "options": {{ "caseSensitive": true, "leftValue": "", "typeValidation": "strict" }},
+          "conditions": [{{ "leftValue": "", "rightValue": "", "operator": {{ "type": "string", "operation": "equals" }} }}],
+          "combinator": "and"
+        }},
+        "renameOutput": true,
+        "outputKey": "Output 3 Name"
+      }}
+    ]
+  }}
+}}
+</switch_node_pattern>
+
+<connection_type_examples>
+**Main Connections** (regular data flow):
+- Trigger → HTTP Request → Set → Email
+
+**AI Language Model Connections** (ai_languageModel):
+- OpenAI Chat Model → AI Agent
+
+**AI Tool Connections** (ai_tool):
+- Calculator Tool → AI Agent
+- AI Agent Tool → AI Agent (for multi-agent systems)
+
+**AI Document Connections** (ai_document):
+- Document Loader → Vector Store
+
+**AI Embedding Connections** (ai_embedding):
+- OpenAI Embeddings → Vector Store
+
+**AI Text Splitter Connections** (ai_textSplitter):
+- Token Text Splitter → Document Loader
+
+**AI Memory Connections** (ai_memory):
+- Window Buffer Memory → AI Agent
+
+**AI Vector Store in retrieve-as-tool mode** (ai_tool):
+- Vector Store → AI Agent
+</connection_type_examples>
+
+DO NOT:
+- Respond before calling validate_structure
+- Skip validation even if you think structure is correct
+- Add commentary between tool calls - execute tools silently
+- Configure node parameters (that's the Configurator Agent's job)
+- Search for nodes (that's the Discovery Agent's job)
+- Make assumptions about node types - use exactly what Discovery found
+
+RESPONSE FORMAT (only after validation):
+Provide ONE brief text message summarizing:
+- What nodes were added
+- How they're connected
+
+Example: "Created 4 nodes: Trigger → Weather → Image Generation → Email"`;
+exports.BuilderSubgraphState = langgraph_1.Annotation.Root({
+    workflowJSON: (0, langgraph_1.Annotation)({
+        reducer: (x, y) => y ?? x,
+        default: () => ({ nodes: [], connections: {}, name: '' }),
+    }),
+    userRequest: (0, langgraph_1.Annotation)({
+        reducer: (x, y) => y ?? x,
+        default: () => '',
+    }),
+    workflowContext: (0, langgraph_1.Annotation)({
+        reducer: (x, y) => y ?? x,
+    }),
+    discoveryContext: (0, langgraph_1.Annotation)({
+        reducer: (x, y) => y ?? x,
+        default: () => null,
+    }),
+    messages: (0, langgraph_1.Annotation)({
+        reducer: (x, y) => x.concat(y),
+        default: () => [],
+    }),
+    workflowOperations: (0, langgraph_1.Annotation)({
+        reducer: (x, y) => {
+            if (y === null)
+                return [];
+            if (!y || y.length === 0)
+                return x ?? [];
+            return [...(x ?? []), ...y];
+        },
+        default: () => [],
+    }),
+});
+class BuilderSubgraph extends subgraph_interface_1.BaseSubgraph {
+    name = 'builder_subgraph';
+    description = 'Constructs workflow structure: creating nodes and connections';
+    create(config) {
+        const tools = [
+            (0, add_node_tool_1.createAddNodeTool)(config.parsedNodeTypes),
+            (0, connect_nodes_tool_1.createConnectNodesTool)(config.parsedNodeTypes, config.logger),
+            (0, remove_node_tool_1.createRemoveNodeTool)(config.logger),
+            (0, remove_connection_tool_1.createRemoveConnectionTool)(config.logger),
+            (0, validate_structure_tool_1.createValidateStructureTool)(config.parsedNodeTypes),
+        ];
+        const toolMap = new Map(tools.map((bt) => [bt.tool.name, bt.tool]));
+        const systemPrompt = prompts_1.ChatPromptTemplate.fromMessages([
+            [
+                'system',
+                [
+                    {
+                        type: 'text',
+                        text: BUILDER_PROMPT,
+                        cache_control: { type: 'ephemeral' },
+                    },
+                ],
+            ],
+            ['placeholder', '{messages}'],
+        ]);
+        if (typeof config.llm.bindTools !== 'function') {
+            throw new errors_1.LLMServiceError('LLM does not support tools', {
+                llmModel: config.llm._llmType(),
+            });
+        }
+        const agent = systemPrompt.pipe(config.llm.bindTools(tools.map((bt) => bt.tool)));
+        const callAgent = async (state) => {
+            (0, cache_control_1.applySubgraphCacheMarkers)(state.messages);
+            const response = await agent.invoke({
+                messages: state.messages,
+            });
+            return { messages: [response] };
+        };
+        const shouldContinue = (0, subgraph_helpers_1.createStandardShouldContinue)();
+        const subgraph = new langgraph_1.StateGraph(exports.BuilderSubgraphState)
+            .addNode('agent', callAgent)
+            .addNode('tools', async (state) => await (0, subgraph_helpers_1.executeSubgraphTools)(state, toolMap))
+            .addNode('process_operations', operations_processor_1.processOperations)
+            .addEdge('__start__', 'agent')
+            .addConditionalEdges('agent', shouldContinue)
+            .addEdge('tools', 'process_operations')
+            .addEdge('process_operations', 'agent');
+        return subgraph.compile();
+    }
+    transformInput(parentState) {
+        const userRequest = (0, subgraph_helpers_1.extractUserRequest)(parentState.messages);
+        const contextParts = [];
+        contextParts.push('=== USER REQUEST ===');
+        contextParts.push(userRequest);
+        if (parentState.discoveryContext) {
+            contextParts.push('=== DISCOVERY CONTEXT ===');
+            contextParts.push((0, context_builders_1.buildDiscoveryContextBlock)(parentState.discoveryContext, true));
+        }
+        contextParts.push('=== CURRENT WORKFLOW ===');
+        if (parentState.workflowJSON.nodes.length > 0) {
+            contextParts.push((0, context_builders_1.buildWorkflowJsonBlock)(parentState.workflowJSON));
+        }
+        else {
+            contextParts.push('Empty workflow - ready to build');
+        }
+        const schemaBlock = (0, context_builders_1.buildExecutionSchemaBlock)(parentState.workflowContext);
+        if (schemaBlock) {
+            contextParts.push('=== AVAILABLE DATA SCHEMA ===');
+            contextParts.push(schemaBlock);
+        }
+        const contextMessage = (0, context_builders_1.createContextMessage)(contextParts);
+        return {
+            userRequest,
+            workflowJSON: parentState.workflowJSON,
+            workflowContext: parentState.workflowContext,
+            discoveryContext: parentState.discoveryContext,
+            messages: [contextMessage],
+        };
+    }
+    transformOutput(subgraphOutput, _parentState) {
+        const nodes = subgraphOutput.workflowJSON.nodes;
+        const connections = subgraphOutput.workflowJSON.connections;
+        const connectionCount = Object.values(connections).flat().length;
+        const builderSummary = subgraphOutput.messages
+            .slice()
+            .reverse()
+            .find((m) => m.content &&
+            (!('tool_calls' in m) ||
+                !m.tool_calls ||
+                (m.tool_calls && Array.isArray(m.tool_calls) && m.tool_calls.length === 0)));
+        const summaryText = typeof builderSummary?.content === 'string' ? builderSummary.content : undefined;
+        const logEntry = {
+            phase: 'builder',
+            status: 'completed',
+            timestamp: Date.now(),
+            summary: `Created ${nodes.length} nodes with ${connectionCount} connections`,
+            output: summaryText,
+            metadata: (0, coordination_1.createBuilderMetadata)({
+                nodesCreated: nodes.length,
+                connectionsCreated: connectionCount,
+                nodeNames: nodes.map((n) => n.name),
+            }),
+        };
+        return {
+            workflowJSON: subgraphOutput.workflowJSON,
+            workflowOperations: subgraphOutput.workflowOperations ?? [],
+            coordinationLog: [logEntry],
+        };
+    }
+}
+exports.BuilderSubgraph = BuilderSubgraph;
+//# sourceMappingURL=builder.subgraph.js.map

package/dist/subgraphs/builder.subgraph.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"builder.subgraph.js","sourceRoot":"","sources":["../../src/subgraphs/builder.subgraph.ts"],"names":[],"mappings":"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"}

package/dist/subgraphs/configurator.subgraph.d.ts

@@ -0,0 +1,132 @@
+import type { BaseChatModel } from '@langchain/core/language_models/chat_models';
+import type { BaseMessage } from '@langchain/core/messages';
+import type { Logger } from '@n8n/backend-common';
+import type { INodeTypeDescription } from 'n8n-workflow';
+import { BaseSubgraph } from './subgraph-interface';
+import type { ParentGraphState } from '../parent-graph-state';
+import type { CoordinationLogEntry } from '../types/coordination';
+import type { DiscoveryContext } from '../types/discovery-types';
+import type { SimpleWorkflow, WorkflowOperation } from '../types/workflow';
+export declare const ConfiguratorSubgraphState: import("@langchain/langgraph").AnnotationRoot<{
+    workflowJSON: import("@langchain/langgraph").BinaryOperatorAggregate<SimpleWorkflow, SimpleWorkflow>;
+    workflowContext: import("@langchain/langgraph").BinaryOperatorAggregate<{
+        executionSchema?: import("n8n-workflow").NodeExecutionSchema[];
+        currentWorkflow?: Partial<import("n8n-workflow").IWorkflowBase>;
+        executionData?: import("n8n-workflow").IRunExecutionData["resultData"];
+        expressionValues?: Record<string, import("../workflow-builder-agent").ExpressionValue[]>;
+    } | undefined, {
+        executionSchema?: import("n8n-workflow").NodeExecutionSchema[];
+        currentWorkflow?: Partial<import("n8n-workflow").IWorkflowBase>;
+        executionData?: import("n8n-workflow").IRunExecutionData["resultData"];
+        expressionValues?: Record<string, import("../workflow-builder-agent").ExpressionValue[]>;
+    } | undefined>;
+    instanceUrl: import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+    userRequest: import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+    discoveryContext: import("@langchain/langgraph").BinaryOperatorAggregate<DiscoveryContext | null, DiscoveryContext | null>;
+    messages: import("@langchain/langgraph").BinaryOperatorAggregate<BaseMessage<import("@langchain/core/messages").MessageStructure, import("@langchain/core/messages").MessageType>[], BaseMessage<import("@langchain/core/messages").MessageStructure, import("@langchain/core/messages").MessageType>[]>;
+    workflowOperations: import("@langchain/langgraph").BinaryOperatorAggregate<WorkflowOperation[] | null, WorkflowOperation[] | null>;
+}>;
+export interface ConfiguratorSubgraphConfig {
+    parsedNodeTypes: INodeTypeDescription[];
+    llm: BaseChatModel;
+    logger?: Logger;
+    instanceUrl?: string;
+}
+export declare class ConfiguratorSubgraph extends BaseSubgraph<ConfiguratorSubgraphConfig, typeof ConfiguratorSubgraphState.State, typeof ParentGraphState.State> {
+    name: string;
+    description: string;
+    private agent;
+    private toolMap;
+    private instanceUrl;
+    create(config: ConfiguratorSubgraphConfig): import("@langchain/langgraph").CompiledStateGraph<{
+        workflowJSON: SimpleWorkflow;
+        workflowContext: {
+            executionSchema?: import("n8n-workflow").NodeExecutionSchema[];
+            currentWorkflow?: Partial<import("n8n-workflow").IWorkflowBase>;
+            executionData?: import("n8n-workflow").IRunExecutionData["resultData"];
+            expressionValues?: Record<string, import("../workflow-builder-agent").ExpressionValue[]>;
+        } | undefined;
+        instanceUrl: string;
+        userRequest: string;
+        discoveryContext: DiscoveryContext | null;
+        messages: BaseMessage<import("@langchain/core/messages").MessageStructure, import("@langchain/core/messages").MessageType>[];
+        workflowOperations: WorkflowOperation[] | null;
+    }, {
+        workflowJSON?: SimpleWorkflow | undefined;
+        workflowContext?: {
+            executionSchema?: import("n8n-workflow").NodeExecutionSchema[];
+            currentWorkflow?: Partial<import("n8n-workflow").IWorkflowBase>;
+            executionData?: import("n8n-workflow").IRunExecutionData["resultData"];
+            expressionValues?: Record<string, import("../workflow-builder-agent").ExpressionValue[]>;
+        } | undefined;
+        instanceUrl?: string | undefined;
+        userRequest?: string | undefined;
+        discoveryContext?: DiscoveryContext | null | undefined;
+        messages?: BaseMessage<import("@langchain/core/messages").MessageStructure, import("@langchain/core/messages").MessageType>[] | undefined;
+        workflowOperations?: WorkflowOperation[] | null | undefined;
+    }, "agent" | "tools" | "process_operations" | "__start__", {
+        workflowJSON: import("@langchain/langgraph").BinaryOperatorAggregate<SimpleWorkflow, SimpleWorkflow>;
+        workflowContext: import("@langchain/langgraph").BinaryOperatorAggregate<{
+            executionSchema?: import("n8n-workflow").NodeExecutionSchema[];
+            currentWorkflow?: Partial<import("n8n-workflow").IWorkflowBase>;
+            executionData?: import("n8n-workflow").IRunExecutionData["resultData"];
+            expressionValues?: Record<string, import("../workflow-builder-agent").ExpressionValue[]>;
+        } | undefined, {
+            executionSchema?: import("n8n-workflow").NodeExecutionSchema[];
+            currentWorkflow?: Partial<import("n8n-workflow").IWorkflowBase>;
+            executionData?: import("n8n-workflow").IRunExecutionData["resultData"];
+            expressionValues?: Record<string, import("../workflow-builder-agent").ExpressionValue[]>;
+        } | undefined>;
+        instanceUrl: import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+        userRequest: import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+        discoveryContext: import("@langchain/langgraph").BinaryOperatorAggregate<DiscoveryContext | null, DiscoveryContext | null>;
+        messages: import("@langchain/langgraph").BinaryOperatorAggregate<BaseMessage<import("@langchain/core/messages").MessageStructure, import("@langchain/core/messages").MessageType>[], BaseMessage<import("@langchain/core/messages").MessageStructure, import("@langchain/core/messages").MessageType>[]>;
+        workflowOperations: import("@langchain/langgraph").BinaryOperatorAggregate<WorkflowOperation[] | null, WorkflowOperation[] | null>;
+    }, {
+        workflowJSON: import("@langchain/langgraph").BinaryOperatorAggregate<SimpleWorkflow, SimpleWorkflow>;
+        workflowContext: import("@langchain/langgraph").BinaryOperatorAggregate<{
+            executionSchema?: import("n8n-workflow").NodeExecutionSchema[];
+            currentWorkflow?: Partial<import("n8n-workflow").IWorkflowBase>;
+            executionData?: import("n8n-workflow").IRunExecutionData["resultData"];
+            expressionValues?: Record<string, import("../workflow-builder-agent").ExpressionValue[]>;
+        } | undefined, {
+            executionSchema?: import("n8n-workflow").NodeExecutionSchema[];
+            currentWorkflow?: Partial<import("n8n-workflow").IWorkflowBase>;
+            executionData?: import("n8n-workflow").IRunExecutionData["resultData"];
+            expressionValues?: Record<string, import("../workflow-builder-agent").ExpressionValue[]>;
+        } | undefined>;
+        instanceUrl: import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+        userRequest: import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+        discoveryContext: import("@langchain/langgraph").BinaryOperatorAggregate<DiscoveryContext | null, DiscoveryContext | null>;
+        messages: import("@langchain/langgraph").BinaryOperatorAggregate<BaseMessage<import("@langchain/core/messages").MessageStructure, import("@langchain/core/messages").MessageType>[], BaseMessage<import("@langchain/core/messages").MessageStructure, import("@langchain/core/messages").MessageType>[]>;
+        workflowOperations: import("@langchain/langgraph").BinaryOperatorAggregate<WorkflowOperation[] | null, WorkflowOperation[] | null>;
+    }, import("@langchain/langgraph").StateDefinition, {
+        agent: {
+            messages: BaseMessage<import("@langchain/core/messages").MessageStructure, import("@langchain/core/messages").MessageType>[];
+        };
+        tools: {
+            messages?: BaseMessage[];
+            workflowOperations?: WorkflowOperation[] | null;
+            templateIds?: number[];
+            nodeConfigurations?: import("..").NodeConfigurationsMap;
+        };
+    }, unknown, unknown>;
+    transformInput(parentState: typeof ParentGraphState.State): {
+        workflowJSON: SimpleWorkflow;
+        workflowContext: {
+            executionSchema?: import("n8n-workflow").NodeExecutionSchema[];
+            currentWorkflow?: Partial<import("n8n-workflow").IWorkflowBase>;
+            executionData?: import("n8n-workflow").IRunExecutionData["resultData"];
+            expressionValues?: Record<string, import("../workflow-builder-agent").ExpressionValue[]>;
+        } | undefined;
+        instanceUrl: string;
+        userRequest: string;
+        discoveryContext: DiscoveryContext | null;
+        messages: import("@langchain/core/messages").HumanMessage<import("@langchain/core/messages").MessageStructure>[];
+    };
+    transformOutput(subgraphOutput: typeof ConfiguratorSubgraphState.State, _parentState: typeof ParentGraphState.State): {
+        workflowJSON: SimpleWorkflow;
+        workflowOperations: WorkflowOperation[];
+        coordinationLog: CoordinationLogEntry[];
+    };
+}