@desplega.ai/agent-swarm 2.7.4 → 2.7.6

package/src/tests/explicit-model-validation.test.ts

@@ -112,10 +112,15 @@ afterAll(async () => {
   await removeDbFiles(TEST_DB_PATH);
 });
 
-async function api(method: string, path: string, body: unknown) {
+async function api(
+  method: string,
+  path: string,
+  body: unknown,
+  headers: Record<string, string> = {},
+) {
   const res = await fetch(`${baseUrl}${path}`, {
     method,
-    headers: { "content-type": "application/json" },
+    headers: { "content-type": "application/json", ...headers },
     body: JSON.stringify(body),
   });
   const text = await res.text();
@@ -331,6 +336,44 @@ describe("grok model namespace", () => {
   });
 });
 
+describe("fx model routes", () => {
+  test("an unrouted namespace, a bare non-OpenAI id or latest:anthropic is refused, even with allowCustomModel", async () => {
+    for (const [model, reason] of [
+      ["nan/glm5.3-flash", "InconsistentFinishReason"],
+      ["helmcode/qwen3.6", "Helmcode is not verified on fx"],
+      ["anthropic/claude-opus-5-5", "Anthropic Messages API"],
+      ["claude-opus-5-5", "is in the anthropic catalog"],
+      ["latest:anthropic/opus", "latest:anthropic alias"],
+    ] as const) {
+      for (const allowCustomModel of [false, true]) {
+        const error = await explicitModelError({ model, harnessProvider: "fx", allowCustomModel });
+        expect(error).toContain(`Model "${model}" does not run on the fx harness`);
+        expect(error).toContain(reason);
+      }
+    }
+  });
+
+  test("the OpenRouter, AI Gateway and OpenAI routes pass", async () => {
+    for (const model of [
+      "openrouter/deepseek/deepseek-v4.1-flash",
+      "vercel/anthropic/claude-opus-5.5",
+      "gpt-5-mini",
+      "latest:openrouter/deepseek/deepseek-v4.1-*",
+    ]) {
+      expect(await explicitModelError({ model, harnessProvider: "fx" })).toBeNull();
+    }
+  });
+
+  test("MODEL_TIER_FX_<TIER> refuses a model fx cannot route", () => {
+    expect(validateTierConfigValue("MODEL_TIER_FX_SMART", "nan/glm5.3-flash")).toContain(
+      'model "nan/glm5.3-flash" does not run on the fx harness',
+    );
+    expect(
+      validateTierConfigValue("MODEL_TIER_FX_SMOL", "openrouter/deepseek/deepseek-v4.1-flash"),
+    ).toBeNull();
+  });
+});
+
 describe("MODEL_TIER_<PROVIDER>_<TIER> values", () => {
   test("a model from another harness family is rejected on write", () => {
     expect(validateTierConfigValue("MODEL_TIER_CODEX_SMART", "claude-opus-5-5")).toBe(
@@ -574,12 +617,13 @@ describe("harness compatibility at every create entry point", () => {
   test("internal script-run agent-task route: a cross-harness model is a 400", async () => {
     const runId = crypto.randomUUID();
     await createScriptRun({ id: runId, agentId: workerId, source: "inline", args: {} });
-    const res = await api("POST", `/api/internal/script-runs/${runId}/agent-task`, {
-      stepKey: "step-1",
-      task: "script step",
-      agentId: codexId,
-      model: "claude-opus-5-5",
-    });
+    // The run's own harness calls this route with the run's agent id.
+    const res = await api(
+      "POST",
+      `/api/internal/script-runs/${runId}/agent-task`,
+      { stepKey: "step-1", task: "script step", agentId: codexId, model: "claude-opus-5-5" },
+      { "X-Agent-ID": workerId },
+    );
     expect(res.status).toBe(400);
     expect(String(res.body.error)).toContain("does not run on the codex harness");
   });
@@ -766,3 +810,64 @@ describe("nan and helmcode catalog models", () => {
     expect(res.status).toBe(200);
   });
 });
+
+describe("ChatGPT subscription models (openai-codex/<id>)", () => {
+  let piId = "";
+
+  beforeAll(async () => {
+    piId = (
+      await createAgent({
+        name: "validation-pi-subscription",
+        isLead: false,
+        status: "idle",
+        harnessProvider: "pi",
+      })
+    ).id;
+  });
+
+  test("known when the bare id is an openai catalog model", () => {
+    const catalog = { openai: { models: { "gpt-5.6-sol": {} } } };
+    expect(isKnownCatalogModel("openai-codex/gpt-5.6-sol", catalog)).toBe(true);
+    expect(isKnownCatalogModel("openai-codex/gpt-9", catalog)).toBe(false);
+    expect(isKnownCatalogModel("openai-codex/openai/gpt-5.6-sol", catalog)).toBe(false);
+  });
+
+  test("pi takes it; opencode, codex, claude and grok get a mismatch", async () => {
+    const model = "openai-codex/gpt-5.6-sol";
+    expect(await explicitModelError({ model, harnessProvider: "pi" })).toBeNull();
+    for (const harnessProvider of ["opencode", "codex", "claude", "grok"]) {
+      const error = await explicitModelError({ model, harnessProvider, allowCustomModel: true });
+      expect(error).toContain(`does not run on the ${harnessProvider} harness`);
+    }
+    expect(await explicitModelError({ model, harnessProvider: "codex" })).toContain(
+      'On codex, use "gpt-5.6-sol"',
+    );
+  });
+
+  test("send-task to a pi agent and the agent runtime PATCH accept it", async () => {
+    const sender = ownerCtx({ agentId: leadId });
+    const accepted = await sendTaskHandler(sender, {
+      task: "run on the chatgpt subscription",
+      offerMode: false,
+      allowDuplicate: false,
+      agentId: piId,
+      model: "openai-codex/gpt-5.6-sol",
+      routingReason: "human_pinned",
+      routingNote: "pinned to check the subscription model id",
+    });
+    expect({ ok: accepted.ok, message: accepted.message }).toEqual({
+      ok: true,
+      message: expect.any(String),
+    });
+
+    const res = await api("PATCH", `/api/agents/${piId}/runtime`, {
+      harness_provider: "pi",
+      model: "openai-codex/gpt-5.6-sol",
+      reasoning_effort: "high",
+    });
+    expect({ status: res.status, body: res.body }).toEqual({
+      status: 200,
+      body: expect.anything(),
+    });
+  });
+});

package/src/tests/extensions-run-context.test.ts

@@ -24,6 +24,17 @@ describe("runContext", () => {
     expect(context.subject?.includes("sk-ant-")).toBe(false);
   });
 
+  test("steering records its source and sender agent without message content", () => {
+    expect(
+      runContext("pre.task.steer", {
+        task: { id: "task-1", agentId: "worker", task: "Private task" },
+        source: "mcp",
+        sender: { kind: "agent", agentId: "lead" },
+        message: "Private correction",
+      }),
+    ).toEqual({ agentId: "lead", subject: "mcp: task task-1" });
+  });
+
   test("post task events record the task's agent", () => {
     expect(
       runContext("post.task.completed", {

package/src/tests/extensions-steering.test.ts

@@ -0,0 +1,353 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, spyOn, test } from "bun:test";
+import { createServer, type Server } from "node:http";
+import {
+  closeDb,
+  createAgent,
+  createTaskExtended,
+  createUser,
+  getChildTasks,
+  getDbClient,
+  getKv,
+  getLogsByTaskId,
+  getSteeringMessagesForTask,
+  getTaskById,
+  initDb,
+  pauseTask,
+  startTask,
+} from "../be/db";
+import { getExtensionByName, installExtension, listExtensionRuns } from "../be/extensions/db";
+import { requestSteering, SteeringBlockedError } from "../be/steering";
+import type { TaskSteerEvent } from "../extensions/contract";
+import { enableExtension, stopExtensionRuntime } from "../extensions/lifecycle";
+import { handleMcpBridge } from "../http/mcp-bridge";
+import { handleTasks } from "../http/tasks";
+import { SwarmConfig } from "../scripts-runtime/swarm-config";
+import { createSwarmSdk } from "../scripts-runtime/swarm-sdk";
+import * as slackApp from "../slack/app";
+import { requestSlackThreadSteering } from "../slack/steering";
+import { bufferThreadMessage, instantFlush } from "../slack/thread-buffer";
+import { steerTaskHandler } from "../tools/steer-task";
+import { ownerCtx } from "../tools/task-tool-ctx";
+import { loadBundleFixture } from "./fixtures/extensions/load";
+import { listenOnFreePort } from "./test-net";
+
+const TEST_DB_PATH = `./test-extensions-steering-${process.pid}.sqlite`;
+const ENV_KEYS = [
+  "STEERING_ENABLED",
+  "SLACK_THREAD_STEERING",
+  "SLACK_THREAD_STEERING_MODE",
+  "SLACK_RENDER_V2",
+];
+const savedEnv = new Map(ENV_KEYS.map((key) => [key, process.env[key]]));
+let leadId: string;
+let server: Server;
+let baseUrl: string;
+
+async function removeDbFiles() {
+  for (const suffix of ["", "-wal", "-shm"]) {
+    await Bun.file(TEST_DB_PATH + suffix)
+      .delete()
+      .catch(() => {});
+  }
+}
+
+async function installPolicy(config: Record<string, unknown>, name = "steering-policy") {
+  const bundle = await loadBundleFixture("steering-policy");
+  const installed = await installExtension({
+    ...bundle,
+    manifest: { ...bundle.manifest, name },
+    config,
+  });
+  return await enableExtension(installed.extension.id);
+}
+
+async function runningTask() {
+  const task = await createTaskExtended("Existing task", {
+    agentId: leadId,
+    source: "slack",
+    slackChannelId: "C_STEER_POLICY",
+    slackThreadTs: "1000.0001",
+  });
+  await startTask(task.id);
+  return task;
+}
+
+async function lastEvent(name = "steering-policy"): Promise<TaskSteerEvent | undefined> {
+  const extension = await getExtensionByName(name);
+  return (await getKv(`task:agent:${extension?.agentId}`, `ext:${name}:last`))?.value as
+    | TaskSteerEvent
+    | undefined;
+}
+
+async function expectNoSteering(taskId: string) {
+  expect(await getSteeringMessagesForTask(taskId)).toEqual([]);
+  expect(
+    (await getLogsByTaskId(taskId)).filter((log) => log.eventType === "task_steering"),
+  ).toEqual([]);
+  expect(await getChildTasks(taskId)).toEqual([]);
+}
+
+describe("extension steering boundary", () => {
+  beforeAll(async () => {
+    process.env.STEERING_ENABLED = "true";
+    process.env.SLACK_THREAD_STEERING = "lead";
+    process.env.SLACK_THREAD_STEERING_MODE = "queue";
+    process.env.SLACK_RENDER_V2 = "false";
+    await removeDbFiles();
+    initDb(TEST_DB_PATH);
+    server = createServer(async (req, res) => {
+      res.setHeader("Content-Type", "application/json");
+      const path = new URL(req.url ?? "/", "http://localhost").pathname.split("/").filter(Boolean);
+      if (await handleMcpBridge(req, res, path, new URLSearchParams(), leadId)) return;
+      await handleTasks(req, res, path, new URLSearchParams(), leadId);
+    });
+    baseUrl = `http://127.0.0.1:${await listenOnFreePort(server)}`;
+  });
+
+  beforeEach(async () => {
+    await stopExtensionRuntime();
+    const client = getDbClient();
+    await client.run("DELETE FROM agent_tasks");
+    await client.run("DELETE FROM extensions");
+    await client.run("DELETE FROM kv_entries WHERE key LIKE 'ext:%'");
+    await client.run("DELETE FROM agents");
+    leadId = (
+      await createAgent({
+        name: "Steering policy lead",
+        isLead: true,
+        status: "busy",
+        maxTasks: 10,
+        harnessProvider: "pi",
+      })
+    ).id;
+  });
+
+  afterAll(async () => {
+    await stopExtensionRuntime();
+    await new Promise<void>((resolve) => server.close(() => resolve()));
+    closeDb();
+    await removeDbFiles();
+    for (const [key, value] of savedEnv) {
+      if (value === undefined) delete process.env[key];
+      else process.env[key] = value;
+    }
+  });
+
+  test("continue records the task, source, mode and sender before queuing the original text", async () => {
+    await installPolicy({ action: "continue" });
+    const task = await runningTask();
+    const result = await requestSteering({
+      taskId: task.id,
+      message: "Add the charts",
+      mode: "steer",
+      source: "mcp",
+      createdByKind: "agent",
+      createdByAgentId: leadId,
+    });
+    expect(result.outcome).toBe("steered");
+    expect(await lastEvent()).toMatchObject({
+      task: { id: task.id, status: "in_progress" },
+      message: "Add the charts",
+      mode: "steer",
+      source: "mcp",
+      sender: { kind: "agent", agentId: leadId },
+    });
+    expect((await getSteeringMessagesForTask(task.id))[0]?.body).toBe("Add the charts");
+  });
+
+  test("valid modifications flow through successive handlers and are the only text delivered", async () => {
+    await installPolicy({ action: "modify", prefix: "first: " });
+    await installPolicy({ action: "modify", prefix: "second: " }, "steering-policy-z");
+    const task = await runningTask();
+    await requestSteering({ taskId: task.id, message: "Add the charts" });
+    expect((await lastEvent("steering-policy-z"))?.message).toBe("first: Add the charts");
+    expect((await getSteeringMessagesForTask(task.id))[0]?.body).toBe(
+      "second: first: Add the charts",
+    );
+  });
+
+  test("block returns an actionable refusal without steering rows, logs or follow-up tasks", async () => {
+    const extension = await installPolicy({ action: "block" });
+    const task = await runningTask();
+    try {
+      await requestSteering({ taskId: task.id, message: "Do not deliver" });
+      throw new Error("Expected steering to be blocked");
+    } catch (error) {
+      expect(error).toBeInstanceOf(SteeringBlockedError);
+      expect(error).toMatchObject({
+        statusCode: 403,
+        extension: { id: extension.id },
+        reason: "Steering denied by policy",
+      });
+    }
+    await expectNoSteering(task.id);
+    expect((await listExtensionRuns(extension.id)).map((run) => run.action)).toEqual(["block"]);
+  });
+
+  test("a blocked paused task is not resumed", async () => {
+    await installPolicy({ action: "block" });
+    const task = await runningTask();
+    await pauseTask(task.id);
+    await expect(
+      requestSteering({ taskId: task.id, message: "Do not resume" }),
+    ).rejects.toBeInstanceOf(SteeringBlockedError);
+    expect((await getTaskById(task.id))?.status).toBe("paused");
+    await expectNoSteering(task.id);
+  });
+
+  for (const action of ["empty", "retarget", "throw"]) {
+    test(`${action} fails open and records an extension error`, async () => {
+      const extension = await installPolicy({ action });
+      const task = await runningTask();
+      await requestSteering({ taskId: task.id, message: "Keep the original" });
+      expect((await getSteeringMessagesForTask(task.id))[0]?.body).toBe("Keep the original");
+      expect((await listExtensionRuns(extension.id))[0]?.action).toBe("error");
+    });
+  }
+
+  test("valid rewritten text is secret-scrubbed before storage", async () => {
+    const secret = `sk-ant-${"a".repeat(40)}`;
+    await installPolicy({ action: "modify", prefix: `${secret} ` });
+    const task = await runningTask();
+    await requestSteering({ taskId: task.id, message: "Keep this" });
+    const body = (await getSteeringMessagesForTask(task.id))[0]?.body;
+    expect(body).not.toContain(secret);
+    expect(body).toContain("Keep this");
+  });
+
+  test("extension-originated steering skips its own handler", async () => {
+    const extension = await installPolicy({ action: "block" });
+    const task = await runningTask();
+    await requestSteering({
+      taskId: task.id,
+      message: "From the extension",
+      createdByKind: "agent",
+      createdByAgentId: extension.agentId!,
+    });
+    expect(await lastEvent()).toBeUndefined();
+    expect((await getSteeringMessagesForTask(task.id))[0]?.body).toBe("From the extension");
+  });
+
+  test("HTTP steering returns 403 for a policy block", async () => {
+    await installPolicy({ action: "block" });
+    const task = await runningTask();
+    const response = await fetch(`${baseUrl}/api/tasks/${task.id}/steer`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", "X-Agent-ID": leadId },
+      body: JSON.stringify({ message: "Do not deliver" }),
+    });
+    expect(response.status).toBe(403);
+    expect(await response.text()).toContain("Steering denied by policy");
+    await expectNoSteering(task.id);
+  });
+
+  test("MCP steering reports a policy block as a tool error", async () => {
+    await installPolicy({ action: "block" });
+    const task = await runningTask();
+    const result = await steerTaskHandler(ownerCtx({ agentId: leadId }), {
+      taskId: task.id,
+      message: "Do not deliver",
+    });
+    expect(result.ok).toBe(false);
+    expect(result.message).toContain("Steering denied by policy");
+    expect(await lastEvent()).toMatchObject({ source: "mcp" });
+    await expectNoSteering(task.id);
+  });
+
+  test("script SDK steering reaches the hook through the bridge with the script source", async () => {
+    await installPolicy({ action: "continue" });
+    const task = await runningTask();
+    const sdk = createSwarmSdk(
+      new SwarmConfig({
+        system: {
+          apiKey: { value: "steering-sdk-test-key", isSecret: true },
+          agentId: { value: leadId, isSecret: false },
+          mcpBaseUrl: { value: baseUrl, isSecret: false },
+        },
+        user: {},
+      }),
+    );
+
+    const result = await sdk.task_steer({ taskId: task.id, message: "From the script SDK" });
+
+    expect(result).toMatchObject({
+      success: true,
+      status: 200,
+      data: { success: true, outcome: "queued" },
+    });
+    expect(await lastEvent()).toMatchObject({
+      task: { id: task.id },
+      message: "From the script SDK",
+      mode: "queue",
+      source: "script",
+      sender: { kind: "agent", agentId: leadId },
+    });
+    expect(await getSteeringMessagesForTask(task.id)).toEqual([
+      expect.objectContaining({ source: "script", body: "From the script SDK" }),
+    ]);
+  });
+
+  test("Slack supplies message timestamps and sender metadata without acknowledgement log rows on block", async () => {
+    await installPolicy({ action: "block" });
+    const task = await runningTask();
+    const user = await createUser({ name: "Steering sender" });
+    await expect(
+      requestSlackThreadSteering({
+        channelId: "C_STEER_POLICY",
+        threadTs: "1000.0001",
+        message: "Do not deliver",
+        messageTimestamps: ["1000.0002", "1000.0003"],
+        requestedByUserId: user.id,
+        slackUserId: "U_SENDER",
+      }),
+    ).rejects.toBeInstanceOf(SteeringBlockedError);
+    expect(await lastEvent()).toMatchObject({
+      source: "slack",
+      sender: { kind: "user", userId: user.id },
+      messageTimestamps: ["1000.0002", "1000.0003"],
+      slack: { channelId: "C_STEER_POLICY", threadTs: "1000.0001", userId: "U_SENDER" },
+    });
+    await expectNoSteering(task.id);
+  });
+
+  test("a blocked buffer flush is consumed and later senders still get delivered", async () => {
+    await installPolicy({ action: "block", slackUserId: "U_BLOCKED" });
+    const task = await runningTask();
+    const acked: string[] = [];
+    const posted: string[] = [];
+    const appSpy = spyOn(slackApp, "getSlackApp").mockReturnValue({
+      client: {
+        users: { info: async () => ({ ok: false }) },
+        reactions: {
+          add: async (args: { timestamp: string; name: string }) => {
+            acked.push(`${args.timestamp}:${args.name}`);
+            return { ok: true };
+          },
+          remove: async () => ({ ok: true }),
+        },
+        chat: {
+          postMessage: async (args: { text: string }) => {
+            posted.push(args.text);
+            return { ok: true };
+          },
+        },
+      },
+    } as unknown as NonNullable<ReturnType<typeof slackApp.getSlackApp>>);
+    try {
+      bufferThreadMessage("C_STEER_POLICY", "1000.0001", "Drop this", "U_BLOCKED", "1000.0002");
+      bufferThreadMessage("C_STEER_POLICY", "1000.0001", "Keep this", "U_ALLOWED", "1000.0003");
+      await instantFlush("C_STEER_POLICY:1000.0001");
+      expect((await getSteeringMessagesForTask(task.id)).map((row) => row.body)).toEqual([
+        "Keep this",
+      ]);
+      expect(acked).toContain("1000.0002:no_entry");
+      expect(posted).toHaveLength(1);
+      expect(await getChildTasks(task.id)).toEqual([]);
+      expect(
+        (await getLogsByTaskId(task.id)).filter((log) => log.newValue === "slack_reaction"),
+      ).toEqual([expect.objectContaining({ metadata: expect.stringContaining("1000.0003") })]);
+    } finally {
+      appSpy.mockRestore();
+    }
+  });
+});

package/src/tests/extensions-validate.test.ts

@@ -29,6 +29,11 @@ describe("extension bundle validation", () => {
     expect(await validateBundle(bundle)).toEqual({ ok: true, manifest: bundle.manifest });
   });
 
+  test("accepts the steering event and message rewrite types", async () => {
+    const bundle = await loadBundleFixture("steering-policy");
+    expect(await validateBundle(bundle)).toEqual({ ok: true, manifest: bundle.manifest });
+  });
+
   test("accepts zod and stdlib imports", async () => {
     const bundle = await loadBundleFixture("minimal");
     bundle.files["hooks.ts"] = `import { table } from "stdlib";

package/src/tests/fixtures/extensions/steering-policy/hooks.ts

@@ -0,0 +1,39 @@
+import { block, modify, type SwarmExtension } from "swarm-extension";
+import { z } from "zod";
+
+export const config = z.object({
+  action: z.enum(["continue", "modify", "block", "empty", "retarget", "throw"]),
+  prefix: z.string().default("rewritten: "),
+  slackUserId: z.string().optional(),
+});
+const manifest = {
+  name: "steering-policy",
+  description: "Records, rewrites, or blocks steering messages",
+  version: "1.0.0",
+  runtime: "api",
+  assets: { hooks: "hooks.ts" },
+  config,
+} as const;
+
+const extension: SwarmExtension<typeof manifest> = (api) => {
+  api.on("pre.task.steer", async (event, ctx) => {
+    await ctx.state.set("last", event);
+    if (ctx.config.slackUserId && event.slack?.userId !== ctx.config.slackUserId) return;
+    switch (ctx.config.action) {
+      case "continue":
+        return { action: "continue" };
+      case "modify":
+        return modify({ message: ctx.config.prefix + event.message });
+      case "block":
+        return block("Steering denied by policy");
+      case "empty":
+        return modify({ message: " \n " });
+      case "retarget":
+        return modify({ message: "Unauthorized rewrite", mode: "steer" });
+      case "throw":
+        throw new Error("Steering policy failed");
+    }
+  });
+};
+
+export default extension;

package/src/tests/fixtures/extensions/steering-policy/manifest.json

@@ -0,0 +1,7 @@
+{
+  "name": "steering-policy",
+  "description": "Records, rewrites, or blocks steering messages",
+  "version": "1.0.0",
+  "runtime": "api",
+  "assets": { "hooks": "hooks.ts" }
+}