@desplega.ai/agent-swarm 1.173.0 → 2.0.0

package/src/server.ts

@@ -6,6 +6,7 @@ import { startPricingRefreshLoop } from "./be/pricing-refresh";
 import { isSteeringEnabled } from "./be/steering";
 import { registerGithubTaskReactions } from "./github/task-reactions";
 import { loadGlobalConfigsIntoEnv } from "./http/core";
+import { isChatSdkEnabled } from "./integrations/chat-sdk/config";
 import { resolveTemplate } from "./prompts/resolver";
 import { isRbacEnabled } from "./rbac";
 import { getSlackConfiguration } from "./slack/config";
@@ -21,6 +22,10 @@ import { registerAppSyncTool } from "./tools/app-sync";
 import { registerAppUpsertTool } from "./tools/app-upsert";
 import { registerCancelApprovalRequestTool } from "./tools/cancel-approval-request";
 import { registerCancelTaskTool } from "./tools/cancel-task";
+import { registerChatOpenDmTool } from "./tools/chat-open-dm";
+import { registerChatPostTool } from "./tools/chat-post";
+import { registerChatReadThreadTool } from "./tools/chat-read-thread";
+import { registerChatReplyTool } from "./tools/chat-reply";
 import { registerContextDiffTool } from "./tools/context-diff";
 import { registerContextHistoryTool } from "./tools/context-history";
 import { registerCreateChannelTool } from "./tools/create-channel";
@@ -54,7 +59,6 @@ import {
 } from "./tools/kv";
 // Messaging capability
 import { registerListChannelsTool } from "./tools/list-channels";
-import { registerListServicesTool } from "./tools/list-services";
 import { registerManageUserTool } from "./tools/manage-user";
 // MCP Servers capability
 import {
@@ -91,12 +95,15 @@ import {
 } from "./tools/prompt-templates";
 import { registerReadMessagesTool } from "./tools/read-messages";
 import { registerRegisterAgentmailInboxTool } from "./tools/register-agentmail-inbox";
+import {
+  registerRegisterChatChannelTool,
+  registerUnregisterChatChannelTool,
+} from "./tools/register-chat-channel";
 import {
   registerRegisterKapsoNumberTool,
   registerUnregisterKapsoNumberTool,
 } from "./tools/register-kapso-number";
 // Services capability
-import { registerRegisterServiceTool } from "./tools/register-service";
 // Repo management tools
 import { registerGetReposTool, registerUpdateRepoTool } from "./tools/repos";
 import { registerRequestHumanInputTool } from "./tools/request-human-input";
@@ -178,10 +185,8 @@ import {
   registerTrackerSyncStatusTool,
   registerTrackerUnlinkTool,
 } from "./tools/tracker";
-import { registerUnregisterServiceTool } from "./tools/unregister-service";
 // Profiles capability
 import { registerUpdateProfileTool } from "./tools/update-profile";
-import { registerUpdateServiceStatusTool } from "./tools/update-service-status";
 import { setPreloadedTools } from "./tools/utils";
 import {
   registerReplyWhatsappMessageTool,
@@ -216,7 +221,6 @@ export const ALL_CAPABILITIES = [
   "prompt-templates",
   "mcp",
   "profiles",
-  "services",
   "scheduling",
   "memory",
   "workflows",
@@ -230,6 +234,7 @@ export const ALL_CAPABILITIES = [
   "repo",
   "agentmail",
   "kapso",
+  "chat-sdk",
   "swarm-x",
 ] as const;
 
@@ -256,12 +261,12 @@ const DEFAULT_CAPABILITIES: string = [
   //
   // Disabled by default
   //
-  // "services",
   // "prompt-templates",
   // "messaging",
   // "swarm-x",
   // "agentmail",
   // "kapso",
+  // "chat-sdk", (added by getEnabledCapabilities when CHAT_SDK_ENABLED is true)
 ].join(",");
 
 // Note: unknown names are kept (they never match hasCapability); workers
@@ -280,11 +285,22 @@ export function hasCapability(cap: CAPABILITIES_T): boolean {
   return getCapabilities().has(cap);
 }
 
+const KNOWN_CAPABILITIES: ReadonlySet<string> = new Set(ALL_CAPABILITIES);
+
 export function getEnabledCapabilities(): CAPABILITIES_T[] {
-  const capabilities = Array.from(getCapabilities());
+  // Only known flags: the register response validates against ALL_CAPABILITIES,
+  // so a retired name still listed in CAPABILITIES (e.g. `services`) would
+  // otherwise turn every agent registration into a 500.
+  const capabilities: CAPABILITIES_T[] = Array.from(getCapabilities()).filter(
+    (capability) => KNOWN_CAPABILITIES.has(capability) && capability !== "chat-sdk",
+  );
+  // The Chat SDK channel follows CHAT_SDK_ENABLED, not the CAPABILITIES list.
+  if (isChatSdkEnabled()) capabilities.push("chat-sdk");
   // Phase 1 has no HTTP receiver. Do not advertise usable Slack tools to
-  // workers when HTTP (or an invalid transport) was selected.
-  return getSlackConfiguration().mode === "socket"
+  // workers when HTTP (or an invalid transport) was selected, or when the
+  // built-in Slack app is off (SLACK_DISABLE, required by the Chat SDK Slack adapter).
+  const slack = getSlackConfiguration();
+  return slack.mode === "socket" && !slack.disabled
     ? capabilities
     : capabilities.filter((capability) => capability !== "slack");
 }
@@ -344,6 +360,13 @@ function applyToolAllowlist(server: McpServer, allowlist: readonly string[]): vo
   }
 }
 
+function removeTools(server: McpServer, names: readonly string[]): void {
+  // oxlint-disable-next-line anti-slop/no-chained-type-assertions -- the MCP SDK keeps its tool registry private.
+  const tools = (server as unknown as { _registeredTools: Record<string, { remove(): void }> })
+    ._registeredTools;
+  for (const name of names) tools[name]?.remove();
+}
+
 export async function createServer(
   opts: {
     scriptsOnly?: boolean;
@@ -351,6 +374,8 @@ export async function createServer(
     preloadedTools?: readonly string[];
     /** Raw SWARM_ENABLED_TOOLS value for this session; defaults to the env. */
     enabledTools?: string;
+    /** Tool names removed from this session after registration (task-context filters). */
+    excludedTools?: readonly string[];
   } = {},
 ) {
   // Reload env
@@ -368,8 +393,12 @@ export async function createServer(
   // fullSurface to register every tool group regardless of CAPABILITIES.
   // An allowlist also registers every group, then prunes to the listed names.
   // This shadows the module-level hasCapability for the registrations below.
+  // `chat-sdk` follows CHAT_SDK_ENABLED (as in getEnabledCapabilities), not
+  // the CAPABILITIES list.
   const hasCapability = (cap: CAPABILITIES_T): boolean =>
-    opts.fullSurface === true || toolAllowlist !== undefined || getCapabilities().has(cap);
+    opts.fullSurface === true ||
+    toolAllowlist !== undefined ||
+    (cap === "chat-sdk" ? isChatSdkEnabled() : getCapabilities().has(cap));
 
   // Initialize database with WAL mode
   // Uses DATABASE_PATH env var for Docker volume compatibility (WAL needs .sqlite, .sqlite-wal, .sqlite-shm on same filesystem)
@@ -677,6 +706,16 @@ export async function createServer(
     registerReplyWhatsappMessageTool(server);
   }
 
+  // Chat SDK capability - Telegram/Slack/Discord/Teams through the Chat SDK channel (reply, post, DM, read, channel routes)
+  if (hasCapability("chat-sdk")) {
+    registerChatReplyTool(server);
+    registerChatPostTool(server);
+    registerChatOpenDmTool(server);
+    registerChatReadThreadTool(server);
+    registerRegisterChatChannelTool(server);
+    registerUnregisterChatChannelTool(server);
+  }
+
   // Swarm-x capability - external command routes mirroring the `agent-swarm x ...` CLI surface
   if (hasCapability("swarm-x")) {
     registerSwarmXTool(server);
@@ -693,15 +732,10 @@ export async function createServer(
     registerDeleteChannelTool(server);
   }
 
-  // Services capability - PM2/background service registry
-  if (hasCapability("services")) {
-    registerRegisterServiceTool(server);
-    registerUnregisterServiceTool(server);
-    registerListServicesTool(server);
-    registerUpdateServiceStatusTool(server);
-  }
-
   if (toolAllowlist) applyToolAllowlist(server, toolAllowlist);
+  if (opts.fullSurface !== true && opts.excludedTools?.length) {
+    removeTools(server, opts.excludedTools);
+  }
 
   return server;
 }

package/src/slack/event-dedup.ts

@@ -18,7 +18,7 @@
  * safe-but-tight bound.
  *
  * Single-pod-only. The API server (which owns the Slack socket) runs as a
- * single PM2 process; if that ever changes, swap this for a DB-backed table.
+ * single API process; if that ever changes, swap this for a DB-backed table.
  */
 
 const DEFAULT_TTL_MS = 300_000; // 5 minutes

package/src/tasks/additive-buffer.ts

@@ -22,8 +22,10 @@
  *     the underlying context becomes irrelevant — e.g. user cancels).
  *
  * Concurrency: single-process, single-event-loop. No cross-instance locking.
- * Flush callbacks run sequentially per key (the buffer is cleared BEFORE the
- * callback fires, so re-enqueues during `onFlush` create a fresh buffer).
+ * The buffer is cleared BEFORE the callback fires, so re-enqueues during
+ * `onFlush` create a fresh buffer, and its flush can start while the earlier
+ * `onFlush` for the same key still runs. A caller that needs per-key order
+ * must serialize inside `onFlush`.
  */
 
 export type BufferFlushReason = "timer" | "manual";

package/src/tasks/context-key.ts

@@ -14,6 +14,9 @@
  * Key schema:
  *   task:slack:{channelId}:{threadTs}
  *   task:agentmail:{threadId}
+ *   task:chat-sdk:{adapter}:{encodeURIComponent(platformThreadId)}
+ *                                                 (Chat SDK thread ids carry `:`, so the
+ *                                                  part after the adapter is URI-encoded)
  *   task:trackers:github:{owner}:{repo}:{issue|pr}:{number}
  *   task:trackers:gitlab:{projectId}:{mr|issue}:{iid}
  *   task:trackers:azure-devops:{repositoryId}:pr:{pullRequestId}
@@ -39,13 +42,20 @@
 
 const SEPARATOR = ":";
 
-export type ContextKeyFamily = "slack" | "agentmail" | "trackers" | "schedule" | "workflow";
+export type ContextKeyFamily =
+  | "slack"
+  | "agentmail"
+  | "chat-sdk"
+  | "trackers"
+  | "schedule"
+  | "workflow";
 
 export type TrackerProvider = "github" | "gitlab" | "azure-devops" | "linear" | "jira";
 
 export type ParsedContextKey =
   | { family: "slack"; parts: { channelId: string; threadTs: string } }
   | { family: "agentmail"; parts: { threadId: string } }
+  | { family: "chat-sdk"; parts: { adapter: string; threadId: string } }
   | {
       family: "trackers";
       subFamily: "github";
@@ -101,6 +111,42 @@ export function slackContextKey(input: { channelId: string; threadTs: string }):
   return ["task", "slack", channelId, threadTs].join(SEPARATOR);
 }
 
+/**
+ * Chat SDK thread ids are `<adapter>:<platform id>` and the platform id itself
+ * may contain `:` (Telegram `telegram:<chatId>:<topicId>`, Slack
+ * `slack:<channel>:<ts>`). The adapter stays a plain key part; the rest is
+ * URI-encoded so the key keeps a fixed part count. `parseContextKey` returns
+ * the original thread id in `parts.threadId`.
+ */
+export function chatSdkContextKey(threadId: string): string {
+  const raw = typeof threadId === "string" ? threadId : "";
+  const separatorIndex = raw.indexOf(SEPARATOR);
+  if (separatorIndex <= 0 || separatorIndex === raw.length - 1) {
+    throw new Error(
+      `context-key: chat-sdk thread id must be "<adapter>:<id>" (got ${JSON.stringify(threadId)})`,
+    );
+  }
+  const adapter = assertSafePart(raw.slice(0, separatorIndex), "adapter");
+  const rest = encodeURIComponent(raw.slice(separatorIndex + 1));
+  return ["task", "chat-sdk", adapter, rest].join(SEPARATOR);
+}
+
+/**
+ * The Chat SDK thread a contextKey points at, or null when the key is missing,
+ * malformed, or of another family. Never throws.
+ */
+export function chatThreadOfContextKey(
+  key: string | null | undefined,
+): { adapter: string; threadId: string } | null {
+  if (!key) return null;
+  try {
+    const parsed = parseContextKey(key);
+    return parsed.family === "chat-sdk" ? parsed.parts : null;
+  } catch {
+    return null;
+  }
+}
+
 export function agentmailContextKey(input: { threadId: string }): string {
   const threadId = assertSafePart(input.threadId, "threadId");
   return ["task", "agentmail", threadId].join(SEPARATOR);
@@ -255,6 +301,19 @@ export function parseContextKey(key: string): ParsedContextKey {
       }
       return { family: "agentmail", parts: { threadId: parts[2] as string } };
     }
+    case "chat-sdk": {
+      if (parts.length !== 4 || !parts[2] || !parts[3]) {
+        throw new Error(`context-key: malformed chat-sdk key: ${JSON.stringify(key)}`);
+      }
+      const adapter = parts[2];
+      let rest: string;
+      try {
+        rest = decodeURIComponent(parts[3]);
+      } catch {
+        throw new Error(`context-key: malformed chat-sdk key: ${JSON.stringify(key)}`);
+      }
+      return { family: "chat-sdk", parts: { adapter, threadId: `${adapter}:${rest}` } };
+    }
     case "schedule": {
       if (parts.length !== 3) {
         throw new Error(`context-key: malformed schedule key: ${JSON.stringify(key)}`);

package/src/tasks/model-pin.ts

@@ -0,0 +1,67 @@
+import type { AgentTask } from "../types";
+
+/** Missing fields read as unset, so a bare `{ model }` is its own pin. */
+export type TaskModelPinFields = {
+  [K in
+    | "model"
+    | "modelSource"
+    | "modelAlias"
+    | "modelTier"
+    | "resolvedModel"
+    | "claudeSessionId"]?: AgentTask[K] | null;
+};
+
+/**
+ * The task's own `model` pin, or undefined when the task has none.
+ *
+ * `agent_tasks.model` is not always the creator's pin: the worker reports the
+ * model it actually ran on `PUT /api/tasks/{id}/session`, which overwrites the
+ * column. So the pin is read from the claim-time record instead:
+ *   - `modelSource = "model"`: the task's own `model` won at claim. A `latest:`
+ *     alias survives only in `modelAlias` (the session report replaced `model`
+ *     with the concrete id), so the alias is the pin.
+ *   - `modelSource = "fallback:cli-unsupported:model"`: the task's own
+ *     `latest:` alias won, then the claiming CLI rejected what it resolved to.
+ *     The alias in `modelAlias` is the pin, with or without a `modelTier`.
+ *   - `modelSource = "fallback:cli-unsupported"` (a tier layer's alias fell
+ *     back) is not a pin. Rows written before the `:model` variant existed are
+ *     ambiguous; one with a `modelAlias` and no `modelTier` can only have come
+ *     from a `model` alias, so its alias is the pin. With a `modelTier` it stays
+ *     ambiguous and only the tier counts.
+ *   - no claim record and no session: `model` is still the creator's value.
+ * Anything else (a tier layer won, or `model` is just the session report) is
+ * not a pin: re-running the row must resolve the model again, from the agent's
+ * current config, instead of replaying the model of the previous run.
+ */
+export function taskModelPin(task: TaskModelPinFields): string | undefined {
+  if (task.modelSource === "model") return task.modelAlias ?? task.model ?? undefined;
+  if (task.modelSource === "fallback:cli-unsupported:model" && task.modelAlias) {
+    return task.modelAlias;
+  }
+  if (task.modelSource === "fallback:cli-unsupported" && task.modelAlias && !task.modelTier) {
+    return task.modelAlias;
+  }
+  if (!task.modelSource && !task.resolvedModel && !task.claudeSessionId) {
+    return task.model ?? undefined;
+  }
+  return undefined;
+}
+
+/**
+ * The model fields a re-run of the SAME task row (paused-task resume) passes to
+ * the spawn: the pin and the claim record that resolved it, or nothing, so the
+ * worker resolves the model from the agent's current config.
+ */
+export function resumedTaskModelSelection(task: TaskModelPinFields): {
+  model: string | undefined;
+  resolvedModel: string | undefined;
+  modelSource: string | undefined;
+} {
+  const pin = taskModelPin(task);
+  if (!pin) return { model: undefined, resolvedModel: undefined, modelSource: undefined };
+  return {
+    model: pin,
+    resolvedModel: task.resolvedModel ?? undefined,
+    modelSource: task.modelSource ?? undefined,
+  };
+}

package/src/tasks/worker-follow-up.ts

@@ -32,6 +32,7 @@ import {
 } from "../types";
 import { isEnvFlagEnabled } from "../utils/env-flag";
 import { taskAttachmentDisplayUrl } from "../utils/task-attachment-links";
+import { taskModelPin } from "./model-pin";
 import { createTaskWithSiblingAwareness } from "./sibling-awareness";
 // Side-effect import: registers task lifecycle templates in the in-memory registry.
 import "../tools/templates";
@@ -165,23 +166,8 @@ export function getNextResumeGeneration(parent: Pick<AgentTask, "tags">): number
  * reboot retry) must carry: the parent's portable `modelTier`, plus its
  * concrete `model` only when that `model` was a task-level pin.
  *
- * `agent_tasks.model` is not always the creator's pin: the worker reports the
- * model it actually ran on `POST /api/tasks/{id}/session`, which overwrites the
- * column. So the pin is read from the claim-time record instead:
- *   - `modelSource = "model"`: the task's own `model` won at claim. A `latest:`
- *     alias survives only in `modelAlias` (the session report replaced `model`
- *     with the concrete id), so the alias is what travels.
- *   - `modelSource = "fallback:cli-unsupported:model"`: the task's own
- *     `latest:` alias won, then the claiming CLI rejected what it resolved to.
- *     The alias in `modelAlias` travels, with or without a `modelTier`.
- *   - `modelSource = "fallback:cli-unsupported"` (a tier layer's alias fell
- *     back) is not a pin. Rows written before the `:model` variant existed are
- *     ambiguous; one with a `modelAlias` and no `modelTier` can only have come
- *     from a `model` alias, so its alias travels. With a `modelTier` it stays
- *     ambiguous and only the tier travels.
- *   - no claim record and no session: `model` is still the creator's value.
- * Anything else (a tier layer won, or `model` is just the session report) is
- * not a pin and is left off, so the resume resolves on its claiming worker.
+ * The pin rules live in `taskModelPin` (`./model-pin`); anything that is not
+ * a pin is left off, so the resume resolves on its claiming worker.
  *
  * `resolvedModel`, `modelSource` and `modelAlias` themselves are NOT copied:
  * claim time writes all three together for the task being claimed, and the
@@ -196,20 +182,7 @@ export function inheritedModelSelection(
     "model" | "modelTier" | "modelSource" | "modelAlias" | "resolvedModel" | "claudeSessionId"
   >,
 ): Pick<CreateTaskOptions, "model" | "modelTier"> {
-  let model: string | undefined;
-  if (parent.modelSource === "model") {
-    model = parent.modelAlias ?? parent.model;
-  } else if (parent.modelSource === "fallback:cli-unsupported:model" && parent.modelAlias) {
-    model = parent.modelAlias;
-  } else if (
-    parent.modelSource === "fallback:cli-unsupported" &&
-    parent.modelAlias &&
-    !parent.modelTier
-  ) {
-    model = parent.modelAlias;
-  } else if (!parent.modelSource && !parent.resolvedModel && !parent.claudeSessionId) {
-    model = parent.model;
-  }
+  const model = taskModelPin(parent);
   return {
     ...(model ? { model } : {}),
     ...(parent.modelTier ? { modelTier: parent.modelTier } : {}),

package/src/tests/acp-adapter.test.ts

@@ -667,6 +667,48 @@ new AgentSideConnection((connection) => new FakeAgent(connection), stream);
     expect(resolveAcpTarget(config).env(config).OPENCODE_CONFIG_CONTENT).toBe(content);
   });
 
+  test("OpenCode preset adds the helmcode block with an {env:} key reference, never the key", () => {
+    const sentinel = "sk-helmcode-acp-sentinel-0123456789";
+    const config = baseConfig({
+      model: "helmcode/glm5.3",
+      env: {
+        ACP_TARGET: "opencode",
+        HELMCODE_API_KEY: sentinel,
+        OPENCODE_CONFIG_CONTENT: JSON.stringify({
+          provider: { helmcode: { options: { timeout: 1000 } } },
+        }),
+      },
+    });
+    const env = resolveAcpTarget(config).env(config);
+    expect(env.HELMCODE_API_KEY).toBe(sentinel);
+    expect(env.OPENCODE_CONFIG_CONTENT).not.toContain(sentinel);
+    const helmcode = JSON.parse(env.OPENCODE_CONFIG_CONTENT!).provider.helmcode;
+    expect(helmcode).toMatchObject({
+      npm: "@ai-sdk/openai-compatible",
+      name: "Helmcode",
+      env: [],
+      options: {
+        baseURL: "https://api.helmcode.com/v1",
+        apiKey: "{env:HELMCODE_API_KEY}",
+        timeout: 1000,
+      },
+    });
+    expect(helmcode.models["glm5.3"]).toMatchObject({
+      tool_call: true,
+      limit: { context: 1048576, output: 32768 },
+    });
+  });
+
+  test("OpenCode preset adds no custom block for a nan model", () => {
+    const config = baseConfig({
+      model: "nan/glm5.3-flash",
+      env: { ACP_TARGET: "opencode", NAN_API_KEY: "example-test-key" },
+    });
+    const env = resolveAcpTarget(config).env(config);
+    expect(env.NAN_API_KEY).toBe("example-test-key");
+    expect(JSON.parse(env.OPENCODE_CONFIG_CONTENT!).provider?.helmcode).toBeUndefined();
+  });
+
   test("OpenCode preset injects gateway even without a model fallback", () => {
     const config = baseConfig({
       model: "",

package/src/tests/api-drain-worker-e2e.test.ts

@@ -28,7 +28,6 @@ let sut: Sut;
 let api: ApiClient;
 let fixtureDir: string;
 let fixturePath: string;
-let pm2StubPath: string;
 
 /** A `claude` that initializes, accepts the prompt, and then never answers. */
 const hangingFixtureSource = `#!/usr/bin/env bun
@@ -87,12 +86,8 @@ describe("API drain with a real worker", () => {
   beforeAll(async () => {
     fixtureDir = await mkdtemp("/tmp/api-drain-worker-");
     fixturePath = join(fixtureDir, "claude-fixture");
-    pm2StubPath = join(fixtureDir, "bin");
-    await Bun.$`mkdir -p ${pm2StubPath}`.quiet();
     await Bun.write(fixturePath, hangingFixtureSource);
-    await Bun.write(join(pm2StubPath, "pm2"), "#!/bin/sh\nexit 0\n");
     await Bun.$`chmod 755 ${fixturePath}`.quiet();
-    await Bun.$`chmod 755 ${join(pm2StubPath, "pm2")}`.quiet();
     sut = await startSut(
       false,
       {},
@@ -138,7 +133,7 @@ describe("API drain with a real worker", () => {
       cwd: repoRoot,
       env: {
         ...minimalEnv(),
-        PATH: `${pm2StubPath}:${process.env.PATH ?? "/usr/bin:/bin"}`,
+        PATH: process.env.PATH ?? "/usr/bin:/bin",
         HOME: home,
         AGENT_SWARM_API_KEY: sut.apiKey,
         API_KEY: sut.apiKey,