n8n 2.32.5 → 2.33.0

package/dist/modules/agents/builder/agents-builder-prompts.js

@@ -1,9 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FEW_SHOT_FLOWS_SECTION = exports.WORKFLOW_SECTION = exports.RESPONSE_STYLE_SECTION = exports.READ_CONFIG_FRESHNESS_SECTION = exports.INTERACTIVE_TOOLS_SECTION = exports.TARGET_AGENT_SECTION = void 0;
+exports.FEW_SHOT_FLOWS_SECTION = exports.WORKFLOW_SECTION = exports.RESPONSE_STYLE_SECTION = exports.READ_CONFIG_FRESHNESS_SECTION = exports.INTERACTIVE_TOOLS_SECTION = exports.PREREQUISITES_SECTION = exports.TARGET_AGENT_SECTION = void 0;
 exports.getConversationModeSection = getConversationModeSection;
 exports.buildBuilderPrompt = buildBuilderPrompt;
 const config_mutation_prompt_1 = require("./prompts/config-mutation.prompt");
+const initial_build_prompt_1 = require("./prompts/initial-build.prompt");
 const llm_selection_prompt_1 = require("./prompts/llm-selection.prompt");
 const memory_prompt_1 = require("./prompts/memory.prompt");
 const tools_prompt_1 = require("./prompts/tools.prompt");
@@ -14,6 +15,12 @@ You are the builder agent, not the target agent.
 The target agent is the AI agent you are configuring for the user. Changes to
 config, tools, memory, integrations, and target-agent skills affect the target
 agent, not your own builder behavior.`;
+exports.PREREQUISITES_SECTION = `\
+## Prerequisites you cannot create
+
+You cannot create n8n workflows or data tables. Attach existing workflows only via \`list_workflows\` and \`{ "type": "workflow", "workflow": "<name>" }\`.
+
+If the target agent needs workflows or tables that do not exist yet, finish what you can and state the missing prerequisites clearly in your reply (names, schema, purpose). Do not ask the user to create them in this chat.`;
 function getConversationModeSection(agentPreviewPath) {
     return `\
 ## When To Build vs When To Converse
@@ -29,8 +36,13 @@ agent in this Build chat, do not call tools. Reply exactly:
 "Head to the [Preview](${agentPreviewPath}) section to chat with your agent."
 Do not say anything else. Keep the Preview link as a relative app path.
 
-Never write empty, placeholder, or guessed \`instructions\`. If you do not have
-enough detail to write meaningful instructions, ask the user first.`;
+After a successful build or config change that leaves the agent ready to try,
+include the same [Preview](${agentPreviewPath}) markdown link in your wrap-up
+(it can be part of a longer reply). Do not invent a different path.
+
+Never write empty or placeholder \`instructions\`. When the user gave a
+concrete goal, write real instructions from it and fill gaps with sensible assumptions
+stated in your summary. Only ask first when the overall goal itself is missing.`;
 }
 exports.INTERACTIVE_TOOLS_SECTION = `\
 ## Interactive tools
@@ -49,14 +61,32 @@ Exception: the opening reply to a greeting, a "what do you do", or a vague
 intent — there you reply conversationally and ask for the overall goal, per
 "When To Build vs When To Converse".
 
+"Initial build" means the first build pass on a fresh agent; per the Initial
+Build section, never suspend during it except the single trailing
+\`finish_setup\` call. Interactive tools are for everything after that —
+additions or changes to an existing agent (ask before the related config
+mutation, batching what you can) and follow-up turns where the user asked to
+do setup in chat.
+
+- \`finish_setup\`: use ONCE, only in the trailing step of an initial build
+  when only blocked tasks remain — the model choice and every open decision
+  as \`questions\`, one \`credentialRequests\` entry per credential slot, and
+  one \`channels\` entry per drafted channel integration. It shows the setup
+  cards back-to-back without returning control to you between them —
+  questions, then credentials, then channels (channels always last, since
+  connecting one needs credentials already resolved). Never call it
+  together with another interactive tool.
 - \`ask_credential\`: use once per required node-tool, MCP-server, or fallback
-  web-search credential slot. For node tools and fallback web search, call it
-  before the related config mutation; for MCP servers, call it before
-  verification. NEVER use it for a chat-channel
+  web-search credential slot. During an initial build, never call it
+  (see Initial Build). For an addition to an existing
+  agent, call it before the related config mutation. For MCP servers, call it
+  before verification. NEVER use it for a chat-channel
   credential — use \`configure_channel\` instead.
 - \`configure_channel\`: ALWAYS use this to connect a chat platform (Slack,
   Telegram, ...) as an agent channel, with a type from \`list_integration_types\`.
-  The setup UI creates and persists the credential itself.
+  The setup UI creates and persists the credential itself. During an initial
+  build, do not call it — write the draft integration instead (see Initial
+  Build and the integrations skill).
 - \`ask_questions\`: the default way to ask the user anything that isn't a
   node-tool credential, MCP-server credential, fallback web-search credential,
   or channel choice, including when the user must choose, confirm, configure, or
@@ -65,8 +95,11 @@ intent — there you reply conversationally and ask for the overall goal, per
   question you currently need into a single call instead of asking one at a
   time. Each question is single-select, multi-select, or free-text; pass
   discrete \`options\` for a known small set of choices, or \`type: "text"\` for
-  an open-ended question.
+  an open-ended question. Never call it during an initial build
+  (see Initial Build).
 - Never call two interactive tools in parallel. The run suspends on the first.
+- Never suspend during an initial build except the trailing \`finish_setup\`
+  call; see the Initial Build section.
 - Never re-ask a question the user already answered in this thread.
 - After resume, continue with the next concrete tool action. Do not narrate the
   answer back to the user.`;
@@ -104,20 +137,36 @@ exports.RESPONSE_STYLE_SECTION = `\
 
 Be concise. After a build step, give a 1-2 sentence summary of what changed and
 one useful next step if there is one. Do not narrate reasoning before tool
-calls, reprint JSON, or list what is already visible in the sidebar.`;
+calls, reprint JSON, or list what is already visible in the sidebar. When
+setup remains after \`finish_setup\` (skipped or dismissed items), end with
+the setup checklist per the Initial Build section; keep it to one line per
+item.`;
 exports.WORKFLOW_SECTION = `\
 ## Workflow
 
-1. Clarify missing decisions through the Interactive tools, batching questions.
-2. For fresh agents, resolve the main model and credential with \`resolve_llm\`.
-3. Draft real target-agent \`instructions\`; never write empty placeholders.
+1. For every request that builds or changes the agent, call \`write_todos\`
+   with the full plan first — even short ones. Mark tasks that cannot
+   proceed without user input as \`blocked\`, stating exactly what is
+   missing.
+2. For fresh agents, call \`resolve_llm\` once, silently. If it resolves —
+   including an auto-picked provider or newly provisioned free OpenAI
+   credits — use the result and mention the choice in your summary. If it
+   reports missing or ambiguous credentials, mark the model
+   task \`blocked\` and keep building: write the config with \`model: ""\` and
+   no \`credential\`.
+3. Draft real target-agent \`instructions\` and write the config early; never
+   write empty placeholders, and never wait for setup answers before writing
+   instructions, tools, skills, or tasks.
 4. Load relevant runtime skills before specialized discovery or asset work.
 5. Perform discovery and create any requested tools, skills, or tasks.
 6. Follow Config Freshness immediately before every config mutation.
 7. When both skill and task batches are fully specified, call \`create_skills\`
    and \`create_tasks\` in the same assistant response. Do not combine either
    with an interactive tool or \`write_config\`/\`patch_config\` in that response.
-8. When the user asks to publish, activate, or make the agent live/usable, call
+8. When only blocked tasks remain, call \`finish_setup\` once with every
+   pending item, per the Initial Build section, then resolve its results and
+   finish the plan — re-check with \`read_config\` before patching.
+9. When the user asks to publish, activate, or make the agent live/usable, call
    \`publish_agent\`. Never tell them to click Publish in the editor. Do not
    auto-publish without that intent. Use \`unpublish_agent\` when they ask to
    unpublish.`;
@@ -125,29 +174,41 @@ exports.FEW_SHOT_FLOWS_SECTION = `\
 ## Example flows
 
 ### New agent: "Build me an agent teammates can @mention in Slack to triage messages"
-1. \`ask_questions({ ... })\` for the model choice, then
-   \`resolve_llm({ provider, model })\` -> resolved provider, model, and credential.
+1. \`write_todos\` with the plan. \`resolve_llm({})\` once, silently; if it
+   reports missing credentials, mark the model task \`blocked\`.
 2. \`read_config()\`.
-3. \`write_config(...)\` with the model, credential, and instructions.
-4. Load \`agent-builder-integrations\`, call \`list_integration_types()\`, and
-   select the returned Slack type.
-5. \`configure_channel({ integrationType: "slack" })\`. The setup UI persists or
-   skips the channel; do not follow it with a config read or mutation.
+3. \`write_config(...)\` with the instructions, and the resolved model and
+   credential — or \`model: ""\` and no \`credential\` while the model task
+   is blocked.
+4. Load \`agent-builder-external-services\`, call \`list_integration_types()\`,
+   \`read_config()\`, then \`patch_config(...)\` adding the returned Slack type
+   to \`/integrations/-\` with \`credentialId: ""\`.
+5. \`finish_setup({ channels: [{ integrationType: "slack" }] })\` — include
+   \`questions: [<model choice>]\` only if the model task is blocked; when
+   \`resolve_llm\` already resolved in step 1, pass only the channel. For a
+   model answer, call \`resolve_llm\` with it, then \`read_config()\` and
+   \`patch_config(...)\` replacing \`/model\` and \`/credential\`. The channel
+   card in \`finish_setup\` already persisted or skipped the Slack
+   connection — do not follow it with a config mutation. If the user skips
+   it, end with a one-line checklist item pointing at the channel chip in
+   the agent panel.
 
 ### New agent: "Use Anthropic via OpenRouter"
-1. \`resolve_llm({ provider: "openrouter" })\`.
-2. \`read_config()\`.
-3. \`write_config(...)\` with \`model: "openrouter/{resolvedModel}"\`,
+1. \`write_todos\` with the plan.
+2. \`resolve_llm({ provider: "openrouter" })\`.
+3. \`read_config()\`.
+4. \`write_config(...)\` with \`model: "openrouter/{resolvedModel}"\`,
    \`credential\`, and requested instructions.
 
 ### Change the existing model
-1. \`ask_questions({ ... })\` for the new model choice, then
+1. \`write_todos\` with the plan.
+2. \`ask_questions({ ... })\` for the new model choice, then
    \`resolve_llm({ provider, model })\`.
-2. \`read_config()\`.
-3. \`patch_config(...)\` replacing \`/model\` and \`/credential\`.
+3. \`read_config()\`.
+4. \`patch_config(...)\` replacing \`/model\` and \`/credential\`.
 
 ### Add an explicitly requested n8n node tool to an existing agent
-1. Load \`agent-builder-node-tools\`, then call \`search_nodes\` and
+1. Load \`agent-builder-external-services\`, then call \`search_nodes\` and
    \`get_node_types\`; the explicit n8n-node request does not need
    \`resolve_integration\`.
 2. \`ask_credential\` for every required slot.
@@ -155,16 +216,27 @@ exports.FEW_SHOT_FLOWS_SECTION = `\
 4. \`patch_config(...)\` adding the node tool to \`/tools/-\`.
 
 ### Add an explicitly requested n8n node tool when credential setup is skipped
-1. Load \`agent-builder-node-tools\`, then call \`search_nodes\` and
+1. Load \`agent-builder-external-services\`, then call \`search_nodes\` and
    \`get_node_types\`.
 2. \`ask_credential(...)\` -> \`{ skipped: true }\`.
 3. \`read_config()\`.
 4. \`patch_config(...)\` adding the tool and omitting only the skipped
    credential slot. Do not abort the tool addition.
+5. Summarize it as a successful addition, not a failure: the tool is in
+   place and starts working once a credential is connected. Never say you
+   could not complete it — end with a one-line checklist item for
+   connecting the credential later.
 
 ### Add MCP integration: "Connect Notion MCP"
+This flow is user-initiated on an existing agent, so the credential ask is
+immediate. During an initial build, pick the best candidate as a stated
+assumption, write the draft \`/mcpServers/-\` entry with \`credential\` omitted,
+skip verification, and include the credential in the trailing \`finish_setup\`
+call; verify with the returned credential id — on success the tool writes the
+credential into the matching entry itself; no \`read_config\`/\`patch_config\`
+follow-up for the credential.
 1. \`resolve_integration({ queries: ["notion"] })\`.
-2. When it returns \`kind: "mcp"\`, load \`agent-builder-mcp\`.
+2. When it returns \`kind: "mcp"\`, load \`agent-builder-external-services\`.
 3. For MCP candidates, select one entry from \`results[]\`. If
    multiple candidates remain, use \`ask_questions\` with their titles and
    descriptions; never choose by array order. If the user dismisses the
@@ -181,17 +253,18 @@ exports.FEW_SHOT_FLOWS_SECTION = `\
 
 ### Ambiguous request: "Make it post somewhere"
 1. \`ask_questions(...)\` with the known destination choices.
-2. Load \`agent-builder-integrations\` to decide whether the destination is the
-   agent's chat/trigger surface.
+2. Load \`agent-builder-external-services\` to decide whether the destination is
+   the agent's chat/trigger surface.
 3. If it is a chat integration, call \`configure_channel\` with the returned
    \`integrationType\`. After \`configure_channel\` returns, stop this flow; the
    setup UI already persisted or skipped the channel, so do not read or mutate
    the config.
 4. Otherwise call \`resolve_integration({ queries: ["<selected service>"] })\`
    and follow the returned kind:
-   - \`kind: "mcp"\`: load \`agent-builder-mcp\`, verify, and wire the MCP server.
-   - \`kind: "node"\`: load \`agent-builder-node-tools\`, use the returned node
-     results with \`get_node_types\`, and ask for every required credential.
+   - \`kind: "mcp"\`: follow the skill's MCP Servers section — verify and wire
+     the MCP server.
+   - \`kind: "node"\`: follow the skill's Node Tools section, use the returned
+     node results with \`get_node_types\`, and ask for every required credential.
 5. In this non-chat branch only, \`read_config()\`, then \`patch_config(...)\` or
    \`write_config(...)\` with the resolved capability.
 
@@ -204,12 +277,14 @@ function buildBuilderPrompt(ctx) {
     const sections = [
         'You are an expert agent builder. You help users create and configure AI agents by writing raw JSON configuration and building custom tools.',
         exports.TARGET_AGENT_SECTION,
+        exports.PREREQUISITES_SECTION,
         getConversationModeSection(agentPreviewPath),
         (0, config_mutation_prompt_1.getConfigMutationPrompt)(),
         (0, llm_selection_prompt_1.getLlmSelectionPrompt)(modelRecommendationsSection),
         memory_prompt_1.MEMORY_PROMPT,
         tools_prompt_1.TOOLS_PROMPT,
         exports.INTERACTIVE_TOOLS_SECTION,
+        initial_build_prompt_1.INITIAL_BUILD_SECTION,
         exports.READ_CONFIG_FRESHNESS_SECTION,
         exports.WORKFLOW_SECTION,
         exports.FEW_SHOT_FLOWS_SECTION,

package/dist/modules/agents/builder/agents-builder-prompts.js.map

@@ -1 +1 @@
-{"version":3,"file":"agents-builder-prompts.js","sourceRoot":"","sources":["../../../../src/modules/agents/builder/agents-builder-prompts.ts"],"names":[],"mappings":";;;;;AAAA,6EAA2E;AAC3E,yEAAuE;AACvE,2DAAwD;AACxD,yDAAsD;AAEzC,QAAA,oBAAoB,GAAG;;;;;;sCAME,CAAC;AAEvC,oCAA2C,gBAAwB;IAClE,OAAO;;;;;;;;;;;yBAWiB,gBAAgB;;;;oEAI2B,CAAC;AACrE,CAAC;AAEY,QAAA,yBAAyB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAqCd,CAAC;AAEf,QAAA,6BAA6B,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BA4BnB,CAAC;AACd,QAAA,sBAAsB,GAAG;;;;;qEAK+B,CAAC;AAEzD,QAAA,gBAAgB,GAAG;;;;;;;;;;;;;;;cAelB,CAAC;AAEF,QAAA,sBAAsB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iFA6E2C,CAAC;AAOlF,4BAAmC,GAAyB;IAC3D,MAAM,EAAE,gBAAgB,EAAE,2BAA2B,EAAE,GAAG,GAAG,CAAC;IAE9D,MAAM,QAAQ,GAAG;QAChB,6IAA6I;QAC7I,QAAA,oBAAoB;QACpB,0BAA0B,CAAC,gBAAgB,CAAC;QAC5C,IAAA,gDAAuB,GAAE;QACzB,IAAA,4CAAqB,EAAC,2BAA2B,CAAC;QAClD,6BAAa;QACb,2BAAY;QACZ,QAAA,yBAAyB;QACzB,QAAA,6BAA6B;QAC7B,QAAA,gBAAgB;QAChB,QAAA,sBAAsB;QACtB,QAAA,sBAAsB;KACtB,CAAC;IAEF,OAAO,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;AAC9B,CAAC"}
+{"version":3,"file":"agents-builder-prompts.js","sourceRoot":"","sources":["../../../../src/modules/agents/builder/agents-builder-prompts.ts"],"names":[],"mappings":";;;;;AAAA,6EAA2E;AAC3E,yEAAuE;AACvE,yEAAuE;AACvE,2DAAwD;AACxD,yDAAsD;AAEzC,QAAA,oBAAoB,GAAG;;;;;;sCAME,CAAC;AAE1B,QAAA,qBAAqB,GAAG;;;;;8NAKyL,CAAC;AAE/N,oCAA2C,gBAAwB;IAClE,OAAO;;;;;;;;;;;yBAWiB,gBAAgB;;;;6BAIZ,gBAAgB;;;;;gFAKmC,CAAC;AACjF,CAAC;AAEY,QAAA,yBAAyB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BA0Dd,CAAC;AAEf,QAAA,6BAA6B,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BA4BnB,CAAC;AACd,QAAA,sBAAsB,GAAG;;;;;;;;MAQhC,CAAC;AAEM,QAAA,gBAAgB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA4BlB,CAAC;AAEF,QAAA,sBAAsB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iFAqG2C,CAAC;AAOlF,4BAAmC,GAAyB;IAC3D,MAAM,EAAE,gBAAgB,EAAE,2BAA2B,EAAE,GAAG,GAAG,CAAC;IAE9D,MAAM,QAAQ,GAAG;QAChB,6IAA6I;QAC7I,QAAA,oBAAoB;QACpB,QAAA,qBAAqB;QACrB,0BAA0B,CAAC,gBAAgB,CAAC;QAC5C,IAAA,gDAAuB,GAAE;QACzB,IAAA,4CAAqB,EAAC,2BAA2B,CAAC;QAClD,6BAAa;QACb,2BAAY;QACZ,QAAA,yBAAyB;QACzB,4CAAqB;QACrB,QAAA,6BAA6B;QAC7B,QAAA,gBAAgB;QAChB,QAAA,sBAAsB;QACtB,QAAA,sBAAsB;KACtB,CAAC;IAEF,OAAO,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;AAC9B,CAAC"}

package/dist/modules/agents/builder/agents-builder-tools.service.d.ts

@@ -9,17 +9,24 @@ import { NodeTypes } from '../../../node-types';
 import { OauthService } from '../../../oauth/oauth.service';
 import { AiService } from '../../../services/ai.service';
 import { DynamicNodeParametersService } from '../../../services/dynamic-node-parameters.service';
+import { FreeAiCreditsService } from '../../../services/free-ai-credits.service';
+import { Telemetry } from '../../../telemetry';
 import { AgentConfigService } from '../agent-config.service';
 import { AgentCustomToolsService } from '../agent-custom-tools.service';
 import { AgentIntegrationPersistenceService } from '../agent-integration-persistence.service';
 import { AgentPublishService } from '../agent-publish.service';
 import { AgentSkillsService } from '../agent-skills.service';
 import { AgentTaskService } from '../agent-task.service';
+import { AgentValidationService } from '../agent-validation.service';
 import { AgentsToolsService } from '../agents-tools.service';
 import { AgentsService } from '../agents.service';
 import { AttachableWorkflowsService } from '../attachable-workflows.service';
 import { BuilderModelLiveLookupService } from './builder-model-live-lookup.service';
 import { AgentSecureRuntime } from '../runtime/agent-secure-runtime';
+interface BuilderTelemetryContext {
+    threadId?: string;
+    runId?: string;
+}
 export declare function getAgentConfigHash(config: AgentJsonConfig | null): string | null;
 export interface BuilderTools {
     json: BuiltTool[];
@@ -46,9 +53,16 @@ export declare class AgentsBuilderToolsService {
     private readonly nodeTypes;
     private readonly ssrfConfig;
     private readonly ssrfProtectionService;
-    constructor(agentsService: AgentsService, agentConfigService: AgentConfigService, agentCustomToolsService: AgentCustomToolsService, agentIntegrationPersistenceService: AgentIntegrationPersistenceService, agentSkillsService: AgentSkillsService, secureRuntime: AgentSecureRuntime, attachableWorkflowsService: AttachableWorkflowsService, agentsToolsService: AgentsToolsService, builderModelLiveLookupService: BuilderModelLiveLookupService, mcpRegistryService: McpRegistryService, oauthService: OauthService, credentialTypes: CredentialTypes, agentTaskService: AgentTaskService, agentPublishService: AgentPublishService, aiService: AiService, outboundHttp: OutboundHttp, dynamicNodeParametersService: DynamicNodeParametersService, nodeTypes: NodeTypes, ssrfConfig: SsrfProtectionConfig, ssrfProtectionService: SsrfProtectionService);
-    getTools(agentId: string, projectId: string, credentialProvider: CredentialProvider, user: User): BuilderTools;
+    private readonly freeAiCreditsService;
+    private readonly telemetry;
+    private readonly agentValidationService;
+    constructor(agentsService: AgentsService, agentConfigService: AgentConfigService, agentCustomToolsService: AgentCustomToolsService, agentIntegrationPersistenceService: AgentIntegrationPersistenceService, agentSkillsService: AgentSkillsService, secureRuntime: AgentSecureRuntime, attachableWorkflowsService: AttachableWorkflowsService, agentsToolsService: AgentsToolsService, builderModelLiveLookupService: BuilderModelLiveLookupService, mcpRegistryService: McpRegistryService, oauthService: OauthService, credentialTypes: CredentialTypes, agentTaskService: AgentTaskService, agentPublishService: AgentPublishService, aiService: AiService, outboundHttp: OutboundHttp, dynamicNodeParametersService: DynamicNodeParametersService, nodeTypes: NodeTypes, ssrfConfig: SsrfProtectionConfig, ssrfProtectionService: SsrfProtectionService, freeAiCreditsService: FreeAiCreditsService, telemetry: Telemetry, agentValidationService: AgentValidationService);
+    private withConfigMutationMarker;
+    getTools(agentId: string, projectId: string, credentialProvider: CredentialProvider, user: User, telemetryContext?: BuilderTelemetryContext): BuilderTools;
     private getJsonTools;
     private getSharedTools;
     private getConfigSnapshot;
+    private emitConfigDiffTelemetry;
+    private applyCredentialToMcpServer;
 }
+export {};