n8n 2.35.4 → 2.36.2

package/dist/modules/agents/builder/prompts/tools.prompt.js

@@ -17,7 +17,8 @@ changing, or removing entries in \`tools[]\` / \`mcpServers\` / \`providerTools\
 
 For an external product, load \`agent-builder-external-services\` once and
 follow it. It covers the chat-integration-versus-callable-tool decision, chat
-integration setup, MCP servers, and node tools.
+integration setup, and MCP servers. Load \`agent-builder-node-tools\` before
+configuring a node tool.
 
 - Chat/trigger integration: call \`list_integration_types\`, then
   \`configure_channel\` with a returned type. Do not call \`resolve_integration\`
@@ -29,8 +30,8 @@ integration setup, MCP servers, and node tools.
   from memory.
   - \`kind: "mcp"\`: follow the skill's MCP Servers section — credential,
     verification, and config workflow.
-  - \`kind: "node"\`: follow the skill's Node Tools section, use the returned
-    node results, and continue with \`get_node_types\`.
+  - \`kind: "node"\`: load \`agent-builder-node-tools\`, use the returned node
+    results, and continue with \`get_node_types\`.
 
 Use \`search_nodes\` directly only when the user explicitly asks for an n8n node,
 when refining node results, or when a verified MCP server lacks the requested
@@ -52,10 +53,13 @@ they cannot perform live network, filesystem, process, timer, or host I/O.
 
 #### Node Tools
 
-Load \`agent-builder-external-services\` when the user explicitly requests an
-n8n node, and follow its Node Tools section before adding, changing, or
-removing node-backed tools, \`nodeParameters\`, \`$fromAI\` usage, or n8n
-expressions.
+Load \`agent-builder-node-tools\` before adding, changing, or removing
+node-backed tools, \`nodeParameters\`, \`$fromAI\` usage, or n8n expressions.
+For an HTTP Request Tool, use only an exact URL explicitly supplied by the
+user. If the user has not supplied one during an initial build, you MUST ask
+for it through the trailing \`finish_setup\` call, then configure the tool with
+the answer. On later turns, use \`ask_questions\` before mutating the config.
+Never infer or invent a URL.
 
 #### MCP Servers
 

package/dist/modules/agents/builder/prompts/tools.prompt.js.map

@@ -1 +1 @@
-{"version":3,"file":"tools.prompt.js","sourceRoot":"","sources":["../../../../../src/modules/agents/builder/prompts/tools.prompt.ts"],"names":[],"mappings":";;;AAAa,QAAA,YAAY,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iFAwFqD,CAAC"}
+{"version":3,"file":"tools.prompt.js","sourceRoot":"","sources":["../../../../../src/modules/agents/builder/prompts/tools.prompt.ts"],"names":[],"mappings":";;;AAAa,QAAA,YAAY,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iFA4FqD,CAAC"}

package/dist/modules/agents/builder/resolve-integration.tool.js

@@ -12,7 +12,7 @@ const resolveIntegrationInputSchema = zod_1.z.object({
 });
 function buildResolveIntegrationTool(deps) {
     return new tool_1.Tool(builder_tool_names_1.BUILDER_TOOLS.RESOLVE_INTEGRATION)
-        .description('Resolve external services to MCP servers or n8n node tools. Searches the MCP registry first and returns kind: "mcp" when a match exists; only searches agent-eligible n8n node tools and returns kind: "node" when no MCP server matches. For either kind, load agent-builder-external-services and follow its matching section, using the returned results.')
+        .description('Resolve external services to MCP servers or n8n node tools. Searches the MCP registry first and returns kind: "mcp" when a match exists; only searches agent-eligible n8n node tools and returns kind: "node" when no MCP server matches. For kind "mcp", load agent-builder-external-services. For kind "node", load agent-builder-node-tools. Follow the loaded skill using the returned results.')
         .input(resolveIntegrationInputSchema)
         .handler(async ({ queries }) => {
         const mcpResults = await deps.mcpRegistryService.search(queries);

package/dist/modules/agents/builder/resolve-integration.tool.js.map

@@ -1 +1 @@
-{"version":3,"file":"resolve-integration.tool.js","sourceRoot":"","sources":["../../../../src/modules/agents/builder/resolve-integration.tool.ts"],"names":[],"mappings":";;;AACA,2CAAwC;AACxC,6BAAwB;AAKxB,6DAAqD;AAOrD,MAAM,6BAA6B,GAAG,OAAC,CAAC,MAAM,CAAC;IAC9C,OAAO,EAAE,OAAC;SACR,KAAK,CAAC,OAAC,CAAC,MAAM,EAAE,CAAC;SACjB,GAAG,CAAC,CAAC,CAAC;SACN,QAAQ,CAAC,2DAA2D,CAAC;CACvE,CAAC,CAAC;AAEH,qCAA4C,IAA4B;IACvE,OAAO,IAAI,WAAI,CAAC,kCAAa,CAAC,mBAAmB,CAAC;SAChD,WAAW,CACX,8VAA8V,CAC9V;SACA,KAAK,CAAC,6BAA6B,CAAC;SACpC,OAAO,CAAC,KAAK,EAAE,EAAE,OAAO,EAAyB,EAAE,EAAE;QACrD,MAAM,UAAU,GAAG,MAAM,IAAI,CAAC,kBAAkB,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;QACjE,IAAI,UAAU,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAC3B,OAAO,EAAE,IAAI,EAAE,KAAc,EAAE,OAAO,EAAE,UAAU,EAAE,CAAC;QACtD,CAAC;QAED,MAAM,WAAW,GAAG,MAAM,IAAI,CAAC,kBAAkB,CAAC,oBAAoB,CAAC,OAAO,CAAC,CAAC;QAChF,OAAO;YACN,IAAI,EAAE,MAAe;YACrB,OAAO,EAAE,WAAW,CAAC,OAAO;YAC5B,oBAAoB,EAAE,WAAW,CAAC,oBAAoB;SACtD,CAAC;IACH,CAAC,CAAC;SACD,KAAK,EAAE,CAAC;AACX,CAAC"}
+{"version":3,"file":"resolve-integration.tool.js","sourceRoot":"","sources":["../../../../src/modules/agents/builder/resolve-integration.tool.ts"],"names":[],"mappings":";;;AACA,2CAAwC;AACxC,6BAAwB;AAKxB,6DAAqD;AAOrD,MAAM,6BAA6B,GAAG,OAAC,CAAC,MAAM,CAAC;IAC9C,OAAO,EAAE,OAAC;SACR,KAAK,CAAC,OAAC,CAAC,MAAM,EAAE,CAAC;SACjB,GAAG,CAAC,CAAC,CAAC;SACN,QAAQ,CAAC,2DAA2D,CAAC;CACvE,CAAC,CAAC;AAEH,qCAA4C,IAA4B;IACvE,OAAO,IAAI,WAAI,CAAC,kCAAa,CAAC,mBAAmB,CAAC;SAChD,WAAW,CACX,qYAAqY,CACrY;SACA,KAAK,CAAC,6BAA6B,CAAC;SACpC,OAAO,CAAC,KAAK,EAAE,EAAE,OAAO,EAAyB,EAAE,EAAE;QACrD,MAAM,UAAU,GAAG,MAAM,IAAI,CAAC,kBAAkB,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;QACjE,IAAI,UAAU,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAC3B,OAAO,EAAE,IAAI,EAAE,KAAc,EAAE,OAAO,EAAE,UAAU,EAAE,CAAC;QACtD,CAAC;QAED,MAAM,WAAW,GAAG,MAAM,IAAI,CAAC,kBAAkB,CAAC,oBAAoB,CAAC,OAAO,CAAC,CAAC;QAChF,OAAO;YACN,IAAI,EAAE,MAAe;YACrB,OAAO,EAAE,WAAW,CAAC,OAAO;YAC5B,oBAAoB,EAAE,WAAW,CAAC,oBAAoB;SACtD,CAAC;IACH,CAAC,CAAC;SACD,KAAK,EAAE,CAAC;AACX,CAAC"}

package/dist/modules/agents/builder/skills/external-services.skill.js

@@ -10,13 +10,11 @@ function externalServicesSkill() {
     return {
         id: 'agent-builder-external-services',
         name: 'Agent Builder External Services',
-        description: 'Use when connecting the target agent to any external product: deciding whether Slack, Discord, Linear, Telegram, or another platform is a chat integration/trigger versus an MCP, node, or workflow tool; adding, removing, or updating chat integrations or MCP servers; and wiring n8n node-backed tools (search_nodes/get_node_types discovery, nodeParameters, node credential slots, $fromAI usage, n8n expressions).',
+        description: 'Use when connecting the target agent to an external product: deciding whether Slack, Discord, Linear, Telegram, or another platform is a chat integration/trigger versus a callable service, and adding, removing, or updating chat integrations or MCP servers.',
         recommendedTools: [
             'resolve_integration',
             'list_integration_types',
             'configure_channel',
-            'search_nodes',
-            'get_node_types',
             'ask_credential',
             'verify_mcp_server',
             'read_config',
@@ -27,11 +25,8 @@ function externalServicesSkill() {
             'list_integration_types',
             'configure_channel',
             'search_mcp_servers',
-            'search_nodes',
-            'get_node_types',
             'ask_credential',
             'verify_mcp_server',
-            'get_resource_locator_options',
             'ask_questions',
             'read_config',
             'patch_config',
@@ -41,11 +36,10 @@ function externalServicesSkill() {
         instructions: `\
 ## Purpose
 
-Use this to connect the target agent to external products across all three
-surfaces: chat integrations (the \`integrations\` array), MCP servers
-(\`mcpServers\`), and n8n node tools (entries in \`tools[]\` with
-\`nodeParameters\`). Decide the right surface first, then follow that
-section.
+Use this to connect the target agent to external products across chat
+integrations (the \`integrations\` array), MCP servers (\`mcpServers\`), and
+n8n node tools. Decide the right surface first. For a node tool, load
+\`agent-builder-node-tools\` and follow that skill.
 
 ## Integration vs Callable Tool Decision
 
@@ -81,18 +75,7 @@ Examples:
 
 For callable (non-chat) services, call \`resolve_integration\` separately per
 service and follow the returned \`kind\`: \`"mcp"\` -> MCP Servers section
-below, \`"node"\` -> Node Tools section below.
-
-## Web Search vs Direct HTTP Requests
-
-Generic web search, browsing, research, current-information, and source-finding
-requests must use \`config.webSearch\` according to the system prompt's
-web-search rules. Do not call \`resolve_integration\` or \`search_nodes\` for
-these requests.
-
-Never add \`n8n-nodes-base.httpRequestTool\` or
-\`@n8n/n8n-nodes-langchain.toolHttpRequest\` unless the user explicitly
-requests the HTTP Request Tool or direct HTTP, API, or specific-page fetching.
+below, \`"node"\` -> load \`agent-builder-node-tools\`.
 
 ## Chat Integrations
 
@@ -157,8 +140,9 @@ call \`resolve_integration\` with queries matching the requested service.
 Resolve one requested service per call; use \`queries\` only for alternative
 search terms for that service.
 
-- If it returns \`kind: "node"\` for a generic service request, follow the Node
-  Tools section with the returned node results. Stop this MCP workflow.
+- If it returns \`kind: "node"\` for a generic service request, load
+  \`agent-builder-node-tools\` and follow it with the returned node results.
+  Stop this MCP workflow.
 - If it returns \`kind: "node"\` but the user explicitly requested an MCP server,
   do not silently substitute a node tool. Continue with manual MCP setup by
   asking for the URL and transport/authentication decision through
@@ -206,9 +190,9 @@ credential into the matching entry itself (\`credentialApplied: true\`); no
 additions keep the immediate ask + verify flow above unchanged.
 
 If verification succeeds but the tools do not cover the requested capability
-for a generic service request, switch to the Node Tools section, call
-\`search_nodes\` with the same service queries, and continue with node setup. Do
-not add the MCP server merely because its registry entry matched.
+for a generic service request, load \`agent-builder-node-tools\`, call
+\`search_nodes\` with the same service queries, and follow that skill. Do not
+add the MCP server merely because its registry entry matched.
 
 Full schema reference:
 
@@ -302,70 +286,6 @@ Auth, or None) via \`${api_types_1.ASK_QUESTIONS_TOOL_NAME}\`. Then map to:
 - A registry match proves server availability, not support for the requested
   capability; use the verified live tool list for that decision.
 
-## Node Tools
-
-Use this section to discover, configure, and wire node tools into the target
-agent's \`tools[]\`, including \`nodeParameters\` and n8n expressions.
-
-### Workflow
-
-- For a generic external-service request, call \`resolve_integration\` before
-  node discovery unless a resolver result is already available.
-- If it returns \`kind: "mcp"\`, follow the MCP Servers section instead and stop
-  this node-tool workflow.
-- If it returns \`kind: "node"\`, use its returned node results and call
-  \`get_node_types\`; do not repeat the same search with \`search_nodes\`.
-- Call \`search_nodes\` directly only when the user explicitly requests an n8n
-  node, when refining node results, or when a verified MCP server lacks the
-  requested capability.
-- Never guess node type names.
-- Use the tool node id from discovery, usually ending in \`Tool\`.
-- Put fixed values in \`nodeParameters\`; use complete n8n expressions for values the agent should decide at runtime:
-  \`={{ $fromAI('url', 'The URL to inspect', 'string') }}\`.
-- For stable dynamic selectors, load \`agent-builder-resource-locators\` and
-  follow it.
-- Never write literal \`"$fromAI"\` or bare \`$fromAI\`; the node will treat it as the actual value.
-- Do not pipe AI-chosen fields through \`$json\`.
-- Do not include \`inputSchema\` or \`toolDescription\` for node tools.
-- n8n Connect (\`n8n credits\`) covers many services, including some community nodes. Adding a node tool with its credential slot omitted triggers server-side assignment: for a covered service the server attaches the managed \`n8n credits\` credential (\`{ id: null, name: "n8n credits", __aiGatewayManaged: true }\`) to each required, eligible slot on write — but only when the project has no credential of that type; an existing credential of the type wins and the slot stays empty for the normal credential flow below. Add the tool with the credential slot omitted, then \`read_config\`.
-- Exception — when the user explicitly asks to run a tool on n8n credits, write \`{ "id": null, "name": "n8n credits", "__aiGatewayManaged": true }\` into that credential slot yourself: the server keeps it when the service is covered (even if the user has their own credential of the type) and removes it when not covered — check \`read_config\` after the write and resolve a real credential if it was removed.
-- The \`n8n credits\` managed credential IS the real, working credential — the tool executes through n8n's gateway on n8n credits, so NO separate API key is needed. It is NOT a placeholder and NOT "invalid for the service", even for a community node. For a slot \`read_config\` shows populated with it: the slot is fully connected and the tool WILL run. Do NOT call \`ask_credential\` for it; do NOT include it in \`finish_setup\`; NEVER clear, remove, or replace it via \`patch_config\`; and NEVER seek a "real" API key to swap in for it. Report the tool as ready, running on n8n credits — exactly like a managed model. Never tell the user the credential is "not connected"/"not set up" or that the tool "won't run until a credential is added".
-- Only for a required slot that \`read_config\` shows still empty after the write (a service n8n Connect does not cover) do you resolve a real credential: call \`ask_credential\` once before the config mutation for an addition to an existing agent. ${initial_build_prompt_1.INITIAL_BUILD_NOTE} After the trailing \`finish_setup\` resolves the credential, copy the returned credentials into \`node.credentials\` via \`patch_config\`; for resource-locator resolution follow \`agent-builder-resource-locators\` then. Pass the node's credential key as \`credentialSlot\`. On success, copy the returned \`credentials\` object directly to \`node.credentials\`. If skipped, still add the tool and omit only that credential slot.
-- When the agent already has a chat channel configured and the tool needs the same
-  credential type, \`ask_credential\` reuses the channel's credential automatically —
-  do not ask the user to pick a different one.
-
-### n8n Expressions
-
-Node tool parameters inside \`nodeParameters\` can use n8n expressions.
-Prefer \`$fromAI\` whenever the target agent should decide a value at runtime.
-Do not use \`$fromAI\` for stable resource IDs that the target agent cannot know
-at runtime, such as Linear \`teamId\`, project IDs, channel IDs, calendar IDs,
-database IDs, table IDs, or other dynamic "Name or ID" selectors. Resolve those
-with the \`agent-builder-resource-locators\` skill, \`ask_credential\`, and
-\`get_resource_locator_options\`; write the returned \`parameterValue\` into
-\`nodeParameters\`.
-
-- \`={{ /*n8n-auto-generated-fromAI-override*/ $fromAI('fieldName', 'What value to provide', 'string') }}\`
-- \`={{ /*n8n-auto-generated-fromAI-override*/ $fromAI('count', 'How many items', 'number') }}\`
-- \`={{ /*n8n-auto-generated-fromAI-override*/ $fromAI('enabled', 'Whether to enable this option', 'boolean') }}\`
-- \`={{ $now.toISO() }}\` for current date/time.
-- \`={{ $today }}\` for the start of today.
-
-Always wrap expressions in \`={{ }}\`. Never pipe AI-chosen node-tool fields
-through \`$json\`; use \`$fromAI\` for those fields instead.
-
-### Gotchas
-
-- Do not include \`inputSchema\` or \`toolDescription\` for node tools.
-- \`$fromAI(...)\` placeholders define the node tool input schema; do not add it manually.
-- Follow \`agent-builder-resource-locators\` for dynamic selector lookup,
-  credentials, and \`parameterValue\` handling.
-- If a required node-tool credential is skipped, add the tool and omit only that credential slot.
-- Node tools execute inline, so never use waiting operations such as \`sendAndWait\`
-  or \`dispatchAndWait\`. When the user requests human approval, configure the
-  intended non-waiting operation and set \`requireApproval: true\` on the tool.
-
 ## Verify
 
 - Configured chat integrations were set up through \`configure_channel\` or the
@@ -377,8 +297,7 @@ through \`$json\`; use \`$fromAI\` for those fields instead.
 - Generic non-chat external services were routed through \`resolve_integration\`
   before MCP or node setup.
 - The final \`integrations\` array keeps unrelated integrations intact and
-  removes only the requested channel entries.
-- Node tools use discovered tool node ids and valid node parameters.`,
+  removes only the requested channel entries.`,
     };
 }
 //# sourceMappingURL=external-services.skill.js.map

package/dist/modules/agents/builder/skills/external-services.skill.js.map

@@ -1 +1 @@
-{"version":3,"file":"external-services.skill.js","sourceRoot":"","sources":["../../../../../src/modules/agents/builder/skills/external-services.skill.ts"],"names":[],"mappings":";;;AACA,8CAAgF;AAEhF,2DAAqD;AAErD,qFAAmF;AACnF,0EAAqE;AAErE,MAAM,mBAAmB,GAAG,IAAA,gDAAuB,EAClD,IAAA,oCAAe,EAAC,iCAAqB,CAAgB,CACrD,CAAC;AAEF;IACC,OAAO;QACN,EAAE,EAAE,iCAAiC;QACrC,IAAI,EAAE,iCAAiC;QACvC,WAAW,EACV,4ZAA4Z;QAC7Z,gBAAgB,EAAE;YACjB,qBAAqB;YACrB,wBAAwB;YACxB,mBAAmB;YACnB,cAAc;YACd,gBAAgB;YAChB,gBAAgB;YAChB,mBAAmB;YACnB,aAAa;YACb,cAAc;SACd;QACD,YAAY,EAAE;YACb,qBAAqB;YACrB,wBAAwB;YACxB,mBAAmB;YACnB,oBAAoB;YACpB,cAAc;YACd,gBAAgB;YAChB,gBAAgB;YAChB,mBAAmB;YACnB,8BAA8B;YAC9B,eAAe;YACf,aAAa;YACb,cAAc;YACd,cAAc;YACd,YAAY;SACZ;QACD,YAAY,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAsEZ,yCAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAsDhB,mCAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgC3B,yCAAkB;;;;;;;;;;;;;;;;;;EAkBlB,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBAiEE,mCAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2PAqD6M,yCAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qEAgDxM;KACnE,CAAC;AACH,CAAC"}
+{"version":3,"file":"external-services.skill.js","sourceRoot":"","sources":["../../../../../src/modules/agents/builder/skills/external-services.skill.ts"],"names":[],"mappings":";;;AACA,8CAAgF;AAEhF,2DAAqD;AAErD,qFAAmF;AACnF,0EAAqE;AAErE,MAAM,mBAAmB,GAAG,IAAA,gDAAuB,EAClD,IAAA,oCAAe,EAAC,iCAAqB,CAAgB,CACrD,CAAC;AAEF;IACC,OAAO;QACN,EAAE,EAAE,iCAAiC;QACrC,IAAI,EAAE,iCAAiC;QACvC,WAAW,EACV,kQAAkQ;QACnQ,gBAAgB,EAAE;YACjB,qBAAqB;YACrB,wBAAwB;YACxB,mBAAmB;YACnB,gBAAgB;YAChB,mBAAmB;YACnB,aAAa;YACb,cAAc;SACd;QACD,YAAY,EAAE;YACb,qBAAqB;YACrB,wBAAwB;YACxB,mBAAmB;YACnB,oBAAoB;YACpB,gBAAgB;YAChB,mBAAmB;YACnB,eAAe;YACf,aAAa;YACb,cAAc;YACd,cAAc;YACd,YAAY;SACZ;QACD,YAAY,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA0DZ,yCAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAuDhB,mCAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgC3B,yCAAkB;;;;;;;;;;;;;;;;;;EAkBlB,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBAiEE,mCAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8CAoCA;KAC5C,CAAC;AACH,CAAC"}

package/dist/modules/agents/builder/skills/index.js

@@ -4,6 +4,7 @@ exports.getBuilderRuntimeSkills = getBuilderRuntimeSkills;
 const custom_tools_skill_1 = require("./custom-tools.skill");
 const external_services_skill_1 = require("./external-services.skill");
 const memory_skill_1 = require("./memory.skill");
+const node_tools_skill_1 = require("./node-tools.skill");
 const resource_locators_skill_1 = require("./resource-locators.skill");
 const sub_agents_skill_1 = require("./sub-agents.skill");
 const target_skills_skill_1 = require("./target-skills.skill");
@@ -13,6 +14,7 @@ function getBuilderRuntimeSkills() {
         (0, custom_tools_skill_1.customToolsSkill)(),
         (0, external_services_skill_1.externalServicesSkill)(),
         (0, memory_skill_1.memorySkill)(),
+        (0, node_tools_skill_1.nodeToolsSkill)(),
         (0, resource_locators_skill_1.resourceLocatorsSkill)(),
         (0, sub_agents_skill_1.subAgentsSkill)(),
         (0, target_skills_skill_1.targetSkillsSkill)(),

package/dist/modules/agents/builder/skills/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../src/modules/agents/builder/skills/index.ts"],"names":[],"mappings":";;;AAEA,6DAAwD;AACxD,uEAAkE;AAClE,iDAA6C;AAC7C,uEAAkE;AAClE,yDAAoD;AACpD,+DAA0D;AAC1D,6DAAwD;AAExD;IACC,OAAO;QACN,IAAA,qCAAgB,GAAE;QAClB,IAAA,+CAAqB,GAAE;QACvB,IAAA,0BAAW,GAAE;QACb,IAAA,+CAAqB,GAAE;QACvB,IAAA,iCAAc,GAAE;QAChB,IAAA,uCAAiB,GAAE;QACnB,IAAA,qCAAgB,GAAE;KAKlB,CAAC;AACH,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../src/modules/agents/builder/skills/index.ts"],"names":[],"mappings":";;;AAEA,6DAAwD;AACxD,uEAAkE;AAClE,iDAA6C;AAC7C,yDAAoD;AACpD,uEAAkE;AAClE,yDAAoD;AACpD,+DAA0D;AAC1D,6DAAwD;AAExD;IACC,OAAO;QACN,IAAA,qCAAgB,GAAE;QAClB,IAAA,+CAAqB,GAAE;QACvB,IAAA,0BAAW,GAAE;QACb,IAAA,iCAAc,GAAE;QAChB,IAAA,+CAAqB,GAAE;QACvB,IAAA,iCAAc,GAAE;QAChB,IAAA,uCAAiB,GAAE;QACnB,IAAA,qCAAgB,GAAE;KAKlB,CAAC;AACH,CAAC"}

package/dist/modules/agents/builder/skills/node-tools.skill.d.ts

@@ -0,0 +1,2 @@
+import type { RuntimeSkill } from '@n8n/agents';
+export declare function nodeToolsSkill(): RuntimeSkill;

package/dist/modules/agents/builder/skills/node-tools.skill.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nodeToolsSkill = nodeToolsSkill;
+const api_types_1 = require("@n8n/api-types");
+const initial_build_prompt_1 = require("../prompts/initial-build.prompt");
+function nodeToolsSkill() {
+    return {
+        id: 'agent-builder-node-tools',
+        name: 'Agent Builder Node Tools',
+        description: 'Use whenever adding, removing, or updating an n8n node-backed tool, including search_nodes/get_node_types discovery, nodeParameters, node credential slots, $fromAI usage, n8n expressions, and HTTP Request Tool configuration.',
+        recommendedTools: [
+            'resolve_integration',
+            'search_nodes',
+            'get_node_types',
+            'ask_credential',
+            'read_config',
+            'patch_config',
+        ],
+        allowedTools: [
+            'resolve_integration',
+            'search_nodes',
+            'get_node_types',
+            'ask_credential',
+            'get_resource_locator_options',
+            'ask_questions',
+            'read_config',
+            'patch_config',
+            'write_config',
+            'load_skill',
+        ],
+        instructions: `\
+## Purpose
+
+Use this to discover, configure, and wire node tools into the target agent's
+\`tools[]\`, including \`nodeParameters\`, credentials, and n8n expressions.
+
+## Web Search vs Direct HTTP Requests
+
+Generic web search, browsing, research, current-information, and source-finding
+requests must use \`config.webSearch\` according to the system prompt's
+web-search rules. Do not call \`resolve_integration\` or \`search_nodes\` for
+these requests.
+
+Never add the retired \`@n8n/n8n-nodes-langchain.toolHttpRequest\`. When the
+user explicitly requests the HTTP Request Tool or direct HTTP, API, or
+specific-page fetching, use only \`n8n-nodes-base.httpRequestTool\`.
+
+### Mandatory HTTP Request URL Gate
+
+Use only an exact URL explicitly supplied by the user for
+\`n8n-nodes-base.httpRequestTool\`. If the user has not supplied one, you MUST
+ask which URL the tool should fetch. During an initial build, mark this setup
+as blocked and include the URL question in the single trailing \`finish_setup\`
+call; add the tool with the returned URL after the user answers. On later
+turns, call \`${api_types_1.ASK_QUESTIONS_TOOL_NAME}\` and wait for the answer before
+mutating the config. Do not search for, derive, infer, guess, or invent a URL
+from a service name, requested action, documentation, or common API
+conventions. Never add an incomplete tool or use a placeholder URL.
+
+## Workflow
+
+- For a generic external-service request, call \`resolve_integration\` before
+  node discovery unless a resolver result is already available.
+- If it returns \`kind: "mcp"\`, load \`agent-builder-external-services\`,
+  follow its MCP Servers section, and stop this node-tool workflow.
+- If it returns \`kind: "node"\`, use its returned node results and call
+  \`get_node_types\`; do not repeat the same search with \`search_nodes\`.
+- Call \`search_nodes\` directly only when the user explicitly requests an n8n
+  node, when refining node results, or when a verified MCP server lacks the
+  requested capability.
+- Never guess node type names.
+- Use the tool node id from discovery, usually ending in \`Tool\`.
+- Put fixed values in \`nodeParameters\`; use complete n8n expressions for values the agent should decide at runtime:
+  \`={{ $fromAI('message', 'The message to send', 'string') }}\`.
+- \`n8n-nodes-base.httpRequestTool\` requires a fixed \`nodeParameters.url\`; it
+  does not work with a dynamic or model-selected URL. Never use \`$fromAI\` in
+  the URL; use it only in other request fields.
+- For stable dynamic selectors, load \`agent-builder-resource-locators\` and
+  follow it.
+- Never write literal \`"$fromAI"\` or bare \`$fromAI\`; the node will treat it as the actual value.
+- Do not pipe AI-chosen fields through \`$json\`.
+- Do not include \`inputSchema\` or \`toolDescription\` for node tools.
+- n8n Connect (\`n8n credits\`) covers many services, including some community nodes. Adding a node tool with its credential slot omitted triggers server-side assignment: for a covered service the server attaches the managed \`n8n credits\` credential (\`{ id: null, name: "n8n credits", __aiGatewayManaged: true }\`) to each required, eligible slot on write — but only when the project has no credential of that type; an existing credential of the type wins and the slot stays empty for the normal credential flow below. Add the tool with the credential slot omitted, then \`read_config\`.
+- Exception — when the user explicitly asks to run a tool on n8n credits, write \`{ "id": null, "name": "n8n credits", "__aiGatewayManaged": true }\` into that credential slot yourself: the server keeps it when the service is covered (even if the user has their own credential of the type) and removes it when not covered — check \`read_config\` after the write and resolve a real credential if it was removed.
+- The \`n8n credits\` managed credential IS the real, working credential — the tool executes through n8n's gateway on n8n credits, so NO separate API key is needed. It is NOT a placeholder and NOT "invalid for the service", even for a community node. For a slot \`read_config\` shows populated with it: the slot is fully connected and the tool WILL run. Do NOT call \`ask_credential\` for it; do NOT include it in \`finish_setup\`; NEVER clear, remove, or replace it via \`patch_config\`; and NEVER seek a "real" API key to swap in for it. Report the tool as ready, running on n8n credits — exactly like a managed model. Never tell the user the credential is "not connected"/"not set up" or that the tool "won't run until a credential is added".
+- Only for a required slot that \`read_config\` shows still empty after the write (a service n8n Connect does not cover) do you resolve a real credential: call \`ask_credential\` once before the config mutation for an addition to an existing agent. ${initial_build_prompt_1.INITIAL_BUILD_NOTE} After the trailing \`finish_setup\` resolves the credential, copy the returned credentials into \`node.credentials\` via \`patch_config\`; for resource-locator resolution follow \`agent-builder-resource-locators\` then. Pass the node's credential key as \`credentialSlot\`. On success, copy the returned \`credentials\` object directly to \`node.credentials\`. If skipped, still add the tool and omit only that credential slot.
+- When the agent already has a chat channel configured and the tool needs the same
+  credential type, \`ask_credential\` reuses the channel's credential automatically —
+  do not ask the user to pick a different one.
+
+## n8n Expressions
+
+Node tool parameters inside \`nodeParameters\` can use n8n expressions.
+Prefer \`$fromAI\` whenever the target agent should decide a value at runtime,
+except where this skill requires a fixed value, especially the HTTP Request
+Tool URL.
+Do not use \`$fromAI\` for stable resource IDs that the target agent cannot know
+at runtime, such as Linear \`teamId\`, project IDs, channel IDs, calendar IDs,
+database IDs, table IDs, or other dynamic "Name or ID" selectors. Resolve those
+with the \`agent-builder-resource-locators\` skill, \`ask_credential\`, and
+\`get_resource_locator_options\`; write the returned \`parameterValue\` into
+\`nodeParameters\`.
+
+- \`={{ /*n8n-auto-generated-fromAI-override*/ $fromAI('fieldName', 'What value to provide', 'string') }}\`
+- \`={{ /*n8n-auto-generated-fromAI-override*/ $fromAI('count', 'How many items', 'number') }}\`
+- \`={{ /*n8n-auto-generated-fromAI-override*/ $fromAI('enabled', 'Whether to enable this option', 'boolean') }}\`
+- \`={{ $now.toISO() }}\` for current date/time.
+- \`={{ $today }}\` for the start of today.
+
+Always wrap expressions in \`={{ }}\`. Never pipe AI-chosen node-tool fields
+through \`$json\`; use \`$fromAI\` for those fields instead.
+
+## Gotchas
+
+- Do not include \`inputSchema\` or \`toolDescription\` for node tools.
+- \`$fromAI(...)\` placeholders define the node tool input schema; do not add it manually.
+- Follow \`agent-builder-resource-locators\` for dynamic selector lookup,
+  credentials, and \`parameterValue\` handling.
+- If a required node-tool credential is skipped, add the tool and omit only that credential slot.
+- Node tools execute inline, so never use waiting operations such as \`sendAndWait\`
+  or \`dispatchAndWait\`. When the user requests human approval, configure the
+  intended non-waiting operation and set \`requireApproval: true\` on the tool.
+
+## Verify
+
+- Generic external-service requests were routed through \`resolve_integration\`
+  before node setup.
+- Node tools use discovered tool node ids and valid node parameters.
+- HTTP Request Tools use a fixed URL supplied by the user.`,
+    };
+}
+//# sourceMappingURL=node-tools.skill.js.map

package/dist/modules/agents/builder/skills/node-tools.skill.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-tools.skill.js","sourceRoot":"","sources":["../../../../../src/modules/agents/builder/skills/node-tools.skill.ts"],"names":[],"mappings":";;;AACA,8CAAyD;AAEzD,0EAAqE;AAErE;IACC,OAAO;QACN,EAAE,EAAE,0BAA0B;QAC9B,IAAI,EAAE,0BAA0B;QAChC,WAAW,EACV,kOAAkO;QACnO,gBAAgB,EAAE;YACjB,qBAAqB;YACrB,cAAc;YACd,gBAAgB;YAChB,gBAAgB;YAChB,aAAa;YACb,cAAc;SACd;QACD,YAAY,EAAE;YACb,qBAAqB;YACrB,cAAc;YACd,gBAAgB;YAChB,gBAAgB;YAChB,8BAA8B;YAC9B,eAAe;YACf,aAAa;YACb,cAAc;YACd,cAAc;YACd,YAAY;SACZ;QACD,YAAY,EAAE;;;;;;;;;;;;;;;;;;;;;;;;gBAwBA,mCAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2PA+BoN,yCAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2DA2ClN;KACzD,CAAC;AACH,CAAC"}

package/dist/modules/agents/builder/skills/target-skills.skill.js

@@ -6,27 +6,48 @@ function targetSkillsSkill() {
     return {
         id: 'agent-builder-target-skills',
         name: 'Agent Builder Target Skills',
-        description: 'Use when creating reusable target-agent skills, playbooks, policies, style guides, or domain instructions with create_skills that should load only for relevant future requests; not for builder guidance or one-off instructions.',
-        recommendedTools: ['create_skills', 'ask_questions', 'read_config', 'patch_config'],
-        allowedTools: ['create_skills', 'ask_questions', 'read_config', 'patch_config', 'write_config'],
+        description: 'Use when designing, creating, or editing target-agent behavior that belongs in focused load-on-demand skills, including when the user describes a function without calling it a skill; not for builder guidance or universal target-agent instructions.',
+        recommendedTools: [
+            'list_skills',
+            'read_skill',
+            'update_skill',
+            'create_skills',
+            'ask_questions',
+            'read_config',
+            'patch_config',
+        ],
+        allowedTools: [
+            'list_skills',
+            'read_skill',
+            'update_skill',
+            'create_skills',
+            'ask_questions',
+            'read_config',
+            'patch_config',
+            'write_config',
+        ],
         instructions: `\
 ## Purpose
 
-Use this to create reusable load-on-demand instructions for the target agent.
+Use this to design, create, and edit focused load-on-demand instructions for
+the target agent. Keep the target agent's always-on instructions limited to its
+identity, overall purpose, and rules that apply to every operation.
 
 ## Use when
 
-- The user wants reusable target-agent guidance (for example playbooks,
-  policies, or domain instructions) that should load only for relevant future
-  requests.
-- The same behavior is likely to be reused across multiple future tasks and
-  should be captured as a target-agent skill.
-- You want conditional, load-on-demand behavior instead of always-on target
-  agent instructions.
+- The target agent has a distinct function, workflow, playbook, policy, style
+  guide, or domain behavior that should load only for relevant requests.
+- The user asks to change how the target agent performs an existing function,
+  even when they do not mention skills.
+- A build contains multiple functions. Create one focused skill per function;
+  infer this decomposition without asking the user to label anything a skill.
 
 ## Don't use when:
 
-- The user asks for one-off target-agent instructions or config/tool/integration/model/memory edits.
+- The behavior is the target agent's identity, overall purpose, or a rule that
+  truly applies to every operation; keep that in the main instructions.
+- The request changes only a tool, integration, model, or memory setting and
+  does not add or change how the target agent performs a function.
 
 ## Description (routing contract)
 
@@ -40,8 +61,8 @@ ${skill_body_template_1.SKILL_BODY_TEMPLATE}
 
 ## Fill the template with assumptions (required)
 
-Do NOT call \`create_skills\` until you have enough concrete domain detail to write
-a genuinely useful skill: a specific routing description and a body whose
+Do NOT create or update a skill until you have enough concrete domain detail to
+write a genuinely useful skill: a specific routing description and a body whose
 applicable sections are filled with real content (the actual steps, rules,
 examples, and edge cases). Derive missing domain detail from the user's
 stated goal as stated assumptions, and list them in your summary. Use
@@ -52,20 +73,38 @@ skill.
 
 ## Workflow
 
-- Fill the domain detail you need, deriving missing detail from the goal as
-  stated assumptions so the description and every applicable body section can
-  be written with concrete content, for every skill you plan to create.
+- Classify requested behavior before writing: identity, overall purpose, and
+  universal rules stay in main instructions; each distinct or conditional
+  function becomes a focused skill.
+- Call \`read_config\` and use its \`skills\` refs as the authoritative set of
+  skills attached to the target agent.
+- Call \`list_skills\` once and compare its metadata with the attached ids from
+  the config. Use each description as the routing contract to identify whether
+  an attached skill already owns the capability. Do not read every skill body.
+- Call \`read_skill\` only for the relevant attached skill. Its default response
+  includes reference paths and sizes but omits reference content; request
+  specific \`referencePaths\` only when that content is needed.
+- Call \`update_skill\` for an existing capability, changing only the supplied
+  fields and preserving its id and existing config reference. Do not create a
+  replacement skill. Pass \`null\` for \`allowedTools\` to remove the tool
+  restriction or for \`references\` to remove all references; do not pass empty
+  arrays. When replacing \`references\`, first read the content of every existing
+  reference that must be preserved, because the field is replaced as a whole.
+- Only call \`create_skills\` when no attached skill owns the capability. Fill the
+  domain detail you need, deriving missing detail from the goal as stated
+  assumptions so each description and applicable body section is concrete.
 - Write each skill's \`description\` as the routing contract and \`instructions\`
   using the template above. Put all "when to use" / "when not to use" guidance
   in the description, never in the body (the body is invisible until the skill
   loads).
-- Call \`create_skills\` once with a \`skills\` array containing every skill you
+- For new skills, call \`create_skills\` once with a \`skills\` array containing every skill you
   currently know how to write — do not spread multiple fully-specified skills
   across separate calls. A single skill is still a one-item array.
 - \`create_skills\` stores the skill bodies only; it does not attach them. The
   batch is all-or-nothing: an invalid or duplicate-named skill rejects the
   whole call.
-- After it returns an id per skill, call \`read_config\`.
+- After it returns an id per new skill, call \`read_config\` again for a fresh
+  config and hash.
 - Use \`patch_config\` or \`write_config\` to add a \`{ "type": "skill", "id": "<returned id>" }\`
   entry per skill to \`skills\`.
 
@@ -84,7 +123,7 @@ skill.
   \`references/intake-checklist.md\`".
 - Omit fields you cannot fill confidently. Do not invent tool names or file paths.
 - Scripts are not supported in this phase. Do not pass scripts or non-markdown
-  linked files to \`create_skills\`.
+  linked files to \`create_skills\` or \`update_skill\`.
 
 ## Rules
 
@@ -94,11 +133,13 @@ skill.
 - Do not rely on a body "Use when" section to trigger the skill; the body is
   not visible until after the skill is selected.
 - Include concrete gotchas that prevent predictable target-agent mistakes.
-- Do not use \`create_skills\` for builder instructions. These skills belong to the target agent.
+- Do not use target-agent skill tools for builder instructions. These skills
+  belong to the target agent.
 
 ## Gotchas
 
 - \`create_skills\` does not attach any skill to the target agent config.
+- \`update_skill\` edits the existing body in place and needs no config patch.
 - A skill that is useful for every request probably belongs in instructions, not in \`skills\`.
 - A vague description creates a vague skill, even if the body is excellent.
 - Do not create placeholder or vague skills; derive missing domain details from

package/dist/modules/agents/builder/skills/target-skills.skill.js.map

@@ -1 +1 @@
-{"version":3,"file":"target-skills.skill.js","sourceRoot":"","sources":["../../../../../src/modules/agents/builder/skills/target-skills.skill.ts"],"names":[],"mappings":";;;AAEA,gEAIgC;AAEhC;IACC,OAAO;QACN,EAAE,EAAE,6BAA6B;QACjC,IAAI,EAAE,6BAA6B;QACnC,WAAW,EACV,oOAAoO;QACrO,gBAAgB,EAAE,CAAC,eAAe,EAAE,eAAe,EAAE,aAAa,EAAE,cAAc,CAAC;QACnF,YAAY,EAAE,CAAC,eAAe,EAAE,eAAe,EAAE,aAAa,EAAE,cAAc,EAAE,cAAc,CAAC;QAC/F,YAAY,EAAE;;;;;;;;;;;;;;;;;;;;;EAqBd,4CAAsB;;;;EAItB,4CAAsB;;EAEtB,yCAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBA6EE;KACrB,CAAC;AACH,CAAC"}
+{"version":3,"file":"target-skills.skill.js","sourceRoot":"","sources":["../../../../../src/modules/agents/builder/skills/target-skills.skill.ts"],"names":[],"mappings":";;;AAEA,gEAIgC;AAEhC;IACC,OAAO;QACN,EAAE,EAAE,6BAA6B;QACjC,IAAI,EAAE,6BAA6B;QACnC,WAAW,EACV,yPAAyP;QAC1P,gBAAgB,EAAE;YACjB,aAAa;YACb,YAAY;YACZ,cAAc;YACd,eAAe;YACf,eAAe;YACf,aAAa;YACb,cAAc;SACd;QACD,YAAY,EAAE;YACb,aAAa;YACb,YAAY;YACZ,cAAc;YACd,eAAe;YACf,eAAe;YACf,aAAa;YACb,cAAc;YACd,cAAc;SACd;QACD,YAAY,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;EAyBd,4CAAsB;;;;EAItB,4CAAsB;;EAEtB,yCAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBAiGE;KACrB,CAAC;AACH,CAAC"}