@vellumai/assistant 0.10.5 → 0.10.6-dev.202607062043.72bc40b

package/node_modules/@vellumai/gateway-client/src/__tests__/invite-contract.test.ts

@@ -0,0 +1,233 @@
+/**
+ * Tests for the shared invite contract.
+ *
+ * The pinned hash vectors below define the hash compatibility contract:
+ * `hashInviteToken` and `hashInviteCode` must produce exactly these outputs
+ * because invite hashes already stored in the assistant and gateway DBs were
+ * produced with them. Do not update the vectors to "fix" a failure — a
+ * mismatch means the hash scheme broke.
+ */
+
+import { describe, expect, test } from "bun:test";
+
+import {
+  ActiveVoiceInviteSchema,
+  generateInviteCode,
+  generateInviteToken,
+  GetActiveVoiceInviteRequestSchema,
+  hashInviteCode,
+  hashInviteToken,
+  INVITE_CODE_REDEMPTION_CHANNELS,
+  InviteRedemptionOutcomeSchema,
+  isInviteCodeRedemptionEnabled,
+  isValidE164,
+  RedeemInviteByCodeRequestSchema,
+  RedeemInviteByTokenRequestSchema,
+  RedeemVoiceInviteRequestSchema,
+  type InviteRedemptionOutcome,
+} from "../invite-contract.js";
+
+describe("hash helpers — pinned compatibility vectors", () => {
+  test("hashInviteToken matches invite-store.ts hashToken output", () => {
+    expect(hashInviteToken("test-raw-token")).toBe(
+      "7ef58e99b3406554f5ce0c0055b8ed3ea4db2c8a36613092d644c57c6a033330",
+    );
+    expect(hashInviteToken("AbC123_-xyz")).toBe(
+      "860c47c13bb8d13decd6815b20be7de8cf11597e4b704af58b00048e90a5a337",
+    );
+  });
+
+  test("hashInviteCode matches voice-code.ts hashVoiceCode output", () => {
+    expect(hashInviteCode("123456")).toBe(
+      "8d969eef6ecad3c29a3a629280e686cf0c3f5d5a86aff3ca12020c923adc6c92",
+    );
+    expect(hashInviteCode("0000")).toBe(
+      "9af15b336e6a9619928537df30b2e6a2376569fcf9d7e773eccede65606529a0",
+    );
+    expect(hashInviteCode("987654321")).toBe(
+      "8a9bcf1e51e812d0af8465a8dbcc9f741064bf0af3b3d08e6b0246437c19f7fb",
+    );
+  });
+});
+
+describe("generateInviteToken", () => {
+  test("produces a 43-character base64url token", () => {
+    const token = generateInviteToken();
+    expect(token).toMatch(/^[A-Za-z0-9_-]{43}$/);
+  });
+
+  test("produces unique tokens", () => {
+    expect(generateInviteToken()).not.toBe(generateInviteToken());
+  });
+});
+
+describe("generateInviteCode", () => {
+  test("defaults to 6 digits with no leading zero", () => {
+    const code = generateInviteCode();
+    expect(code).toMatch(/^[1-9]\d{5}$/);
+  });
+
+  test("honors the digit count at both bounds", () => {
+    expect(generateInviteCode(4)).toMatch(/^[1-9]\d{3}$/);
+    expect(generateInviteCode(10)).toMatch(/^[1-9]\d{9}$/);
+  });
+
+  test("rejects out-of-range digit counts", () => {
+    expect(() => generateInviteCode(3)).toThrow();
+    expect(() => generateInviteCode(11)).toThrow();
+  });
+});
+
+describe("isValidE164", () => {
+  test("valid E.164 number", () => {
+    expect(isValidE164("+15551234567")).toBe(true);
+  });
+
+  test("missing + prefix", () => {
+    expect(isValidE164("5551234567")).toBe(false);
+  });
+
+  test("too short", () => {
+    expect(isValidE164("+123")).toBe(false);
+  });
+});
+
+describe("invite-code channel gating", () => {
+  test("allows exactly the redemption-enabled channels", () => {
+    expect([...INVITE_CODE_REDEMPTION_CHANNELS].sort()).toEqual([
+      "email",
+      "slack",
+      "telegram",
+      "whatsapp",
+    ]);
+  });
+
+  test("isInviteCodeRedemptionEnabled matches the allowlist", () => {
+    for (const channel of ["telegram", "whatsapp", "slack", "email"]) {
+      expect(isInviteCodeRedemptionEnabled(channel)).toBe(true);
+    }
+    for (const channel of ["vellum", "platform", "phone", "a2a", "nope"]) {
+      expect(isInviteCodeRedemptionEnabled(channel)).toBe(false);
+    }
+  });
+});
+
+const fullOutcome: InviteRedemptionOutcome = {
+  inviteId: "inv-1",
+  contactId: "c-1",
+  sourceChannel: "telegram",
+  memberExternalUserId: "tg-user-1",
+  memberExternalChatId: "tg-chat-1",
+  displayName: "Member Name",
+  username: "member",
+  sourceConversationId: "conv-1",
+  result: "redeemed",
+};
+
+describe("InviteRedemptionOutcomeSchema", () => {
+  test("round-trips a fully-populated outcome", () => {
+    expect(InviteRedemptionOutcomeSchema.parse(fullOutcome)).toEqual(
+      fullOutcome,
+    );
+  });
+
+  test("parses a minimal outcome", () => {
+    const minimal = {
+      inviteId: "inv-1",
+      contactId: "c-1",
+      sourceChannel: "slack",
+      memberExternalUserId: "U123",
+      result: "already_member",
+    } satisfies InviteRedemptionOutcome;
+    expect(InviteRedemptionOutcomeSchema.parse(minimal)).toEqual(minimal);
+  });
+
+  test("rejects an invalid result", () => {
+    expect(() =>
+      InviteRedemptionOutcomeSchema.parse({
+        ...fullOutcome,
+        result: "definitely_not_a_result",
+      }),
+    ).toThrow();
+  });
+});
+
+describe("invite IPC request schemas", () => {
+  test("RedeemInviteByCodeRequestSchema round-trips full and minimal requests", () => {
+    const full = {
+      code: "123456",
+      sourceChannel: "telegram",
+      externalUserId: "tg-user-1",
+      externalChatId: "tg-chat-1",
+      displayName: "Member Name",
+      username: "member",
+    };
+    expect(RedeemInviteByCodeRequestSchema.parse(full)).toEqual(full);
+    const minimal = { code: "123456", sourceChannel: "email" };
+    expect(RedeemInviteByCodeRequestSchema.parse(minimal)).toEqual(minimal);
+    expect(() =>
+      RedeemInviteByCodeRequestSchema.parse({ code: "", sourceChannel: "" }),
+    ).toThrow();
+  });
+
+  test("RedeemInviteByTokenRequestSchema round-trips full and minimal requests", () => {
+    const full = {
+      token: "raw-token",
+      sourceChannel: "slack",
+      externalUserId: "U123",
+      externalChatId: "D456",
+      displayName: "Member Name",
+      username: "member",
+    };
+    expect(RedeemInviteByTokenRequestSchema.parse(full)).toEqual(full);
+    const minimal = { token: "raw-token", sourceChannel: "slack" };
+    expect(RedeemInviteByTokenRequestSchema.parse(minimal)).toEqual(minimal);
+    expect(() =>
+      RedeemInviteByTokenRequestSchema.parse({ sourceChannel: "slack" }),
+    ).toThrow();
+  });
+
+  test("RedeemVoiceInviteRequestSchema requires caller and code", () => {
+    const request = { callerExternalUserId: "+15555550100", code: "123456" };
+    expect(RedeemVoiceInviteRequestSchema.parse(request)).toEqual(request);
+    expect(() =>
+      RedeemVoiceInviteRequestSchema.parse({ callerExternalUserId: "+1555" }),
+    ).toThrow();
+  });
+
+  test("GetActiveVoiceInviteRequestSchema requires the caller", () => {
+    const request = { callerExternalUserId: "+15555550100" };
+    expect(GetActiveVoiceInviteRequestSchema.parse(request)).toEqual(request);
+    expect(() => GetActiveVoiceInviteRequestSchema.parse({})).toThrow();
+  });
+});
+
+describe("ActiveVoiceInviteSchema", () => {
+  test("round-trips populated and null display fields", () => {
+    const populated = {
+      inviteId: "inv-1",
+      inviteeName: "Friend",
+      guardianName: "Guardian",
+      codeDigits: 6,
+    };
+    expect(ActiveVoiceInviteSchema.parse(populated)).toEqual(populated);
+    const anonymous = {
+      inviteId: "inv-2",
+      inviteeName: null,
+      guardianName: null,
+      codeDigits: 6,
+    };
+    expect(ActiveVoiceInviteSchema.parse(anonymous)).toEqual(anonymous);
+  });
+
+  test("rejects a non-integer codeDigits", () => {
+    expect(() =>
+      ActiveVoiceInviteSchema.parse({
+        inviteId: "inv-1",
+        inviteeName: null,
+        guardianName: null,
+        codeDigits: 6.5,
+      }),
+    ).toThrow();
+  });
+});

package/node_modules/@vellumai/gateway-client/src/__tests__/trust-verdict-contract.test.ts

@@ -29,6 +29,8 @@ const fullVerdict: TrustVerdict = {
   policy: "allow",
   verifiedAt: 1699999999,
   verifiedVia: "voice",
+  interactionCount: 12,
+  lastInteraction: 1699999998,
   memberDisplayName: "Member Name",
 };
 
@@ -92,6 +94,26 @@ describe("TrustVerdictSchema", () => {
     });
   });
 
+  test("carries interaction telemetry and tolerates a null lastInteraction", () => {
+    const parsed = TrustVerdictSchema.parse({
+      trustClass: "trusted_contact",
+      canonicalSenderId: "+15555550100",
+      interactionCount: 0,
+      lastInteraction: null,
+    });
+    expect(parsed.interactionCount).toBe(0);
+    expect(parsed.lastInteraction).toBeNull();
+  });
+
+  test("leaves interaction telemetry undefined when absent", () => {
+    const parsed = TrustVerdictSchema.parse({
+      trustClass: "unknown",
+      canonicalSenderId: null,
+    });
+    expect(parsed.interactionCount).toBeUndefined();
+    expect(parsed.lastInteraction).toBeUndefined();
+  });
+
   test("rejects an invalid trustClass", () => {
     expect(() =>
       TrustVerdictSchema.parse({

package/node_modules/@vellumai/gateway-client/src/__tests__/verification-session-contract.test.ts

@@ -0,0 +1,299 @@
+/**
+ * Tests for the shared verification-session contract.
+ *
+ * The pinned hash vectors below define the hash compatibility contract:
+ * `hashVerificationSecret` must produce exactly these outputs because session
+ * hashes already stored in the assistant DB (and backfilled to the gateway)
+ * were produced with the same SHA-256-hex scheme. Do not update the vectors
+ * to "fix" a failure — a mismatch means the hash scheme broke.
+ */
+
+import { describe, expect, test } from "bun:test";
+
+import {
+  BindSessionIdentityIpcParamsSchema,
+  CountRecentSendsIpcParamsSchema,
+  CountRecentSendsIpcResponseSchema,
+  CreateInboundSessionIpcParamsSchema,
+  CreateInboundSessionIpcResponseSchema,
+  CreateOutboundSessionIpcParamsSchema,
+  CreateOutboundSessionIpcResponseSchema,
+  hashVerificationSecret,
+  ResolveBootstrapSessionIpcParamsSchema,
+  SessionLookupIpcResponseSchema,
+  UpdateSessionDeliveryIpcParamsSchema,
+  UpdateSessionStatusIpcParamsSchema,
+  ValidateConsumeSessionIpcParamsSchema,
+  ValidateConsumeSessionIpcResponseSchema,
+  VERIFICATION_SESSIONS_IPC_METHODS,
+  VerificationSessionSchema,
+  type VerificationSessionWire,
+} from "../verification-session-contract.js";
+
+describe("hashVerificationSecret — pinned compatibility vectors", () => {
+  test("matches channel-verification-service.ts hashSecret output", () => {
+    expect(hashVerificationSecret("123456")).toBe(
+      "8d969eef6ecad3c29a3a629280e686cf0c3f5d5a86aff3ca12020c923adc6c92",
+    );
+    expect(hashVerificationSecret("test-bootstrap-token")).toBe(
+      "99ecd312d2f24ffd7011532ba5579dae00103767862bd5b7a79e6efcef99e05e",
+    );
+    expect(hashVerificationSecret("a3f9")).toBe(
+      "a5099480221d1ba2eb1fae7248a0ab2cb15b52ffbe3f3945b3d7e609acd3b2fc",
+    );
+  });
+});
+
+describe("IPC method names", () => {
+  test("exposes 11 unique methods under the verification_sessions_ prefix", () => {
+    const methods = Object.values(VERIFICATION_SESSIONS_IPC_METHODS);
+    expect(methods).toHaveLength(11);
+    expect(new Set(methods).size).toBe(11);
+    for (const method of methods) {
+      // Distinct from the daemon's client-facing
+      // `channel_verification_sessions_*` operationIds.
+      expect(method).toMatch(/^verification_sessions_[a-z_]+$/);
+    }
+  });
+});
+
+const outboundSession: VerificationSessionWire = {
+  id: "sess-1",
+  channel: "telegram",
+  challengeHash: hashVerificationSecret("123456"),
+  expiresAt: 1_700_000_600_000,
+  status: "awaiting_response",
+  sourceConversationId: null,
+  consumedByExternalUserId: null,
+  consumedByChatId: null,
+  expectedExternalUserId: "tg-user-1",
+  expectedChatId: "tg-chat-1",
+  expectedPhoneE164: null,
+  identityBindingStatus: "bound",
+  destinationAddress: "@handle",
+  lastSentAt: 1_700_000_000_000,
+  sendCount: 1,
+  nextResendAt: 1_700_000_060_000,
+  codeDigits: 6,
+  maxAttempts: 3,
+  verificationPurpose: "guardian",
+  bootstrapTokenHash: null,
+  createdAt: 1_700_000_000_000,
+  updatedAt: 1_700_000_000_000,
+};
+
+const inboundSession: VerificationSessionWire = {
+  ...outboundSession,
+  id: "sess-2",
+  status: "pending",
+  sourceConversationId: "conv-1",
+  expectedExternalUserId: null,
+  expectedChatId: null,
+  identityBindingStatus: null,
+  destinationAddress: null,
+  lastSentAt: null,
+  sendCount: 0,
+  nextResendAt: null,
+  verificationPurpose: "trusted_contact",
+};
+
+describe("VerificationSessionSchema", () => {
+  test("round-trips outbound and inbound sessions", () => {
+    expect(VerificationSessionSchema.parse(outboundSession)).toEqual(
+      outboundSession,
+    );
+    expect(VerificationSessionSchema.parse(inboundSession)).toEqual(
+      inboundSession,
+    );
+  });
+
+  test("rejects an unknown status", () => {
+    expect(() =>
+      VerificationSessionSchema.parse({
+        ...outboundSession,
+        status: "definitely_not_a_status",
+      }),
+    ).toThrow();
+  });
+
+  test("SessionLookupIpcResponseSchema accepts a session or null", () => {
+    expect(SessionLookupIpcResponseSchema.parse(outboundSession)).toEqual(
+      outboundSession,
+    );
+    expect(SessionLookupIpcResponseSchema.parse(null)).toBeNull();
+  });
+});
+
+describe("create session IPC schemas", () => {
+  test("create_inbound round-trips params and response", () => {
+    const params = { channel: "telegram", sourceConversationId: "conv-1" };
+    expect(CreateInboundSessionIpcParamsSchema.parse(params)).toEqual(params);
+    const minimal = { channel: "slack" };
+    expect(CreateInboundSessionIpcParamsSchema.parse(minimal)).toEqual(minimal);
+    expect(() =>
+      CreateInboundSessionIpcParamsSchema.parse({ channel: "" }),
+    ).toThrow();
+
+    const response = {
+      session: inboundSession,
+      secret: "raw-secret",
+      verifyCommand: "raw-secret",
+      ttlSeconds: 600,
+    };
+    expect(CreateInboundSessionIpcResponseSchema.parse(response)).toEqual(
+      response,
+    );
+  });
+
+  test("create_outbound round-trips full and minimal params + response", () => {
+    const full = {
+      channel: "telegram",
+      expectedExternalUserId: "tg-user-1",
+      expectedChatId: "tg-chat-1",
+      expectedPhoneE164: "+15551234567",
+      identityBindingStatus: "pending_bootstrap",
+      destinationAddress: "@handle",
+      codeDigits: 6,
+      maxAttempts: 3,
+      verificationPurpose: "trusted_contact",
+      bootstrapTokenHash: hashVerificationSecret("test-bootstrap-token"),
+      sessionId: "sess-1",
+    } as const;
+    expect(CreateOutboundSessionIpcParamsSchema.parse(full)).toEqual(full);
+    const minimal = { channel: "phone" };
+    expect(CreateOutboundSessionIpcParamsSchema.parse(minimal)).toEqual(
+      minimal,
+    );
+    expect(() =>
+      CreateOutboundSessionIpcParamsSchema.parse({
+        channel: "phone",
+        identityBindingStatus: "unbound",
+      }),
+    ).toThrow();
+
+    const response = {
+      sessionId: "sess-1",
+      secret: "123456",
+      challengeHash: hashVerificationSecret("123456"),
+      expiresAt: 1_700_000_600_000,
+      ttlSeconds: 600,
+    };
+    expect(CreateOutboundSessionIpcResponseSchema.parse(response)).toEqual(
+      response,
+    );
+  });
+});
+
+describe("lifecycle IPC param schemas", () => {
+  test("resolve_bootstrap requires channel and raw token", () => {
+    const params = { channel: "telegram", token: "raw-deep-link-token" };
+    expect(ResolveBootstrapSessionIpcParamsSchema.parse(params)).toEqual(
+      params,
+    );
+    expect(() =>
+      ResolveBootstrapSessionIpcParamsSchema.parse({ channel: "telegram" }),
+    ).toThrow();
+  });
+
+  test("bind_identity requires all three fields", () => {
+    const params = {
+      sessionId: "sess-1",
+      externalUserId: "tg-user-1",
+      chatId: "tg-chat-1",
+    };
+    expect(BindSessionIdentityIpcParamsSchema.parse(params)).toEqual(params);
+    expect(() =>
+      BindSessionIdentityIpcParamsSchema.parse({ sessionId: "sess-1" }),
+    ).toThrow();
+  });
+
+  test("update_status accepts consumed-by fields and rejects bad statuses", () => {
+    const params = {
+      sessionId: "sess-1",
+      status: "consumed",
+      consumedByExternalUserId: "tg-user-1",
+      consumedByChatId: "tg-chat-1",
+    } as const;
+    expect(UpdateSessionStatusIpcParamsSchema.parse(params)).toEqual(params);
+    const minimal = { sessionId: "sess-1", status: "revoked" } as const;
+    expect(UpdateSessionStatusIpcParamsSchema.parse(minimal)).toEqual(minimal);
+    expect(() =>
+      UpdateSessionStatusIpcParamsSchema.parse({
+        sessionId: "sess-1",
+        status: "nope",
+      }),
+    ).toThrow();
+  });
+
+  test("update_delivery accepts a null nextResendAt", () => {
+    const params = {
+      sessionId: "sess-1",
+      lastSentAt: 1_700_000_000_000,
+      sendCount: 2,
+      nextResendAt: null,
+    };
+    expect(UpdateSessionDeliveryIpcParamsSchema.parse(params)).toEqual(params);
+    expect(() =>
+      UpdateSessionDeliveryIpcParamsSchema.parse({
+        sessionId: "sess-1",
+        lastSentAt: 1_700_000_000_000,
+        sendCount: 2,
+      }),
+    ).toThrow();
+  });
+
+  test("count_recent_sends round-trips params and response", () => {
+    const params = {
+      channel: "telegram",
+      destinationAddress: "@handle",
+      windowMs: 900_000,
+    };
+    expect(CountRecentSendsIpcParamsSchema.parse(params)).toEqual(params);
+    expect(CountRecentSendsIpcResponseSchema.parse({ count: 3 })).toEqual({
+      count: 3,
+    });
+    expect(() =>
+      CountRecentSendsIpcResponseSchema.parse({ count: 3.5 }),
+    ).toThrow();
+  });
+});
+
+describe("validate_consume IPC schemas", () => {
+  test("params require channel and secret", () => {
+    const params = {
+      channel: "phone",
+      secret: "123456",
+      actorExternalUserId: "+15551234567",
+      actorChatId: "+15551234567",
+    };
+    expect(ValidateConsumeSessionIpcParamsSchema.parse(params)).toEqual(params);
+    expect(() =>
+      ValidateConsumeSessionIpcParamsSchema.parse({
+        channel: "phone",
+        secret: "",
+        actorExternalUserId: "x",
+        actorChatId: "y",
+      }),
+    ).toThrow();
+  });
+
+  test("response discriminates success from failure", () => {
+    const success = { success: true, verificationType: "guardian" } as const;
+    expect(ValidateConsumeSessionIpcResponseSchema.parse(success)).toEqual(
+      success,
+    );
+    const failure = {
+      success: false,
+      reason: "invalid_or_expired_code",
+    } as const;
+    expect(ValidateConsumeSessionIpcResponseSchema.parse(failure)).toEqual(
+      failure,
+    );
+    expect(() =>
+      ValidateConsumeSessionIpcResponseSchema.parse({
+        success: true,
+        reason: "invalid_or_expired_code",
+      }),
+    ).toThrow();
+  });
+});