n8n 2.44.4 → 2.45.0

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

@@ -13,19 +13,19 @@ function externalServicesSkill() {
         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: [
             'agent-context',
-            'configure_channel',
-            'ask_credential',
-            'verify_mcp_server',
-            'patch_config',
+            'agent_builder_configure_channel',
+            'agent_builder_ask_credential',
+            'agent_builder_verify_mcp_server',
+            'agent_builder_patch_config',
         ],
         allowedTools: [
             'agent-context',
-            'configure_channel',
-            'ask_credential',
-            'verify_mcp_server',
-            'ask_questions',
-            'patch_config',
-            'write_config',
+            'agent_builder_configure_channel',
+            'agent_builder_ask_credential',
+            'agent_builder_verify_mcp_server',
+            'agent_builder_ask_questions',
+            'agent_builder_patch_config',
+            'agent_builder_write_config',
             'report_required_artifact',
             'load_skill',
         ],
@@ -124,32 +124,35 @@ The \`integrations\` array controls how the target agent is triggered.
 - Call \`agent-context({ type: "integrations" })\` first.
 - Read the returned \`capabilities\`, \`useIntegrationWhen\`, and
   \`useNodeToolWhen\` fields before deciding to add an integration.
-- Pick one returned \`type\` and pass it to \`configure_channel\` as
-  \`integrationType\`. ALWAYS use \`configure_channel\` for chat-channel
-  credentials — never \`ask_credential\` or a raw config write. The setup UI it
+- Pick one returned \`type\` and pass it to \`agent_builder_configure_channel\` as
+  \`integrationType\`. ALWAYS use \`agent_builder_configure_channel\` for chat-channel
+  credentials — never \`agent_builder_ask_credential\` or a raw config write. The setup UI it
   shows creates and persists the channel configuration without publishing the
-  agent; do not follow up with \`patch_config\`/\`write_config\` to write the
+  agent; do not follow up with \`agent_builder_patch_config\`/\`agent_builder_write_config\` to write the
   credential.
-- ${initial_build_prompt_1.INITIAL_BUILD_NOTE} Instead of \`configure_channel\`: after
-  \`agent-context({ type: "integrations" })\` returns the matching type,
-  \`patch_config\` (with the \`configHash\` from your latest config read or write) adding \`{ "type": "<integrationType>", "credentialId": "" }\`
-  to \`/integrations/-\` (include a minimal valid draft \`settings\` object for
-  telegram) so the channel appears in the agent panel as needing setup. Pass
-  the same \`integrationType\` in the trailing \`finish_setup\` call's
+- ${initial_build_prompt_1.INITIAL_BUILD_NOTE} Instead of \`agent_builder_configure_channel\`: after
+  \`agent-context({ type: "integrations" })\` returns the matching type, add
+  \`{ "type": "<integrationType>", "credentialId": "" }\` to \`integrations\`
+  in your single initial config write (include a minimal valid draft
+  \`settings\` object for telegram) so the channel appears in the agent panel
+  as needing setup. If the config is already written, \`agent_builder_patch_config\` (with
+  the \`configHash\` from your latest config read or write) adding it to
+  \`/integrations/-\` instead. Pass
+  the same \`integrationType\` in the trailing \`agent_builder_finish_setup\` call's
   \`channels\` array — its card configures or skips the channel itself. Do not
-  call \`configure_channel\` again after \`finish_setup\` handles the card. If
+  call \`agent_builder_configure_channel\` again after \`agent_builder_finish_setup\` handles the card. If
   skipped, list it in the closing setup checklist pointing at the channel
   chip in the agent panel.
 - Preserve existing chat integrations unless the user asked to remove them.
 - To remove an existing chat integration, call \`agent-context({ type: "config" })\` and inspect
   \`config.integrations\`.
 - If exactly one existing integration matches the requested platform, remove
-  that entry with \`patch_config\` by index (or replace \`/integrations\` with a
+  that entry with \`agent_builder_patch_config\` by index (or replace \`/integrations\` with a
   filtered array when clearer).
 - If multiple existing integrations match the requested platform, ask which one
   to remove before editing \`integrations\`.
 - Removing a chat integration means deleting its entry from
-  \`integrations[]\`. Do not call \`configure_channel\` to remove a channel.
+  \`integrations[]\`. Do not call \`agent_builder_configure_channel\` to remove a channel.
 
 ### Gotchas
 
@@ -163,7 +166,7 @@ The \`integrations\` array controls how the target agent is triggered.
 - Do not add a chat integration just because the agent needs CRUD or notifications
   for that product. Resolve the callable capability through \`agent-context\`
   unless the product itself is the chat/trigger context.
-- For recurring or scheduled runs, create a task (\`create_tasks\`) for the
+- For recurring or scheduled runs, create a task (\`agent_builder_create_tasks\`) for the
   cadence. Keep a requested chat integration, and use its generated action
   tools when the task sends through that same platform.
 - Omitting \`integrations\` from a config write preserves the current channels.
@@ -198,12 +201,12 @@ search terms for that service.
   - If \`results[]\` contains one entry, use it as \`selectedResult\`.
   - If the request uniquely identifies one entry by \`name\` or \`title\`, use
     that entry as \`selectedResult\`.
-  - If multiple candidates remain, call \`ask_questions\` with the candidate
+  - If multiple candidates remain, call \`agent_builder_ask_questions\` with the candidate
     titles and descriptions; never choose by array order. During an initial
-    build, do not call \`ask_questions\` for this: pick the best candidate by
+    build, do not call \`agent_builder_ask_questions\` for this: pick the best candidate by
     title/description relevance yourself, and list the pick as an assumption
     in your summary. Use the chosen entry as \`selectedResult\`. If
-    \`ask_questions\` returns \`{ answered: false }\`, stop MCP setup without
+    \`agent_builder_ask_questions\` returns \`{ answered: false }\`, stop MCP setup without
     selecting a server, asking for credentials, verifying a connection, or
     mutating config. Do not re-present the question.
 - Use \`name\`, \`url\`, \`transport\`, \`authentication\`, \`credentialType\`,
@@ -211,33 +214,35 @@ search terms for that service.
 
 Follow these steps for the selected MCP result:
 
-1. Credential: call \`ask_credential\` with a short \`purpose\`, using
+1. Credential: call \`agent_builder_ask_credential\` with a short \`purpose\`, using
    \`selectedResult.credentialType\` as \`credentialType\`. Never invent
    credential IDs.
-2. Verify: call \`verify_mcp_server\` with the selected result's \`name\`, \`url\`,
+2. Verify: call \`agent_builder_verify_mcp_server\` with the selected result's \`name\`, \`url\`,
    \`transport\`, \`authentication\`, and optional \`metadata\`, plus the returned
    \`credentialId\` as \`credential\` when authentication is required.
 3. Capability check: confirm the verified tool names and descriptions cover the
    capability the user requested.
-4. Write config: call \`agent-context({ type: "config" })\`, then \`patch_config\` to add the entry to
+4. Write config: call \`agent-context({ type: "config" })\`, then \`agent_builder_patch_config\` to add the entry to
    \`mcpServers[]\` using the patch pattern below. When the entry already
    exists and verify returned \`credentialApplied: true\`, skip this step — the
    credential is already persisted.
 
 ${initial_build_prompt_1.INITIAL_BUILD_NOTE} For MCP that means: pick the best candidate as an
-assumption (above), then \`patch_config\` (with the \`configHash\` from your latest config read or write) a draft
-\`/mcpServers/-\` entry using \`name\`, \`url\`, \`transport\`,
+assumption (above), then add a draft \`mcpServers\` entry to your single
+initial config write (or \`agent_builder_patch_config\` it to \`/mcpServers/-\`, with the
+\`configHash\` from your latest config read or write, if the config is
+already written) using \`name\`, \`url\`, \`transport\`,
 \`authentication\`, and \`metadata.nodeTypeName\` from \`selectedResult\` with
-\`credential\` omitted, and skip \`verify_mcp_server\` — there is nothing to
-authenticate yet. Include the credential in the trailing \`finish_setup\` call;
+\`credential\` omitted, and skip \`agent_builder_verify_mcp_server\` — there is nothing to
+authenticate yet. Include the credential in the trailing \`agent_builder_finish_setup\` call;
 verify with the returned credential id — on success the tool writes the
 credential into the matching entry itself (\`credentialApplied: true\`); no
-\`agent-context({ type: "config" })\`/\`patch_config\` follow-up for the credential. Existing-agent
+\`agent-context({ type: "config" })\`/\`agent_builder_patch_config\` follow-up for the credential. Existing-agent
 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, load \`agent-builder-node-tools\`, call
-\`search_nodes\` with the same service queries, and follow that skill. Do not
+\`agent_builder_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:
@@ -246,39 +251,49 @@ ${mcpServerSchemaText}
 
 ### Tool exposure and approval
 
-- Expose every available MCP tool by default: omit \`toolFilter\` unless the user
-  explicitly asks to restrict which tools are exposed. Do not infer an allowlist
-  from the requested capability.
-- For an explicit filter or selected approval list, use only exact, unprefixed
-  \`name\` values from \`selectedResult.tools\` or a successful
-  \`verify_mcp_server\` result.
-- Never prepend the server name. Never invent MCP tool names. \`toolFilter.tools\`
-  and \`approval.tools\` match original MCP names; the SDK adds the server prefix
-  only when exposing tools to the model.
+- Omit \`toolPermissions\` unless the user explicitly asks to require approval,
+  block a tool or category, or restrict which tools are exposed. Omission
+  allows all MCP tools without approval.
+- Treat requests to expose or allow only named tools as an allowlist. Set both
+  \`toolPermissions.categories.read\` and
+  \`toolPermissions.categories.write\` to \`"blocked"\`, then add each selected
+  tool to \`toolPermissions.tools\` as an \`"always_allow"\` override.
+- For other permission controls, set both
+  \`toolPermissions.categories.read\` and
+  \`toolPermissions.categories.write\`. Use \`"always_allow"\` for categories
+  the user did not restrict.
+- Use \`"require_approval"\` when the user asks to approve a category or tool
+  before execution. Use \`"blocked"\` when the user asks to hide or disable it.
+- Use category policies for broad read/write rules. Add \`toolPermissions.tools\`
+  overrides only for exceptions to those category rules.
+- For an exact tool override, use only an unprefixed \`name\` from
+  \`selectedResult.tools\` or a successful
+  \`agent_builder_verify_mcp_server\` result. Never
+  prepend the server name and never invent MCP tool names.
 
 ### Credential flow
 
-- For \`bearerAuth\`, call \`ask_credential\` with
+- For \`bearerAuth\`, call \`agent_builder_ask_credential\` with
   \`credentialType: "httpBearerAuth"\`.
-- For \`headerAuth\`, call \`ask_credential\` with
+- For \`headerAuth\`, call \`agent_builder_ask_credential\` with
   \`credentialType: "httpHeaderAuth"\`.
-- For \`multipleHeadersAuth\`, call \`ask_credential\` with
+- For \`multipleHeadersAuth\`, call \`agent_builder_ask_credential\` with
   \`credentialType: "httpMultipleHeadersAuth"\`.
-- For \`mcpOAuth2Api\`, call \`ask_credential\` with
+- For \`mcpOAuth2Api\`, call \`agent_builder_ask_credential\` with
   \`credentialType: "mcpOAuth2Api"\`.
 
 ### Testing the connection
 
-Before writing to config, call \`verify_mcp_server\` with server \`name\`,
+Before writing to config, call \`agent_builder_verify_mcp_server\` with server \`name\`,
 \`url\`, \`transport\`, optional registry \`metadata\`, and (if applicable) the
-credential id from \`ask_credential\`.
+credential id from \`agent_builder_ask_credential\`.
 
 - Success returns \`{ ok: true, tools: [{ name, description }] }\`, and when a
   matching \`mcpServers\` entry exists, also \`credentialApplied: true,
   configMutated: true, agentId\` — the credential is written automatically; do
-  not follow with \`agent-context({ type: "config" })\`/\`patch_config\` for the credential.
+  not follow with \`agent-context({ type: "config" })\`/\`agent_builder_patch_config\` for the credential.
 - When verify succeeds but \`credentialApplied: false\` and the entry already
-  exists, fall back to \`agent-context({ type: "config" })\` then \`patch_config\` for the credential.
+  exists, fall back to \`agent-context({ type: "config" })\` then \`agent_builder_patch_config\` for the credential.
 - For an explicitly requested filter or selected approval list, copy exact names
   from the returned tool list following Tool exposure and approval above.
 - Failure returns \`{ ok: false, error: "..." }\`.
@@ -292,13 +307,14 @@ invent a credential ID or a placeholder URL to fill the gap, and never abort
 the server addition — always persist what is known and let the user finish
 setup later:
 
-- Credential skipped (\`ask_credential\` returned \`{ skipped: true }\`): omit
+- Credential skipped (\`agent_builder_ask_credential\` returned \`{ skipped: true }\`): omit
   only the \`credential\` field.
 - URL skipped: persist \`url: ""\`.
-- Either case: skip \`verify_mcp_server\` (there is nothing to authenticate or
-  connect to), then \`agent-context({ type: "config" })\` and \`patch_config\` the entry, preserving
+- Either case: skip \`agent_builder_verify_mcp_server\` (there is nothing to authenticate or
+  connect to), then \`agent-context({ type: "config" })\` and \`agent_builder_patch_config\` the entry, preserving
   every other known field — \`name\`, \`transport\`, \`authentication\`, an
-  already-selected credential, and registry \`metadata\`.
+  already-selected credential, registry \`metadata\`, and any explicitly
+  configured \`toolPermissions\`.
 
 ### Selecting credentials
 
@@ -309,11 +325,11 @@ For custom MCP servers, if credential type is unknown, ask the user which
 credential type to use (OAuth2, Bearer Token, Header Auth, Multiple Headers
 Auth, or None) via \`${api_types_1.ASK_QUESTIONS_TOOL_NAME}\`. Then map to:
 
-- \`bearerAuth\` -> \`ask_credential\` with \`credentialType: "httpBearerAuth"\`
-- \`headerAuth\` -> \`ask_credential\` with \`credentialType: "httpHeaderAuth"\`
-- \`multipleHeadersAuth\` -> \`ask_credential\` with
+- \`bearerAuth\` -> \`agent_builder_ask_credential\` with \`credentialType: "httpBearerAuth"\`
+- \`headerAuth\` -> \`agent_builder_ask_credential\` with \`credentialType: "httpHeaderAuth"\`
+- \`multipleHeadersAuth\` -> \`agent_builder_ask_credential\` with
   \`credentialType: "httpMultipleHeadersAuth"\`
-- \`mcpOAuth2Api\` -> \`ask_credential\` with \`credentialType: "mcpOAuth2Api"\`
+- \`mcpOAuth2Api\` -> \`agent_builder_ask_credential\` with \`credentialType: "mcpOAuth2Api"\`
 
 ### Patch pattern
 
@@ -331,11 +347,13 @@ Auth, or None) via \`${api_types_1.ASK_QUESTIONS_TOOL_NAME}\`. Then map to:
   entry so the UI can render the correct server form.
 - A registry match proves server availability, not support for the requested
   capability; use the verified live tool list for that decision.
+- Describe an MCP server only by its name, or by text the user or the registry
+  gave. If you cannot identify it, do not state what it does.
 
 ## Verify
 
-- Configured chat integrations were set up through \`configure_channel\` or the
-  initial-build \`finish_setup\` channel card, not \`ask_credential\` or a manual
+- Configured chat integrations were set up through \`agent_builder_configure_channel\` or the
+  initial-build \`agent_builder_finish_setup\` channel card, not \`agent_builder_ask_credential\` or a manual
   config write.
 - The chosen integration matches \`useIntegrationWhen\`; otherwise resolve the
   callable capability through \`agent-context\` and use MCP, node, or

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,+DAAsE;AACtE,8CAAgF;AAEhF,qFAAmF;AACnF,0EAAqE;AAErE,MAAM,mBAAmB,GAAG,IAAA,gDAAuB,EAAC,IAAA,mCAAqB,EAAC,iCAAqB,CAAC,CAAC,CAAC;AAElG;IACC,OAAO;QACN,EAAE,EAAE,iCAAiC;QACrC,IAAI,EAAE,iCAAiC;QACvC,WAAW,EACV,kQAAkQ;QACnQ,gBAAgB,EAAE;YACjB,eAAe;YACf,mBAAmB;YACnB,gBAAgB;YAChB,mBAAmB;YACnB,cAAc;SACd;QACD,YAAY,EAAE;YACb,eAAe;YACf,mBAAmB;YACnB,gBAAgB;YAChB,mBAAmB;YACnB,eAAe;YACf,cAAc;YACd,cAAc;YACd,0BAA0B;YAC1B,YAAY;SACZ;QACD,YAAY,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAqGZ,yCAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA8DhB,mCAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgC3B,yCAAkB;;;;;;;;;;;;;;;;;;EAkBlB,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBAiEE,mCAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8CAsCA;KAC5C,CAAC;AACH,CAAC"}
+{"version":3,"file":"external-services.skill.js","sourceRoot":"","sources":["../../../../../src/modules/agents/builder/skills/external-services.skill.ts"],"names":[],"mappings":";;;AACA,+DAAsE;AACtE,8CAAgF;AAEhF,qFAAmF;AACnF,0EAAqE;AAErE,MAAM,mBAAmB,GAAG,IAAA,gDAAuB,EAAC,IAAA,mCAAqB,EAAC,iCAAqB,CAAC,CAAC,CAAC;AAElG;IACC,OAAO;QACN,EAAE,EAAE,iCAAiC;QACrC,IAAI,EAAE,iCAAiC;QACvC,WAAW,EACV,kQAAkQ;QACnQ,gBAAgB,EAAE;YACjB,eAAe;YACf,iCAAiC;YACjC,8BAA8B;YAC9B,iCAAiC;YACjC,4BAA4B;SAC5B;QACD,YAAY,EAAE;YACb,eAAe;YACf,iCAAiC;YACjC,8BAA8B;YAC9B,iCAAiC;YACjC,6BAA6B;YAC7B,4BAA4B;YAC5B,4BAA4B;YAC5B,0BAA0B;YAC1B,YAAY;SACZ;QACD,YAAY,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAqGZ,yCAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAiEhB,mCAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgC3B,yCAAkB;;;;;;;;;;;;;;;;;;;;EAoBlB,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBA4EE,mCAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8CAwCA;KAC5C,CAAC;AACH,CAAC"}

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getBuilderRuntimeSkills = getBuilderRuntimeSkills;
+const config_skill_1 = require("./config.skill");
 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");
@@ -9,8 +10,17 @@ 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");
 const target_tasks_skill_1 = require("./target-tasks.skill");
+const AGENT_BUILDER_SKILL_ID = 'agent-builder';
+function asAgentBuilderReference(skill) {
+    return {
+        ...skill,
+        parents: [AGENT_BUILDER_SKILL_ID],
+        reference: { owner: AGENT_BUILDER_SKILL_ID, path: `references/${skill.id}.md` },
+    };
+}
 function getBuilderRuntimeSkills() {
     return [
+        (0, config_skill_1.configSkill)(),
         (0, custom_tools_skill_1.customToolsSkill)(),
         (0, external_services_skill_1.externalServicesSkill)(),
         (0, memory_skill_1.memorySkill)(),
@@ -19,6 +29,6 @@ function getBuilderRuntimeSkills() {
         (0, sub_agents_skill_1.subAgentsSkill)(),
         (0, target_skills_skill_1.targetSkillsSkill)(),
         (0, target_tasks_skill_1.targetTasksSkill)(),
-    ];
+    ].map(asAgentBuilderReference);
 }
 //# sourceMappingURL=index.js.map

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,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"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../src/modules/agents/builder/skills/index.ts"],"names":[],"mappings":";;;AAEA,iDAA6C;AAC7C,6DAAwD;AACxD,uEAAkE;AAClE,iDAA6C;AAC7C,yDAAoD;AACpD,uEAAkE;AAClE,yDAAoD;AACpD,+DAA0D;AAC1D,6DAAwD;AAGxD,MAAM,sBAAsB,GAAG,eAAe,CAAC;AAE/C,SAAS,uBAAuB,CAAC,KAAmB;IACnD,OAAO;QACN,GAAG,KAAK;QACR,OAAO,EAAE,CAAC,sBAAsB,CAAC;QACjC,SAAS,EAAE,EAAE,KAAK,EAAE,sBAAsB,EAAE,IAAI,EAAE,cAAc,KAAK,CAAC,EAAE,KAAK,EAAE;KAC/E,CAAC;AACH,CAAC;AAED;IACC,OAAO;QACN,IAAA,0BAAW,GAAE;QACb,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,GAAG,CAAC,uBAAuB,CAAC,CAAC;AAChC,CAAC"}

package/dist/modules/agents/builder/skills/memory.skill.js

@@ -8,20 +8,20 @@ function memorySkill() {
         name: 'Agent Builder Memory',
         description: 'Use for explicit memory changes: Episodic/long-term/cross-session memory, observer/reflector worker models, threshold/budget tuning, or disabling memory. Not for ordinary fresh-agent creation, which uses the default memory config in Memory Guidance.',
         recommendedTools: [
-            'ask_embedding_credential',
-            'resolve_llm',
-            'ask_credential',
+            'agent_builder_ask_embedding_credential',
+            'agent_builder_resolve_llm',
+            'agent_builder_ask_credential',
             'agent-context',
-            'patch_config',
+            'agent_builder_patch_config',
         ],
         allowedTools: [
-            'ask_embedding_credential',
-            'resolve_llm',
-            'ask_credential',
-            'ask_questions',
+            'agent_builder_ask_embedding_credential',
+            'agent_builder_resolve_llm',
+            'agent_builder_ask_credential',
+            'agent_builder_ask_questions',
             'agent-context',
-            'patch_config',
-            'write_config',
+            'agent_builder_patch_config',
+            'agent_builder_write_config',
         ],
         instructions: `\
 ## Purpose
@@ -43,18 +43,18 @@ Memory (long-term, cross-session recall).
 - Supported observational memory tuning fields: \`enabled\`, \`observerModel\`, \`reflectorModel\`, \`observerThresholdTokens\`, \`reflectorThresholdTokens\`, \`renderTokenBudget\`, \`observationLogTailLimit\`, and \`lockTtlMs\`.
 - Memory worker model fields must use object shape: \`{ "model": "provider/model-name", "credential": "<credentialId>" }\`.
 - Only set \`observerModel\`, \`reflectorModel\`, or \`episodicMemory.reflectorModel\` when the user explicitly asks to use a specific model for memory work.
-- Use only credential IDs returned by \`resolve_llm\` or \`ask_credential\` for memory worker model fields. Do not invent IDs or copy a main-model credential unless one of those tools returned it for that worker model provider.
+- Use only credential IDs returned by \`agent_builder_resolve_llm\` or \`agent_builder_ask_credential\` for memory worker model fields. Do not invent IDs or copy a main-model credential unless one of those tools returned it for that worker model provider.
 
 ## Episodic Memory
 
 - Enable \`memory.episodicMemory\` only when the user asks for Episodic Memory, long-term memory, prior conversations, remembered decisions, exact artifacts, or cross-session memory.
-- Before enabling it, call \`ask_embedding_credential({ credentialType: "openAiApi", purpose: "OpenAI credential for Episodic Memory embeddings" })\`. Without the assistant proxy: ${initial_build_prompt_1.INITIAL_BUILD_NOTE} Leave Episodic Memory disabled, include an \`openAiApi\` entry in the trailing \`finish_setup\` call, and enable it with the returned credential id — the draft schema requires a credential to enable it.
+- Before enabling it, call \`agent_builder_ask_embedding_credential({ credentialType: "openAiApi", purpose: "OpenAI credential for Episodic Memory embeddings" })\`. Without the assistant proxy: ${initial_build_prompt_1.INITIAL_BUILD_NOTE} Leave Episodic Memory disabled, include an \`openAiApi\` entry in the trailing \`agent_builder_finish_setup\` call, and enable it with the returned credential id — the draft schema requires a credential to enable it.
 - On success, set \`memory.episodicMemory = { "enabled": true, "credential": "<credentialId>" }\`, using the returned \`credentialId\` value. This can be a real credential id or \`"managed"\` when the assistant proxy is available. Preserve existing \`topK\` or \`maxEntriesPerRun\`.
 - \`memory.episodicMemory.credential\` is only for OpenAI embeddings. It is separate from the optional \`reflectorModel\` worker credential.
 - If credential selection is skipped, do not enable Episodic Memory; explain that it needs an OpenAI credential for embeddings.
 - Do not add instructions saying the agent should remember, store, save, or decide what context matters. The runtime handles memory extraction and indexing.
 - If instructions mention Episodic Memory, phrase it as retrieval/use only, e.g. "Use recalled prior context when relevant to the user's request."
-- Do not invent Episodic Memory credential IDs or reuse the main model credential unless \`ask_embedding_credential\` returned it for this purpose.
+- Do not invent Episodic Memory credential IDs or reuse the main model credential unless \`agent_builder_ask_embedding_credential\` returned it for this purpose.
 
 ## Gotchas
 
@@ -64,7 +64,7 @@ Memory (long-term, cross-session recall).
 
 ## Verify
 
-- Episodic Memory has an OpenAI credential or \`"managed"\` returned by \`ask_embedding_credential\`.
+- Episodic Memory has an OpenAI credential or \`"managed"\` returned by \`agent_builder_ask_embedding_credential\`.
 - Existing memory tuning is preserved unless the user asked to change it.`,
     };
 }

package/dist/modules/agents/builder/skills/memory.skill.js.map

@@ -1 +1 @@
-{"version":3,"file":"memory.skill.js","sourceRoot":"","sources":["../../../../../src/modules/agents/builder/skills/memory.skill.ts"],"names":[],"mappings":";;;AAEA,0EAAqE;AAErE;IACC,OAAO;QACN,EAAE,EAAE,sBAAsB;QAC1B,IAAI,EAAE,sBAAsB;QAC5B,WAAW,EACV,2PAA2P;QAC5P,gBAAgB,EAAE;YACjB,0BAA0B;YAC1B,aAAa;YACb,gBAAgB;YAChB,eAAe;YACf,cAAc;SACd;QACD,YAAY,EAAE;YACb,0BAA0B;YAC1B,aAAa;YACb,gBAAgB;YAChB,eAAe;YACf,eAAe;YACf,cAAc;YACd,cAAc;SACd;QACD,YAAY,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;sLAyBsK,yCAAkB;;;;;;;;;;;;;;;;;0EAiB9H;KACxE,CAAC;AACH,CAAC"}
+{"version":3,"file":"memory.skill.js","sourceRoot":"","sources":["../../../../../src/modules/agents/builder/skills/memory.skill.ts"],"names":[],"mappings":";;;AAEA,0EAAqE;AAErE;IACC,OAAO;QACN,EAAE,EAAE,sBAAsB;QAC1B,IAAI,EAAE,sBAAsB;QAC5B,WAAW,EACV,2PAA2P;QAC5P,gBAAgB,EAAE;YACjB,wCAAwC;YACxC,2BAA2B;YAC3B,8BAA8B;YAC9B,eAAe;YACf,4BAA4B;SAC5B;QACD,YAAY,EAAE;YACb,wCAAwC;YACxC,2BAA2B;YAC3B,8BAA8B;YAC9B,6BAA6B;YAC7B,eAAe;YACf,4BAA4B;YAC5B,4BAA4B;SAC5B;QACD,YAAY,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;oMAyBoL,yCAAkB;;;;;;;;;;;;;;;;;0EAiB5I;KACxE,CAAC;AACH,CAAC"}

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

@@ -7,23 +7,23 @@ 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.',
+        description: 'Use whenever adding, removing, or updating an n8n node-backed tool, including agent_builder_search_nodes/agent_builder_get_node_types discovery, nodeParameters, node credential slots, $fromAI usage, n8n expressions, and HTTP Request Tool configuration.',
         recommendedTools: [
             'agent-context',
-            'search_nodes',
-            'get_node_types',
-            'ask_credential',
-            'patch_config',
+            'agent_builder_search_nodes',
+            'agent_builder_get_node_types',
+            'agent_builder_ask_credential',
+            'agent_builder_patch_config',
         ],
         allowedTools: [
             'agent-context',
-            'search_nodes',
-            'get_node_types',
-            'ask_credential',
-            'get_resource_locator_options',
-            'ask_questions',
-            'patch_config',
-            'write_config',
+            'agent_builder_search_nodes',
+            'agent_builder_get_node_types',
+            'agent_builder_ask_credential',
+            'agent_builder_get_resource_locator_options',
+            'agent_builder_ask_questions',
+            'agent_builder_patch_config',
+            'agent_builder_write_config',
             'load_skill',
         ],
         instructions: `\
@@ -35,7 +35,7 @@ Use this to discover, configure, and wire node tools into the target agent's
 ## 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
+requests must use \`config.webSearch\` according to the \`agent-builder-config\` skill's
 web-search rules. Do not search integrations or nodes for
 these requests.
 
@@ -47,8 +47,8 @@ specific-page fetching, use only \`n8n-nodes-base.httpRequestTool\`.
 
 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\`
+ask which URL the tool should fetch. During an initial build, add this to the
+pending setup and include the URL question in the single trailing \`agent_builder_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
@@ -63,8 +63,11 @@ conventions. Never add an incomplete tool or use a placeholder URL.
 - 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
+  \`agent_builder_get_node_types\`; do not repeat the same search with \`agent_builder_search_nodes\`.
+- Fetch every node definition that the build needs in one
+  \`agent_builder_get_node_types\` call, with all nodes and operations together.
+  Do not fetch one service per call.
+- Call \`agent_builder_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.
@@ -81,10 +84,10 @@ conventions. Never add an incomplete tool or use a placeholder URL.
 - Do not include \`inputSchema\` or \`toolDescription\` for node tools.
 - Gateway credits cover 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 \`Gateway credits\` credential (\`{ id: null, name: "Gateway 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 check the slot in the write result: when the server assigned a credential, the result carries the saved \`config\`; when the result has no \`config\`, the slot stayed empty.
 - Exception — when the user explicitly asks to run a tool on Gateway credits, write \`{ "id": null, "name": "Gateway 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 the \`config\` in the write result (it is present when the server removed the slot) and resolve a real credential if it was removed.
-- The \`Gateway credits\` managed credential IS the real, working credential — the tool executes through n8n's gateway on Gateway 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 that the config (from \`agent-context({ type: "config" })\` or a write result) 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 Gateway 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 is still empty after the write (a service Gateway credits do 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.
+- The \`Gateway credits\` managed credential IS the real, working credential — the tool executes through n8n's gateway on Gateway 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 that the config (from \`agent-context({ type: "config" })\` or a write result) shows populated with it: the slot is fully connected and the tool WILL run. Do NOT call \`agent_builder_ask_credential\` for it; do NOT include it in \`agent_builder_finish_setup\`; NEVER clear, remove, or replace it via \`agent_builder_patch_config\`; and NEVER seek a "real" API key to swap in for it. Report the tool as ready, running on Gateway 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 is still empty after the write (a service Gateway credits do not cover) do you resolve a real credential: call \`agent_builder_ask_credential\` once before the config mutation for an addition to an existing agent. ${initial_build_prompt_1.INITIAL_BUILD_NOTE} The trailing \`agent_builder_finish_setup\` writes the resolved credential into every empty node-tool slot of that type, so do not patch it in yourself, unless the \`agent_builder_finish_setup\` result lists that slot in \`configApplyErrors\`. In that case the write failed, so patch the resolved credential into the slot yourself. For resource-locator resolution, follow \`agent-builder-resource-locators\` after \`agent_builder_finish_setup\`. 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 —
+  credential type, \`agent_builder_ask_credential\` reuses the channel's credential automatically —
   do not ask the user to pick a different one.
 
 ## n8n Expressions
@@ -96,8 +99,8 @@ 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
+with the \`agent-builder-resource-locators\` skill, \`agent_builder_ask_credential\`, and
+\`agent_builder_get_resource_locator_options\`; write the returned \`parameterValue\` into
 \`nodeParameters\`.
 
 - \`={{ /*n8n-auto-generated-fromAI-override*/ $fromAI('fieldName', 'What value to provide', 'string') }}\`

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

@@ -1 +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,eAAe;YACf,cAAc;YACd,gBAAgB;YAChB,gBAAgB;YAChB,cAAc;SACd;QACD,YAAY,EAAE;YACb,eAAe;YACf,cAAc;YACd,gBAAgB;YAChB,gBAAgB;YAChB,8BAA8B;YAC9B,eAAe;YACf,cAAc;YACd,cAAc;YACd,YAAY;SACZ;QACD,YAAY,EAAE;;;;;;;;;;;;;;;;;;;;;;;;gBAwBA,mCAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0OAgCmM,yCAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2DA2CjM;KACzD,CAAC;AACH,CAAC"}
+{"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,8PAA8P;QAC/P,gBAAgB,EAAE;YACjB,eAAe;YACf,4BAA4B;YAC5B,8BAA8B;YAC9B,8BAA8B;YAC9B,4BAA4B;SAC5B;QACD,YAAY,EAAE;YACb,eAAe;YACf,4BAA4B;YAC5B,8BAA8B;YAC9B,8BAA8B;YAC9B,4CAA4C;YAC5C,6BAA6B;YAC7B,4BAA4B;YAC5B,4BAA4B;YAC5B,YAAY;SACZ;QACD,YAAY,EAAE;;;;;;;;;;;;;;;;;;;;;;;;gBAwBA,mCAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wPAmCiN,yCAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2DA2C/M;KACzD,CAAC;AACH,CAAC"}