@vellumai/assistant 0.11.4 → 0.11.5-staging.2

package/src/notifications/__tests__/home-feed-side-effect.test.ts

@@ -2,7 +2,10 @@ import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 import type { FeedItem } from "../../home/feed-types.js";
 import type { NotificationSignal } from "../signal.js";
-import type { NotificationDecision } from "../types.js";
+import type {
+  NotificationDecision,
+  NotificationDeliveryResult,
+} from "../types.js";
 
 // ── Module mocks ───────────────────────────────────────────────────────
 //
@@ -13,8 +16,40 @@ import type { NotificationDecision } from "../types.js";
 
 const appendCalls: FeedItem[] = [];
 const conversationLookups: string[] = [];
+const messageAppends: Array<{
+  conversationId: string;
+  role: string;
+  content: string;
+  options?: { skipIndexing?: boolean };
+}> = [];
+const messageRewrites: Array<{ messageId: string; content: string }> = [];
+/** messageId -> the conversation it belongs to, for the scoped lookup. */
+const messageOwners = new Map<string, string>();
 let conversationRow: { conversationType: string } | null = null;
 let conversationLookupShouldThrow = false;
+let messageAppendShouldThrow = false;
+let messageRewriteShouldThrow = false;
+let messageLookupShouldThrow = false;
+
+let feedItemSchemaShouldReject = false;
+const messagesInvalidated: string[] = [];
+
+mock.module("../../runtime/sync/resource-sync-events.js", () => ({
+  publishConversationMessagesChanged: (conversationId: string) => {
+    messagesInvalidated.push(conversationId);
+  },
+}));
+
+mock.module("../../home/feed-types.js", () => ({
+  feedItemSchema: {
+    parse: (item: unknown) => {
+      if (feedItemSchemaShouldReject) {
+        throw new Error("simulated schema rejection");
+      }
+      return item;
+    },
+  },
+}));
 
 mock.module("../../home/feed-writer.js", () => ({
   appendFeedItem: async (item: FeedItem) => {
@@ -30,10 +65,38 @@ mock.module("../../persistence/conversation-crud.js", () => ({
     }
     return conversationRow;
   },
+  addMessage: async (
+    conversationId: string,
+    role: string,
+    content: string,
+    options?: { skipIndexing?: boolean },
+  ) => {
+    if (messageAppendShouldThrow) {
+      throw new Error("simulated message write failure");
+    }
+    messageAppends.push({ conversationId, role, content, options });
+    return { id: `msg-${messageAppends.length}` };
+  },
+  getMessageById: (messageId: string, conversationId?: string) => {
+    if (messageLookupShouldThrow) {
+      throw new Error("simulated message lookup failure");
+    }
+    const owner = messageOwners.get(messageId);
+    if (!owner || (conversationId && owner !== conversationId)) {
+      return null;
+    }
+    return { id: messageId, conversationId: owner };
+  },
+  updateMessageContent: (messageId: string, content: string) => {
+    if (messageRewriteShouldThrow) {
+      throw new Error("simulated message rewrite failure");
+    }
+    messageRewrites.push({ messageId, content });
+  },
   reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 
-const { writeHomeFeedItemForSignal } =
+const { updateFeedItemConversationMessage, writeHomeFeedItemForSignal } =
   await import("../home-feed-side-effect.js");
 
 // ── Test fixtures ──────────────────────────────────────────────────────
@@ -58,6 +121,19 @@ function makeSignal(
   };
 }
 
+function makeVellumDelivery(
+  overrides: Partial<NotificationDeliveryResult> = {},
+): NotificationDeliveryResult {
+  return {
+    channel: "vellum",
+    destination: "vellum",
+    status: "sent",
+    conversationId: "conv-source-1",
+    messageId: "msg-paired",
+    ...overrides,
+  };
+}
+
 function makeDecision(
   overrides: Partial<NotificationDecision> = {},
 ): NotificationDecision {
@@ -76,8 +152,16 @@ function makeDecision(
 beforeEach(() => {
   appendCalls.length = 0;
   conversationLookups.length = 0;
+  messageAppends.length = 0;
+  messageRewrites.length = 0;
+  messageOwners.clear();
   conversationRow = null;
   conversationLookupShouldThrow = false;
+  messageAppendShouldThrow = false;
+  messageRewriteShouldThrow = false;
+  messageLookupShouldThrow = false;
+  feedItemSchemaShouldReject = false;
+  messagesInvalidated.length = 0;
 });
 
 describe("writeHomeFeedItemForSignal", () => {
@@ -261,7 +345,7 @@ describe("writeHomeFeedItemForSignal", () => {
     const item = await writeHomeFeedItemForSignal(
       signal,
       decision,
-      "paired-delivery-conv-id",
+      makeVellumDelivery({ conversationId: "paired-delivery-conv-id" }),
     );
 
     expect(item).not.toBeNull();
@@ -287,7 +371,7 @@ describe("writeHomeFeedItemForSignal", () => {
     const item = await writeHomeFeedItemForSignal(
       signal,
       decision,
-      "paired-delivery-conv-id",
+      makeVellumDelivery({ conversationId: "paired-delivery-conv-id" }),
     );
 
     expect(item).not.toBeNull();
@@ -840,4 +924,452 @@ describe("writeHomeFeedItemForSignal", () => {
     expect(item?.noteworthy).toBe(true);
     expect(appendCalls[0]!.noteworthy).toBe(true);
   });
+
+  describe("body append into the feed item's conversation", () => {
+    test("appends the card summary when no vellum conversation was paired", async () => {
+      // The Slack/Telegram-only routing case: nothing paired a vellum
+      // conversation, so this seam is the only writer that can put the body
+      // where the card's button points.
+      conversationRow = { conversationType: "background" };
+      const signal = makeSignal({
+        contextPayload: { title: "Nightly briefing" },
+      });
+      const decision = makeDecision({
+        selectedChannels: ["telegram"],
+        renderedCopy: {
+          telegram: { title: "Nightly briefing", body: "Three things today." },
+        },
+      });
+
+      const item = await writeHomeFeedItemForSignal(signal, decision);
+
+      expect(item?.conversationId).toBe("conv-source-1");
+      expect(messageAppends).toHaveLength(1);
+      expect(messageAppends[0]).toMatchObject({
+        conversationId: "conv-source-1",
+        role: "assistant",
+        content: "Three things today.",
+        options: { skipIndexing: true },
+      });
+      expect(item?.metadata?.notificationConversationMessageId).toBe("msg-1");
+      // A client with the conversation open refetches only on the messages
+      // tag; `addMessage` publishes the metadata tag alone.
+      expect(messagesInvalidated).toEqual(["conv-source-1"]);
+    });
+
+    test("writes exactly the summary the card renders", async () => {
+      // The button's promise is that the conversation holds what the card
+      // shows, so the two read from the same resolved text.
+      conversationRow = { conversationType: "background" };
+      const signal = makeSignal();
+      const decision = makeDecision({
+        selectedChannels: ["slack"],
+        renderedCopy: {
+          slack: {
+            title: "Digest",
+            body: "Short popup line.",
+            conversationSeedMessage:
+              "**Digest**\n\n- First item\n- Second item",
+          },
+        },
+      });
+
+      const item = await writeHomeFeedItemForSignal(signal, decision);
+
+      expect(messageAppends[0]!.content).toBe(item!.summary);
+      expect(messageAppends[0]!.content).toBe(
+        "**Digest**\n\n- First item\n- Second item",
+      );
+    });
+
+    test("records the paired row when vellum already wrote the body", async () => {
+      // `pairDeliveryWithConversation` wrote the body, so nothing is written
+      // again here, but the card still records the row so an edit can reach it
+      // when the delivery walk does not.
+      conversationRow = { conversationType: "background" };
+      const signal = makeSignal();
+      const decision = makeDecision({
+        selectedChannels: ["vellum"],
+        renderedCopy: {
+          vellum: { title: "Nightly briefing", body: "Three things today." },
+        },
+      });
+
+      const item = await writeHomeFeedItemForSignal(
+        signal,
+        decision,
+        makeVellumDelivery(),
+      );
+
+      expect(item?.conversationId).toBe("conv-source-1");
+      expect(messageAppends).toHaveLength(0);
+      expect(item?.metadata?.notificationConversationMessageId).toBe(
+        "msg-paired",
+      );
+    });
+
+    test("skips the append when a sentinel source context leaves no target", async () => {
+      // No resolvable conversation means the client hides the button, so
+      // there is nothing to keep honest.
+      conversationRow = null;
+      const signal = makeSignal({
+        sourceContextId: "job-1700000000",
+        attentionHints: {
+          requiresAction: false,
+          urgency: "medium",
+          isAsyncBackground: true,
+          visibleInSourceNow: false,
+        },
+      });
+      const decision = makeDecision({
+        selectedChannels: ["telegram"],
+        renderedCopy: {
+          telegram: { title: "Retries exhausted", body: "Gave up after 3." },
+        },
+      });
+
+      const item = await writeHomeFeedItemForSignal(signal, decision);
+
+      expect(item).not.toBeNull();
+      expect(item?.conversationId).toBeUndefined();
+      expect(messageAppends).toHaveLength(0);
+    });
+
+    test("writes no message when the card is rejected", async () => {
+      // The body only belongs in a conversation because a card sends the user
+      // there, so a rejected card must not leave one behind.
+      conversationRow = { conversationType: "background" };
+      feedItemSchemaShouldReject = true;
+      const signal = makeSignal();
+      const decision = makeDecision({
+        selectedChannels: ["telegram"],
+        renderedCopy: {
+          telegram: { title: "Nightly briefing", body: "Three things today." },
+        },
+      });
+
+      const item = await writeHomeFeedItemForSignal(signal, decision);
+
+      expect(item).toBeNull();
+      expect(appendCalls).toHaveLength(0);
+      expect(messageAppends).toHaveLength(0);
+      expect(messagesInvalidated).toHaveLength(0);
+    });
+
+    test("a failed message write leaves the persisted feed item intact", async () => {
+      conversationRow = { conversationType: "background" };
+      messageAppendShouldThrow = true;
+      const signal = makeSignal();
+      const decision = makeDecision({
+        selectedChannels: ["telegram"],
+        renderedCopy: {
+          telegram: { title: "Nightly briefing", body: "Three things today." },
+        },
+      });
+
+      const item = await writeHomeFeedItemForSignal(signal, decision);
+
+      expect(item).not.toBeNull();
+      expect(appendCalls).toHaveLength(1);
+      expect(messageAppends).toHaveLength(0);
+      expect(item?.metadata?.notificationConversationMessageId).toBeUndefined();
+    });
+
+    test("records the paired row when the vellum delivery failed", async () => {
+      // The row exists whatever the delivery reported, and a failed delivery
+      // is exactly the case the edit path's delivery walk skips.
+      conversationRow = { conversationType: "background" };
+      const signal = makeSignal();
+      const decision = makeDecision({
+        selectedChannels: ["vellum"],
+        renderedCopy: {
+          vellum: { title: "Nightly briefing", body: "Three things today." },
+        },
+      });
+
+      const item = await writeHomeFeedItemForSignal(
+        signal,
+        decision,
+        makeVellumDelivery({ status: "failed", messageId: "msg-paired" }),
+      );
+
+      expect(item?.metadata?.notificationConversationMessageId).toBe(
+        "msg-paired",
+      );
+      // The row already exists, so nothing is written a second time.
+      expect(messageAppends).toHaveLength(0);
+    });
+
+    test("records nothing when the paired row sits outside the card's conversation", async () => {
+      // Guardian producers pair a fresh conversation rather than the one the
+      // card opens, so its row is not the card's to rewrite.
+      conversationRow = { conversationType: "background" };
+      const signal = makeSignal();
+      const decision = makeDecision({
+        selectedChannels: ["vellum"],
+        renderedCopy: {
+          vellum: { title: "Approval needed", body: "Allow this?" },
+        },
+      });
+
+      const item = await writeHomeFeedItemForSignal(
+        signal,
+        decision,
+        makeVellumDelivery({
+          conversationId: "conv-guardian-request",
+          messageId: "msg-guardian",
+        }),
+      );
+
+      expect(item?.conversationId).toBe("conv-source-1");
+      expect(item?.metadata?.notificationConversationMessageId).toBeUndefined();
+      expect(messageAppends).toHaveLength(0);
+    });
+
+    test("records the paired row when it backs a sentinel card", async () => {
+      // A sentinel `sourceContextId` puts the paired conversation behind the
+      // button, so its row is the one the card carries.
+      conversationRow = null;
+      const signal = makeSignal({
+        sourceContextId: "job-1700000000",
+        attentionHints: {
+          requiresAction: false,
+          urgency: "medium",
+          isAsyncBackground: true,
+          visibleInSourceNow: false,
+        },
+      });
+      const decision = makeDecision({
+        selectedChannels: ["vellum"],
+        renderedCopy: {
+          vellum: { title: "Retries exhausted", body: "Gave up after 3." },
+        },
+      });
+
+      const item = await writeHomeFeedItemForSignal(
+        signal,
+        decision,
+        makeVellumDelivery({ conversationId: "conv-paired", messageId: "m-p" }),
+      );
+
+      expect(item?.conversationId).toBe("conv-paired");
+      expect(item?.metadata?.notificationConversationMessageId).toBe("m-p");
+    });
+
+    test("strips a producer-supplied handle from the card metadata", async () => {
+      // `contextPayload` reaches the card verbatim, and this key addresses a
+      // row for rewriting, so a producer must not be able to set it.
+      conversationRow = { conversationType: "background" };
+      const signal = makeSignal({
+        contextPayload: {
+          title: "Nightly briefing",
+          notificationConversationMessageId: "msg-somebody-elses",
+        },
+      });
+      const decision = makeDecision({
+        selectedChannels: ["vellum"],
+        renderedCopy: {
+          vellum: { title: "Nightly briefing", body: "Three things today." },
+        },
+      });
+
+      const item = await writeHomeFeedItemForSignal(
+        signal,
+        decision,
+        makeVellumDelivery(),
+      );
+
+      expect(item?.metadata?.notificationConversationMessageId).toBe(
+        "msg-paired",
+      );
+    });
+
+    test("drops a producer-supplied handle when the card records none", async () => {
+      conversationRow = { conversationType: "background" };
+      const signal = makeSignal({
+        contextPayload: {
+          title: "Approval needed",
+          notificationConversationMessageId: "msg-somebody-elses",
+        },
+      });
+      const decision = makeDecision({
+        selectedChannels: ["vellum"],
+        renderedCopy: {
+          vellum: { title: "Approval needed", body: "Allow this?" },
+        },
+      });
+
+      const item = await writeHomeFeedItemForSignal(
+        signal,
+        decision,
+        makeVellumDelivery({ conversationId: "conv-guardian-request" }),
+      );
+
+      expect(item?.metadata?.notificationConversationMessageId).toBeUndefined();
+    });
+
+    test("a producer-supplied handle never displaces the real one", async () => {
+      conversationRow = { conversationType: "background" };
+      const signal = makeSignal({
+        contextPayload: {
+          title: "Nightly briefing",
+          notificationConversationMessageId: "msg-somebody-elses",
+        },
+      });
+      const decision = makeDecision({
+        selectedChannels: ["telegram"],
+        renderedCopy: {
+          telegram: { title: "Nightly briefing", body: "Three things today." },
+        },
+      });
+
+      const item = await writeHomeFeedItemForSignal(signal, decision);
+
+      expect(item?.metadata?.notificationConversationMessageId).toBe("msg-1");
+    });
+
+    test("preserves producer metadata alongside the message handle", async () => {
+      conversationRow = { conversationType: "background" };
+      const signal = makeSignal({
+        contextPayload: { title: "Nightly briefing", scheduleId: "sched-7" },
+      });
+      const decision = makeDecision({
+        selectedChannels: ["telegram"],
+        renderedCopy: {
+          telegram: { title: "Nightly briefing", body: "Three things today." },
+        },
+      });
+
+      const item = await writeHomeFeedItemForSignal(signal, decision);
+
+      expect(item?.metadata).toMatchObject({
+        title: "Nightly briefing",
+        scheduleId: "sched-7",
+        notificationConversationMessageId: "msg-1",
+      });
+    });
+  });
+
+  describe("updateFeedItemConversationMessage", () => {
+    function makeItem(metadata?: Record<string, unknown>): FeedItem {
+      return {
+        id: "notif:sig-test-1",
+        type: "notification",
+        priority: 50,
+        title: "Nightly briefing",
+        summary: "Three things today.",
+        timestamp: "2026-08-19T00:00:00.000Z",
+        createdAt: "2026-08-19T00:00:00.000Z",
+        status: "new",
+        category: "scheduling",
+        noteworthy: false,
+        fromAssistant: false,
+        conversationId: "conv-source-1",
+        ...(metadata ? { metadata } : {}),
+      };
+    }
+
+    test("rewrites the message the card owns", () => {
+      messageOwners.set("msg-9", "conv-source-1");
+
+      const rewritten = updateFeedItemConversationMessage(
+        makeItem({ notificationConversationMessageId: "msg-9" }),
+        "Four things now.",
+      );
+
+      expect(rewritten).toBe(true);
+      expect(messageRewrites).toEqual([
+        { messageId: "msg-9", content: "Four things now." },
+      ]);
+      expect(messagesInvalidated).toEqual(["conv-source-1"]);
+    });
+
+    test("reports no rewrite when the card owns no message", () => {
+      // The vellum-delivered case: the delivery row carries the handle and
+      // the adapter rewrites it, so there is nothing to do here.
+      const rewritten = updateFeedItemConversationMessage(
+        makeItem({ scheduleId: "sched-7" }),
+        "Four things now.",
+      );
+
+      expect(rewritten).toBe(false);
+      expect(messageRewrites).toHaveLength(0);
+    });
+
+    test("refuses a handle addressing a row outside the card's conversation", () => {
+      // Nothing should be able to point the rewrite at an unrelated message.
+      messageOwners.set("msg-9", "conv-somebody-elses");
+
+      const rewritten = updateFeedItemConversationMessage(
+        makeItem({ notificationConversationMessageId: "msg-9" }),
+        "Four things now.",
+      );
+
+      expect(rewritten).toBe(false);
+      expect(messageRewrites).toHaveLength(0);
+    });
+
+    test("refuses a handle whose row no longer exists", () => {
+      const rewritten = updateFeedItemConversationMessage(
+        makeItem({ notificationConversationMessageId: "msg-9" }),
+        "Four things now.",
+      );
+
+      expect(rewritten).toBe(false);
+      expect(messageRewrites).toHaveLength(0);
+    });
+
+    test("stands down when the delivery walk already rewrote the row", () => {
+      messageOwners.set("msg-9", "conv-source-1");
+
+      const rewritten = updateFeedItemConversationMessage(
+        makeItem({ notificationConversationMessageId: "msg-9" }),
+        "Four things now.",
+        new Set(["msg-9"]),
+      );
+
+      expect(rewritten).toBe(false);
+      expect(messageRewrites).toHaveLength(0);
+    });
+
+    test("rewrites when the walk touched some other row", () => {
+      messageOwners.set("msg-9", "conv-source-1");
+
+      const rewritten = updateFeedItemConversationMessage(
+        makeItem({ notificationConversationMessageId: "msg-9" }),
+        "Four things now.",
+        new Set(["1700000000.0001"]),
+      );
+
+      expect(rewritten).toBe(true);
+      expect(messageRewrites).toHaveLength(1);
+    });
+
+    test("reports no rewrite when the ownership lookup throws", () => {
+      // The edit has already patched the feed and run the channel updates by
+      // the time this runs, so a store that cannot answer must not abort it.
+      messageOwners.set("msg-9", "conv-source-1");
+      messageLookupShouldThrow = true;
+
+      const rewritten = updateFeedItemConversationMessage(
+        makeItem({ notificationConversationMessageId: "msg-9" }),
+        "Four things now.",
+      );
+
+      expect(rewritten).toBe(false);
+      expect(messageRewrites).toHaveLength(0);
+    });
+
+    test("reports no rewrite when the store write throws", () => {
+      messageOwners.set("msg-9", "conv-source-1");
+      messageRewriteShouldThrow = true;
+
+      const rewritten = updateFeedItemConversationMessage(
+        makeItem({ notificationConversationMessageId: "msg-9" }),
+        "Four things now.",
+      );
+
+      expect(rewritten).toBe(false);
+    });
+  });
 });

package/src/notifications/adapters/macos.ts

@@ -20,11 +20,15 @@
 
 import type { AssistantEvent } from "../../api/index.js";
 import type { InterfaceId } from "../../channels/types.js";
+import { updateMessageContent } from "../../persistence/conversation-crud.js";
+import { publishConversationMessagesChanged } from "../../runtime/sync/resource-sync-events.js";
 import { getLogger } from "../../util/logger.js";
 import type {
   ChannelAdapter,
   ChannelDeliveryPayload,
   ChannelDestination,
+  ChannelUpdateContext,
+  ChannelUpdatePayload,
   DeliveryResult,
   NotificationChannel,
 } from "../types.js";
@@ -132,4 +136,55 @@ export class VellumAdapter implements ChannelAdapter {
       return { success: false, error: message };
     }
   }
+
+  /**
+   * Rewrite the conversation message this delivery persisted.
+   *
+   * A vellum delivery has no channel-native message to patch, but it does
+   * carry the id of the row written into the conversation the notification
+   * card links to. Editing a notification patches the feed item, so without
+   * this the card would show the new body while "Go to Conversation" opened
+   * the old one.
+   *
+   * That row holds the body, and the feed rewrites its summary only when the
+   * patch carries one, so a title-only patch leaves the row alone to keep the
+   * two in step. A delivery carrying no message id has no row to rewrite.
+   */
+  async update(
+    delivery: ChannelUpdateContext,
+    patch: ChannelUpdatePayload,
+  ): Promise<DeliveryResult> {
+    if (!delivery.messageId) {
+      return {
+        success: false,
+        error:
+          "missing_message_id: this delivery persisted no conversation message",
+      };
+    }
+    if (patch.body === undefined) {
+      log.info(
+        { deliveryId: delivery.deliveryId, messageId: delivery.messageId },
+        "Vellum notification edit carried no body, conversation message left as is",
+      );
+      return { success: true, messageId: delivery.messageId };
+    }
+    try {
+      updateMessageContent(delivery.messageId, patch.body);
+      if (delivery.conversationId) {
+        publishConversationMessagesChanged(delivery.conversationId);
+      }
+      log.info(
+        { deliveryId: delivery.deliveryId, messageId: delivery.messageId },
+        "Vellum notification conversation message updated",
+      );
+      return { success: true, messageId: delivery.messageId };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      log.error(
+        { err, deliveryId: delivery.deliveryId, messageId: delivery.messageId },
+        "Failed to update Vellum notification conversation message",
+      );
+      return { success: false, error: message };
+    }
+  }
 }

package/src/notifications/adapters/slack.ts

@@ -14,7 +14,10 @@
 
 import type { Button, CardBlock, ContextBlock, KnownBlock } from "@slack/types";
 
-import { sendSlackReply } from "../../messaging/providers/slack/send.js";
+import {
+  sendSlackReply,
+  updateSlackMessage,
+} from "../../messaging/providers/slack/send.js";
 import { APPROVAL_INSTRUCTION_BLOCK_ID_PREFIX } from "../../messaging/providers/slack/withdraw.js";
 import type { ApprovalUIMetadata } from "../../runtime/channel-approval-types.js";
 import { getLogger } from "../../util/logger.js";
@@ -476,10 +479,12 @@ export class SlackAdapter implements ChannelAdapter {
       return { success: false, error: "no body or title supplied for update" };
     }
     try {
-      const result = await sendSlackReply(delivery.destination, text, {
-        messageTs: delivery.messageId,
-        useBlocks: true,
-      });
+      const result = await updateSlackMessage(
+        delivery.destination,
+        delivery.messageId,
+        text,
+        { useBlocks: true },
+      );
       log.info(
         { chatId: delivery.destination, messageTs: delivery.messageId },
         "Slack notification updated",