@desplega.ai/agent-swarm 1.172.0 → 2.0.0

package/src/tasks/context-key.ts

@@ -14,9 +14,13 @@
  * 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}
+ *   task:trackers:azure-devops:{organization}:workitem:{workItemId}
  *   task:trackers:linear:{issueIdentifier}        (e.g. DES-42 — case preserved)
  *   task:trackers:jira:{issueIdentifier}          (e.g. PROJ-123 — case preserved)
  *   task:schedule:{scheduleId}
@@ -38,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";
@@ -60,6 +71,11 @@ export type ParsedContextKey =
       subFamily: "azure-devops";
       parts: { repositoryId: string; kind: "pr"; pullRequestId: number };
     }
+  | {
+      family: "trackers";
+      subFamily: "azure-devops";
+      parts: { organization: string; kind: "workitem"; workItemId: number };
+    }
   | {
       family: "trackers";
       subFamily: "linear";
@@ -95,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);
@@ -158,6 +210,20 @@ export function azureDevOpsContextKey(input: {
   return ["task", "trackers", "azure-devops", repositoryId, "pr", pullRequestId].join(SEPARATOR);
 }
 
+export function azureDevOpsWorkItemContextKey(input: {
+  organization: string;
+  workItemId: number;
+}): string {
+  const organization = assertSafePart(input.organization, "organization");
+  const workItemId = assertSafePart(input.workItemId, "workItemId");
+  if (!/^\d+$/.test(workItemId)) {
+    throw new Error(
+      `context-key: azure-devops "workItemId" must be a positive integer (got ${JSON.stringify(workItemId)})`,
+    );
+  }
+  return ["task", "trackers", "azure-devops", organization, "workitem", workItemId].join(SEPARATOR);
+}
+
 export function linearContextKey(input: { issueIdentifier: string }): string {
   const issueIdentifier = assertSafePart(input.issueIdentifier, "issueIdentifier");
   return ["task", "trackers", "linear", issueIdentifier].join(SEPARATOR);
@@ -235,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)}`);
@@ -293,10 +372,23 @@ export function parseContextKey(key: string): ParsedContextKey {
         };
       }
       if (subFamily === "azure-devops") {
-        if (parts.length !== 6 || parts[4] !== "pr") {
+        if (parts.length !== 6 || (parts[4] !== "pr" && parts[4] !== "workitem")) {
           throw new Error(`context-key: malformed azure-devops key: ${JSON.stringify(key)}`);
         }
         const idStr = parts[5] as string;
+        if (parts[4] === "workitem") {
+          const workItemId = Number.parseInt(idStr, 10);
+          if (!/^\d+$/.test(idStr) || !Number.isFinite(workItemId)) {
+            throw new Error(
+              `context-key: malformed azure-devops workItemId "${idStr}": ${JSON.stringify(key)}`,
+            );
+          }
+          return {
+            family: "trackers",
+            subFamily: "azure-devops",
+            parts: { organization: parts[3] as string, kind: "workitem", workItemId },
+          };
+        }
         const pullRequestId = Number.parseInt(idStr, 10);
         if (!Number.isFinite(pullRequestId)) {
           throw new Error(

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/telemetry.ts

@@ -24,6 +24,7 @@ import {
 } from "./telemetry-context";
 import type { PropsFor, TelemetryEventName } from "./telemetry-contract";
 import { isEnvFlagEnabled } from "./utils/env-flag";
+import { getNodeEnv } from "./utils/node-env";
 import { normalizeOrgWebsite } from "./utils/org-website";
 import { getCurrentRequestUserId } from "./utils/request-auth-context";
 
@@ -588,7 +589,7 @@ function getTelemetryEnvironment(): string {
 
   // Do not default from NODE_ENV: shipped Bun/npm installs can report
   // "development" even when the operator did not choose a telemetry cohort.
-  if (process.env.NODE_ENV === "test") return "test";
+  if (getNodeEnv() === "test") return "test";
   return "production";
 }
 

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,