@desplega.ai/agent-swarm 1.113.0 → 1.115.0

package/src/tests/jira-sync.test.ts

@@ -1,6 +1,14 @@
 import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
 import { unlink } from "node:fs/promises";
-import { closeDb, completeTask, createAgent, getDb, getTaskById, initDb } from "../be/db";
+import {
+  closeDb,
+  completeTask,
+  createAgent,
+  createUser,
+  getDb,
+  getTaskById,
+  initDb,
+} from "../be/db";
 import { upsertOAuthApp } from "../be/db-queries/oauth";
 import {
   createTrackerSync,
@@ -8,6 +16,9 @@ import {
   getTrackerSyncByExternalId,
   updateTrackerSync,
 } from "../be/db-queries/tracker";
+import { findUserByExternalId, type IdentityActor, linkIdentity } from "../be/users";
+
+const SYSTEM_ACTOR: IdentityActor = { kind: "system", id: "test" };
 
 const TEST_DB_PATH = "./test-jira-sync.sqlite";
 const BOT_ACCOUNT_ID = "bot-account-12345";
@@ -303,6 +314,93 @@ describe("handleCommentEvent — short-circuits", () => {
   });
 });
 
+describe("identity resolution — Jira routes through resolveIdentity, never raw displayName", () => {
+  test("issue-assigned: reporter linked by accountId -> requestedByUserId set + rendered pair in task text", async () => {
+    const reporter = createUser({ name: "Zbigniew Reporter", email: "zbigniew-jira@example.com" });
+    linkIdentity(reporter.id, "jira", "reporter-linked-1", SYSTEM_ACTOR);
+
+    const event = makeIssueAssignedEvent("10030", "KAN-30", "Linked reporter issue");
+    event.issue.fields.reporter = {
+      displayName: "Reporter Name",
+      accountId: "reporter-linked-1",
+    };
+    await handleIssueEvent(event);
+
+    const sync = getTrackerSyncByExternalId("jira", "task", "10030");
+    const task = getTaskById(sync?.swarmId ?? "");
+    expect(task).not.toBeNull();
+    expect(task?.requestedByUserId).toBe(reporter.id);
+    expect(task?.task).toContain("Zbigniew Reporter (jira:reporter-linked-1)");
+    expect(task?.task).not.toContain("Reporter Name");
+  });
+
+  test("issue-assigned: reporter with an email but no prior link auto-links via findOrCreateUserByEmail", async () => {
+    const event = makeIssueAssignedEvent("10031", "KAN-31", "Email-cascade issue");
+    event.issue.fields.reporter = {
+      displayName: "Auto Linked",
+      accountId: "reporter-autolink-1",
+      emailAddress: "auto-linked-jira@example.com",
+    };
+    await handleIssueEvent(event);
+
+    const linked = findUserByExternalId("jira", "reporter-autolink-1");
+    expect(linked).not.toBeNull();
+    expect(linked?.name).toBe("Auto Linked");
+
+    const sync = getTrackerSyncByExternalId("jira", "task", "10031");
+    const task = getTaskById(sync?.swarmId ?? "");
+    expect(task?.requestedByUserId).toBe(linked?.id);
+    expect(task?.task).toContain("Auto Linked (jira:reporter-autolink-1)");
+  });
+
+  test("issue-assigned: unlinked reporter with no email renders the UNKNOWN sentinel, never the displayName", async () => {
+    const event = makeIssueAssignedEvent("10032", "KAN-32", "Unknown reporter issue");
+    event.issue.fields.reporter = {
+      displayName: "Never Registered",
+      accountId: "reporter-unknown-1",
+    };
+    await handleIssueEvent(event);
+
+    const sync = getTrackerSyncByExternalId("jira", "task", "10032");
+    const task = getTaskById(sync?.swarmId ?? "");
+    expect(task).not.toBeNull();
+    expect(task?.requestedByUserId ?? null).toBeNull();
+    expect(task?.task).toContain("jira:reporter-unknown-1 (unknown user)");
+    expect(task?.task).not.toContain("Never Registered");
+  });
+
+  test("comment-mention: linked author -> requestedByUserId set + rendered pair as comment_author", async () => {
+    const author = createUser({ name: "Manuel Commenter", email: "manuel-jira@example.com" });
+    linkIdentity(author.id, "jira", "commenter-linked-1", SYSTEM_ACTOR);
+
+    await handleCommentEvent(
+      makeCommentEvent("10033", "KAN-33", "commenter-linked-1", "please take a look", [
+        BOT_ACCOUNT_ID,
+      ]),
+    );
+
+    const sync = getTrackerSyncByExternalId("jira", "task", "10033");
+    const task = getTaskById(sync?.swarmId ?? "");
+    expect(task).not.toBeNull();
+    expect(task?.requestedByUserId).toBe(author.id);
+    expect(task?.task).toContain("Manuel Commenter (jira:commenter-linked-1)");
+    expect(task?.task).not.toContain("Some User");
+  });
+
+  test("comment-mention: unlinked author renders the UNKNOWN sentinel, never the raw displayName", async () => {
+    await handleCommentEvent(
+      makeCommentEvent("10034", "KAN-34", "commenter-unknown-1", "any updates?", [BOT_ACCOUNT_ID]),
+    );
+
+    const sync = getTrackerSyncByExternalId("jira", "task", "10034");
+    const task = getTaskById(sync?.swarmId ?? "");
+    expect(task).not.toBeNull();
+    expect(task?.requestedByUserId ?? null).toBeNull();
+    expect(task?.task).toContain("jira:commenter-unknown-1 (unknown user)");
+    expect(task?.task).not.toContain("Some User");
+  });
+});
+
 describe("createTrackerSyncIfAbsent — UNIQUE-gated insert", () => {
   test("first call inserts; second call returns existing", () => {
     const first = createTrackerSyncIfAbsent({

package/src/tests/kapso-inbound.test.ts

@@ -147,6 +147,10 @@ describe("routeKapsoInbound", () => {
     const task = getTaskById(routing.taskId);
     expect(task!.requestedByUserId).toBe(user.id);
     expect(getKv("integration:unmapped:kapso", "34679077778:meta")).toBeNull();
+    // The resolved canonical name renders in the task text — never the raw
+    // WhatsApp profile `contact_name` ("Taras" from the fixture payload).
+    expect(task!.task).toContain("Known WhatsApp Sender (kapso:34679077778)");
+    expect(task!.task).not.toContain("Taras");
   });
 
   test("unknown Kapso sender → records unmapped identity and leaves task unowned", () => {
@@ -170,6 +174,9 @@ describe("routeKapsoInbound", () => {
     if (routing.kind !== "task") throw new Error("expected task");
     const task = getTaskById(routing.taskId);
     expect(task!.requestedByUserId).toBeUndefined();
+    // Unresolved -> explicit UNKNOWN sentinel, never the raw contact_name.
+    expect(task!.task).toContain("kapso:34679077779 (unknown user)");
+    expect(task!.task).not.toContain("Taras");
 
     const meta = getKv("integration:unmapped:kapso", "34679077779:meta");
     expect(meta?.valueType).toBe("json");

package/src/tests/mcp-tools-user.test.ts

@@ -106,12 +106,17 @@ describe("resolve-user MCP tool (new {kind, externalId, email} shape)", () => {
     expect(textOf(byAlias)).toContain(user.id);
   });
 
-  test("returns 'No user found' when nothing matches", async () => {
+  test("returns a structured {status: 'unknown', ...} payload when nothing matches — never prose", async () => {
     const result = await callTool(server, "resolve-user", {
       kind: "slack",
       externalId: "U_DOES_NOT_EXIST",
     });
-    expect(textOf(result)).toContain("No user found");
+    const parsed = JSON.parse(textOf(result));
+    expect(parsed).toEqual({
+      status: "unknown",
+      kind: "slack",
+      externalId: "U_DOES_NOT_EXIST",
+    });
   });
 
   // Schema-level validation tests. The MCP SDK runs Zod at the transport
@@ -132,12 +137,17 @@ describe("resolve-user MCP tool (new {kind, externalId, email} shape)", () => {
     expect(parsed.success).toBe(false);
     if (!parsed.success) {
       const msg = JSON.stringify(parsed.error.issues);
-      expect(msg).toMatch(/Provide either \(kind \+ externalId\), email, or userId/);
+      expect(msg).toMatch(/Provide either \(kind \+ externalId\), email, userId, or name/);
     }
   });
 
-  test("name parameter (old shape) is rejected", () => {
+  test("valid {name} input passes the schema", () => {
     const parsed = resolveUserInputSchema.safeParse({ name: "Whoever" });
+    expect(parsed.success).toBe(true);
+  });
+
+  test("name shorter than 2 chars fails the min-length constraint", () => {
+    const parsed = resolveUserInputSchema.safeParse({ name: "A" });
     expect(parsed.success).toBe(false);
   });
 
@@ -201,9 +211,53 @@ describe("resolve-user MCP tool (new {kind, externalId, email} shape)", () => {
     expect(parsed.externalIds[0]).toMatchObject({ kind: "linear", externalId: "L_UIDLOOKUP" });
   });
 
-  test("userId lookup returns 'No user found' for unknown ID", async () => {
+  test("userId lookup returns a structured {status: 'unknown', ...} payload for an unknown ID", async () => {
     const result = await callTool(server, "resolve-user", { userId: "nonexistent-user-id-xyz" });
-    expect(textOf(result)).toContain("No user found");
+    const parsed = JSON.parse(textOf(result));
+    expect(parsed).toEqual({
+      status: "unknown",
+      kind: "userId",
+      externalId: "nonexistent-user-id-xyz",
+    });
+  });
+
+  test("name lookup: single exact match resolves to the user profile", async () => {
+    const user = createUser({ name: "Zbigniew Solo", email: "zbigniew@example.com" });
+
+    const result = await callTool(server, "resolve-user", { name: "Zbigniew Solo" });
+    const parsed = JSON.parse(textOf(result));
+    expect(parsed.id).toBe(user.id);
+    expect(parsed.name).toBe("Zbigniew Solo");
+  });
+
+  test("name lookup: single first-token prefix match resolves to the user profile", async () => {
+    const user = createUser({ name: "Priyanka Unique Prefix", email: "priyanka@example.com" });
+
+    const result = await callTool(server, "resolve-user", { name: "Priyanka" });
+    const parsed = JSON.parse(textOf(result));
+    expect(parsed.id).toBe(user.id);
+  });
+
+  test("name lookup: multiple matches return {status: 'ambiguous', candidates: [...]} — never a guess", async () => {
+    const a = createUser({ name: "Alberto Maurel", email: "alberto.maurel@example.com" });
+    const b = createUser({ name: "Alberto Dubois", email: "alberto.dubois@example.com" });
+
+    const result = await callTool(server, "resolve-user", { name: "Alberto" });
+    const parsed = JSON.parse(textOf(result));
+    expect(parsed.status).toBe("ambiguous");
+    expect(parsed.message).toMatch(/AMBIGUOUS/);
+    const candidateIds = parsed.candidates.map((c: { userId: string }) => c.userId).sort();
+    expect(candidateIds).toEqual([a.id, b.id].sort());
+  });
+
+  test("name lookup: zero matches return a structured {status: 'unknown', kind: 'name', ...} payload", async () => {
+    const result = await callTool(server, "resolve-user", { name: "Nobody Registered Xyz" });
+    const parsed = JSON.parse(textOf(result));
+    expect(parsed).toEqual({
+      status: "unknown",
+      kind: "name",
+      externalId: "Nobody Registered Xyz",
+    });
   });
 });
 

package/src/tests/model-control.test.ts

@@ -485,7 +485,10 @@ describe("Model Control - Priority Resolution Logic", () => {
 
   test("task.modelTier resolves using the claiming worker harness", () => {
     expect(resolveModelTier({ tier: "smol", harnessProvider: "claude" })).toBe("haiku");
-    expect(resolveModelTier({ tier: "smol", harnessProvider: "codex" })).toBe("gpt-5.4-mini");
+    expect(resolveModelTier({ tier: "smol", harnessProvider: "codex" })).toBe("gpt-5.6-luna");
+    expect(resolveModelTier({ tier: "regular", harnessProvider: "codex" })).toBe("gpt-5.6-terra");
+    expect(resolveModelTier({ tier: "smart", harnessProvider: "codex" })).toBe("gpt-5.6-sol");
+    expect(resolveModelTier({ tier: "ultra", harnessProvider: "codex" })).toBe("gpt-5.6-sol");
     expect(resolveModelTier({ tier: "smart", harnessProvider: "opencode" })).toBe(
       "openrouter/deepseek/deepseek-v4-pro",
     );
@@ -561,11 +564,14 @@ describe("Model Control - Zod Validation Schema", () => {
       sendTaskInputSchema.parse({ agentId: crypto.randomUUID(), task: "x", effort: "xhigh" })
         .effort,
     ).toBe("xhigh");
+    expect(
+      sendTaskInputSchema.parse({ agentId: crypto.randomUUID(), task: "x", effort: "max" }).effort,
+    ).toBe("max");
     expect(taskActionInputSchema.parse({ action: "create", task: "x", effort: "off" }).effort).toBe(
       "off",
     );
     expect(() =>
-      sendTaskInputSchema.parse({ agentId: crypto.randomUUID(), task: "x", effort: "max" }),
+      sendTaskInputSchema.parse({ agentId: crypto.randomUUID(), task: "x", effort: "ultra" }),
     ).toThrow();
   });