@desplega.ai/agent-swarm 1.172.0 → 2.0.0

package/src/tools/chat-reply.ts

@@ -0,0 +1,75 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import * as z from "zod";
+import { getAgentCurrentTask, getTaskById } from "@/be/db";
+import { errorMessage } from "@/integrations/chat-sdk/logger";
+import { ChatAdapterUnavailableError, postChatMessage } from "@/integrations/chat-sdk/outbound";
+import { chatThreadOfContextKey } from "@/tasks/context-key";
+import { createToolRegistrar, swarmToolOutputSchema, toolErr, toolOk } from "@/tools/utils";
+
+export const registerChatReplyTool = (server: McpServer) => {
+  createToolRegistrar(server)(
+    "chat-reply",
+    {
+      title: "Reply in the chat thread of this task",
+      description:
+        "Post a message to the Telegram, Slack, Discord or Teams thread your current task came from. Works only on a task whose contextKey starts with task:chat-sdk:. The task's final output is posted to the thread automatically when the task ends, so use this only for a question to the user or a short progress note on long work. Markdown is supported; long text is split into several messages.",
+      annotations: { openWorldHint: true },
+      inputSchema: z.object({
+        text: z.string().min(1).max(20_000).describe("Markdown text to post to the thread."),
+      }),
+      outputSchema: swarmToolOutputSchema({
+        yourAgentId: z.string().optional(),
+        messageId: z.string().optional(),
+        adapter: z.string().optional(),
+        threadId: z.string().optional(),
+      }),
+    },
+    async ({ text }, requestInfo) => {
+      if (!requestInfo.agentId) return toolErr("Agent ID not found.");
+      const data = { yourAgentId: requestInfo.agentId };
+
+      // The header names the task this session works on; without it, the
+      // agent's current in-progress task.
+      const task = requestInfo.sourceTaskId
+        ? await getTaskById(requestInfo.sourceTaskId)
+        : await getAgentCurrentTask(requestInfo.agentId);
+      if (!task) return toolErr("No current task found for chat-reply.", { data });
+      // Creator is safe: a non-lead agent can only create a chat-bound task under a parent it owns or created.
+      if (task.agentId !== requestInfo.agentId && task.creatorAgentId !== requestInfo.agentId) {
+        return toolErr("You don't have context for this task.", { data });
+      }
+      const thread = chatThreadOfContextKey(task.contextKey);
+      if (!thread) {
+        return toolErr(
+          `Task ${task.id} did not come from a chat thread (no task:chat-sdk contextKey). Use the tool of the channel the task came from.`,
+          { data },
+        );
+      }
+
+      try {
+        const sent = await postChatMessage({
+          adapter: thread.adapter,
+          threadId: thread.threadId,
+          text,
+          taskId: task.id,
+        });
+        return toolOk(`Posted to ${thread.adapter} thread ${sent.threadId}.`, {
+          data: {
+            ...data,
+            messageId: sent.messageIds.at(-1),
+            adapter: sent.adapter,
+            threadId: sent.threadId,
+          },
+        });
+      } catch (error) {
+        const message = errorMessage(error);
+        return toolErr(
+          error instanceof ChatAdapterUnavailableError
+            ? `${message}. The final task output is still posted when the adapter is back.`
+            : `Could not post to the chat thread: ${message}`,
+          { data },
+        );
+      }
+    },
+  );
+};

package/src/tools/create-page.ts

@@ -21,7 +21,8 @@ import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import * as z from "zod";
 import { authorizeAssetKeyWrite } from "@/be/asset-key-auth";
 import { resolveTaskAuditUserId } from "@/be/audit-user";
-import { createPage, getPage, getPageBySlug, getPageVersions, updatePage } from "@/be/db";
+import { createPage, getPage, getPageBySlug, updatePage } from "@/be/db";
+import { getPageEditCounter } from "@/be/db/page-versions";
 import { snapshotPage } from "@/pages/version";
 import { createToolRegistrar, swarmToolOutputSchema, toolErr, toolOk } from "@/tools/utils";
 import { AssetKeySchema, PageAuthModeSchema, PageContentTypeSchema } from "@/types";
@@ -45,17 +46,6 @@ function getAppBaseUrl(): string {
   return getAppUrl();
 }
 
-/**
- * Edit counter for a page — `MAX(page_versions.version) + 1`. Returned to
- * the agent as `version` so they have a monotonic "this page has been
- * edited N times" signal. Mirrors the value returned by
- * `PUT /api/pages/:id` (see src/http/pages.ts:pageEditCounter).
- */
-async function pageEditCounter(pageId: string): Promise<number> {
-  const versions = await getPageVersions(pageId);
-  return versions.length > 0 ? versions[0]!.version + 1 : 1;
-}
-
 export const registerCreatePageTool = (server: McpServer) => {
   createToolRegistrar(server)(
     "create_page",
@@ -217,7 +207,7 @@ export const registerCreatePageTool = (server: McpServer) => {
 
       const apiUrl = `${getApiBaseUrl()}/p/${id}`;
       const appUrl = `${getAppBaseUrl()}/pages/${id}`;
-      const version = await pageEditCounter(id);
+      const version = await getPageEditCounter(id);
 
       return toolOk(`Page "${input.title}" saved (slug=${finalSlug}, version=${version}).`, {
         details: `API: ${apiUrl}\n  App: ${appUrl}`,

package/src/tools/defer-task.ts

@@ -306,6 +306,23 @@ export const registerDeferTaskTool = (server: McpServer) => {
 
       try {
         const committed = await getDbClient().transaction(async () => {
+          // The transaction's write lock makes admission atomic with the INSERT.
+          if (watchedTaskIds.length) {
+            const existing = await getDbClient().get<{ scheduleId: string; parentTaskId: string }>(
+              `SELECT w.scheduleId, s.parentTaskId FROM deferred_task_waits w
+               JOIN scheduled_tasks s ON s.id = w.scheduleId
+               JOIN deferred_task_wait_members m ON m.scheduleId = w.scheduleId
+               WHERE w.status = 'pending' AND s.enabled = 1 AND s.targetAgentId = ?
+                 AND m.taskId IN (${watchedTaskIds.map(() => "?").join(", ")})
+               LIMIT 1`,
+              [agent.id, ...watchedTaskIds],
+            );
+            if (existing) {
+              throw new DeferAbortedError(
+                `Pending watcher ${existing.scheduleId} (task ${existing.parentTaskId}) already watches these tasks for this agent.`,
+              );
+            }
+          }
           const watchedAgentNames: string[] = [];
           for (const watchedId of watchedTaskIds) {
             if (watchedId === taskId)

package/src/tools/model-catalog/index.ts

@@ -1,3 +1,4 @@
+import { openAICompatibleProviderIds } from "@desplega/model-catalog";
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import * as z from "zod";
 import { getAgentById } from "@/be/db";
@@ -86,7 +87,7 @@ export const registerModelCatalogOverlayUpsertTool = (server: McpServer) => {
           .string()
           .min(1)
           .describe(
-            "models.dev provider id: anthropic, openai, openrouter, amazon-bedrock, opencode.",
+            `models.dev provider id: anthropic, openai, openrouter, amazon-bedrock, opencode, ${openAICompatibleProviderIds().join(", ")}.`,
           ),
         modelId: z
           .string()

package/src/tools/register-chat-channel.ts

@@ -0,0 +1,139 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import * as z from "zod";
+import { getAgentById, getWorkflow } from "@/be/db";
+import { CHAT_SDK_ADAPTER_NAMES } from "@/integrations/chat-sdk/config";
+import { errorMessage } from "@/integrations/chat-sdk/logger";
+import {
+  type ChatChannelMapping,
+  chatChannelKey,
+  deleteChatChannelMapping,
+  putChatChannelMapping,
+} from "@/integrations/chat-sdk/router";
+import { can } from "@/rbac";
+import {
+  createToolRegistrar,
+  type RequestInfo,
+  swarmToolOutputSchema,
+  toolErr,
+  toolOk,
+} from "@/tools/utils";
+
+async function canManageChatChannels(requestInfo: RequestInfo): Promise<boolean> {
+  const caller = requestInfo.agentId ? await getAgentById(requestInfo.agentId) : null;
+  return can({
+    principal: {
+      kind: "agent",
+      agentId: requestInfo.agentId ?? "",
+      isLead: caller?.isLead ?? false,
+    },
+    verb: "integration.chat.manage",
+    resource: { kind: "none" },
+    source: "mcp",
+  }).allow;
+}
+
+export const registerRegisterChatChannelTool = (server: McpServer) => {
+  createToolRegistrar(server)(
+    "register-chat-channel",
+    {
+      title: "Route a chat channel to an agent or workflow",
+      annotations: { idempotentHint: true },
+      description:
+        "Lead-only. Route every swarm-addressed message from one Chat SDK channel (a Telegram group, Slack channel, Discord channel or Teams chat) to a fixed agent or workflow instead of the lead. Give exactly one of agentId or workflowId. A swarm#<agentId> token in a message still wins over the mapping. Remove it with unregister-chat-channel.",
+      inputSchema: z.object({
+        adapter: z.enum(CHAT_SDK_ADAPTER_NAMES).describe("Chat SDK adapter name."),
+        channelId: z
+          .string()
+          .min(1)
+          .describe("SDK channel id, such as telegram:-100123 or slack:C123 (prefix optional)."),
+        agentId: z.string().optional().describe("Agent that receives the channel's tasks."),
+        workflowId: z
+          .string()
+          .optional()
+          .describe("Workflow whose webhook trigger receives the channel's messages."),
+        name: z.string().max(200).optional().describe("Display name for the mapping."),
+      }),
+      outputSchema: swarmToolOutputSchema({
+        yourAgentId: z.string().optional(),
+        key: z.string().optional(),
+        mapping: z
+          .looseObject({
+            agentId: z.string().optional(),
+            workflowId: z.string().optional(),
+            name: z.string().optional(),
+            createdAt: z.string().optional(),
+          })
+          .optional(),
+      }),
+    },
+    async ({ adapter, channelId, agentId, workflowId, name }, requestInfo) => {
+      const data = { yourAgentId: requestInfo.agentId };
+      try {
+        if (!(await canManageChatChannels(requestInfo))) {
+          return toolErr("Permission denied. Only the lead can register a chat channel.", {
+            data,
+          });
+        }
+        if (Boolean(agentId) === Boolean(workflowId)) {
+          return toolErr("Give exactly one of agentId or workflowId.", { data });
+        }
+        if (agentId && !(await getAgentById(agentId))) {
+          return toolErr(`Agent ${agentId} not found.`, { data });
+        }
+        if (workflowId && !(await getWorkflow(workflowId))) {
+          return toolErr(`Workflow ${workflowId} not found.`, { data });
+        }
+        const mapping: ChatChannelMapping = {
+          ...(agentId ? { agentId } : {}),
+          ...(workflowId ? { workflowId } : {}),
+          ...(name ? { name } : {}),
+          createdAt: new Date().toISOString(),
+        };
+        const key = await putChatChannelMapping(adapter, channelId, mapping);
+        return toolOk(
+          `Registered chat channel ${key} -> ${workflowId ? `workflow ${workflowId}` : `agent ${agentId}`}.`,
+          { data: { ...data, key, mapping } },
+        );
+      } catch (error) {
+        return toolErr(errorMessage(error), { data });
+      }
+    },
+  );
+};
+
+export const registerUnregisterChatChannelTool = (server: McpServer) => {
+  createToolRegistrar(server)(
+    "unregister-chat-channel",
+    {
+      title: "Remove a chat channel route",
+      annotations: { idempotentHint: true },
+      description:
+        "Lead-only. Remove the channel-to-agent or channel-to-workflow route that register-chat-channel stored. Messages from the channel go back to the default route (thread owner, then the lead).",
+      inputSchema: z.object({
+        adapter: z.enum(CHAT_SDK_ADAPTER_NAMES).describe("Chat SDK adapter name."),
+        channelId: z.string().min(1).describe("SDK channel id (prefix optional)."),
+      }),
+      outputSchema: swarmToolOutputSchema({
+        yourAgentId: z.string().optional(),
+        key: z.string().optional(),
+      }),
+    },
+    async ({ adapter, channelId }, requestInfo) => {
+      const data = { yourAgentId: requestInfo.agentId };
+      try {
+        if (!(await canManageChatChannels(requestInfo))) {
+          return toolErr("Permission denied. Only the lead can unregister a chat channel.", {
+            data,
+          });
+        }
+        const key = chatChannelKey(adapter, channelId);
+        const deleted = await deleteChatChannelMapping(adapter, channelId);
+        return deleted
+          ? toolOk(`Unregistered chat channel ${key}.`, { data: { ...data, key } })
+          : toolErr(`No mapping found for chat channel ${key}.`, { data: { ...data, key } });
+      } catch (error) {
+        return toolErr(errorMessage(error), { data });
+      }
+    },
+  );
+};

package/src/tools/send-task.ts

@@ -378,6 +378,30 @@ export async function sendTaskHandler(
   const effectiveParentTask = effectiveParentTaskId
     ? await getTaskById(effectiveParentTaskId)
     : null;
+  // The child inherits the parent's contextKey (its Slack or chat thread) and requester, and
+  // thread-scoped tools trust that binding. An agent can only build on a parent it owns or
+  // created; otherwise a worker could mint access to a foreign thread.
+  if (ctx.kind === "owner" && creatorAgentId && effectiveParentTask) {
+    const caller = await getAgentById(creatorAgentId);
+    const decision = can({
+      principal: { kind: "agent", agentId: creatorAgentId, isLead: caller?.isLead ?? false },
+      verb: "task.parent.attach",
+      resource: {
+        kind: "task",
+        taskId: effectiveParentTask.id,
+        requestedByUserId: effectiveParentTask.requestedByUserId,
+        creatorAgentId: effectiveParentTask.creatorAgentId,
+        agentId: effectiveParentTask.agentId,
+      },
+      source: "mcp",
+    });
+    if (!decision.allow) {
+      return toolErr(
+        `You don't have context for parent task ${effectiveParentTask.id}. Only its assignee, its creator, or a lead can create a child task under it.`,
+        { data: { yourAgentId: creatorAgentId } },
+      );
+    }
+  }
   if (effectiveParentTask?.routingAffinityInvalid) {
     return toolErr("Cannot continue a task with an invalid routing affinity.", {
       data: { yourAgentId: creatorAgentId },

package/src/tools/skills/skill-get.ts

@@ -1,6 +1,7 @@
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import * as z from "zod";
 import { getSkillById, getSkillByName } from "@/be/db";
+import { resolveSwarmSkillByName } from "@/be/db/skill-name-resolution";
 import { createToolRegistrar, swarmToolOutputSchema, toolErr, toolOk } from "@/tools/utils";
 
 export const registerSkillGetTool = (server: McpServer) => {
@@ -10,7 +11,7 @@ export const registerSkillGetTool = (server: McpServer) => {
       title: "Get Skill",
       annotations: { destructiveHint: false },
       description:
-        "Get full skill content by ID or name. Name resolution checks agent scope first, then swarm, then global.",
+        "Get full skill content by ID or name. Name resolution checks agent scope first, then swarm, then global. In swarm scope the ownerless skill wins, then your own, then the only agent-owned one; when several other agents own that name, it errors with their IDs: pass skillId instead.",
       inputSchema: z.object({
         skillId: z.string().optional().describe("Skill ID"),
         name: z.string().optional().describe("Skill name (resolved with precedence)"),
@@ -29,15 +30,22 @@ export const registerSkillGetTool = (server: McpServer) => {
 
       if (args.skillId) {
         skill = await getSkillById(args.skillId);
-      } else if (args.name && requestInfo.agentId) {
-        // Precedence: agent (personal) → swarm → global
-        skill =
-          (await getSkillByName(args.name, "agent", requestInfo.agentId)) ||
-          (await getSkillByName(args.name, "swarm")) ||
-          (await getSkillByName(args.name, "global"));
       } else if (args.name) {
-        skill =
-          (await getSkillByName(args.name, "swarm")) || (await getSkillByName(args.name, "global"));
+        // Precedence: agent (personal) → swarm → global
+        if (requestInfo.agentId) {
+          skill = await getSkillByName(args.name, "agent", requestInfo.agentId);
+        }
+        if (!skill) {
+          const swarm = await resolveSwarmSkillByName(args.name, requestInfo.agentId);
+          if (swarm.kind === "ambiguous") {
+            return toolErr(
+              `Skill name "${args.name}" matches ${swarm.skillIds.length} swarm skills owned by other agents: ${swarm.skillIds.join(", ")}. Call skill-get with skillId instead.`,
+              { data: { yourAgentId: requestInfo.agentId } },
+            );
+          }
+          if (swarm.kind === "found") skill = await getSkillById(swarm.skillId);
+        }
+        if (!skill) skill = await getSkillByName(args.name, "global");
       }
 
       if (!skill) {

package/src/tools/slack-post.ts

@@ -10,6 +10,7 @@ import { can } from "@/rbac";
 import { getSlackApp } from "@/slack/app";
 import { getTaskLink } from "@/slack/blocks";
 import { withAutoJoin } from "@/slack/channel-join";
+import { externalChannelToolError, getChannelBlockReason } from "@/slack/external-channel";
 import { getAgentDisplayName, getAgentEmoji, markdownToSlack } from "@/slack/responses";
 import { createToolRegistrar, swarmToolOutputSchema, toolErr, toolOk } from "@/tools/utils";
 
@@ -67,6 +68,11 @@ export const registerSlackPostTool = (server: McpServer) => {
         return toolErr("Slack not configured.");
       }
 
+      const blockReason = await getChannelBlockReason(app.client, channelId);
+      if (blockReason) {
+        return toolErr(externalChannelToolError(channelId, blockReason));
+      }
+
       try {
         const slackMessage = markdownToSlack(message);
 

package/src/tools/slack-read.ts

@@ -4,6 +4,7 @@ import { getAgentById, getInboxMessageById, getTaskById } from "@/be/db";
 import { can } from "@/rbac";
 import { getSlackApp } from "@/slack/app";
 import { withAutoJoin } from "@/slack/channel-join";
+import { externalChannelToolError, getChannelBlockReason } from "@/slack/external-channel";
 import { downloadFile, type SlackFile } from "@/slack/files";
 import { attachableTask, attachSlackFilesForAgent } from "@/slack/inbound-files";
 import { extractSlackMessageText } from "@/slack/message-text";
@@ -154,6 +155,13 @@ export const registerSlackReadTool = (server: McpServer) => {
         return toolErr("Slack not configured.", { data: { messages: [] } });
       }
 
+      const blockReason = await getChannelBlockReason(app.client, slackChannelId);
+      if (blockReason) {
+        return toolErr(externalChannelToolError(slackChannelId, blockReason), {
+          data: { messages: [] },
+        });
+      }
+
       try {
         const client = app.client;
 

package/src/tools/slack-reply.ts

@@ -13,6 +13,7 @@ import { getTaskCitations } from "@/be/task-citations";
 import { getSlackApp } from "@/slack/app";
 import { buildCaptionBlock, getTaskLink, getTaskUrl } from "@/slack/blocks";
 import { withAutoJoin } from "@/slack/channel-join";
+import { externalChannelToolError, getChannelBlockReason } from "@/slack/external-channel";
 import { getAgentDisplayName, getAgentEmoji, markdownToSlack } from "@/slack/responses";
 import { createToolRegistrar, swarmToolOutputSchema, toolErr, toolOk } from "@/tools/utils";
 import {
@@ -110,6 +111,11 @@ export const registerSlackReplyTool = (server: McpServer) => {
         return toolErr("Slack not configured.");
       }
 
+      const blockReason = await getChannelBlockReason(app.client, slackChannelId);
+      if (blockReason) {
+        return toolErr(externalChannelToolError(slackChannelId, blockReason));
+      }
+
       try {
         const citations = taskId ? await getTaskCitations(taskId) : [];
         // Sources go in a caption under the reply, never in the body or the

package/src/tools/slack-start-thread.ts

@@ -4,6 +4,7 @@ import { getAgentById, getTaskById, recordSlackMessage } from "@/be/db";
 import { can } from "@/rbac";
 import { getSlackApp } from "@/slack/app";
 import { withAutoJoin } from "@/slack/channel-join";
+import { externalChannelToolError, getChannelBlockReason } from "@/slack/external-channel";
 import { getAgentDisplayName, getAgentEmoji, markdownToSlack } from "@/slack/responses";
 import { createToolRegistrar, swarmToolOutputSchema, toolErr, toolOk } from "@/tools/utils";
 
@@ -56,6 +57,11 @@ export const registerSlackStartThreadTool = (server: McpServer) => {
         return toolErr("Slack not configured.");
       }
 
+      const blockReason = await getChannelBlockReason(app.client, channelId);
+      if (blockReason) {
+        return toolErr(externalChannelToolError(channelId, blockReason));
+      }
+
       try {
         const slackMessage = markdownToSlack(message);
         const messageBlocks = blocks ?? [

package/src/tools/slack-update.ts

@@ -4,6 +4,7 @@ import * as z from "zod";
 import { getAgentById } from "@/be/db";
 import { can } from "@/rbac";
 import { getSlackApp } from "@/slack/app";
+import { externalChannelToolError, getChannelBlockReason } from "@/slack/external-channel";
 import { parseSlackTs } from "@/slack/message-text";
 import { markdownToSlack } from "@/slack/responses";
 import { createToolRegistrar, swarmToolOutputSchema, toolErr, toolOk } from "@/tools/utils";
@@ -61,6 +62,11 @@ export const registerSlackUpdateTool = (server: McpServer) => {
         return toolErr("Slack not configured.");
       }
 
+      const blockReason = await getChannelBlockReason(app.client, channelId);
+      if (blockReason) {
+        return toolErr(externalChannelToolError(channelId, blockReason));
+      }
+
       try {
         const ts = parseSlackTs(messageTs);
         const slackMessage = markdownToSlack(message);

package/src/tools/slack-upload-file.ts

@@ -3,6 +3,7 @@ import * as z from "zod";
 import { getAgentById, getInboxMessageById, getTaskById } from "@/be/db";
 import { can } from "@/rbac";
 import { getSlackApp } from "@/slack/app";
+import { externalChannelToolError, getChannelBlockReason } from "@/slack/external-channel";
 import { MAX_FILE_SIZE, uploadFile } from "@/slack/files";
 import { createToolRegistrar, swarmToolOutputSchema, toolErr, toolOk } from "@/tools/utils";
 
@@ -223,6 +224,11 @@ export const registerSlackUploadFileTool = (server: McpServer) => {
         return toolErr("Slack not configured.");
       }
 
+      const blockReason = await getChannelBlockReason(app.client, slackChannelId);
+      if (blockReason) {
+        return toolErr(externalChannelToolError(slackChannelId, blockReason));
+      }
+
       // Validate: must provide either filePath OR content (not both, not neither)
       if (!filePath && !content) {
         return toolErr("Must provide either filePath or content (base64).");

package/src/tools/swarm-config/get-config.ts

@@ -19,6 +19,7 @@ const configEntryShape = z.looseObject({
   createdAt: z.string().optional(),
   lastUpdatedAt: z.string().optional(),
   encrypted: z.boolean().optional(),
+  exportToEnv: z.boolean().optional(),
 });
 
 export const registerGetConfigTool = (server: McpServer) => {
@@ -110,7 +111,7 @@ export const registerGetConfigTool = (server: McpServer) => {
             : result
                 .map(
                   (c) =>
-                    `- ${c.key}=${c.isSecret && !effectiveIncludeSecrets ? "********" : c.value} (scope: ${c.scope}${c.scopeId ? `, scopeId: ${c.scopeId}` : ""})`,
+                    `- ${c.key}=${c.isSecret && !effectiveIncludeSecrets ? "********" : c.value} (scope: ${c.scope}${c.scopeId ? `, scopeId: ${c.scopeId}` : ""}${c.exportToEnv ? "" : ", not in agent env"})`,
                 )
                 .join("\n");
 

package/src/tools/swarm-config/list-config.ts

@@ -19,6 +19,7 @@ const configEntryShape = z.looseObject({
   createdAt: z.string().optional(),
   lastUpdatedAt: z.string().optional(),
   encrypted: z.boolean().optional(),
+  exportToEnv: z.boolean().optional(),
 });
 
 export const registerListConfigTool = (server: McpServer) => {
@@ -102,7 +103,7 @@ export const registerListConfigTool = (server: McpServer) => {
             : result
                 .map(
                   (c) =>
-                    `- [${c.scope}${c.scopeId ? `:${c.scopeId}` : ""}] ${c.key}=${c.isSecret && !effectiveIncludeSecrets ? "********" : c.value}${c.description ? ` — ${c.description}` : ""}`,
+                    `- [${c.scope}${c.scopeId ? `:${c.scopeId}` : ""}] ${c.key}=${c.isSecret && !effectiveIncludeSecrets ? "********" : c.value}${c.exportToEnv ? "" : " [not in agent env]"}${c.description ? ` — ${c.description}` : ""}`,
                 )
                 .join("\n");
 

package/src/tools/swarm-config/set-config.ts

@@ -8,6 +8,7 @@ import {
   isReservedConfigKey,
   reservedKeyError,
   validateConfigValue,
+  validateExportToEnv,
 } from "@/be/swarm-config-guard";
 import { scheduleIntegrationsReload } from "@/http/core";
 import { can } from "@/rbac";
@@ -26,6 +27,7 @@ const configEntryShape = z.looseObject({
   createdAt: z.string().optional(),
   lastUpdatedAt: z.string().optional(),
   encrypted: z.boolean().optional(),
+  exportToEnv: z.boolean().optional(),
 });
 
 export const registerSetConfigTool = (server: McpServer) => {
@@ -34,7 +36,7 @@ export const registerSetConfigTool = (server: McpServer) => {
     {
       title: "Set Config",
       description:
-        "Set or update a swarm configuration value. Upserts by (scope, scopeId, key). Use scope='global' for server-wide settings, 'agent' for agent-specific, or 'repo' for repo-specific. Set isSecret=true to mask the value in API responses.",
+        "Set or update a swarm configuration value. Upserts by (scope, scopeId, key). Use scope='global' for server-wide settings, 'agent' for agent-specific, or 'repo' for repo-specific. Set isSecret=true to mask the value in API responses. Set exportToEnv=false to keep the row out of agent process env (agents then reach it through a connection or script credential binding).",
       annotations: { idempotentHint: true },
 
       inputSchema: z.object({
@@ -63,13 +65,22 @@ export const registerSetConfigTool = (server: McpServer) => {
           .string()
           .optional()
           .describe("Optional human-readable description of this config entry."),
+        exportToEnv: z
+          .boolean()
+          .optional()
+          .describe(
+            "Export this row into agent process env (default true on create, false for a few server-side secrets; omitted on update keeps the stored flag). Rejected as true for keys only the API server reads.",
+          ),
       }),
       outputSchema: swarmToolOutputSchema({
         yourAgentId: z.string().optional(),
         config: configEntryShape.optional(),
       }),
     },
-    async ({ scope, scopeId, key, value, isSecret, envPath, description }, requestInfo) => {
+    async (
+      { scope, scopeId, key, value, isSecret, envPath, description, exportToEnv },
+      requestInfo,
+    ) => {
       if (!requestInfo.agentId) {
         return toolErr('Agent ID not found. Set the "X-Agent-ID" header.');
       }
@@ -114,7 +125,8 @@ export const registerSetConfigTool = (server: McpServer) => {
           });
         }
 
-        const validationError = validateConfigValue(key, value);
+        const validationError =
+          validateConfigValue(key, value) ?? validateExportToEnv(key, exportToEnv);
         if (validationError) {
           return toolErr(validationError, { data: { yourAgentId: requestInfo.agentId } });
         }
@@ -127,6 +139,7 @@ export const registerSetConfigTool = (server: McpServer) => {
           isSecret,
           envPath,
           description,
+          exportToEnv,
         });
 
         if (scope === "global") {

package/src/tools/tool-config.ts

@@ -72,12 +72,6 @@ export const DEFERRED_TOOLS = new Set([
   "retry-workflow-run",
   "cancel-workflow-run",
 
-  // Services (4)
-  "register-service",
-  "unregister-service",
-  "list-services",
-  "update-service-status",
-
   // Config (7)
   "set-config",
   "list-config",
@@ -127,6 +121,14 @@ export const DEFERRED_TOOLS = new Set([
   "send-whatsapp-message",
   "reply-whatsapp-message",
 
+  // Chat SDK (6)
+  "chat-reply",
+  "chat-post",
+  "chat-open-dm",
+  "chat-read-thread",
+  "register-chat-channel",
+  "unregister-chat-channel",
+
   // Tracker (7)
   "tracker-status",
   "get-oauth-access-token",