@desplega.ai/agent-swarm 1.173.0 → 2.1.0

package/src/http/apps.ts

@@ -12,6 +12,7 @@ import {
   parseAppDefinition,
   SORTABLE_SYSTEM_DATE_COLUMNS,
   SYSTEM_COLUMN_KINDS,
+  scriptCompatWarnings,
 } from "../apps/definition";
 import {
   type AppRow,
@@ -227,9 +228,14 @@ const AppUserConfigFieldSchema = z.object({
 /** Mirrors an app definition's `userConfig` declaration map. */
 const AppUserConfigSchema = z.record(AppNameSchema, AppUserConfigFieldSchema);
 
+const compatWarningsSchema = z
+  .array(z.string())
+  .optional()
+  .describe("Advisory quickjs-executor compatibility findings for the app's scripts.");
 const appWriteResponseSchema = z.object({
   app: AppRecordSchema,
   migration: AppMigrationReportSchema,
+  warnings: compatWarningsSchema,
 });
 const userConfigBodySchema = z.object({ values: z.record(z.string(), z.unknown()) }).strict();
 
@@ -307,7 +313,10 @@ const createAppRoute = route({
     forceElementBreak: ForceElementBreakSchema.optional(),
   }),
   responses: {
-    201: { description: "Created app", schema: z.object({ app: AppRecordSchema }) },
+    201: {
+      description: "Created app",
+      schema: z.object({ app: AppRecordSchema, warnings: compatWarningsSchema }),
+    },
     400: { description: "Invalid app definition" },
     403: { description: "Permission denied" },
   },
@@ -1020,12 +1029,14 @@ export async function handleApps(
       invalidDefinition(res, definition.issues);
       return true;
     }
+    const warnings = await scriptCompatWarnings(definition.definition);
     createAppRoute.respond(res, 201, {
       app: await createApp({
         name: parsed.body.name,
         description: parsed.body.description,
         definition: definition.definition,
       }),
+      ...(warnings.length > 0 ? { warnings } : {}),
     });
     return true;
   }
@@ -1482,6 +1493,7 @@ export async function handleApps(
     }
     let app: Awaited<ReturnType<typeof updateApp>> = null;
     let migration!: AppMigrationReport;
+    let writtenDefinition: unknown;
     let responseHandled = false;
     try {
       await withAppDefinitionLock(parsed.params.id, async () => {
@@ -1513,6 +1525,7 @@ export async function handleApps(
           responseHandled = true;
           return;
         }
+        if (parsed.body.definition !== undefined) writtenDefinition = definition.definition;
         const migrated = await migrateAppSchema({
           appId: parsed.params.id,
           previousDefinition: existing.definition,
@@ -1553,7 +1566,13 @@ export async function handleApps(
       jsonError(res, "app not found", 404);
       return true;
     }
-    patchAppRoute.respond(res, 200, { app, migration });
+    const warnings =
+      writtenDefinition === undefined ? [] : await scriptCompatWarnings(writtenDefinition);
+    patchAppRoute.respond(res, 200, {
+      app,
+      migration,
+      ...(warnings.length > 0 ? { warnings } : {}),
+    });
     return true;
   }
 
@@ -1568,6 +1587,7 @@ export async function handleApps(
     }
     let app: Awaited<ReturnType<typeof updateApp>> = null;
     let migration!: AppMigrationReport;
+    let writtenDefinition: unknown;
     let responseHandled = false;
     try {
       await withAppDefinitionLock(parsed.params.id, async () => {
@@ -1597,6 +1617,7 @@ export async function handleApps(
           return;
         }
         const nextDefinition = definition ?? existing.definition;
+        writtenDefinition = definition;
         const migrated = await migrateAppSchema({
           appId: parsed.params.id,
           previousDefinition: appDefinitionNeedsRepair(existing) ? undefined : existing.definition,
@@ -1637,7 +1658,13 @@ export async function handleApps(
       jsonError(res, "app not found", 404);
       return true;
     }
-    updateAppRoute.respond(res, 200, { app, migration });
+    const warnings =
+      writtenDefinition === undefined ? [] : await scriptCompatWarnings(writtenDefinition);
+    updateAppRoute.respond(res, 200, {
+      app,
+      migration,
+      ...(warnings.length > 0 ? { warnings } : {}),
+    });
     return true;
   }
 

package/src/http/config.ts

@@ -9,6 +9,7 @@ import {
   getSwarmConfigs,
   maskSecrets,
 } from "../be/db";
+import { modelProfileRefError } from "../be/db/model-profiles";
 import {
   AGENT_MAX_TASKS_CONFIG_KEY,
   resetAgentMaxTasksMirror,
@@ -18,14 +19,16 @@ import { fillOrgLogoFromWebsite } from "../be/org-profile";
 import { getUserGrant } from "../be/rbac-roles";
 import {
   internalConfigKeyError,
+  isApiOnlyConfigKey,
   isInternalConfigKey,
   isReservedConfigKey,
   reservedKeyError,
   validateConfigValue,
+  validateExportToEnv,
 } from "../be/swarm-config-guard";
 import { can, isRbacEnabled, type PermissionVerb } from "../rbac";
 import { SwarmConfigSchema } from "../types";
-import { getRequestAuth } from "../utils/request-auth-context";
+import { getRequestAuth, type HttpRequestAuth } from "../utils/request-auth-context";
 import { registerVolatileSecret } from "../utils/secret-scrubber";
 import { reloadGlobalConfigsAndIntegrations, scheduleIntegrationsReload } from "./core";
 import { route } from "./route-def";
@@ -35,16 +38,9 @@ const MAX_ENV_PRESENCE_KEYS = 200;
 const SECRETS_FORCE_MASK_NOTE =
   " (secret values masked: this token cannot read secrets in this scope)";
 
-// Config keys the API server owns for its own use and must NEVER hand out over
-// HTTP — workers/entrypoints read config to build their env, and the agent-fs
-// bootstrap admin key would let a compromised worker administer the shared org.
-// The API materializes these into its own process.env at boot via
-// getInjectableGlobalConfigs, so no HTTP consumer legitimately needs them.
-const API_ONLY_CONFIG_KEYS = new Set(["API_AGENT_FS_API_KEY", "SLACK_SIGNING_SECRET"]);
-
 function stripApiOnlyKeys<T extends { key: string }>(configs: T[]): T[] {
   return configs.filter(
-    (config) => !API_ONLY_CONFIG_KEYS.has(config.key) && !isInternalConfigKey(config.key),
+    (config) => !isApiOnlyConfigKey(config.key) && !isInternalConfigKey(config.key),
   );
 }
 
@@ -53,6 +49,25 @@ function singleHeader(req: IncomingMessage, name: string): string | undefined {
   return Array.isArray(raw) ? raw[0] : raw;
 }
 
+/**
+ * Whether this caller's `/api/config/resolved` carries secret repo rows (the
+ * `includeRepoSecrets` of {@link resolveSecretsRead}): a runtime-token agent
+ * gets them only with `config.read.secrets`. Claim uses it so an agent's
+ * default profile yields only to repo rows that worker's env really gets.
+ */
+export function readsRepoSecrets(
+  auth: HttpRequestAuth | null,
+  agent: { isLead?: boolean } | null | undefined,
+): boolean {
+  if (auth?.kind !== "agent" || !auth.runtimeId) return true;
+  return can({
+    principal: { kind: "agent", agentId: auth.agentId, isLead: agent?.isLead ?? false },
+    verb: "config.read.secrets",
+    resource: { kind: "none" },
+    source: "http",
+  }).allow;
+}
+
 async function requestSecretReadScope(
   req: IncomingMessage,
   resolvedScope?: { agentId?: string; repoId?: string },
@@ -116,6 +131,28 @@ export async function ensureConfigAdmin(
   req: IncomingMessage,
   res: ServerResponse,
   verb: Extract<PermissionVerb, "config.write.any" | "config.delete.any">,
+): Promise<boolean> {
+  return ensureHttpPermission(
+    req,
+    res,
+    verb,
+    verb === "config.write.any"
+      ? "Writing swarm config requires the lead agent"
+      : "Deleting swarm config requires the lead agent",
+  );
+}
+
+/**
+ * The general form of `ensureConfigAdmin`: operators and users pass, guests
+ * get a plain 403, and an agent principal (session identity first, then the
+ * legacy X-Agent-ID header) must hold `verb`. On denial it writes a 403 with
+ * `forbiddenMessage` and returns false.
+ */
+export async function ensureHttpPermission(
+  req: IncomingMessage,
+  res: ServerResponse,
+  verb: PermissionVerb,
+  forbiddenMessage: string,
 ): Promise<boolean> {
   const auth = getRequestAuth(req);
   if (auth?.kind === "operator" || auth?.kind === "user") return true;
@@ -132,13 +169,7 @@ export async function ensureConfigAdmin(
     source: "http",
   });
   if (!decision.allow) {
-    jsonError(
-      res,
-      verb === "config.write.any"
-        ? "Writing swarm config requires the lead agent"
-        : "Deleting swarm config requires the lead agent",
-      403,
-    );
+    jsonError(res, forbiddenMessage, 403);
     return false;
   }
   return true;
@@ -276,6 +307,12 @@ const upsertConfig = route({
     isSecret: z.boolean().optional(),
     envPath: z.string().nullish(),
     description: z.string().nullish(),
+    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.",
+      ),
   }),
   responses: {
     200: { description: "Config entry upserted", schema: SwarmConfigSchema },
@@ -442,7 +479,7 @@ export async function handleConfig(
     const parsed = await upsertConfig.parse(req, res, pathSegments, queryParams);
     if (!parsed) return true;
     if (!(await ensureConfigAdmin(req, res, "config.write.any"))) return true;
-    const { scope, scopeId, key, value, isSecret, envPath, description } = parsed.body;
+    const { scope, scopeId, key, value, isSecret, envPath, description, exportToEnv } = parsed.body;
 
     if (scope === "global" && scopeId) {
       jsonError(res, "Global scope must not have scopeId", 400);
@@ -464,7 +501,8 @@ export async function handleConfig(
       return true;
     }
 
-    const validationError = validateConfigValue(key, value);
+    const validationError =
+      validateConfigValue(key, value) ?? validateExportToEnv(key, exportToEnv);
     if (validationError) {
       jsonError(res, validationError, 400);
       return true;
@@ -480,6 +518,7 @@ export async function handleConfig(
         isSecret: isSecret || false,
         envPath: envPath || null,
         description: description || null,
+        exportToEnv,
       });
       // Auto-reload integrations when a global-scoped config changes so callers
       // (CLI, automation, dashboard) don't have to remember to hit /reload.
@@ -493,7 +532,11 @@ export async function handleConfig(
       }
       const result = includeSecrets || !config.isSecret ? config : maskSecrets([config])[0]!;
       upsertConfig.respond(res, 200, result);
-    } catch (_error) {
+    } catch (error) {
+      if (modelProfileRefError(error) === "missing") {
+        jsonError(res, `Unknown model profile "${String(value)}"`, 400);
+        return true;
+      }
       jsonError(res, "Failed to upsert config", 500);
     }
     return true;

package/src/http/core.ts

@@ -3,9 +3,11 @@ import { z } from "zod";
 import { initAgentMail, resetAgentMail } from "../agentmail";
 import {
   initAzureDevOps,
+  initAzureDevOpsOutbound,
   isAzureDevOpsEnabled,
   resetAzureDevOps,
   resetAzureDevOpsBotIdCache,
+  teardownAzureDevOpsOutbound,
 } from "../azure-devops";
 import {
   getAgentById,
@@ -29,6 +31,7 @@ import { getUserGrant } from "../be/rbac-roles";
 import { syncTelemetryEnabled } from "../be/telemetry-enable";
 import { initGitHub, resetGitHub } from "../github";
 import { initGitLab, isGitLabEnabled, resetGitLab } from "../gitlab";
+import { restartChatSdkIfConfigChanged } from "../integrations/chat-sdk/runtime";
 import { initJira, resetJira } from "../jira";
 import { initLinear, resetLinear } from "../linear";
 import { can, decideAdmission, isRbacEnabled } from "../rbac";
@@ -234,6 +237,8 @@ async function reloadGlobalConfigsAndIntegrationsInner(): Promise<ReloadConfigRe
   resetAzureDevOpsBotIdCache();
   initAzureDevOps();
   if (isAzureDevOpsEnabled()) integrations.push("azure-devops");
+  teardownAzureDevOpsOutbound();
+  if (isAzureDevOpsEnabled()) initAzureDevOpsOutbound();
 
   resetLinear();
   if (await initLinear()) integrations.push("linear");
@@ -243,6 +248,9 @@ async function reloadGlobalConfigsAndIntegrationsInner(): Promise<ReloadConfigRe
 
   if (await startSlackApp()) integrations.push("slack");
 
+  // After Slack: the Chat SDK Slack clash check reads SLACK_DISABLE.
+  if (await restartChatSdkIfConfigChanged()) integrations.push("chat-sdk");
+
   return {
     configsLoaded: updated.length,
     keysUpdated: updated,

package/src/http/index.ts

@@ -7,7 +7,7 @@ import {
 import type { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 import { getEnabledCapabilities, hasCapability } from "@/server";
 import { initAgentMail } from "../agentmail";
-import { initAzureDevOps } from "../azure-devops";
+import { initAzureDevOps, initAzureDevOpsOutbound } from "../azure-devops";
 import { drainApi, isApiDraining } from "../be/api-drain";
 import {
   closeDb,
@@ -41,6 +41,7 @@ import {
 import { initGitHub } from "../github";
 import { initGitLab } from "../gitlab";
 import { stopHeartbeat } from "../heartbeat";
+import { startChatSdk, stopChatSdk } from "../integrations/chat-sdk/runtime";
 import { initJira } from "../jira";
 import { initLinear } from "../linear";
 import {
@@ -81,7 +82,6 @@ import { handleConfig } from "./config";
 import { handleContext } from "./context";
 import { handleCore, loadGlobalConfigsIntoEnv } from "./core";
 import { handleDbQuery } from "./db-query";
-import { handleEcosystem } from "./ecosystem";
 import { handleEvents } from "./events";
 import { handleExtensions } from "./extensions";
 import { handleFavorites } from "./favorites";
@@ -104,6 +104,7 @@ import { handleMcpServers } from "./mcp-servers";
 import { closeIdleMcpUserTransports, handleMcpUser } from "./mcp-user";
 import { handleMemory, startMemoryGc, stopMemoryGc } from "./memory";
 import { handleMetrics } from "./metrics";
+import { handleModelProfiles } from "./model-profiles";
 import { handleModelsCatalog } from "./models-catalog";
 import { handleOAuthCallback, startOAuthPendingGc, stopOAuthPendingGc } from "./oauth-callback";
 import { handleGenericOAuth } from "./oauth-generic";
@@ -345,7 +346,6 @@ const httpServer = createHttpServer(async (req, res) => {
         () => handleAgentRegister(req, res, pathSegments, myAgentId),
         () => handlePoll(req, res, pathSegments, queryParams, myAgentId),
         () => handleSessionData(req, res, pathSegments, queryParams, myAgentId),
-        () => handleEcosystem(req, res, pathSegments, myAgentId),
         () => handleTrackers(req, res, pathSegments),
         () => handleWebhooks(req, res, pathSegments),
         () => handleAgentsRest(req, res, pathSegments, queryParams, myAgentId),
@@ -377,6 +377,7 @@ const httpServer = createHttpServer(async (req, res) => {
         () => handleDbQuery(req, res, pathSegments, queryParams),
         () => handleMetrics(req, res, pathSegments, queryParams, myAgentId),
         () => handleModelsCatalog(req, res, pathSegments, queryParams),
+        () => handleModelProfiles(req, res, pathSegments, queryParams, myAgentId),
         () => handleRepos(req, res, pathSegments, queryParams, myAgentId),
         () => handleSkills(req, res, pathSegments, queryParams, myAgentId),
         () => handleScriptConnections(req, res, pathSegments, queryParams, myAgentId),
@@ -503,6 +504,9 @@ async function shutdown() {
   // Stop Slack bot
   await stopSlackApp();
 
+  // Stop Chat SDK adapters and drain their background handlers before the DB closes
+  await stopChatSdk();
+
   // Stop OAuth keepalive
   if (process.env.OAUTH_KEEPALIVE_DISABLE !== "true") {
     const { stopOAuthKeepalive } = await import("../oauth/keepalive");
@@ -663,6 +667,13 @@ try {
   console.error("[startup] Failed to seed pricing rows:", err);
 }
 
+try {
+  const { ensureModelProfilesSeeded } = await import("../be/boot-seeds");
+  await ensureModelProfilesSeeded();
+} catch (err) {
+  console.error("[startup] Failed to seed model profiles:", err);
+}
+
 try {
   const { ensureRbacSeeded } = await import("../be/boot-seeds");
   ensureRbacSeeded();
@@ -762,6 +773,16 @@ httpServer
       console.error("[Slack] Failed to start, continuing boot without Slack:", err);
     }
 
+    // Chat SDK channel: never the boot path, so not awaited. Adapter init
+    // makes network calls (Slack's auth.test retries for up to ~30 min), and
+    // the scheduler, heartbeat and supervisor below must start regardless.
+    void startChatSdk().catch((err: unknown) => {
+      console.error(
+        "[chat-sdk] Failed to start, continuing without Chat SDK:",
+        scrubSecrets(err instanceof Error ? err.message : String(err)),
+      );
+    });
+
     // Independent of workers, scheduler targets, and heartbeat agent tasks.
     startQueueStallAlarm();
 
@@ -773,6 +794,7 @@ httpServer
 
     // Initialize Azure DevOps service-hook handler (if configured)
     initAzureDevOps();
+    initAzureDevOpsOutbound();
 
     // Initialize AgentMail webhook handler (if configured)
     initAgentMail();

package/src/http/integrations.ts

@@ -1,9 +1,17 @@
 import type { IncomingMessage, ServerResponse } from "node:http";
 import Anthropic from "@anthropic-ai/sdk";
 import { z } from "zod";
+import {
+  ChatSdkActionError,
+  ChatSdkStatusSchema,
+  getChatSdkStatus,
+  registerTelegramWebhook,
+} from "../integrations/chat-sdk/status";
 import { buildSlackManifest } from "../slack/manifest";
+import { ensureHttpPermission } from "./config";
 import { resolveConfigValue, resolveMcpBaseUrl } from "./config-values";
 import { route } from "./route-def";
+import { jsonError } from "./utils";
 
 // ─── Types ───────────────────────────────────────────────────────────────────
 
@@ -48,6 +56,20 @@ const McpUserConfigSchema = z.object({
 
 const SlackManifestSchema = z.record(z.string(), z.unknown());
 
+const TelegramRegisterWebhookSchema = z.object({
+  webhookUrl: z.string(),
+  webhookInfo: z.looseObject({
+    url: z.string(),
+    has_custom_certificate: z.boolean().optional(),
+    pending_update_count: z.number().optional(),
+    last_error_date: z.number().optional(),
+    last_error_message: z.string().optional(),
+    max_connections: z.number().optional(),
+    ip_address: z.string().optional(),
+    allowed_updates: z.array(z.string()).optional(),
+  }),
+});
+
 // ─── Route Definition ────────────────────────────────────────────────────────
 
 const claudeManagedTestRoute = route({
@@ -94,7 +116,38 @@ const slackManifestRoute = route({
   },
 });
 
-// ─── Helpers ─────────────────────────────────────────────────────────────────
+const chatSdkStatusRoute = route({
+  method: "get",
+  path: "/api/integrations/chat/status",
+  pattern: ["api", "integrations", "chat", "status"],
+  summary:
+    "Chat SDK channel status: enabled flag, Slack clash, per-adapter health and webhook URL.",
+  tags: ["Integrations"],
+  responses: {
+    200: {
+      description:
+        "Per-adapter status. `health` is `disabled` for an adapter that is not running. Never contains secret values.",
+      schema: ChatSdkStatusSchema,
+    },
+  },
+});
+
+const chatSdkTelegramRegisterWebhookRoute = route({
+  method: "post",
+  path: "/api/integrations/chat/telegram/register-webhook",
+  pattern: ["api", "integrations", "chat", "telegram", "register-webhook"],
+  summary:
+    "Register this swarm's public Telegram webhook URL and secret token with the Bot API (setWebhook), then return getWebhookInfo.",
+  tags: ["Integrations"],
+  body: z.object({}).optional(),
+  responses: {
+    200: { description: "Webhook registered", schema: TelegramRegisterWebhookSchema },
+    400: { description: "Telegram is not configured for webhook mode" },
+    403: { description: "Only the lead agent or a dashboard user can register the webhook" },
+    502: { description: "The Telegram Bot API rejected the call" },
+  },
+  rbac: { permission: "integration.chat.manage" },
+});
 
 // ─── Public handler factory ──────────────────────────────────────────────────
 
@@ -122,6 +175,40 @@ export function createIntegrationsHandler(deps: TestConnectionDeps = {}) {
       return true;
     }
 
+    if (chatSdkStatusRoute.match(req.method, pathSegments)) {
+      chatSdkStatusRoute.respond(res, 200, await getChatSdkStatus());
+      return true;
+    }
+
+    if (chatSdkTelegramRegisterWebhookRoute.match(req.method, pathSegments)) {
+      const parsed = await chatSdkTelegramRegisterWebhookRoute.parse(
+        req,
+        res,
+        pathSegments,
+        queryParams,
+      );
+      if (!parsed) return true;
+      // Operators and dashboard users pass; agents need the verb (lead-only
+      // under the legacy policy).
+      if (
+        !(await ensureHttpPermission(
+          req,
+          res,
+          "integration.chat.manage",
+          "Registering the Telegram webhook requires the lead agent",
+        ))
+      ) {
+        return true;
+      }
+      try {
+        chatSdkTelegramRegisterWebhookRoute.respond(res, 200, await registerTelegramWebhook());
+      } catch (error) {
+        if (!(error instanceof ChatSdkActionError)) throw error;
+        jsonError(res, error.message, error.status);
+      }
+      return true;
+    }
+
     if (mcpUserConfigRoute.match(req.method, pathSegments)) {
       const mcpBaseUrl = await resolveMcpBaseUrl();
       mcpUserConfigRoute.respond(res, 200, { mcpBaseUrl, mcpUserUrl: `${mcpBaseUrl}/mcp-user` });

package/src/http/mcp.ts

@@ -7,7 +7,12 @@ import { createServer } from "@/server";
 import { parseEnvFlag } from "@/utils/env-flag";
 import { getRequestAuth } from "@/utils/request-auth-context";
 import { resolveScriptsOnlyMode } from "@/utils/scripts-only-mode";
-import { parseTaskToolManifest, selectTaskTools } from "@/utils/task-tool-manifest";
+import {
+  CHAT_TASK_ONLY_TOOLS,
+  isChatSdkTask,
+  parseTaskToolManifest,
+  selectTaskTools,
+} from "@/utils/task-tool-manifest";
 
 export type McpTransportActivity = Record<string, number>;
 export type McpSessionAgents = Record<string, string>;
@@ -218,18 +223,22 @@ export async function handleMcp(
         true,
       );
       let preloadedTools: string[] = [];
+      const sourceTaskId = headerValue(req.headers["x-source-task-id"]);
+      const sourceTask = sourceTaskId ? await getTaskById(sourceTaskId) : undefined;
+      // A session bound to a non-chat task never sees chat-reply. Without the
+      // header the tool stays, and resolves the agent's current task itself.
+      const excludedTools =
+        sourceTask && !isChatSdkTask(sourceTask) ? [...CHAT_TASK_ONLY_TOOLS] : [];
       if (preloadEnabled) {
-        const taskId = headerValue(req.headers["x-source-task-id"]);
-        const task = taskId ? await getTaskById(taskId) : undefined;
         // Never select a manifest using another agent's task. Session-token
         // identity is also checked above, before any MCP session is created.
-        if (task?.agentId === agentId) {
+        if (sourceTask?.agentId === agentId) {
           const manifestValue =
             configs.find((config) => config.key === "TASK_TOOL_MANIFESTS")?.value ??
             process.env.TASK_TOOL_MANIFESTS ??
             "{}";
           try {
-            preloadedTools = selectTaskTools(parseTaskToolManifest(manifestValue), task);
+            preloadedTools = selectTaskTools(parseTaskToolManifest(manifestValue), sourceTask);
           } catch {
             // An invalid deployment value must not prevent tool discovery.
             // Avoid logging its contents, which may contain misfiled secrets.
@@ -239,6 +248,7 @@ export async function handleMcp(
       }
       const server = await createServer({
         preloadedTools,
+        excludedTools,
         // Agent row, then global row, then deployment env. A blank agent row
         // resolves to "unset" for that agent.
         enabledTools: