@vellumai/assistant 0.10.0 → 0.10.1-dev.202606240317.ea25efe

package/src/notifications/__tests__/connected-channels.test.ts

@@ -0,0 +1,114 @@
+/**
+ * Tests for getConnectedChannels connectivity resolution.
+ *
+ * Connectivity must mirror destination-resolver's `resolveGuardian`:
+ * gateway-first, with a LOCAL contacts fallback on ANY per-channel no-match
+ * (gateway list null OR no active gateway entry for the channel). This keeps a
+ * channel from being marked connected when it can't be delivered (and
+ * vice-versa).
+ */
+
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+import type { GuardianDelivery } from "@vellumai/gateway-client";
+
+mock.module("../../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, { get: () => () => {} }),
+  truncateForLog: (value: string) => value,
+}));
+
+let deliverableChannels: string[] = [];
+let gatewayGuardians: GuardianDelivery[] | null = null;
+let localChatId: string | null = null;
+
+const realConfig = await import("../../channels/config.js");
+
+mock.module("../../channels/config.js", () => ({
+  ...realConfig,
+  getDeliverableChannels: () => deliverableChannels,
+}));
+
+const realReader = await import("../../contacts/guardian-delivery-reader.js");
+
+mock.module("../../contacts/guardian-delivery-reader.js", () => ({
+  ...realReader,
+  getGuardianDelivery: async () => gatewayGuardians,
+}));
+
+const realContactStore = await import("../../contacts/contact-store.js");
+
+mock.module("../../contacts/contact-store.js", () => ({
+  ...realContactStore,
+  findGuardianForChannel: (_channelType: string) =>
+    localChatId === null
+      ? null
+      : { contact: { principalId: "p1" }, channel: { externalChatId: localChatId } },
+}));
+
+const { getConnectedChannels } = await import("../emit-signal.js");
+
+function gatewayBinding(channelType: string, externalChatId: string): GuardianDelivery {
+  return { channelType, contactId: "c1", address: "addr", externalChatId, status: "active" };
+}
+
+beforeEach(() => {
+  deliverableChannels = [];
+  gatewayGuardians = null;
+  localChatId = null;
+});
+
+describe("getConnectedChannels gateway-first-then-local connectivity", () => {
+  test("marks telegram connected from a gateway-only binding", async () => {
+    deliverableChannels = ["telegram"];
+    gatewayGuardians = [gatewayBinding("telegram", "123")];
+    localChatId = null;
+
+    expect(await getConnectedChannels()).toContain("telegram");
+  });
+
+  test("falls back to a local binding when the gateway is unreachable (null)", async () => {
+    deliverableChannels = ["telegram"];
+    gatewayGuardians = null;
+    localChatId = "456";
+
+    expect(await getConnectedChannels()).toContain("telegram");
+  });
+
+  test("marks telegram disconnected when neither source has a binding", async () => {
+    deliverableChannels = ["telegram"];
+    gatewayGuardians = null;
+    localChatId = null;
+
+    expect(await getConnectedChannels()).not.toContain("telegram");
+  });
+
+  test("falls back to local when the gateway responds without that channel", async () => {
+    // Gateway present but with no active telegram entry ⇒ per-channel no-match,
+    // so connectivity falls back to the local mirror (mirrors
+    // destination-resolver's per-channel fallback).
+    deliverableChannels = ["telegram"];
+    gatewayGuardians = [];
+    localChatId = "789";
+
+    expect(await getConnectedChannels()).toContain("telegram");
+  });
+
+  test("only marks slack connected for D-prefixed (DM) chat IDs", async () => {
+    deliverableChannels = ["slack"];
+    gatewayGuardians = [gatewayBinding("slack", "C-public")];
+    expect(await getConnectedChannels()).not.toContain("slack");
+
+    gatewayGuardians = [gatewayBinding("slack", "D-dm")];
+    expect(await getConnectedChannels()).toContain("slack");
+  });
+
+  test("always reports vellum and platform connected", async () => {
+    deliverableChannels = ["vellum", "platform"];
+    gatewayGuardians = null;
+
+    const connected = await getConnectedChannels();
+    expect(connected).toContain("vellum");
+    expect(connected).toContain("platform");
+  });
+});

package/src/notifications/__tests__/decision-engine.test.ts

@@ -34,19 +34,38 @@ mock.module("../../prompts/system-prompt.js", () => ({
   buildCoreIdentityContext: () => null,
 }));
 
+// Guardian binding (ACL) is resolved via the gateway pull; notes (INFO) are
+// joined locally by contactId. Tests drive both via mutable slots.
+let guardianDeliveryFixture: Array<{ contactId: string }> = [];
+let contactInfoFixture: Record<string, { notes: string | null } | null> = {};
+
+mock.module("../../contacts/guardian-delivery-reader.js", () => ({
+  getGuardianDelivery: async () => guardianDeliveryFixture,
+  anyGuardian: (list: Array<{ contactId: string }>) => list[0],
+}));
+
 mock.module("../../contacts/contact-store.js", () => ({
-  listGuardianChannels: () => null,
+  findContactInfoById: (contactId: string) =>
+    contactInfoFixture[contactId] ?? null,
 }));
 
-// Provider mock — if `getConfiguredProvider` is ever called by the
-// assistant_tool pass-through path, this throw makes the test fail
-// loudly instead of silently exercising the LLM path.
+// Provider mock. By default `sendMessage` throws so the assistant_tool
+// pass-through path (which must skip the LLM) fails loudly if it reaches the
+// provider. LLM-path tests override `providerSendMessage` to capture inputs.
+let providerSendMessage: (
+  messages: unknown[],
+  opts: { systemPrompt?: string },
+) => Promise<unknown> = () => {
+  throw new Error(
+    "provider.sendMessage should NOT be invoked for assistant_tool pass-through",
+  );
+};
+
 mock.module("../../providers/provider-send-message.js", () => ({
-  getConfiguredProvider: async () => {
-    throw new Error(
-      "getConfiguredProvider should NOT be invoked for assistant_tool pass-through",
-    );
-  },
+  getConfiguredProvider: async () => ({
+    sendMessage: (messages: unknown[], opts: { systemPrompt?: string }) =>
+      providerSendMessage(messages, opts),
+  }),
   createTimeout: () => ({
     signal: new AbortController().signal,
     cleanup: () => {},
@@ -281,3 +300,53 @@ describe("assistant_tool pass-through in notification decision engine", () => {
     expect(decision.renderedCopy.vellum?.body).toBe("fyi");
   });
 });
+
+describe("recipient notes injection (ACL from gateway, notes joined locally)", () => {
+  function makeLlmSignal(): NotificationSignal {
+    return {
+      signalId: "sig-llm-notes-1",
+      createdAt: Date.now(),
+      sourceChannel: "scheduler",
+      sourceContextId: "schedule-1",
+      sourceEventName: "schedule.notify",
+      contextPayload: {},
+      attentionHints: {
+        requiresAction: false,
+        urgency: "low",
+        isAsyncBackground: false,
+        visibleInSourceNow: false,
+      },
+    };
+  }
+
+  test("injects the guardian's local notes, resolved via the gateway contactId", async () => {
+    guardianDeliveryFixture = [{ contactId: "contact-42" }];
+    contactInfoFixture = { "contact-42": { notes: "Prefers terse updates." } };
+
+    let capturedSystemPrompt: string | undefined;
+    providerSendMessage = async (_messages, opts) => {
+      capturedSystemPrompt = opts.systemPrompt;
+      return {};
+    };
+
+    await evaluateSignal(makeLlmSignal(), ["vellum"] as NotificationChannel[]);
+
+    expect(capturedSystemPrompt).toContain("<recipient-context>");
+    expect(capturedSystemPrompt).toContain("Prefers terse updates.");
+  });
+
+  test("omits recipient context when no guardian is bound", async () => {
+    guardianDeliveryFixture = [];
+    contactInfoFixture = {};
+
+    let capturedSystemPrompt: string | undefined;
+    providerSendMessage = async (_messages, opts) => {
+      capturedSystemPrompt = opts.systemPrompt;
+      return {};
+    };
+
+    await evaluateSignal(makeLlmSignal(), ["vellum"] as NotificationChannel[]);
+
+    expect(capturedSystemPrompt).not.toContain("<recipient-context>");
+  });
+});

package/src/notifications/__tests__/destination-resolver.test.ts

@@ -0,0 +1,256 @@
+/**
+ * Verifies resolveDestinations resolves guardian delivery endpoints from the
+ * gateway-provided guardian list, with shapes identical to the local read, and
+ * falls back to the local contacts read when the list is null.
+ */
+
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+import type { GuardianDelivery } from "@vellumai/gateway-client";
+
+mock.module("../../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+// Local fallback read; mocked so the null-list path is deterministic.
+let localGuardian:
+  | { contact: { principalId?: string }; channel: { address: string; externalChatId?: string } }
+  | null = null;
+
+mock.module("../../contacts/contact-store.js", () => ({
+  findGuardianForChannel: (_channelType: string) => localGuardian,
+}));
+
+const { resolveDestinations } = await import("../destination-resolver.js");
+
+function guardian(
+  overrides: Partial<GuardianDelivery> & Pick<GuardianDelivery, "channelType" | "address">,
+): GuardianDelivery {
+  return {
+    contactId: "contact-1",
+    status: "active",
+    ...overrides,
+  } as GuardianDelivery;
+}
+
+describe("resolveDestinations — gateway guardian list", () => {
+  beforeEach(() => {
+    localGuardian = null;
+  });
+
+  test("vellum carries guardianPrincipalId from the gateway list", () => {
+    const list = [
+      guardian({ channelType: "vellum", address: "user@example.com", principalId: "prin-1" }),
+    ];
+    const result = resolveDestinations(["vellum"], list);
+    expect(result.get("vellum")).toEqual({
+      channel: "vellum",
+      metadata: { guardianPrincipalId: "prin-1" },
+    });
+  });
+
+  test("platform carries guardianPrincipalId from the vellum guardian", () => {
+    const list = [
+      guardian({ channelType: "vellum", address: "user@example.com", principalId: "prin-1" }),
+    ];
+    const result = resolveDestinations(["platform"], list);
+    expect(result.get("platform")).toEqual({
+      channel: "platform",
+      metadata: { guardianPrincipalId: "prin-1" },
+    });
+  });
+
+  test("telegram resolves endpoint and binding context", () => {
+    const list = [
+      guardian({
+        channelType: "telegram",
+        address: "tg-user",
+        externalChatId: "12345",
+      }),
+    ];
+    const result = resolveDestinations(["telegram"], list);
+    expect(result.get("telegram")).toEqual({
+      channel: "telegram",
+      endpoint: "12345",
+      metadata: { externalUserId: "tg-user" },
+      bindingContext: {
+        sourceChannel: "telegram",
+        externalChatId: "12345",
+        externalUserId: "tg-user",
+      },
+    });
+  });
+
+  test("telegram without externalChatId is omitted", () => {
+    const list = [guardian({ channelType: "telegram", address: "tg-user" })];
+    const result = resolveDestinations(["telegram"], list);
+    expect(result.has("telegram")).toBe(false);
+  });
+
+  test("slack resolves DM endpoint and binding context", () => {
+    const list = [
+      guardian({
+        channelType: "slack",
+        address: "slack-user",
+        externalChatId: "D123",
+      }),
+    ];
+    const result = resolveDestinations(["slack"], list);
+    expect(result.get("slack")).toEqual({
+      channel: "slack",
+      endpoint: "D123",
+      metadata: { externalUserId: "slack-user" },
+      bindingContext: {
+        sourceChannel: "slack",
+        externalChatId: "D123",
+        externalUserId: "slack-user",
+      },
+    });
+  });
+
+  test("slack non-DM channel is dropped", () => {
+    const list = [
+      guardian({
+        channelType: "slack",
+        address: "slack-user",
+        externalChatId: "C123",
+      }),
+    ];
+    const result = resolveDestinations(["slack"], list);
+    expect(result.has("slack")).toBe(false);
+  });
+
+  test("inactive guardian is ignored", () => {
+    const list = [
+      guardian({
+        channelType: "telegram",
+        address: "tg-user",
+        externalChatId: "12345",
+        status: "revoked",
+      }),
+    ];
+    const result = resolveDestinations(["telegram"], list);
+    expect(result.has("telegram")).toBe(false);
+  });
+});
+
+describe("resolveDestinations — null list falls back to local read", () => {
+  beforeEach(() => {
+    localGuardian = null;
+  });
+
+  test("telegram resolves from the local contacts read", () => {
+    localGuardian = {
+      contact: {},
+      channel: { address: "tg-user", externalChatId: "12345" },
+    };
+    const result = resolveDestinations(["telegram"], null);
+    expect(result.get("telegram")).toEqual({
+      channel: "telegram",
+      endpoint: "12345",
+      metadata: { externalUserId: "tg-user" },
+      bindingContext: {
+        sourceChannel: "telegram",
+        externalChatId: "12345",
+        externalUserId: "tg-user",
+      },
+    });
+  });
+
+  test("slack DM resolves from the local contacts read", () => {
+    localGuardian = {
+      contact: {},
+      channel: { address: "slack-user", externalChatId: "D123" },
+    };
+    const result = resolveDestinations(["slack"], null);
+    expect(result.get("slack")).toEqual({
+      channel: "slack",
+      endpoint: "D123",
+      metadata: { externalUserId: "slack-user" },
+      bindingContext: {
+        sourceChannel: "slack",
+        externalChatId: "D123",
+        externalUserId: "slack-user",
+      },
+    });
+  });
+
+  test("vellum carries principalId from the local contacts read", () => {
+    localGuardian = {
+      contact: { principalId: "prin-1" },
+      channel: { address: "user@example.com" },
+    };
+    const result = resolveDestinations(["vellum"], null);
+    expect(result.get("vellum")).toEqual({
+      channel: "vellum",
+      metadata: { guardianPrincipalId: "prin-1" },
+    });
+  });
+});
+
+describe("resolveDestinations — gateway yields no channel match falls back to local", () => {
+  beforeEach(() => {
+    localGuardian = null;
+  });
+
+  test("empty gateway list falls back to local telegram binding", () => {
+    localGuardian = {
+      contact: {},
+      channel: { address: "tg-user", externalChatId: "12345" },
+    };
+    const result = resolveDestinations(["telegram"], []);
+    expect(result.get("telegram")).toEqual({
+      channel: "telegram",
+      endpoint: "12345",
+      metadata: { externalUserId: "tg-user" },
+      bindingContext: {
+        sourceChannel: "telegram",
+        externalChatId: "12345",
+        externalUserId: "tg-user",
+      },
+    });
+  });
+
+  test("gateway list missing the channel falls back to local slack DM", () => {
+    localGuardian = {
+      contact: {},
+      channel: { address: "slack-user", externalChatId: "D123" },
+    };
+    // Gateway returns a telegram guardian but no slack entry.
+    const list = [
+      guardian({ channelType: "telegram", address: "tg", externalChatId: "999" }),
+    ];
+    const result = resolveDestinations(["slack"], list);
+    expect(result.get("slack")).toEqual({
+      channel: "slack",
+      endpoint: "D123",
+      metadata: { externalUserId: "slack-user" },
+      bindingContext: {
+        sourceChannel: "slack",
+        externalChatId: "D123",
+        externalUserId: "slack-user",
+      },
+    });
+  });
+
+  test("empty gateway list falls back to local vellum principalId", () => {
+    localGuardian = {
+      contact: { principalId: "prin-1" },
+      channel: { address: "user@example.com" },
+    };
+    const result = resolveDestinations(["vellum"], []);
+    expect(result.get("vellum")).toEqual({
+      channel: "vellum",
+      metadata: { guardianPrincipalId: "prin-1" },
+    });
+  });
+
+  test("empty gateway list with no local binding omits telegram", () => {
+    localGuardian = null;
+    const result = resolveDestinations(["telegram"], []);
+    expect(result.has("telegram")).toBe(false);
+  });
+});

package/src/notifications/__tests__/deterministic-checks.test.ts

@@ -20,13 +20,14 @@ import { getDb } from "../../memory/db-connection.js";
 import { initializeDb } from "../../memory/db-init.js";
 import { notificationEvents } from "../../memory/schema.js";
 import {
+  checkSourceActiveSuppression,
   type DeterministicCheckContext,
   runDeterministicChecks,
 } from "../deterministic-checks.js";
 import type { NotificationSignal } from "../signal.js";
 import type { NotificationDecision } from "../types.js";
 
-initializeDb();
+await initializeDb();
 
 beforeEach(() => {
   getDb().delete(notificationEvents).run();
@@ -284,3 +285,44 @@ describe("checkRenderedCopyQuality (via runDeterministicChecks)", () => {
     expect(result.reason).toContain("fallback leak");
   });
 });
+
+describe("checkSourceActiveSuppression (pre-decision gate)", () => {
+  test("fails when visibleInSourceNow is set", () => {
+    const result = checkSourceActiveSuppression(
+      makeSignal({
+        attentionHints: {
+          requiresAction: false,
+          urgency: "low",
+          isAsyncBackground: true,
+          visibleInSourceNow: true,
+        },
+      }),
+    );
+    expect(result.passed).toBe(false);
+    expect(result.reason).toContain("Source-active suppression");
+  });
+
+  test("passes when visibleInSourceNow is false", () => {
+    expect(checkSourceActiveSuppression(makeSignal()).passed).toBe(true);
+  });
+
+  test("runDeterministicChecks does not suppress source-active signals (handled by the pre-decision gate)", async () => {
+    // Source-active suppression is enforced by the pre-decision gate in
+    // emitNotificationSignal, not by this stage. A source-active signal
+    // evaluated here therefore passes — this stage only validates the decision.
+    const signal = makeSignal({
+      attentionHints: {
+        requiresAction: false,
+        urgency: "low",
+        isAsyncBackground: true,
+        visibleInSourceNow: true,
+      },
+    });
+    const result = await runDeterministicChecks(
+      signal,
+      makeDecision(),
+      context,
+    );
+    expect(result.passed).toBe(true);
+  });
+});

package/src/notifications/adapters/slack.ts

@@ -12,6 +12,8 @@
  * https://docs.slack.dev/reference/block-kit/blocks/card-block
  */
 
+import type { Button, CardBlock, ContextBlock, KnownBlock } from "@slack/types";
+
 import { sendSlackReply } from "../../messaging/providers/slack/send.js";
 import type { ApprovalUIMetadata } from "../../runtime/channel-approval-types.js";
 import { getLogger } from "../../util/logger.js";
@@ -39,7 +41,7 @@ const log = getLogger("notif-adapter-slack");
 // ---------------------------------------------------------------------------
 
 /** Build action buttons for a Slack Card block from approval metadata. */
-function buildCardActions(approval: ApprovalUIMetadata): unknown[] {
+function buildCardActions(approval: ApprovalUIMetadata): Button[] {
   return approval.actions.map((action) => ({
     type: "button",
     text: { type: "plain_text", text: action.label, emoji: true },
@@ -80,7 +82,7 @@ function buildAccessRequestBody(view: AccessRequestCardView): string {
 /** Source-channel context block with Slack permalink when available. */
 function buildSourceContextBlock(
   view: AccessRequestCardView,
-): unknown | undefined {
+): ContextBlock | undefined {
   if (view.sourceChannel !== "slack" || !view.conversationExternalId) {
     return undefined;
   }
@@ -107,7 +109,7 @@ function buildSourceContextBlock(
 /** Stable requester identifier context block (external ID when it adds info). */
 function buildRequesterIdBlock(
   view: AccessRequestCardView,
-): unknown | undefined {
+): ContextBlock | undefined {
   const safeExternalId = view.externalId;
   if (!safeExternalId) return undefined;
 
@@ -134,10 +136,10 @@ function buildRequesterIdBlock(
  */
 function buildAccessRequestCardBlocks(
   payload: ChannelDeliveryPayload,
-): unknown[] {
+): KnownBlock[] {
   const approval = payload.approvalContext!;
   const view = buildAccessRequestCardView(payload.accessRequestContext!);
-  const blocks: unknown[] = [];
+  const blocks: KnownBlock[] = [];
 
   const subtitle = buildAccessRequestSubtitle(view);
   const body = buildAccessRequestBody(view);
@@ -147,7 +149,7 @@ function buildAccessRequestCardBlocks(
       ? truncate(view.warnings.map((w) => `:warning: ${w}`).join(" · "), 200)
       : undefined;
 
-  const card: Record<string, unknown> = {
+  const card: CardBlock = {
     type: "card",
     title: { type: "mrkdwn", text: "Access Request" },
     subtitle: { type: "mrkdwn", text: subtitle },
@@ -211,9 +213,9 @@ function buildAccessRequestCardBlocks(
 function buildToolApprovalCardBlocks(
   payload: ChannelDeliveryPayload,
   messageText: string,
-): unknown[] {
+): KnownBlock[] {
   const approval = payload.approvalContext!;
-  const blocks: unknown[] = [];
+  const blocks: KnownBlock[] = [];
 
   const details = approval.permissionDetails;
   const toolName = details?.toolName;
@@ -226,7 +228,7 @@ function buildToolApprovalCardBlocks(
   }
 
   const needsOverflow = messageText.length > 200;
-  const card: Record<string, unknown> = {
+  const card: CardBlock = {
     type: "card",
     title: {
       type: "mrkdwn",
@@ -266,7 +268,7 @@ function buildToolApprovalCardBlocks(
 export function buildApprovalNotificationBlocks(
   payload: ChannelDeliveryPayload,
   messageText: string,
-): unknown[] {
+): KnownBlock[] {
   if (
     payload.sourceEventName === "ingress.access_request" &&
     payload.accessRequestContext != null