@vellumai/assistant 0.10.2 → 0.10.3-dev.202606252046.9075fd5

package/src/runtime/__tests__/trust-verdict-consumer.test.ts

@@ -2,15 +2,21 @@ import { describe, expect, test } from "bun:test";
 
 import type { TrustVerdict } from "@vellumai/gateway-client";
 
+import { channelStatusToMemberStatus } from "../../contacts/member-status.js";
 import type {
+  ChannelPolicy,
+  ChannelStatus,
   ContactChannel,
   ContactWithChannels,
 } from "../../contacts/types.js";
 import type { ActorTrustContext } from "../actor-trust-resolver.js";
 import { toTrustContext } from "../actor-trust-resolver.js";
 import {
-  resolvedMemberFromVerdict,
+  actorTrustContextFromVerdict,
   trustContextFromVerdict,
+  verdictHasMemberIdentity,
+  verdictMemberFromVerdict,
+  verdictMemberUnresolvable,
 } from "../trust-verdict-consumer.js";
 
 const CONV = "conv-123";
@@ -163,10 +169,266 @@ describe("trustContextFromVerdict", () => {
   });
 });
 
+describe("actorTrustContextFromVerdict", () => {
+  test("maps guardian verdict fields", () => {
+    const verdict = {
+      trustClass: "guardian",
+      canonicalSenderId: "+15550100",
+      guardianExternalUserId: "+15550100",
+      guardianDeliveryChatId: "chat-9",
+      guardianPrincipalId: "vellum-principal-abc",
+      memberDisplayName: "Alice",
+    } satisfies TrustVerdict;
+
+    const ctx = actorTrustContextFromVerdict(verdict, {
+      sourceChannel: "phone",
+      conversationExternalId: CONV,
+      actorUsername: "alice",
+      actorDisplayName: "Alice Sender",
+    });
+
+    expect(ctx).toEqual({
+      canonicalSenderId: "+15550100",
+      guardianBindingMatch: {
+        guardianExternalUserId: "+15550100",
+        guardianDeliveryChatId: "chat-9",
+      },
+      guardianPrincipalId: "vellum-principal-abc",
+      memberRecord: null,
+      trustClass: "guardian",
+      actorMetadata: {
+        identifier: "@alice",
+        displayName: "Alice",
+        senderDisplayName: "Alice Sender",
+        memberDisplayName: "Alice",
+        username: "alice",
+        channel: "phone",
+        trustStatus: "guardian",
+      },
+    });
+  });
+
+  test("guardianBindingMatch is null without guardianExternalUserId", () => {
+    const verdict = {
+      trustClass: "trusted_contact",
+      canonicalSenderId: "+15550101",
+      memberDisplayName: "Bob",
+    } satisfies TrustVerdict;
+
+    const ctx = actorTrustContextFromVerdict(verdict, {
+      sourceChannel: "phone",
+      conversationExternalId: CONV,
+    });
+
+    expect(ctx.guardianBindingMatch).toBeNull();
+    expect(ctx.trustClass).toBe("trusted_contact");
+    // identifier falls back to canonicalSenderId when no username.
+    expect(ctx.actorMetadata.identifier).toBe("+15550101");
+    // displayName uses memberDisplayName when present.
+    expect(ctx.actorMetadata.displayName).toBe("Bob");
+    expect(ctx.actorMetadata.channel).toBe("phone");
+    expect(ctx.memberRecord).toBeNull();
+  });
+
+  test("displayName falls back to actorDisplayName; identifier uses @username", () => {
+    const verdict = {
+      trustClass: "unverified_contact",
+      canonicalSenderId: "u-1",
+    } satisfies TrustVerdict;
+
+    const ctx = actorTrustContextFromVerdict(verdict, {
+      sourceChannel: "slack",
+      conversationExternalId: CONV,
+      actorUsername: "carol",
+      actorDisplayName: "Carol Display",
+    });
+
+    expect(ctx.trustClass).toBe("unverified_contact");
+    expect(ctx.actorMetadata.identifier).toBe("@carol");
+    expect(ctx.actorMetadata.displayName).toBe("Carol Display");
+    expect(ctx.actorMetadata.memberDisplayName).toBeUndefined();
+    expect(ctx.actorMetadata.trustStatus).toBe("unverified_contact");
+  });
+
+  test("maps unknown verdict with no identity overrides", () => {
+    const verdict = {
+      trustClass: "unknown",
+      canonicalSenderId: "u-2",
+    } satisfies TrustVerdict;
+
+    const ctx = actorTrustContextFromVerdict(verdict, {
+      sourceChannel: "slack",
+      conversationExternalId: CONV,
+    });
+
+    expect(ctx.trustClass).toBe("unknown");
+    expect(ctx.guardianBindingMatch).toBeNull();
+    expect(ctx.guardianPrincipalId).toBeUndefined();
+    expect(ctx.memberRecord).toBeNull();
+    expect(ctx.actorMetadata.identifier).toBe("u-2");
+    expect(ctx.actorMetadata.displayName).toBeUndefined();
+  });
+
+  test("member verdict populates memberRecord from the verdict (voice ACL)", () => {
+    const verdict = {
+      trustClass: "trusted_contact",
+      canonicalSenderId: "u-1",
+      contactId: "contact-1",
+      channelId: "channel-1",
+      type: "slack",
+      address: "u-1",
+      status: "blocked",
+      policy: "deny",
+    } satisfies TrustVerdict;
+
+    const ctx = actorTrustContextFromVerdict(verdict, {
+      sourceChannel: "slack",
+      conversationExternalId: CONV,
+    });
+
+    expect(ctx.memberRecord).not.toBeNull();
+    expect(ctx.memberRecord!.contact.id).toBe("contact-1");
+    expect(ctx.memberRecord!.channel.id).toBe("channel-1");
+    expect(ctx.memberRecord!.status).toBe("blocked");
+    expect(ctx.memberRecord!.policy).toBe("deny");
+  });
+
+  test("memberRecord surfaces channel ACL/identity, info fields null", () => {
+    const verdict = {
+      trustClass: "trusted_contact",
+      canonicalSenderId: "u-1",
+      contactId: "contact-1",
+      channelId: "channel-1",
+      type: "slack",
+      address: "u-1",
+      status: "active",
+      policy: "allow",
+      externalChatId: "chat-1",
+      verifiedAt: 1700000000,
+      verifiedVia: "code",
+      memberDisplayName: "Dora",
+    } satisfies TrustVerdict;
+
+    const { memberRecord } = actorTrustContextFromVerdict(verdict, {
+      sourceChannel: "slack",
+      conversationExternalId: CONV,
+    });
+    expect(memberRecord!.status).toBe("active");
+    expect(memberRecord!.policy).toBe("allow");
+    expect(memberRecord!.channel.externalChatId).toBe("chat-1");
+
+    expect(memberRecord!.contact.displayName).toBe("Dora");
+    expect(memberRecord!.role).toBe("contact");
+    // INFO fields must be null/default placeholders.
+    expect(memberRecord!.contact.notes).toBeNull();
+    expect(memberRecord!.contact.userFile).toBeNull();
+    expect(memberRecord!.contact.interactionCount).toBe(0);
+    expect(memberRecord!.contact.lastInteraction).toBeNull();
+  });
+
+  test("guardian member verdict maps role guardian + principalId", () => {
+    const verdict = {
+      trustClass: "guardian",
+      canonicalSenderId: "u-g",
+      contactId: "contact-g",
+      channelId: "channel-g",
+      guardianPrincipalId: "vellum-principal-g",
+      status: "active",
+      policy: "allow",
+    } satisfies TrustVerdict;
+
+    const ctx = actorTrustContextFromVerdict(verdict, {
+      sourceChannel: "slack",
+      conversationExternalId: CONV,
+    });
+    expect(ctx.memberRecord!.role).toBe("guardian");
+    expect(ctx.guardianPrincipalId).toBe("vellum-principal-g");
+  });
+
+  test("memberRecord null when status missing (fail-closed)", () => {
+    const verdict = {
+      trustClass: "trusted_contact",
+      canonicalSenderId: "u-4",
+      contactId: "contact-4",
+      channelId: "channel-4",
+      policy: "allow",
+    } satisfies TrustVerdict;
+
+    expect(
+      actorTrustContextFromVerdict(verdict, {
+        sourceChannel: "slack",
+        conversationExternalId: CONV,
+      }).memberRecord,
+    ).toBeNull();
+  });
+
+  test("stranger verdict (no contactId/channelId) leaves memberRecord null", () => {
+    const verdict = {
+      trustClass: "unknown",
+      canonicalSenderId: "u-9",
+    } satisfies TrustVerdict;
+
+    const ctx = actorTrustContextFromVerdict(verdict, {
+      sourceChannel: "slack",
+      conversationExternalId: CONV,
+    });
+
+    expect(ctx.memberRecord).toBeNull();
+  });
+
+  test("malformed member verdict (unknown status) leaves memberRecord null (fail-closed)", () => {
+    const verdict = {
+      trustClass: "trusted_contact",
+      canonicalSenderId: "u-10",
+      contactId: "contact-10",
+      channelId: "channel-10",
+      status: "quarantined",
+      policy: "allow",
+    } satisfies TrustVerdict;
+
+    const ctx = actorTrustContextFromVerdict(verdict, {
+      sourceChannel: "slack",
+      conversationExternalId: CONV,
+    });
+
+    expect(ctx.memberRecord).toBeNull();
+  });
+
+  test("trustContextFromVerdict equals member stamp applied to toTrustContext(actorTrustContextFromVerdict)", () => {
+    const verdict = {
+      trustClass: "trusted_contact",
+      canonicalSenderId: "u-1",
+      contactId: "contact-1",
+      channelId: "channel-1",
+      type: "slack",
+      address: "u-1",
+      status: "unverified",
+      policy: "escalate",
+      memberDisplayName: "Dora",
+    } satisfies TrustVerdict;
+    const input = {
+      sourceChannel: "slack",
+      conversationExternalId: CONV,
+      actorUsername: "dora",
+      actorDisplayName: "Dora Display",
+    } as const;
+
+    const expected = toTrustContext(
+      actorTrustContextFromVerdict(verdict, input),
+      input.conversationExternalId,
+    );
+    const member = verdictMemberFromVerdict(verdict);
+    expect(member).not.toBeNull();
+    expected.requesterContactId = member!.contactId;
+    expected.memberStatus = channelStatusToMemberStatus(member!.status);
+    expected.memberPolicy = member!.policy;
+
+    expect(trustContextFromVerdict(verdict, input)).toEqual(expected);
+  });
+});
+
 describe("toTrustContext member grounding", () => {
-  function memberChannel(
-    overrides: Partial<ContactChannel> = {},
-  ): ContactChannel {
+  function memberChannel(): ContactChannel {
     return {
       id: "channel-1",
       contactId: "contact-1",
@@ -174,19 +436,12 @@ describe("toTrustContext member grounding", () => {
       address: "+15550100",
       isPrimary: true,
       externalChatId: null,
-      status: "unverified",
-      policy: "escalate",
-      verifiedAt: null,
-      verifiedVia: null,
       inviteId: null,
-      revokedReason: null,
-      blockedReason: null,
       lastSeenAt: null,
       interactionCount: 0,
       lastInteraction: null,
       updatedAt: null,
       createdAt: 0,
-      ...overrides,
     };
   }
 
@@ -195,26 +450,34 @@ describe("toTrustContext member grounding", () => {
       id: "contact-1",
       displayName: "Frank",
       notes: null,
+      role: "contact",
       lastInteraction: null,
       interactionCount: 0,
       createdAt: 0,
       updatedAt: 0,
-      role: "contact",
       contactType: "human",
-      principalId: null,
       userFile: null,
       channels: [memberChannel()],
     };
   }
 
   function ctxWithMember(
-    channel: ContactChannel,
+    acl: { status: ChannelStatus; policy: ChannelPolicy } = {
+      status: "unverified",
+      policy: "escalate",
+    },
   ): ActorTrustContext {
     return {
       canonicalSenderId: "+15550100",
       guardianBindingMatch: null,
       guardianPrincipalId: undefined,
-      memberRecord: { contact: memberContact(), channel },
+      memberRecord: {
+        contact: memberContact(),
+        channel: memberChannel(),
+        status: acl.status,
+        policy: acl.policy,
+        role: "contact",
+      },
       trustClass: "trusted_contact",
       actorMetadata: {
         identifier: "+15550100",
@@ -229,7 +492,7 @@ describe("toTrustContext member grounding", () => {
   }
 
   test("populates member fields from memberRecord (voice path)", () => {
-    const context = toTrustContext(ctxWithMember(memberChannel()), CONV);
+    const context = toTrustContext(ctxWithMember(), CONV);
     expect(context.requesterContactId).toBe("contact-1");
     // "unverified" maps to the API-facing "pending" member status.
     expect(context.memberStatus).toBe("pending");
@@ -238,7 +501,7 @@ describe("toTrustContext member grounding", () => {
 
   test("passes through active status + allow policy", () => {
     const context = toTrustContext(
-      ctxWithMember(memberChannel({ status: "active", policy: "allow" })),
+      ctxWithMember({ status: "active", policy: "allow" }),
       CONV,
     );
     expect(context.memberStatus).toBe("active");
@@ -271,8 +534,8 @@ describe("toTrustContext member grounding", () => {
   });
 });
 
-describe("resolvedMemberFromVerdict", () => {
-  test("member verdict surfaces channel ACL/identity, info fields null", () => {
+describe("verdictMemberFromVerdict", () => {
+  test("active member verdict yields the narrow ACL view", () => {
     const verdict = {
       trustClass: "trusted_contact",
       canonicalSenderId: "u-1",
@@ -282,136 +545,152 @@ describe("resolvedMemberFromVerdict", () => {
       address: "u-1",
       status: "active",
       policy: "allow",
-      externalChatId: "chat-1",
       verifiedAt: 1700000000,
-      verifiedVia: "code",
       memberDisplayName: "Dora",
     } satisfies TrustVerdict;
 
-    const member = resolvedMemberFromVerdict(verdict);
-    expect(member).not.toBeNull();
-    expect(member!.channel.id).toBe("channel-1");
-    expect(member!.channel.status).toBe("active");
-    expect(member!.channel.policy).toBe("allow");
-    expect(member!.channel.verifiedAt).toBe(1700000000);
-    expect(member!.channel.verifiedVia).toBe("code");
-    expect(member!.channel.externalChatId).toBe("chat-1");
-
-    expect(member!.contact.id).toBe("contact-1");
-    expect(member!.contact.displayName).toBe("Dora");
-    expect(member!.contact.role).toBe("contact");
-    // INFO fields must be null/default placeholders.
-    expect(member!.contact.notes).toBeNull();
-    expect(member!.contact.userFile).toBeNull();
-    expect(member!.contact.interactionCount).toBe(0);
-    expect(member!.contact.lastInteraction).toBeNull();
-  });
-
-  test("guardian member verdict maps role guardian + principalId", () => {
-    const verdict = {
-      trustClass: "guardian",
-      canonicalSenderId: "u-g",
-      contactId: "contact-g",
-      channelId: "channel-g",
-      guardianPrincipalId: "vellum-principal-g",
+    expect(verdictMemberFromVerdict(verdict)).toEqual({
+      contactId: "contact-1",
+      channelId: "channel-1",
       status: "active",
       policy: "allow",
-    } satisfies TrustVerdict;
-
-    const member = resolvedMemberFromVerdict(verdict);
-    expect(member!.contact.role).toBe("guardian");
-    expect(member!.contact.principalId).toBe("vellum-principal-g");
+      verifiedAt: 1700000000,
+      displayName: "Dora",
+    });
   });
 
-  test("memberless verdict (no contactId) returns null", () => {
+  test("blocked member verdict surfaces status/policy verbatim, null defaults", () => {
     const verdict = {
       trustClass: "unknown",
-      canonicalSenderId: "u-2",
+      canonicalSenderId: "u-3",
+      contactId: "contact-3",
+      channelId: "channel-3",
+      status: "blocked",
+      policy: "deny",
     } satisfies TrustVerdict;
 
-    expect(resolvedMemberFromVerdict(verdict)).toBeNull();
+    expect(verdictMemberFromVerdict(verdict)).toEqual({
+      contactId: "contact-3",
+      channelId: "channel-3",
+      status: "blocked",
+      policy: "deny",
+      verifiedAt: null,
+      displayName: null,
+    });
   });
 
-  test("member verdict missing status returns null (fail-closed)", () => {
-    const verdict = {
-      trustClass: "trusted_contact",
-      canonicalSenderId: "u-4",
-      contactId: "contact-4",
-      channelId: "channel-4",
-      policy: "allow",
-    } satisfies TrustVerdict;
-
-    expect(resolvedMemberFromVerdict(verdict)).toBeNull();
+  test("memberless verdict (no contactId/channelId) returns null", () => {
+    expect(
+      verdictMemberFromVerdict({
+        trustClass: "unknown",
+        canonicalSenderId: "u-2",
+      } satisfies TrustVerdict),
+    ).toBeNull();
   });
 
-  test("member verdict missing policy returns null (fail-closed)", () => {
-    const verdict = {
-      trustClass: "trusted_contact",
-      canonicalSenderId: "u-5",
-      contactId: "contact-5",
-      channelId: "channel-5",
-      status: "active",
-    } satisfies TrustVerdict;
-
-    expect(resolvedMemberFromVerdict(verdict)).toBeNull();
+  test("invalid enum (unknown status/policy) returns null (fail-closed)", () => {
+    expect(
+      verdictMemberFromVerdict({
+        trustClass: "trusted_contact",
+        canonicalSenderId: "u-7",
+        contactId: "contact-7",
+        channelId: "channel-7",
+        status: "quarantined",
+        policy: "allow",
+      } satisfies TrustVerdict),
+    ).toBeNull();
+    expect(
+      verdictMemberFromVerdict({
+        trustClass: "trusted_contact",
+        canonicalSenderId: "u-6",
+        contactId: "contact-6",
+        channelId: "channel-6",
+        status: "active",
+        policy: "bogus",
+      } satisfies TrustVerdict),
+    ).toBeNull();
   });
 
-  test("member verdict with unknown policy returns null (fail-closed)", () => {
-    const verdict = {
-      trustClass: "trusted_contact",
-      canonicalSenderId: "u-6",
-      contactId: "contact-6",
-      channelId: "channel-6",
-      status: "active",
-      policy: "bogus",
-    } satisfies TrustVerdict;
-
-    expect(resolvedMemberFromVerdict(verdict)).toBeNull();
+  test("missing status or policy returns null (fail-closed)", () => {
+    expect(
+      verdictMemberFromVerdict({
+        trustClass: "trusted_contact",
+        canonicalSenderId: "u-4",
+        contactId: "contact-4",
+        channelId: "channel-4",
+        policy: "allow",
+      } satisfies TrustVerdict),
+    ).toBeNull();
+    expect(
+      verdictMemberFromVerdict({
+        trustClass: "trusted_contact",
+        canonicalSenderId: "u-5",
+        contactId: "contact-5",
+        channelId: "channel-5",
+        status: "active",
+      } satisfies TrustVerdict),
+    ).toBeNull();
   });
+});
 
-  test("member verdict with unknown status returns null (fail-closed)", () => {
-    const verdict = {
-      trustClass: "trusted_contact",
-      canonicalSenderId: "u-7",
-      contactId: "contact-7",
-      channelId: "channel-7",
-      status: "quarantined",
-      policy: "allow",
-    } satisfies TrustVerdict;
+describe("verdict predicates", () => {
+  test("verdictHasMemberIdentity is true with contactId or channelId", () => {
+    expect(
+      verdictHasMemberIdentity({
+        trustClass: "unknown",
+        canonicalSenderId: "u-1",
+        contactId: "contact-1",
+      } satisfies TrustVerdict),
+    ).toBe(true);
+    expect(
+      verdictHasMemberIdentity({
+        trustClass: "unknown",
+        canonicalSenderId: "u-1",
+        channelId: "channel-1",
+      } satisfies TrustVerdict),
+    ).toBe(true);
+  });
 
-    expect(resolvedMemberFromVerdict(verdict)).toBeNull();
+  test("verdictHasMemberIdentity is false for a memberless verdict", () => {
+    expect(
+      verdictHasMemberIdentity({
+        trustClass: "unknown",
+        canonicalSenderId: "u-1",
+      } satisfies TrustVerdict),
+    ).toBe(false);
   });
 
-  test("member verdict with valid known status+policy returns a member", () => {
-    const verdict = {
-      trustClass: "trusted_contact",
-      canonicalSenderId: "u-8",
-      contactId: "contact-8",
-      channelId: "channel-8",
-      status: "active",
-      policy: "allow",
-    } satisfies TrustVerdict;
+  test("verdictMemberUnresolvable is true when member identity present but ACL unsynthesizable", () => {
+    expect(
+      verdictMemberUnresolvable({
+        trustClass: "trusted_contact",
+        canonicalSenderId: "u-1",
+        contactId: "contact-1",
+        channelId: "channel-1",
+        policy: "allow",
+      } satisfies TrustVerdict),
+    ).toBe(true);
+  });
 
-    const member = resolvedMemberFromVerdict(verdict);
-    expect(member).not.toBeNull();
-    expect(member!.channel.status).toBe("active");
-    expect(member!.channel.policy).toBe("allow");
+  test("verdictMemberUnresolvable is false for a usable member verdict", () => {
+    expect(
+      verdictMemberUnresolvable({
+        trustClass: "trusted_contact",
+        canonicalSenderId: "u-1",
+        contactId: "contact-1",
+        channelId: "channel-1",
+        status: "active",
+        policy: "allow",
+      } satisfies TrustVerdict),
+    ).toBe(false);
   });
 
-  test("blocked/revoked verdict surfaces channel.status verbatim", () => {
-    for (const status of ["blocked", "revoked"] as const) {
-      const verdict = {
+  test("verdictMemberUnresolvable is false for a memberless verdict", () => {
+    expect(
+      verdictMemberUnresolvable({
         trustClass: "unknown",
-        canonicalSenderId: "u-3",
-        contactId: "contact-3",
-        channelId: "channel-3",
-        status,
-        policy: "deny",
-      } satisfies TrustVerdict;
-
-      const member = resolvedMemberFromVerdict(verdict);
-      expect(member!.channel.status).toBe(status);
-      expect(member!.channel.policy).toBe("deny");
-    }
+        canonicalSenderId: "u-1",
+      } satisfies TrustVerdict),
+    ).toBe(false);
   });
 });