n8n 2.31.5 → 2.32.1

package/dist/modules/agents/builder/prompts/memory.prompt.d.ts

@@ -1 +1 @@
-export declare const MEMORY_PROMPT = "## Memory Guidance\n\n### Purpose\n\nUse this to configure the target agent's memory behavior.\n\n### Workflow\n\nFresh agents must include this default memory config unless the user explicitly asks to disable or change memory:\n```json\n{\n  \"enabled\": true,\n  \"storage\": \"n8n\",\n  \"observationalMemory\": {\n    \"enabled\": true\n  }\n}\n```\n\nThis is the configurable agent's session memory. The runtime-managed\n`observationalMemory` settings tune that memory behavior; they are not a\nseparate user-facing memory product.\n\n### Rules\n\n- When creating a new agent, always write the exact default `memory` object above.\n- Set `storage` to \"n8n\".\n- Set `observationalMemory.enabled` to `true` for new agents unless the user explicitly asks to disable observational memory.\n- Keep the rest of `observationalMemory` optional; add tuning fields only for explicit tuning or disabling.\n- Supported observational memory tuning fields: `enabled`, `observerModel`, `reflectorModel`, `observerThresholdTokens`, `reflectorThresholdTokens`, `renderTokenBudget`, `observationLogTailLimit`, and `lockTtlMs`.\n- Memory worker model fields must use object shape: `{ \"model\": \"provider/model-name\", \"credential\": \"<credentialId>\" }`.\n- Only set `observerModel`, `reflectorModel`, `extractorModel`, or `episodicMemory.reflectorModel` when the user explicitly asks to use a specific model for memory work.\n- 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.\n\n### Episodic Memory\n\n- Enable `memory.episodicMemory` only when the user asks for Episodic Memory, long-term memory, prior conversations, remembered decisions, exact artifacts, or cross-session memory.\n- Before enabling it, call `ask_embedding_credential({ credentialType: \"openAiApi\", purpose: \"OpenAI credential for Episodic Memory embeddings\" })`.\n- 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`.\n- `memory.episodicMemory.credential` is only for OpenAI embeddings. It is separate from optional `extractorModel` and `reflectorModel` worker credentials.\n- If credential selection is skipped, do not enable Episodic Memory; explain that it needs an OpenAI credential for embeddings.\n- Do not add instructions saying the agent should remember, store, save, or decide what context matters. The runtime handles memory extraction and indexing.\n- If instructions mention Episodic Memory, phrase it as retrieval/use only, e.g. \"Use recalled prior context when relevant to the user's request.\"\n- Do not invent Episodic Memory credential IDs or reuse the main model credential unless `ask_embedding_credential` returned it for this purpose.\n\n### Gotchas\n\n- Session memory and Episodic Memory are different features; do not use one as a substitute for the other.\n- Observational memory is runtime-managed session memory behavior; do not add target-agent instructions telling it how to save observations.\n- A skipped Episodic Memory credential means Episodic Memory stays disabled.\n\n### Verify\n\n- Fresh runnable agents have enabled n8n memory unless explicitly disabled.\n- Fresh runnable agents set `observationalMemory.enabled` to `true` unless explicitly disabled.\n- Episodic Memory has an OpenAI credential or `\"managed\"` returned by `ask_embedding_credential`.\n- Existing memory tuning is preserved unless the user asked to change it.";
+export declare const MEMORY_PROMPT = "## Memory Guidance\n\n### Purpose\n\nUse this to configure the target agent's memory behavior.\n\n### Workflow\n\nFresh agents must include this default memory config unless the user explicitly asks to disable or change memory:\n```json\n{\n  \"enabled\": true,\n  \"storage\": \"n8n\",\n  \"observationalMemory\": {\n    \"enabled\": true\n  }\n}\n```\n\nThis is the configurable agent's session memory. The runtime-managed\n`observationalMemory` settings tune that memory behavior; they are not a\nseparate user-facing memory product.\n\nLoad `agent-builder-memory` for Episodic/long-term/cross-session memory,\nobserver/reflector/extractor worker models, threshold/budget tuning, or\ndisabling memory. Do not load it for ordinary fresh-agent creation.\n\n### Rules\n\n- When creating a new agent, always write the exact default `memory` object above.\n- Set `storage` to \"n8n\".\n- Set `observationalMemory.enabled` to `true` for new agents unless the user explicitly asks to disable observational memory.\n- Preserve existing memory tuning unless the user asked to change it.\n\n### Verify\n\n- Fresh runnable agents have enabled n8n memory unless explicitly disabled.\n- Fresh runnable agents set `observationalMemory.enabled` to `true` unless explicitly disabled.";

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

@@ -25,38 +25,19 @@ This is the configurable agent's session memory. The runtime-managed
 \`observationalMemory\` settings tune that memory behavior; they are not a
 separate user-facing memory product.
 
+Load \`agent-builder-memory\` for Episodic/long-term/cross-session memory,
+observer/reflector/extractor worker models, threshold/budget tuning, or
+disabling memory. Do not load it for ordinary fresh-agent creation.
+
 ### Rules
 
 - When creating a new agent, always write the exact default \`memory\` object above.
 - Set \`storage\` to "n8n".
 - Set \`observationalMemory.enabled\` to \`true\` for new agents unless the user explicitly asks to disable observational memory.
-- Keep the rest of \`observationalMemory\` optional; add tuning fields only for explicit tuning or disabling.
-- 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\`, \`extractorModel\`, 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.
-
-### 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" })\`.
-- 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 optional \`extractorModel\` and \`reflectorModel\` worker credentials.
-- 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.
-
-### Gotchas
-
-- Session memory and Episodic Memory are different features; do not use one as a substitute for the other.
-- Observational memory is runtime-managed session memory behavior; do not add target-agent instructions telling it how to save observations.
-- A skipped Episodic Memory credential means Episodic Memory stays disabled.
+- Preserve existing memory tuning unless the user asked to change it.
 
 ### Verify
 
 - Fresh runnable agents have enabled n8n memory unless explicitly disabled.
-- Fresh runnable agents set \`observationalMemory.enabled\` to \`true\` unless explicitly disabled.
-- Episodic Memory has an OpenAI credential or \`"managed"\` returned by \`ask_embedding_credential\`.
-- Existing memory tuning is preserved unless the user asked to change it.`;
+- Fresh runnable agents set \`observationalMemory.enabled\` to \`true\` unless explicitly disabled.`;
 //# sourceMappingURL=memory.prompt.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"memory.prompt.js","sourceRoot":"","sources":["../../../../../src/modules/agents/builder/prompts/memory.prompt.ts"],"names":[],"mappings":";;;AAAa,QAAA,aAAa,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0EAyD6C,CAAC"}
+{"version":3,"file":"memory.prompt.js","sourceRoot":"","sources":["../../../../../src/modules/agents/builder/prompts/memory.prompt.ts"],"names":[],"mappings":";;;AAAa,QAAA,aAAa,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oGAsCuE,CAAC"}

package/dist/modules/agents/builder/prompts/tools.prompt.d.ts

@@ -1 +1 @@
-export declare const TOOLS_PROMPT = "## Tool Guidance\n\n### Purpose\n\nUse this to give the target agent callable capabilities through workflows,\nnodes, custom code tools, or provider tools.\n\n### Workflow\n\nUse this guidance before calling `search_nodes`, `get_node_types`, `build_custom_tool`,\nor adding, changing, or removing entries in `tools[]` / `providerTools`.\n\nCustom tools are for pure computation, validation, formatting, or planning logic;\nthey cannot perform live network, filesystem, process, timer, or host I/O.\n\nIf a product also has a target-agent integration, use node/workflow tools when\nthe product is only an API capability and the conversation or trigger happens\nelsewhere. Use the integration only when that product is the chat/trigger\nsurface or the agent needs the current platform conversation context. For\nexample, use Linear node tools for ordinary issue search/create/update when\nthe agent is triggered from Slack, schedule, Preview, or a workflow; use the\nLinear integration only when people will talk to the agent from Linear\nissues/comments.\n\n#### Workflow Tools\n\n- Call `list_workflows`; reference supported workflows by name with `{ \"type\": \"workflow\", \"workflow\": \"<name>\" }`.\n\n#### Node Tools\n\n- Use `search_nodes`, then `get_node_types`; never guess node type names.\n- Use the tool node id from discovery, usually ending in `Tool`.\n- Put fixed values in `nodeParameters`; use complete n8n expressions for values the agent should decide at runtime:\n  `={{ $fromAI('url', 'The URL to inspect', 'string') }}`.\n- For stable dynamic selectors such as Linear team/teamId, Slack channel, calendar,\n  project, board, database, table, model, or other \"Name or ID\" fields, load skill\n  `agent-builder-resource-locators` and follow it. Do not use `$fromAI` for\n  these fields; resolve them at build time and write the exact returned\n  `parameterValue` into `nodeParameters`.\n- Never write literal `\"$fromAI\"` or bare `$fromAI`; the node will treat it as the actual value.\n- Do not pipe AI-chosen fields through `$json`.\n- Do not include `inputSchema` or `toolDescription` for node tools.\n- For each required credential slot, call `ask_credential` once before config mutation. 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.\n\n#### Custom Tools\n\n- Use `build_custom_tool` with `export default new Tool(...)` and imports only from `@n8n/agents` and `zod`.\n- Do not use custom tools for live website crawling, HTTP fetching, API calls, SEO crawlers, or scraping. Use workflow or node tools for those.\n- The returned `id` is the tool name from the code (e.g. `new Tool(\"my_tool\")` \u2192 id `\"my_tool\"`).\n- Register the returned id in config: `{ \"type\": \"custom\", \"id\": \"<tool name>\" }`.\n- Tool names must be unique per agent and use only letters, digits, and underscores.\n- To update an existing custom tool (fix a bug, change logic, or rename it): call `build_custom_tool` again with the revised code, then update the config.\n- If the tool name changed since the last build: register the new id AND remove the old `{ type: \"custom\", id: \"<old name>\" }` entry from config.\n- Custom handlers are pure functions: take validated `input`, compute, and return a JSON-serializable value. Do not call `.build()`.\n- Follow this pattern:\n```typescript\nimport { Tool } from '@n8n/agents';\nimport { z } from 'zod';\n\nexport default new Tool('tool_name')\n  .description('What the tool does')\n  .input(z.object({ query: z.string() }))\n  .handler(async ({ query }, ctx) => {\n    return { result: query.toUpperCase() };\n  });\n```\n- Custom handlers run in a V8 isolate. No network, filesystem, process, Buffer, fetch, timers, wall-clock waiting, or host I/O.\n- Some globals may exist as stubs: `setTimeout` fires synchronously, `console.log` goes nowhere, and `TextEncoder.encode` returns its input unchanged.\n- Safe globals include `Math`, `Date`, `JSON`, `RegExp`, `Array`, `Object`, `Map`, `Set`, `Promise`, typed arrays, and methods on provided values.\n- The handler receives `(input, ctx)`; `ctx.suspend(payload)` pauses for human-in-the-loop flows. Ignore `ctx` otherwise.\n- Execution is capped at 5 seconds and about 32 MB memory. If runtime fails, fix the code from the returned error and call `build_custom_tool` again.\n\n#### Provider Tools\n\n- Match provider tools to the configured model provider.\n- Anthropic: `providerTools[\"anthropic.web_search\"]`.\n- OpenAI: `providerTools[\"openai.web_search\"]` or `providerTools[\"openai.image_generation\"]`, only for compatible OpenAI models.\n\n### Gotchas\n\n- Web-search fallback services are config, not node tools, unless the user explicitly asks for a node integration.\n- Live crawling, fetching, and API integrations need workflow or node tools, not custom tools.\n- Do not include `inputSchema` or `toolDescription` for node tools.\n- `$fromAI(...)` placeholders define the node tool input schema; do not add it manually.\n- `get_resource_locator_options` response values are builder-time config values. Write\n  `parameterValue` exactly as returned. For resource locators this is an object with\n  `__rl`, `mode`, and `value`; for classic dynamic options it is the raw ID/value.\n- If `get_resource_locator_options` returns `missing_credentials`, call `ask_credential`\n  for one of the returned credential slots and retry. Do not fall back to `$fromAI`\n  for required stable resource IDs.\n- Do not invent node type names, workflow names, credential ids, or provider tool keys.\n- If a required node-tool credential is skipped, add the tool and omit only that credential slot.\n- `build_custom_tool` stores code only; the config still needs a `{ \"type\": \"custom\", \"id\": \"<tool name>\" }` tool ref.\n- When a tool is renamed, update the config to use the new name and remove the old entry.\n\n### Verify\n\n- Workflow tools reference discovered workflow names.\n- Node tools use discovered tool node ids and valid node parameters.\n- Custom tools: returned id equals the tool name; it is registered in config as `{ type: \"custom\", id: \"<tool name>\" }`.\n- Provider tool keys match the configured model provider and the valid key list.";
+export declare const TOOLS_PROMPT = "## Tool Guidance\n\n### Purpose\n\nUse this to give the target agent callable capabilities through MCP servers,\nworkflows, nodes, custom code tools, or provider tools.\n\n### Workflow\n\nUse this guidance before calling `resolve_integration`, `search_nodes`,\n`search_mcp_servers`, `get_node_types`, `build_custom_tool`, or adding,\nchanging, or removing entries in `tools[]` / `mcpServers` / `providerTools`.\n\nFor an external product, first decide whether it is the target agent's chat or\ntrigger surface. Load `agent-builder-integrations` whenever the request could\nmean that the product is where people invoke or converse with the agent.\n\n- Chat/trigger integration: call `list_integration_types`, then\n  `configure_channel` with a returned type. Do not call `resolve_integration`\n  for chat/trigger integrations.\n- Callable external service: the conversation or trigger happens elsewhere and\n  the agent only operates on the product. For each requested non-chat callable\n  service, call `resolve_integration` separately, using `queries` as\n  alternative search terms for that one service. Do not infer MCP availability\n  from memory.\n  - `kind: \"mcp\"`: load `agent-builder-mcp` and follow the MCP credential,\n    verification, and config workflow.\n  - `kind: \"node\"`: load `agent-builder-node-tools`, use the returned node\n    results, and continue with `get_node_types`.\n\nUse `search_nodes` directly only when the user explicitly asks for an n8n node,\nwhen refining node results, or when a verified MCP server lacks the requested\ncapability. Use `search_mcp_servers` directly only when refining MCP results or\nwhen the user explicitly asks to browse the MCP registry.\n\nPreference order for non-chat callable services:\n1. MCP servers selected by `resolve_integration`\n2. Node tools returned by `resolve_integration`\n3. Workflow tools (`list_workflows`)\n4. Custom tools (`build_custom_tool`) \u2014 last resort\n\nCustom tools are for pure computation, validation, formatting, or planning logic;\nthey cannot perform live network, filesystem, process, timer, or host I/O.\n\n#### Workflow Tools\n\n- Call `list_workflows`; reference supported workflows by name with `{ \"type\": \"workflow\", \"workflow\": \"<name>\" }`. Always use the workflow name, never its id.\n\n#### Node Tools\n\nLoad `agent-builder-node-tools` after `resolve_integration` returns\n`kind: \"node\"`, or when the user explicitly requests an n8n node. Follow it\nbefore adding, changing, or removing node-backed tools, `nodeParameters`,\n`$fromAI` usage, or n8n expressions.\n\n#### MCP Servers\n\nLoad `agent-builder-mcp` after `resolve_integration` returns `kind: \"mcp\"`, or\nwhen the user explicitly requests a custom MCP server.\n\n#### Custom Tools\n\nCustom tools are last resort and only for pure computation. Load\n`agent-builder-custom-tools` before calling `build_custom_tool`.\n\n#### Provider Tools\n\n- Match provider tools to the configured model provider.\n- Anthropic: `providerTools[\"anthropic.web_search\"]`.\n- OpenAI: `providerTools[\"openai.web_search\"]` or `providerTools[\"openai.image_generation\"]`, only for compatible OpenAI models.\n\n### Gotchas\n\n- Live crawling, fetching, and API integrations need MCP, workflow, or node tools, not custom tools.\n- Do not invent MCP servers, node type names, workflow names, credential ids, or provider tool keys.\n\n### Verify\n\n- Chat/trigger integrations bypassed `resolve_integration` and were set up\n  through `configure_channel`.\n- Each non-chat callable service was resolved separately through\n  `resolve_integration` unless the user explicitly requested an n8n node or\n  custom MCP server.\n- Workflow tools reference discovered workflow names.\n- Provider tool keys match the configured model provider and the valid key list.";

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

@@ -6,73 +6,66 @@ exports.TOOLS_PROMPT = `\
 
 ### Purpose
 
-Use this to give the target agent callable capabilities through workflows,
-nodes, custom code tools, or provider tools.
+Use this to give the target agent callable capabilities through MCP servers,
+workflows, nodes, custom code tools, or provider tools.
 
 ### Workflow
 
-Use this guidance before calling \`search_nodes\`, \`get_node_types\`, \`build_custom_tool\`,
-or adding, changing, or removing entries in \`tools[]\` / \`providerTools\`.
+Use this guidance before calling \`resolve_integration\`, \`search_nodes\`,
+\`search_mcp_servers\`, \`get_node_types\`, \`build_custom_tool\`, or adding,
+changing, or removing entries in \`tools[]\` / \`mcpServers\` / \`providerTools\`.
+
+For an external product, first decide whether it is the target agent's chat or
+trigger surface. Load \`agent-builder-integrations\` whenever the request could
+mean that the product is where people invoke or converse with the agent.
+
+- Chat/trigger integration: call \`list_integration_types\`, then
+  \`configure_channel\` with a returned type. Do not call \`resolve_integration\`
+  for chat/trigger integrations.
+- Callable external service: the conversation or trigger happens elsewhere and
+  the agent only operates on the product. For each requested non-chat callable
+  service, call \`resolve_integration\` separately, using \`queries\` as
+  alternative search terms for that one service. Do not infer MCP availability
+  from memory.
+  - \`kind: "mcp"\`: load \`agent-builder-mcp\` and follow the MCP credential,
+    verification, and config workflow.
+  - \`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
+capability. Use \`search_mcp_servers\` directly only when refining MCP results or
+when the user explicitly asks to browse the MCP registry.
+
+Preference order for non-chat callable services:
+1. MCP servers selected by \`resolve_integration\`
+2. Node tools returned by \`resolve_integration\`
+3. Workflow tools (\`list_workflows\`)
+4. Custom tools (\`build_custom_tool\`) — last resort
 
 Custom tools are for pure computation, validation, formatting, or planning logic;
 they cannot perform live network, filesystem, process, timer, or host I/O.
 
-If a product also has a target-agent integration, use node/workflow tools when
-the product is only an API capability and the conversation or trigger happens
-elsewhere. Use the integration only when that product is the chat/trigger
-surface or the agent needs the current platform conversation context. For
-example, use Linear node tools for ordinary issue search/create/update when
-the agent is triggered from Slack, schedule, Preview, or a workflow; use the
-Linear integration only when people will talk to the agent from Linear
-issues/comments.
-
 #### Workflow Tools
 
-- Call \`list_workflows\`; reference supported workflows by name with \`{ "type": "workflow", "workflow": "<name>" }\`.
+- Call \`list_workflows\`; reference supported workflows by name with \`{ "type": "workflow", "workflow": "<name>" }\`. Always use the workflow name, never its id.
 
 #### Node Tools
 
-- Use \`search_nodes\`, then \`get_node_types\`; 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 such as Linear team/teamId, Slack channel, calendar,
-  project, board, database, table, model, or other "Name or ID" fields, load skill
-  \`agent-builder-resource-locators\` and follow it. Do not use \`$fromAI\` for
-  these fields; resolve them at build time and write the exact returned
-  \`parameterValue\` into \`nodeParameters\`.
-- 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.
-- For each required credential slot, call \`ask_credential\` once before config mutation. 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.
+Load \`agent-builder-node-tools\` after \`resolve_integration\` returns
+\`kind: "node"\`, or when the user explicitly requests an n8n node. Follow it
+before adding, changing, or removing node-backed tools, \`nodeParameters\`,
+\`$fromAI\` usage, or n8n expressions.
+
+#### MCP Servers
+
+Load \`agent-builder-mcp\` after \`resolve_integration\` returns \`kind: "mcp"\`, or
+when the user explicitly requests a custom MCP server.
 
 #### Custom Tools
 
-- Use \`build_custom_tool\` with \`export default new Tool(...)\` and imports only from \`@n8n/agents\` and \`zod\`.
-- Do not use custom tools for live website crawling, HTTP fetching, API calls, SEO crawlers, or scraping. Use workflow or node tools for those.
-- The returned \`id\` is the tool name from the code (e.g. \`new Tool("my_tool")\` → id \`"my_tool"\`).
-- Register the returned id in config: \`{ "type": "custom", "id": "<tool name>" }\`.
-- Tool names must be unique per agent and use only letters, digits, and underscores.
-- To update an existing custom tool (fix a bug, change logic, or rename it): call \`build_custom_tool\` again with the revised code, then update the config.
-- If the tool name changed since the last build: register the new id AND remove the old \`{ type: "custom", id: "<old name>" }\` entry from config.
-- Custom handlers are pure functions: take validated \`input\`, compute, and return a JSON-serializable value. Do not call \`.build()\`.
-- Follow this pattern:
-\`\`\`typescript
-import { Tool } from '@n8n/agents';
-import { z } from 'zod';
-
-export default new Tool('tool_name')
-  .description('What the tool does')
-  .input(z.object({ query: z.string() }))
-  .handler(async ({ query }, ctx) => {
-    return { result: query.toUpperCase() };
-  });
-\`\`\`
-- Custom handlers run in a V8 isolate. No network, filesystem, process, Buffer, fetch, timers, wall-clock waiting, or host I/O.
-- Some globals may exist as stubs: \`setTimeout\` fires synchronously, \`console.log\` goes nowhere, and \`TextEncoder.encode\` returns its input unchanged.
-- Safe globals include \`Math\`, \`Date\`, \`JSON\`, \`RegExp\`, \`Array\`, \`Object\`, \`Map\`, \`Set\`, \`Promise\`, typed arrays, and methods on provided values.
-- The handler receives \`(input, ctx)\`; \`ctx.suspend(payload)\` pauses for human-in-the-loop flows. Ignore \`ctx\` otherwise.
-- Execution is capped at 5 seconds and about 32 MB memory. If runtime fails, fix the code from the returned error and call \`build_custom_tool\` again.
+Custom tools are last resort and only for pure computation. Load
+\`agent-builder-custom-tools\` before calling \`build_custom_tool\`.
 
 #### Provider Tools
 
@@ -82,25 +75,16 @@ export default new Tool('tool_name')
 
 ### Gotchas
 
-- Web-search fallback services are config, not node tools, unless the user explicitly asks for a node integration.
-- Live crawling, fetching, and API integrations need workflow or node tools, not custom tools.
-- Do not include \`inputSchema\` or \`toolDescription\` for node tools.
-- \`$fromAI(...)\` placeholders define the node tool input schema; do not add it manually.
-- \`get_resource_locator_options\` response values are builder-time config values. Write
-  \`parameterValue\` exactly as returned. For resource locators this is an object with
-  \`__rl\`, \`mode\`, and \`value\`; for classic dynamic options it is the raw ID/value.
-- If \`get_resource_locator_options\` returns \`missing_credentials\`, call \`ask_credential\`
-  for one of the returned credential slots and retry. Do not fall back to \`$fromAI\`
-  for required stable resource IDs.
-- Do not invent node type names, workflow names, credential ids, or provider tool keys.
-- If a required node-tool credential is skipped, add the tool and omit only that credential slot.
-- \`build_custom_tool\` stores code only; the config still needs a \`{ "type": "custom", "id": "<tool name>" }\` tool ref.
-- When a tool is renamed, update the config to use the new name and remove the old entry.
+- Live crawling, fetching, and API integrations need MCP, workflow, or node tools, not custom tools.
+- Do not invent MCP servers, node type names, workflow names, credential ids, or provider tool keys.
 
 ### Verify
 
+- Chat/trigger integrations bypassed \`resolve_integration\` and were set up
+  through \`configure_channel\`.
+- Each non-chat callable service was resolved separately through
+  \`resolve_integration\` unless the user explicitly requested an n8n node or
+  custom MCP server.
 - Workflow tools reference discovered workflow names.
-- Node tools use discovered tool node ids and valid node parameters.
-- Custom tools: returned id equals the tool name; it is registered in config as \`{ type: "custom", id: "<tool name>" }\`.
 - Provider tool keys match the configured model provider and the valid key list.`;
 //# sourceMappingURL=tools.prompt.js.map

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iFAqGqD,CAAC"}
+{"version":3,"file":"tools.prompt.js","sourceRoot":"","sources":["../../../../../src/modules/agents/builder/prompts/tools.prompt.ts"],"names":[],"mappings":";;;AAAa,QAAA,YAAY,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iFAqFqD,CAAC"}

package/dist/modules/agents/builder/resolve-integration.tool.d.ts

@@ -0,0 +1,8 @@
+import type { BuiltTool } from '@n8n/agents';
+import type { McpRegistryService } from '../../../modules/mcp-registry/registry/mcp-registry.service';
+import type { AgentsToolsService } from '../agents-tools.service';
+export interface ResolveIntegrationDeps {
+    mcpRegistryService: McpRegistryService;
+    agentsToolsService: AgentsToolsService;
+}
+export declare function buildResolveIntegrationTool(deps: ResolveIntegrationDeps): BuiltTool;

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

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildResolveIntegrationTool = buildResolveIntegrationTool;
+const tool_1 = require("@n8n/agents/tool");
+const zod_1 = require("zod");
+const builder_tool_names_1 = require("./builder-tool-names");
+const resolveIntegrationInputSchema = zod_1.z.object({
+    queries: zod_1.z
+        .array(zod_1.z.string())
+        .min(1)
+        .describe('External services to resolve (e.g. ["github"], ["slack"])'),
+});
+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 kind: "mcp", load agent-builder-mcp. For kind: "node", load agent-builder-node-tools and use the returned node results.')
+        .input(resolveIntegrationInputSchema)
+        .handler(async ({ queries }) => {
+        const mcpResults = await deps.mcpRegistryService.search(queries);
+        if (mcpResults.length > 0) {
+            return { kind: 'mcp', results: mcpResults };
+        }
+        const nodeResults = await deps.agentsToolsService.searchAgentToolNodes(queries);
+        return {
+            kind: 'node',
+            results: nodeResults.results,
+            queriesWithNoResults: nodeResults.queriesWithNoResults,
+        };
+    })
+        .build();
+}
+//# sourceMappingURL=resolve-integration.tool.js.map

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

@@ -0,0 +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,uWAAuW,CACvW;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/search-mcp-servers.tool.js.map

@@ -1 +1 @@
-{"version":3,"file":"search-mcp-servers.tool.js","sourceRoot":"","sources":["../../../../src/modules/agents/builder/search-mcp-servers.tool.ts"],"names":[],"mappings":";;AAmBA,8DAWC;AA7BD,2CAAwC;AACxC,6BAAwB;AAIxB,6DAAqD;AAMrD,MAAM,2BAA2B,GAAG,OAAC,CAAC,MAAM,CAAC;IAC5C,OAAO,EAAE,OAAC;SACR,KAAK,CAAC,OAAC,CAAC,MAAM,EAAE,CAAC;SACjB,GAAG,CAAC,CAAC,CAAC;SACN,QAAQ,CAAC,8DAA8D,CAAC;CAC1E,CAAC,CAAC;AAEH,SAAgB,yBAAyB,CAAC,IAA0B;IACnE,OAAO,IAAI,WAAI,CAAC,kCAAa,CAAC,kBAAkB,CAAC;SAC/C,WAAW,CACX,8FAA8F;QAC7F,0FAA0F,CAC3F;SACA,KAAK,CAAC,2BAA2B,CAAC;SAClC,OAAO,CAAC,KAAK,EAAE,EAAE,OAAO,EAAyB,EAAE,EAAE;QACrD,OAAO,EAAE,OAAO,EAAE,MAAM,IAAI,CAAC,kBAAkB,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,CAAC;IACnE,CAAC,CAAC;SACD,KAAK,EAAE,CAAC;AACX,CAAC"}
+{"version":3,"file":"search-mcp-servers.tool.js","sourceRoot":"","sources":["../../../../src/modules/agents/builder/search-mcp-servers.tool.ts"],"names":[],"mappings":";;;AACA,2CAAwC;AACxC,6BAAwB;AAIxB,6DAAqD;AAMrD,MAAM,2BAA2B,GAAG,OAAC,CAAC,MAAM,CAAC;IAC5C,OAAO,EAAE,OAAC;SACR,KAAK,CAAC,OAAC,CAAC,MAAM,EAAE,CAAC;SACjB,GAAG,CAAC,CAAC,CAAC;SACN,QAAQ,CAAC,8DAA8D,CAAC;CAC1E,CAAC,CAAC;AAEH,mCAA0C,IAA0B;IACnE,OAAO,IAAI,WAAI,CAAC,kCAAa,CAAC,kBAAkB,CAAC;SAC/C,WAAW,CACX,8FAA8F;QAC7F,0FAA0F,CAC3F;SACA,KAAK,CAAC,2BAA2B,CAAC;SAClC,OAAO,CAAC,KAAK,EAAE,EAAE,OAAO,EAAyB,EAAE,EAAE;QACrD,OAAO,EAAE,OAAO,EAAE,MAAM,IAAI,CAAC,kBAAkB,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,CAAC;IACnE,CAAC,CAAC;SACD,KAAK,EAAE,CAAC;AACX,CAAC"}

package/dist/modules/agents/builder/skill-body-template.js.map

@@ -1 +1 @@
-{"version":3,"file":"skill-body-template.js","sourceRoot":"","sources":["../../../../src/modules/agents/builder/skill-body-template.ts"],"names":[],"mappings":";;;AAgBa,QAAA,sBAAsB,GAClC,+FAA+F;IAC/F,yFAAyF;IACzF,gGAAgG;IAChG,+EAA+E,CAAC;AAGpE,QAAA,sBAAsB,GAClC,+FAA+F;IAC/F,+FAA+F;IAC/F,+FAA+F;IAC/F,iDAAiD,CAAC;AAEtC,QAAA,mBAAmB,GAAG;;;;;;;;;;;;;;;;;yDAiBsB,CAAC;AAG7C,QAAA,mBAAmB,GAAG,GAAG,8BAAsB,OAAO,2BAAmB,EAAE,CAAC"}
+{"version":3,"file":"skill-body-template.js","sourceRoot":"","sources":["../../../../src/modules/agents/builder/skill-body-template.ts"],"names":[],"mappings":";;;AAgBa,QAAA,sBAAsB,GAClC,+FAA+F;IAC/F,yFAAyF;IACzF,gGAAgG;IAChG,+EAA+E,CAAC;AAGpE,QAAA,sBAAsB,GAClC,+FAA+F;IAC/F,+FAA+F;IAC/F,+FAA+F;IAC/F,iDAAiD,CAAC;AAEtC,QAAA,mBAAmB,GAAG;;;;;;;;;;;;;;;;;yDAiBsB,CAAC;AAG7C,QAAA,mBAAmB,GAAG,GAAG,QAAA,sBAAsB,OAAO,QAAA,mBAAmB,EAAE,CAAC"}

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

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

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

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.customToolsSkill = customToolsSkill;
+function customToolsSkill() {
+    return {
+        id: 'agent-builder-custom-tools',
+        name: 'Agent Builder Custom Tools',
+        description: 'Use when building, updating, or registering a pure computation, validation, formatting, or planning tool with build_custom_tool. Not for HTTP, API, crawling, filesystem, or other live integrations — use node or workflow tools for those.',
+        recommendedTools: ['build_custom_tool', 'read_config', 'patch_config'],
+        allowedTools: [
+            'build_custom_tool',
+            'ask_questions',
+            'read_config',
+            'patch_config',
+            'write_config',
+        ],
+        instructions: `\
+## Purpose
+
+Use this to write and register a custom code tool for pure computation logic
+that no node, workflow, or MCP tool covers.
+
+## Workflow
+
+- Use \`build_custom_tool\` with \`export default new Tool(...)\` and imports only from \`@n8n/agents\` and \`zod\`.
+- Do not use custom tools for live website crawling, HTTP fetching, API calls, SEO crawlers, or scraping. Use workflow or node tools for those.
+- The returned \`id\` is the tool name from the code (e.g. \`new Tool("my_tool")\` → id \`"my_tool"\`).
+- Register the returned id in config: \`{ "type": "custom", "id": "<tool name>" }\`.
+- Tool names must be unique per agent and use only letters, digits, and underscores.
+- To update an existing custom tool (fix a bug, change logic, or rename it): call \`build_custom_tool\` again with the revised code, then update the config.
+- If the tool name changed since the last build: register the new id AND remove the old \`{ type: "custom", id: "<old name>" }\` entry from config.
+- Custom handlers are pure functions: take validated \`input\`, compute, and return a JSON-serializable value. Do not call \`.build()\`.
+- Follow this pattern:
+\`\`\`typescript
+import { Tool } from '@n8n/agents';
+import { z } from 'zod';
+
+export default new Tool('tool_name')
+  .description('What the tool does')
+  .input(z.object({ query: z.string() }))
+  .handler(async ({ query }, ctx) => {
+    return { result: query.toUpperCase() };
+  });
+\`\`\`
+- Custom handlers run in a V8 isolate. No network, filesystem, process, Buffer, fetch, timers, wall-clock waiting, or host I/O.
+- Some globals may exist as stubs: \`setTimeout\` fires synchronously, \`console.log\` goes nowhere, and \`TextEncoder.encode\` returns its input unchanged.
+- Safe globals include \`Math\`, \`Date\`, \`JSON\`, \`RegExp\`, \`Array\`, \`Object\`, \`Map\`, \`Set\`, \`Promise\`, typed arrays, and methods on provided values.
+- The handler receives \`(input, ctx)\`; \`ctx.suspend(payload)\` pauses for human-in-the-loop flows. Ignore \`ctx\` otherwise.
+- Execution is capped at 5 seconds and about 32 MB memory. If runtime fails, fix the code from the returned error and call \`build_custom_tool\` again.
+
+## Gotchas
+
+- \`build_custom_tool\` stores code only; the config still needs a \`{ "type": "custom", "id": "<tool name>" }\` tool ref.
+- When a tool is renamed, update the config to use the new name and remove the old entry.
+
+## Verify
+
+- Custom tools: returned id equals the tool name; it is registered in config as \`{ type: "custom", id: "<tool name>" }\`.`,
+    };
+}
+//# sourceMappingURL=custom-tools.skill.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"custom-tools.skill.js","sourceRoot":"","sources":["../../../../../src/modules/agents/builder/skills/custom-tools.skill.ts"],"names":[],"mappings":";;;AAEA;IACC,OAAO;QACN,EAAE,EAAE,4BAA4B;QAChC,IAAI,EAAE,4BAA4B;QAClC,WAAW,EACV,8OAA8O;QAC/O,gBAAgB,EAAE,CAAC,mBAAmB,EAAE,aAAa,EAAE,cAAc,CAAC;QACtE,YAAY,EAAE;YACb,mBAAmB;YACnB,eAAe;YACf,aAAa;YACb,cAAc;YACd,cAAc;SACd;QACD,YAAY,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2HAyC2G;KACzH,CAAC;AACH,CAAC"}

package/dist/modules/agents/builder/skills/index.d.ts

@@ -1,2 +1,2 @@
 import type { RuntimeSkill } from '@n8n/agents';
-export declare function getBuilderRuntimeSkills(excludeTools?: string[]): RuntimeSkill[];
+export declare function getBuilderRuntimeSkills(): RuntimeSkill[];

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

@@ -1,25 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getBuilderRuntimeSkills = getBuilderRuntimeSkills;
-const api_types_1 = require("@n8n/api-types");
+const custom_tools_skill_1 = require("./custom-tools.skill");
 const integrations_skill_1 = require("./integrations.skill");
 const mcp_skill_1 = require("./mcp.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");
 const target_tasks_skill_1 = require("./target-tasks.skill");
-function getBuilderRuntimeSkills(excludeTools = []) {
-    const skills = [
+function getBuilderRuntimeSkills() {
+    return [
+        (0, custom_tools_skill_1.customToolsSkill)(),
         (0, integrations_skill_1.integrationsSkill)(),
         (0, mcp_skill_1.mcpSkill)(),
+        (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)(),
         (0, target_tasks_skill_1.targetTasksSkill)(),
     ];
-    if (excludeTools.includes(api_types_1.CONFIGURE_CHANNEL_TOOL_NAME)) {
-        return skills.filter((skill) => skill.id !== 'agent-builder-integrations');
-    }
-    return skills;
 }
 //# 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":";;AAiBA,0DAmBC;AAnCD,8CAA6D;AAE7D,6DAAyD;AACzD,2CAAuC;AACvC,uEAAkE;AAClE,yDAAoD;AACpD,+DAA0D;AAC1D,6DAAwD;AASxD,SAAgB,uBAAuB,CAAC,eAAyB,EAAE;IAClE,MAAM,MAAM,GAAmB;QAC9B,IAAA,sCAAiB,GAAE;QACnB,IAAA,oBAAQ,GAAE;QACV,IAAA,+CAAqB,GAAE;QACvB,IAAA,iCAAc,GAAE;QAChB,IAAA,uCAAiB,GAAE;QACnB,IAAA,qCAAgB,GAAE;KAKlB,CAAC;IAEF,IAAI,YAAY,CAAC,QAAQ,CAAC,uCAA2B,CAAC,EAAE,CAAC;QACxD,OAAO,MAAM,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,KAAK,4BAA4B,CAAC,CAAC;IAC5E,CAAC;IAED,OAAO,MAAM,CAAC;AACf,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../src/modules/agents/builder/skills/index.ts"],"names":[],"mappings":";;;AAEA,6DAAwD;AACxD,6DAAyD;AACzD,2CAAuC;AACvC,iDAA6C;AAC7C,yDAAoD;AACpD,uEAAkE;AAClE,yDAAoD;AACpD,+DAA0D;AAC1D,6DAAwD;AAExD;IACC,OAAO;QACN,IAAA,qCAAgB,GAAE;QAClB,IAAA,sCAAiB,GAAE;QACnB,IAAA,oBAAQ,GAAE;QACV,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/integrations.skill.js

@@ -5,25 +5,30 @@ function integrationsSkill() {
     return {
         id: 'agent-builder-integrations',
         name: 'Agent Builder Integrations',
-        description: 'Use when deciding whether Slack, Linear, Telegram, or another external platform should be a target-agent chat integration/trigger versus a node tool, and when adding or changing chat integrations; not for built-in Build chat or Preview chat behavior.',
+        description: 'Use when deciding whether Slack, Linear, Telegram, or another external platform should be a target-agent chat integration/trigger versus an MCP, node, or workflow tool, and when adding, changing, or removing chat integrations; not for built-in Build chat or Preview chat behavior.',
         recommendedTools: [
+            'resolve_integration',
             'list_integration_types',
             'configure_channel',
+            'ask_questions',
             'read_config',
             'patch_config',
         ],
         allowedTools: [
+            'resolve_integration',
             'list_integration_types',
             'configure_channel',
+            'ask_questions',
             'read_config',
             'patch_config',
             'write_config',
+            'load_skill',
         ],
         instructions: `\
 ## Purpose
 
 Use this to decide whether the target agent needs an entry in \`integrations\`
-or a normal node/workflow tool for an external product, then configure
+or an MCP, node, or workflow tool for an external product, then configure
 \`integrations\` only when the integration is the right surface.
 
 ## Use when
@@ -33,14 +38,14 @@ or a normal node/workflow tool for an external product, then configure
 - The user asks to connect the target agent to an external chat platform with
   credentials.
 
-## Integration vs Node Tool Decision
+## Integration vs Callable Tool Decision
 
 Use an integration when the product is the agent's conversation or trigger
 surface: humans will mention, message, comment to, or resume the agent there,
 or the agent needs to respond in that same platform conversation context.
 
-Use a node/workflow tool when the product is only something the agent operates
-on: searching records, creating tickets, updating objects, or sending a
+Use an MCP, node, or workflow tool when the product is only something the agent
+operates on: searching records, creating tickets, updating objects, or sending a
 business-process notification while the conversation happens elsewhere.
 
 Examples:
@@ -51,8 +56,9 @@ Examples:
 - Linear integration: the agent should be triggered from Linear issues/comments,
   understand the current Linear subject, or reply in the same Linear
   conversation.
-- Linear node tools: the agent is triggered from Slack, Preview, a task, or a
-  workflow and only needs to search/create/update Linear tickets.
+- Linear callable tools: the agent is triggered from Slack, Preview, a task, or a
+  workflow and only needs to search/create/update Linear tickets via MCP or node
+  tools.
 
 ## Workflow
 
@@ -70,22 +76,53 @@ The \`integrations\` array controls how the target agent is triggered.
   shows creates and persists the credential/connection itself; do not follow up
   with \`patch_config\`/\`write_config\` to write the credential.
 - Preserve existing chat integrations unless the user asked to remove them.
+- To remove an existing chat integration, call \`read_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
+  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.
+
+### Callable External Services
+
+When the product is not a chat/trigger integration, call \`resolve_integration\`
+with queries matching the requested service before loading MCP or node-tool
+skills.
+
+- If it returns \`kind: "mcp"\`, load \`agent-builder-mcp\` and follow the MCP
+  credential, verification, and config workflow.
+- If it returns \`kind: "node"\`, load \`agent-builder-node-tools\`, use the
+  returned node results with \`get_node_types\`, and ask for every required
+  credential.
+- Use workflow tools when the capability should come from an existing workflow
+  instead of a direct MCP or node tool.
 
 ## Gotchas
 
 - Chat integration types must come from \`list_integration_types\`.
-- Do not add a Linear integration just because the agent needs Linear issue
-  CRUD. Use Linear node tools unless Linear itself is the chat/trigger context.
-- For recurring or scheduled runs, create a task (\`create_task\`), not an
+- Do not add a chat integration just because the agent needs CRUD or notifications
+  for that product. Resolve the callable capability through \`resolve_integration\`
+  unless the product itself is the chat/trigger context.
+- For recurring or scheduled runs, create a task (\`create_tasks\`), not an
   integration.
+- Omitting \`integrations\` from a config write preserves the current channels.
+  To remove one, write an explicit filtered array or remove the exact array
+  entry.
 
 ## Verify
 
 - Connected chat integrations were set up through \`configure_channel\`, not
   \`ask_credential\` or a manual config write.
-- The chosen integration matches \`useIntegrationWhen\`; otherwise use node or
+- The chosen integration matches \`useIntegrationWhen\`; otherwise resolve the
+  callable capability through \`resolve_integration\` and use MCP, node, or
   workflow tools.
-- The final \`integrations\` array keeps unrelated integrations intact.`,
+- 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.`,
     };
 }
 //# sourceMappingURL=integrations.skill.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"integrations.skill.js","sourceRoot":"","sources":["../../../../../src/modules/agents/builder/skills/integrations.skill.ts"],"names":[],"mappings":";;AAEA,8CAuFC;AAvFD,SAAgB,iBAAiB;IAChC,OAAO;QACN,EAAE,EAAE,4BAA4B;QAChC,IAAI,EAAE,4BAA4B;QAClC,WAAW,EACV,4PAA4P;QAC7P,gBAAgB,EAAE;YACjB,wBAAwB;YACxB,mBAAmB;YACnB,aAAa;YACb,cAAc;SACd;QACD,YAAY,EAAE;YACb,wBAAwB;YACxB,mBAAmB;YACnB,aAAa;YACb,cAAc;YACd,cAAc;SACd;QACD,YAAY,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wEAkEwD;KACtE,CAAC;AACH,CAAC"}
+{"version":3,"file":"integrations.skill.js","sourceRoot":"","sources":["../../../../../src/modules/agents/builder/skills/integrations.skill.ts"],"names":[],"mappings":";;;AAEA;IACC,OAAO;QACN,EAAE,EAAE,4BAA4B;QAChC,IAAI,EAAE,4BAA4B;QAClC,WAAW,EACV,0RAA0R;QAC3R,gBAAgB,EAAE;YACjB,qBAAqB;YACrB,wBAAwB;YACxB,mBAAmB;YACnB,eAAe;YACf,aAAa;YACb,cAAc;SACd;QACD,YAAY,EAAE;YACb,qBAAqB;YACrB,wBAAwB;YACxB,mBAAmB;YACnB,eAAe;YACf,aAAa;YACb,cAAc;YACd,cAAc;YACd,YAAY;SACZ;QACD,YAAY,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8CAkG8B;KAC5C,CAAC;AACH,CAAC"}