@desplega.ai/agent-swarm 1.149.1 → 1.151.0

package/src/tests/reload-config.test.ts

@@ -3,6 +3,7 @@ import { unlink } from "node:fs/promises";
 import { createServer as createHttpServer, type Server } from "node:http";
 import { initAgentMail, resetAgentMail } from "../agentmail";
 import { closeDb, deleteSwarmConfig, getDbClient, initDb, upsertSwarmConfig } from "../be/db";
+import { getEmbeddingProvider, resetEmbeddingProvider } from "../be/memory";
 import { initGitHub, resetGitHub } from "../github";
 import {
   __resetInjectedEnvTracking,
@@ -10,6 +11,7 @@ import {
   _resetAutoReloadForTests,
   flushPendingIntegrationsReload,
   loadGlobalConfigsIntoEnv,
+  reloadGlobalConfigsAndIntegrations,
   scheduleIntegrationsReload,
 } from "../http/core";
 import { isOriginAllowedForCredentials } from "../http/utils";
@@ -262,6 +264,48 @@ describe("reload-config", () => {
     expect(res.status).toBe(404);
   });
 
+  // Regression: EMBEDDING_API_KEY / OPENAI_API_KEY used to be read once at
+  // OpenAIEmbeddingProvider construction and never revisited, so a key set
+  // (or rotated) via the dashboard/API stayed inert until the API process
+  // restarted (customer-reported, Jan Carbonell 2026-09-16: valid key,
+  // reload reported it loaded, embeddings still stayed off). Assert the
+  // full path: no key -> provider unconfigured -> config write + reload ->
+  // provider live, without a restart.
+  test("reload turns embeddings on without a restart once a key lands via config", async () => {
+    const originalEmbeddingKey = process.env.EMBEDDING_API_KEY;
+    const originalOpenAiKey = process.env.OPENAI_API_KEY;
+    delete process.env.EMBEDDING_API_KEY;
+    delete process.env.OPENAI_API_KEY;
+    resetEmbeddingProvider();
+    expect(getEmbeddingProvider().isConfigured()).toBe(false);
+
+    const config = await upsertSwarmConfig({
+      scope: "global",
+      key: "EMBEDDING_API_KEY",
+      value: "sk-test-not-a-real-key",
+      isSecret: true,
+    });
+
+    try {
+      const result = await reloadGlobalConfigsAndIntegrations();
+      expect(result.keysUpdated).toContain("EMBEDDING_API_KEY");
+      expect(result.integrationsReinitialized).toContain("embeddings");
+      expect(getEmbeddingProvider().isConfigured()).toBe(true);
+    } finally {
+      await deleteSwarmConfig(config.id);
+      delete process.env.EMBEDDING_API_KEY;
+      if (originalOpenAiKey === undefined) {
+        delete process.env.OPENAI_API_KEY;
+      } else {
+        process.env.OPENAI_API_KEY = originalOpenAiKey;
+      }
+      resetEmbeddingProvider();
+      if (originalEmbeddingKey !== undefined) {
+        process.env.EMBEDDING_API_KEY = originalEmbeddingKey;
+      }
+    }
+  });
+
   // Regression: injection used to be one-way. Deleting a global row left the
   // previously-injected value live in process.env until the process restarted,
   // so "reset to default" in the dashboard silently did nothing.
@@ -430,7 +474,7 @@ describe("auto-reload debouncer", () => {
     const testKey = `__TEST_OVERRIDE_LIVE_${Date.now()}`;
     process.env[testKey] = "shipped-by-deploy";
 
-    // Pre-existing env should win at startup, but reload uses override=true.
+    // Pre-existing env set manually here; reload (and boot) use override=true.
     await upsertSwarmConfig({ scope: "global", key: testKey, value: "from-config" });
     scheduleIntegrationsReload(20);
 

package/src/tests/routing-affinity-inventory.test.ts

@@ -101,7 +101,7 @@ const EXPECTED_INVENTORY: InventoryEntry[] = [
     file: "src/tools/send-task.ts",
     owner: "sendTaskHandler",
     syntax: "PropertyAssignment",
-    count: 3,
+    count: 1,
     kind: "producer",
     dispatchProof: {
       file: "src/tests/task-tools-ctx.test.ts",

package/src/tests/routing-reason-contract.test.ts

@@ -13,7 +13,12 @@ const ROUTING_REASONS = [
 describe("send-task routing decision input", () => {
   test.each(ROUTING_REASONS)("accepts routingReason %s", (routingReason) => {
     expect(
-      sendTaskInputSchema.safeParse({ task: "delegate", agentId: "worker", routingReason }).success,
+      sendTaskInputSchema.safeParse({
+        task: "delegate",
+        agentId: "worker",
+        routingReason,
+        routingNote: "Owns this code path",
+      }).success,
     ).toBe(true);
   });
 
@@ -23,6 +28,7 @@ describe("send-task routing decision input", () => {
         task: "delegate",
         agentId: "worker",
         routingReason: "round_robin",
+        routingNote: "Owns this code path",
       }).success,
     ).toBe(false);
   });
@@ -53,6 +59,52 @@ describe("send-task routing decision input", () => {
     ).toBe(false);
   });
 
+  test.each([
+    undefined,
+    "",
+    "         ",
+    "123456789",
+    " 123456789 ",
+  ])("rejects direct assignment and offers with a missing or short note: %s", (routingNote) => {
+    for (const offerMode of [false, true]) {
+      const result = sendTaskInputSchema.safeParse({
+        task: "delegate",
+        agentId: "worker",
+        routingReason: "skill",
+        routingNote,
+        offerMode,
+      });
+      expect(result.success).toBe(false);
+      if (!result.success) expect(result.error.issues[0]?.path).toEqual(["routingNote"]);
+    }
+  });
+
+  test("accepts exactly 10 trimmed characters and does not require a note for implicit routing", () => {
+    expect(
+      sendTaskInputSchema.safeParse({
+        task: "delegate",
+        agentId: "worker",
+        routingReason: "skill",
+        routingNote: " 1234567890 ",
+      }).success,
+    ).toBe(true);
+    expect(sendTaskInputSchema.safeParse({ task: "pool" }).success).toBe(true);
+    expect(
+      sendTaskInputSchema.safeParse({ task: "continue", parentTaskId: crypto.randomUUID() })
+        .success,
+    ).toBe(true);
+  });
+
+  test("handler rejects a missing note before any direct-call write", async () => {
+    const result = await sendTaskHandler({ kind: "owner", agentId: "sender" }, {
+      task: "delegate",
+      agentId: "worker",
+      routingReason: "skill",
+    } as never);
+    expect(result.ok).toBe(false);
+    expect(result.message).toContain("routingNote is required");
+  });
+
   test("handler rejects direct callers that bypass schema parsing", async () => {
     const result = await sendTaskHandler({ kind: "owner", agentId: "sender" }, {
       task: "delegate",
@@ -77,13 +129,34 @@ test("the delegate script requires the caller's reason and forwards it without r
     },
   };
   expect((await delegate({ agentName: "Worker", task: "work" }, ctx)).ok).toBe(false);
+  expect(
+    (await delegate({ agentName: "Worker", task: "work", routingReason: "skill" }, ctx)).ok,
+  ).toBe(false);
+  expect(
+    (
+      await delegate(
+        { agentName: "Worker", task: "work", routingReason: "skill", routingNote: " 123456789 " },
+        ctx,
+      )
+    ).ok,
+  ).toBe(false);
   expect(sent).toHaveLength(0);
   const result = await delegate(
-    { agentName: "Worker", task: "work", routingReason: "continuity", routingNote: "same PR" },
+    {
+      agentName: "Worker",
+      task: "work",
+      routingReason: "continuity",
+      routingNote: "same PR and worker",
+    },
     ctx,
   );
   expect(result.ok).toBe(true);
   expect(sent).toEqual([
-    { agentId: "worker", task: "work", routingReason: "continuity", routingNote: "same PR" },
+    {
+      agentId: "worker",
+      task: "work",
+      routingReason: "continuity",
+      routingNote: "same PR and worker",
+    },
   ]);
 });

package/src/tests/routing-reason-inventory.test.ts

@@ -1,11 +1,15 @@
 import { describe, expect, test } from "bun:test";
 import ts from "typescript";
 
-const TASK_CREATORS = new Set(["createTaskExtended", "createTaskWithSiblingAwareness"]);
+const TASK_CREATORS = new Set([
+  "createTaskExtended",
+  "createTaskWithSiblingAwareness",
+  "createSlackTaskWithFiles",
+]);
 
 type Violation = { file: string; line: number; creator: string };
 
-async function assignedCreatorsWithoutReason(): Promise<Violation[]> {
+async function creatorsWithoutRoutingMetadata(): Promise<Violation[]> {
   const violations: Violation[] = [];
   const glob = new Bun.Glob("src/**/*.ts");
 
@@ -32,8 +36,9 @@ async function assignedCreatorsWithoutReason(): Promise<Violation[]> {
             ),
           );
           if (
-            (propertyNames.has("agentId") || propertyNames.has("offeredTo")) &&
-            !propertyNames.has("routingReason")
+            ((propertyNames.has("agentId") || propertyNames.has("offeredTo")) &&
+              !propertyNames.has("routingReason")) ||
+            (propertyNames.has("routingReason") && !propertyNames.has("routingSource"))
           ) {
             const { line } = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
             violations.push({ file, line: line + 1, creator });
@@ -49,7 +54,7 @@ async function assignedCreatorsWithoutReason(): Promise<Violation[]> {
 }
 
 describe("routing reason production inventory", () => {
-  test("every direct assigned/offer creator declares its reason at the call site", async () => {
-    expect(await assignedCreatorsWithoutReason()).toEqual([]);
+  test("every assigned/offer creator records its reason and provenance at the call site", async () => {
+    expect(await creatorsWithoutRoutingMetadata()).toEqual([]);
   });
 });

package/src/tests/routing-source.test.ts

@@ -0,0 +1,53 @@
+import { Database } from "bun:sqlite";
+import { describe, expect, test } from "bun:test";
+import { runMigrations } from "../be/migrations/runner";
+import { CreateTaskOptionsSchema, RoutingSourceSchema } from "../types";
+
+const migration = await Bun.file(
+  new URL("../be/migrations/154_routing_source.sql", import.meta.url),
+).text();
+
+describe("routing provenance migration", () => {
+  test("preserves historical reasons with unknown provenance and checks new sources", () => {
+    const database = new Database(":memory:");
+    try {
+      database.exec(`CREATE TABLE agent_tasks (id TEXT PRIMARY KEY, routing_reason TEXT);
+        INSERT INTO agent_tasks VALUES ('legacy', 'skill');`);
+      database.exec(migration);
+      expect(database.query("SELECT * FROM agent_tasks").get()).toEqual({
+        id: "legacy",
+        routing_reason: "skill",
+        routing_source: null,
+      });
+      for (const routingSource of RoutingSourceSchema.options) {
+        database.run("INSERT INTO agent_tasks VALUES (?, 'skill', ?)", [
+          routingSource,
+          routingSource,
+        ]);
+        expect(CreateTaskOptionsSchema.parse({ routingSource }).routingSource).toBe(routingSource);
+      }
+      expect(() =>
+        database.run("INSERT INTO agent_tasks VALUES ('invalid', 'skill', 'guessed')"),
+      ).toThrow();
+      expect(CreateTaskOptionsSchema.safeParse({ routingSource: "guessed" }).success).toBe(false);
+    } finally {
+      database.close();
+    }
+  });
+
+  test("applies 154 on a fresh database and reruns cleanly", () => {
+    const database = new Database(":memory:");
+    try {
+      runMigrations(database);
+      runMigrations(database);
+      expect(database.query("SELECT name FROM _migrations WHERE version = 154").all()).toEqual([
+        { name: "154_routing_source" },
+      ]);
+      expect(database.query("PRAGMA table_info(agent_tasks)").all()).toContainEqual(
+        expect.objectContaining({ name: "routing_source", notnull: 0, dflt_value: null }),
+      );
+    } finally {
+      database.close();
+    }
+  });
+});

package/src/tests/runner-agent-fs-provision-retry.test.ts

@@ -21,7 +21,7 @@ import { listenOnFreePort } from "./test-net";
  */
 
 const AGENT_ID = "9b2c4a1e-6d3f-4a55-8f27-1c0e7b5a4d90";
-const API_KEY = "test-swarm-key";
+const API_KEY = "example-test-swarm-key";
 const AGENT_FS_KEY = "af_live_key";
 
 type FakeApiState = {

package/src/tests/runner-context-preamble.test.ts

@@ -11,7 +11,7 @@ import {
 import { listenOnFreePort } from "./test-net";
 
 let API_URL = "";
-const API_KEY = "test-key";
+const API_KEY = "example-test-key";
 
 // In-memory task store for the mock server
 const mockTasks: Record<string, TaskContextForPreamble> = {};

package/src/tests/runner-deployment-resume.test.ts

@@ -71,7 +71,7 @@ describe("deployment resume context", () => {
         mimeType: "text/plain",
         sizeBytes: 42,
       });
-      const tasks = await getPausedTasksFromAPI({ apiUrl, apiKey: "test-key", agentId });
+      const tasks = await getPausedTasksFromAPI({ apiUrl, apiKey: "example-test-key", agentId });
       const paused = tasks.find((row) => row.id === task.id);
       expect(paused).toBeDefined();
       if (!paused) throw new Error("Paused task missing");

package/src/tests/runner-fallback-output.test.ts

@@ -48,7 +48,7 @@ function resetMocks() {
 function makeConfig(): ApiConfig {
   return {
     apiUrl: "http://runner-fallback.test",
-    apiKey: "test-key",
+    apiKey: "example-test-key",
     agentId: "test-agent-id",
   };
 }

package/src/tests/runner-identity-refresh.test.ts

@@ -32,7 +32,7 @@ async function runFixture(scenario: string): Promise<FixtureResult> {
             PATH: process.env.PATH,
             HOME: directory,
             AGENT_ID: "11111111-1111-4111-8111-111111111111",
-            API_KEY: "fixture-key",
+            API_KEY: "example-fixture-key",
             MCP_BASE_URL: "http://runner.invalid",
             HARNESS_PROVIDER: "pi",
             CRED_CHECK_DISABLE: "1",

package/src/tests/runner-skills-refresh.test.ts

@@ -126,7 +126,7 @@ describe("refreshSkillsIfChanged", () => {
     return {
       apiUrl: baseUrl,
       swarmUrl: "app.agent-swarm.dev",
-      apiKey: "test-key",
+      apiKey: "example-test-key",
       agentId: "agent-1",
       role: "worker",
     };

package/src/tests/schedule-target-type.test.ts

@@ -68,7 +68,7 @@ import { SKIP_SANDBOX_SPAWN_TESTS } from "./sandbox-spawn-test-helpers";
 const skip = test.skipIf(SKIP_SANDBOX_SPAWN_TESTS);
 
 const TEST_DB_PATH = "./test-schedule-target-type.sqlite";
-const API_KEY = "test-schedule-target-type-key-1234567890";
+const API_KEY = "example-test-schedule-target-type-key-1234567890";
 
 const noOpEmbeddingProvider = {
   name: "test/noop-schedule-target-type-embedding",
@@ -555,7 +555,7 @@ describe("dispatchScheduleTarget — workflow target", () => {
     );
     expect(after?.count).toBe(before?.count);
     expect(updated?.enabled).toBe(true);
-    expect(updated?.lastRunAt).toBeUndefined();
+    expect(updated?.lastRunAt).toBeDefined();
     expect(updated?.consecutiveErrors).toBe(0);
     expect(updated?.lastErrorMessage).toBe("needs_setup: params=[REPO_URL] integrations=[]");
     expect(new Date(updated!.nextRunAt!).getTime()).toBeGreaterThan(Date.now());
@@ -654,7 +654,7 @@ describe("dispatchScheduleTarget — automation preflight", () => {
     expect(second.lastErrorMessage).toBe("needs_setup: params=[REPO_URL] integrations=[]");
     expect(second.consecutiveErrors).toBe(0);
     expect(second.enabled).toBe(true);
-    expect(second.lastRunAt).toBeUndefined();
+    expect(second.lastRunAt).toBeDefined();
     expect(new Date(second.nextRunAt!).getTime()).toBeGreaterThan(Date.now());
   });
 

package/src/tests/scheduled-tasks.test.ts

@@ -399,13 +399,14 @@ describe("Scheduled Tasks Integration", () => {
 
       // Find the created task
       const createdTask = (await getDbClient().get(
-        "SELECT *, routing_reason AS routingReason FROM agent_tasks WHERE task = ? ORDER BY createdAt DESC LIMIT 1",
+        "SELECT *, routing_reason AS routingReason, routing_source AS routingSource FROM agent_tasks WHERE task = ? ORDER BY createdAt DESC LIMIT 1",
         [schedule.taskTemplate!],
-      )) as { agentId: string; routingReason: string; status: string };
+      )) as { agentId: string; routingReason: string; routingSource: string; status: string };
 
       expect(createdTask).toBeDefined();
       expect(createdTask.agentId).toBe(targetAgent.id);
       expect(createdTask.routingReason).toBe("human_pinned");
+      expect(createdTask.routingSource).toBe("engine_default");
       expect(createdTask.status).toBe("pending"); // Should be pending when assigned to agent
     });
 
@@ -421,13 +422,19 @@ describe("Scheduled Tasks Integration", () => {
 
       // Find the created task
       const createdTask = (await getDbClient().get(
-        "SELECT *, routing_reason AS routingReason FROM agent_tasks WHERE task = ? ORDER BY createdAt DESC LIMIT 1",
+        "SELECT *, routing_reason AS routingReason, routing_source AS routingSource FROM agent_tasks WHERE task = ? ORDER BY createdAt DESC LIMIT 1",
         [schedule.taskTemplate!],
-      )) as { agentId: string | null; routingReason: string | null; status: string };
+      )) as {
+        agentId: string | null;
+        routingReason: string | null;
+        routingSource: string | null;
+        status: string;
+      };
 
       expect(createdTask).toBeDefined();
       expect(createdTask.agentId).toBeNull();
       expect(createdTask.routingReason).toBeNull();
+      expect(createdTask.routingSource).toBeNull();
       expect(createdTask.status).toBe("unassigned");
     });
 
@@ -531,7 +538,7 @@ describe("Scheduled Tasks Integration", () => {
 
       // Find the created task
       const createdTask = (await getDbClient().get(
-        "SELECT *, routing_reason AS routingReason FROM agent_tasks WHERE task = ? ORDER BY createdAt DESC LIMIT 1",
+        "SELECT *, routing_reason AS routingReason, routing_source AS routingSource FROM agent_tasks WHERE task = ? ORDER BY createdAt DESC LIMIT 1",
         [schedule.taskTemplate!],
       )) as {
         task: string;
@@ -540,6 +547,7 @@ describe("Scheduled Tasks Integration", () => {
         priority: number;
         agentId: string;
         routingReason: string;
+        routingSource: string;
         creatorAgentId: string;
       };
 
@@ -548,6 +556,7 @@ describe("Scheduled Tasks Integration", () => {
       expect(createdTask.priority).toBe(90);
       expect(createdTask.agentId).toBe(testAgent.id);
       expect(createdTask.routingReason).toBe("human_pinned");
+      expect(createdTask.routingSource).toBe("engine_default");
       expect(createdTask.creatorAgentId).toBe(testAgent.id);
 
       const tags = JSON.parse(createdTask.tags);