@vellumai/assistant 0.12.1 → 0.12.2-staging.2

package/src/messaging/providers/telegram-bot/client.ts

@@ -41,29 +41,3 @@ export async function getMe(botToken: string): Promise<TelegramGetMeResponse> {
 
   return resp.json() as Promise<TelegramGetMeResponse>;
 }
-
-/** Result returned by sendMessage. */
-export interface TelegramSendResult {
-  ok: boolean;
-  /**
-   * The `message_id` Telegram assigned to the last chunk sent. Telegram
-   * returns the sent Message on every successful `sendMessage`, so this is
-   * absent only when the API answered with an unexpected shape.
-   */
-  lastMessageId?: string;
-}
-
-/**
- * Send a Telegram text message via the Bot API directly.
- *
- * Delegates to sendTelegramReply which handles text splitting (Telegram's
- * sendMessage API has a 4096-char limit per call).
- */
-export async function sendMessage(
-  chatId: string,
-  text: string,
-): Promise<TelegramSendResult> {
-  const { sendTelegramReply } = await import("./send.js");
-  const sent = await sendTelegramReply(chatId, text);
-  return { ok: true, lastMessageId: sent.lastMessageId };
-}

package/src/messaging/providers/telegram-bot/transport.ts

@@ -2,6 +2,7 @@ import type { StreamPlan, StreamPlanStep } from "@vellumai/gateway-client";
 import { ChannelDeliveryError } from "@vellumai/gateway-client/http-delivery";
 
 import { getLogger } from "../../../util/logger.js";
+import { directDeliveryContext } from "../callback-routing.js";
 import type {
   CallbackContext,
   ChannelTransport,
@@ -66,6 +67,25 @@ function mintDraftId(): number {
 export const telegramTransport: ChannelTransport = {
   channel: "telegram",
 
+  /**
+   * A chat is a chat id, with `threadId` naming a forum topic. A person's DM
+   * chat id is their user id on Telegram, so reaching one is naming that
+   * chat and needs no resolution of its own.
+   */
+  addressFor(target) {
+    const threadId = target.threadId?.trim();
+    return {
+      ctx: directDeliveryContext("telegram", threadId ? { threadId } : {}),
+      chatId: target.chatId,
+      ...(threadId ? { threadId } : {}),
+    };
+  },
+
+  // A Telegram chat's inbound conversation is keyed per chat and can be
+  // reset or deleted between sends; a proactive post re-binds it so the
+  // next inbound from the chat lands where the post lives.
+  bindsChatOnProactiveSend: true,
+
   // Telegram clears a chat action after about five seconds.
   activityRefreshMs: 4_000,
 

package/src/messaging/providers/whatsapp/adapter.ts

@@ -5,8 +5,6 @@
  */
 
 import type { OAuthConnection } from "../../../oauth/connection.js";
-import { getOrCreateConversation } from "../../../persistence/conversation-key-store.js";
-import { upsertOutboundBinding } from "../../../persistence/external-conversation-store.js";
 import { credentialKey } from "../../../security/credential-key.js";
 import { getSecureKeyAsync } from "../../../security/secure-keys.js";
 import type { MessagingProvider } from "../../provider.js";
@@ -18,10 +16,7 @@ import type {
   Message,
   SearchOptions,
   SearchResult,
-  SendOptions,
-  SendResult,
 } from "../../provider-types.js";
-import * as whatsapp from "./client.js";
 
 /** Check whether WhatsApp credentials are stored. */
 async function hasWhatsAppCredentials(): Promise<boolean> {
@@ -41,7 +36,7 @@ export const whatsappMessagingProvider: MessagingProvider = {
   id: "whatsapp",
   displayName: "WhatsApp",
   credentialService: "whatsapp",
-  capabilities: new Set(["send"]),
+  capabilities: new Set(),
 
   async isConnected(): Promise<boolean> {
     return hasWhatsAppCredentials();
@@ -74,48 +69,6 @@ export const whatsappMessagingProvider: MessagingProvider = {
     };
   },
 
-  async sendMessage(
-    _connection: OAuthConnection | undefined,
-    conversationId: string,
-    text: string,
-    options?: SendOptions,
-  ): Promise<SendResult> {
-    const assistantId = options?.assistantId;
-
-    const sent = await whatsapp.sendMessage(conversationId, text);
-    if (!sent.messageId) {
-      throw new Error(
-        "WhatsApp accepted the message but returned no message id",
-      );
-    }
-
-    // Upsert external conversation binding so the conversation key mapping
-    // exists for the next inbound WhatsApp message from this number.
-    try {
-      const sourceChannel = "whatsapp";
-      const conversationKey = `asst:${assistantId ?? "self"}:${sourceChannel}:${conversationId}`;
-      const { conversationId: internalId } =
-        getOrCreateConversation(conversationKey);
-      if (!assistantId || assistantId === "self") {
-        upsertOutboundBinding({
-          conversationId: internalId,
-          sourceChannel,
-          externalChatId: conversationId,
-        });
-      }
-    } catch {
-      // Best-effort — don't fail the send if binding upsert fails
-    }
-
-    // The id is the one the Cloud API assigned, so a later reaction or
-    // delete carrying that id resolves to this send.
-    return {
-      id: sent.messageId,
-      timestamp: Date.now(),
-      conversationId,
-    };
-  },
-
   async listConversations(
     _connection?: OAuthConnection,
     _options?: ListOptions,

package/src/messaging/providers/whatsapp/transport.ts

@@ -1,6 +1,7 @@
 import { ChannelDeliveryError } from "@vellumai/gateway-client/http-delivery";
 
 import { getLogger } from "../../../util/logger.js";
+import { directDeliveryContext } from "../callback-routing.js";
 import type { ChannelTransport } from "../channel-transport.js";
 import { sendWhatsAppAttachments, sendWhatsAppReply } from "./send.js";
 
@@ -9,6 +10,23 @@ const log = getLogger("whatsapp-transport");
 export const whatsappTransport: ChannelTransport = {
   channel: "whatsapp",
 
+  /**
+   * A chat is the phone number, which is also how a person is named, so
+   * reaching one needs no resolution of its own. There are no threads, so a
+   * target's thread is not carried and the post lands in the chat itself.
+   */
+  addressFor(target) {
+    return {
+      ctx: directDeliveryContext("whatsapp"),
+      chatId: target.chatId,
+    };
+  },
+
+  // A WhatsApp number's inbound conversation is keyed per chat and can be
+  // reset between sends; a proactive post re-binds it so the next inbound
+  // from the number lands where the post lives.
+  bindsChatOnProactiveSend: true,
+
   async deliver(_ctx, payload) {
     const { chatId, text, attachments, approval } = payload;
 

package/src/monitoring/__tests__/workspace-git-heartbeat.test.ts

@@ -54,4 +54,12 @@ describe("workspace git heartbeat on the monitoring worker", () => {
     expect(worker).toContain("await workspaceGitHeartbeat?.stop()");
     expect(lifecycle).not.toContain("startWorkspaceHeartbeatService");
   });
+
+  test("daemon lifecycle does not stop the in-process heartbeat singleton", () => {
+    const shutdown = readFileSync(
+      join(SRC_ROOT, "daemon/shutdown-handlers.ts"),
+      "utf8",
+    );
+    expect(shutdown).not.toContain("stopWorkspaceHeartbeatService");
+  });
 });

package/src/notifications/__tests__/assistant-reply-producer.test.ts

@@ -5,6 +5,7 @@
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 import { setOverridesForTesting } from "../../__tests__/feature-flag-test-helpers.js";
+import { MESSAGE_KEYS } from "../../i18n/index.js";
 import type { AttentionState } from "../../persistence/conversation-attention-store.js";
 import type {
   ConversationRow,
@@ -589,6 +590,60 @@ describe("emitAssistantReplyNotification", () => {
     });
   });
 
+  // A conversation whose title is still being written stores the message key
+  // itself, which is a non-empty string the sanitizer has no reason to reject.
+  // Sending it would put a raw key on the lock screen, so it counts as absent.
+  test("omits requestedTitle while the title is still generating", async () => {
+    conversationRow = makeConversation({
+      title: MESSAGE_KEYS.CONVERSATION_TITLE_GENERATING,
+    });
+
+    await run();
+
+    expect(emitCalls).toHaveLength(1);
+    expect(emitCalls[0].contextPayload).toEqual({
+      requestedMessage: "Sure, here is the plan.",
+    });
+  });
+
+  test("omits requestedTitle for the legacy generating placeholder", async () => {
+    conversationRow = makeConversation({ title: "Generating title..." });
+
+    await run();
+
+    expect(emitCalls).toHaveLength(1);
+    expect(emitCalls[0].contextPayload).toEqual({
+      requestedMessage: "Sure, here is the plan.",
+    });
+  });
+
+  test("omits requestedTitle for the untitled placeholder key", async () => {
+    conversationRow = makeConversation({
+      title: MESSAGE_KEYS.CONVERSATION_TITLE_UNTITLED,
+    });
+
+    await run();
+
+    expect(emitCalls).toHaveLength(1);
+    expect(emitCalls[0].contextPayload).toEqual({
+      requestedMessage: "Sure, here is the plan.",
+    });
+  });
+
+  // Only an exact key is a system constant. A title the user or the model
+  // wrote that happens to contain one is their copy and travels as written.
+  test("keeps a title that merely contains a message key", async () => {
+    conversationRow = makeConversation({
+      title: `notes on ${MESSAGE_KEYS.CONVERSATION_TITLE_GENERATING}`,
+    });
+
+    await run();
+
+    expect(emitCalls[0].contextPayload.requestedTitle).toBe(
+      "notes on conversation.title.generating",
+    );
+  });
+
   test("caps the preview at 200 chars", async () => {
     assistantRow = makeAssistantRow([
       { type: "text", text: "a".repeat(300) },

package/src/notifications/__tests__/guardian-feed-projection.test.ts

@@ -39,15 +39,35 @@ mock.module("../../channels/gateway-guardian-requests.js", () => ({
   getGuardianRequest: (id: string) => getGuardianRequestStub(id),
 }));
 
+// The heal's completion sentinel lives in the daemon checkpoint ledger. An
+// in-memory map stands in so the heal runs without a database; it is cleared
+// per test so every test starts unhealed. The spread keeps the module's other
+// exports real for transitive importers.
+const actualCheckpoints = await import("../../persistence/checkpoints.js");
+const checkpointStore = new Map<string, string>();
+mock.module("../../persistence/checkpoints.js", () => ({
+  ...actualCheckpoints,
+  getMemoryCheckpoint: (key: string) => checkpointStore.get(key) ?? null,
+  setMemoryCheckpoint: (key: string, value: string) => {
+    checkpointStore.set(key, value);
+  },
+}));
+
 const {
   buildPendingGuardianProjection,
   guardianFeedItemId,
+  healLegacyGuardianReceiptUnread,
   reconcileGuardianFeedProjections,
   requestIdFromGuardianFeedItemId,
   writeGuardianFeedReceipt,
 } = await import("../guardian-feed-projection.js");
-const { appendFeedItem, bulkSetFeedItemStatus, getHomeFeedPath, readHomeFeed } =
-  await import("../../home/feed-writer.js");
+const {
+  appendFeedItem,
+  bulkSetFeedItemStatus,
+  getHomeFeedPath,
+  patchFeedItemStatus,
+  readHomeFeed,
+} = await import("../../home/feed-writer.js");
 const { GUARDIAN_TERMINAL_REASON_SUPERSEDED, isPendingGuardianFeedItem } =
   await import("../../api/responses/home.js");
 type FeedItem = import("../../api/responses/home.js").FeedItem;
@@ -61,6 +81,7 @@ beforeEach(() => {
   process.env.VELLUM_WORKSPACE_DIR = workspaceDir;
   listGuardianRequestsStub = async () => [];
   getGuardianRequestStub = async () => null;
+  checkpointStore.clear();
 });
 
 afterEach(() => {
@@ -104,6 +125,72 @@ function pendingGuardianItem(requestId: string): FeedItem {
   };
 }
 
+/**
+ * A terminal receipt that never passed the pending-to-terminal edge:
+ * terminal projection, urgency `medium`, still `new`.
+ */
+function legacyGuardianReceiptItem(requestId: string): FeedItem {
+  const item = pendingGuardianItem(requestId);
+  return {
+    ...item,
+    urgency: "medium",
+    status: "new",
+    guardianRequest: { ...item.guardianRequest!, status: "approved" },
+  };
+}
+
+describe("healLegacyGuardianReceiptUnread", () => {
+  test("clears unread on a terminal receipt that never passed the edge", async () => {
+    await appendFeedItem(legacyGuardianReceiptItem("legacy-1"));
+
+    await healLegacyGuardianReceiptUnread();
+
+    expect(
+      readHomeFeed().items.find((i) => i.id === guardianFeedItemId("legacy-1"))
+        ?.status,
+    ).toBe("seen");
+  });
+
+  test("runs once per assistant, so a later mark-unread stands", async () => {
+    await appendFeedItem(legacyGuardianReceiptItem("legacy-2"));
+    const itemId = guardianFeedItemId("legacy-2");
+    await healLegacyGuardianReceiptUnread();
+
+    // The user marks the resolved receipt unread again. The pass has
+    // already recorded completion, so a second round leaves it alone.
+    await patchFeedItemStatus(itemId, "new");
+    await healLegacyGuardianReceiptUnread();
+
+    expect(readHomeFeed().items.find((i) => i.id === itemId)?.status).toBe(
+      "new",
+    );
+  });
+
+  test("never revives a dismissed receipt", async () => {
+    const item = legacyGuardianReceiptItem("legacy-3");
+    await appendFeedItem({ ...item, status: "dismissed" });
+
+    await healLegacyGuardianReceiptUnread();
+
+    expect(
+      readHomeFeed().items.find((i) => i.id === guardianFeedItemId("legacy-3"))
+        ?.status,
+    ).toBe("dismissed");
+  });
+
+  test("leaves a still-pending request alone", async () => {
+    await appendFeedItem(pendingGuardianItem("still-pending"));
+
+    await healLegacyGuardianReceiptUnread();
+
+    const item = readHomeFeed().items.find(
+      (i) => i.id === guardianFeedItemId("still-pending"),
+    );
+    expect(item?.status).toBe("new");
+    expect(item && isPendingGuardianFeedItem(item)).toBe(true);
+  });
+});
+
 describe("buildPendingGuardianProjection", () => {
   test("tool approval projects as a pending approval with source facts", () => {
     const projection = buildPendingGuardianProjection(toolApprovalPayload);
@@ -264,6 +351,75 @@ describe("writeGuardianFeedReceipt", () => {
     expect(item?.guardianRequest?.status).toBe("denied");
   });
 
+  test("a receipt stops the item reading as unread", async () => {
+    await appendFeedItem(pendingGuardianItem("req-6"));
+    await writeGuardianFeedReceipt({
+      requestId: "req-6",
+      status: "approved",
+      decidedAction: "approve_once",
+    });
+
+    const item = readHomeFeed().items.find(
+      (i) => i.id === guardianFeedItemId("req-6"),
+    );
+    // The clients' unread test is `status === "new"`, so a receipt left
+    // at `new` keeps lighting the bell for work nobody can act on.
+    expect(item?.status).toBe("seen");
+  });
+
+  test("a terminal status nobody decided also clears unread", async () => {
+    await appendFeedItem(pendingGuardianItem("req-7"));
+    await writeGuardianFeedReceipt({ requestId: "req-7", status: "expired" });
+
+    expect(
+      readHomeFeed().items.find((i) => i.id === guardianFeedItemId("req-7"))
+        ?.status,
+    ).toBe("seen");
+  });
+
+  test("a status the user set survives a re-run of the fan-out", async () => {
+    await appendFeedItem(pendingGuardianItem("req-8"));
+    const itemId = guardianFeedItemId("req-8");
+    await writeGuardianFeedReceipt({ requestId: "req-8", status: "approved" });
+    // The user clears the receipt, then the withdrawal fan-out retries
+    // (its per-request receipt is held back until every surface settles).
+    await patchFeedItemStatus(itemId, "dismissed");
+    await writeGuardianFeedReceipt({ requestId: "req-8", status: "approved" });
+
+    expect(readHomeFeed().items.find((i) => i.id === itemId)?.status).toBe(
+      "dismissed",
+    );
+  });
+
+  test("a pending request dismissed outright is not revived by its receipt", async () => {
+    await appendFeedItem(pendingGuardianItem("req-10"));
+    const itemId = guardianFeedItemId("req-10");
+    // Bulk dismissal spares a pending guardian item, but a deliberate
+    // single-item dismissal stays available and is not undone by the
+    // resolution that follows it.
+    await patchFeedItemStatus(itemId, "dismissed");
+    await writeGuardianFeedReceipt({ requestId: "req-10", status: "denied" });
+
+    expect(readHomeFeed().items.find((i) => i.id === itemId)?.status).toBe(
+      "dismissed",
+    );
+  });
+
+  test("a receipt the user marked unread again stays unread", async () => {
+    await appendFeedItem(pendingGuardianItem("req-9"));
+    const itemId = guardianFeedItemId("req-9");
+    await writeGuardianFeedReceipt({ requestId: "req-9", status: "approved" });
+    // The bell detail's read toggle writes `new` back onto a resolved
+    // receipt. The clear runs on the edge into terminal, which has
+    // already passed, so a later receipt must not take it back.
+    await patchFeedItemStatus(itemId, "new");
+    await writeGuardianFeedReceipt({ requestId: "req-9", status: "approved" });
+
+    expect(readHomeFeed().items.find((i) => i.id === itemId)?.status).toBe(
+      "new",
+    );
+  });
+
   test("a request with no item resolves true (nothing to retry)", async () => {
     expect(
       await writeGuardianFeedReceipt({ requestId: "ghost", status: "expired" }),

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

@@ -26,6 +26,15 @@ 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;
+/**
+ * Rows for specific ids, consulted before the catch-all `conversationRow`,
+ * so a test can hand the signal's source and the delivery's paired
+ * conversation different shapes.
+ */
+const conversationRowsById = new Map<
+  string,
+  { conversationType: string; source?: string }
+>();
 let conversationLookupShouldThrow = false;
 let messageAppendShouldThrow = false;
 let messageRewriteShouldThrow = false;
@@ -71,7 +80,7 @@ mock.module("../../persistence/conversation-crud.js", () => ({
     if (conversationLookupShouldThrow) {
       throw new Error("simulated conversation lookup failure");
     }
-    return conversationRow;
+    return conversationRowsById.get(id) ?? conversationRow;
   },
   addMessage: async (
     conversationId: string,
@@ -164,6 +173,7 @@ beforeEach(() => {
   messageRewrites.length = 0;
   messageOwners.clear();
   conversationRow = null;
+  conversationRowsById.clear();
   conversationLookupShouldThrow = false;
   messageAppendShouldThrow = false;
   messageRewriteShouldThrow = false;
@@ -258,7 +268,11 @@ describe("writeHomeFeedItemForSignal", () => {
       },
     });
 
-    const item = await writeHomeFeedItemForSignal(signal, decision);
+    const item = await writeHomeFeedItemForSignal(
+      signal,
+      decision,
+      makeVellumDelivery(),
+    );
 
     expect(item).not.toBeNull();
     expect(appendCalls).toHaveLength(1);
@@ -267,7 +281,10 @@ describe("writeHomeFeedItemForSignal", () => {
       "The deployment completed successfully.",
     );
     expect(appendCalls[0]!.conversationId).toBe("conv-source-1");
-    expect(conversationLookups).toEqual(["conv-source-1"]);
+    expect(appendCalls[0]!.metadata?.notificationConversationMessageId).toBeUndefined();
+    expect(messageAppends).toEqual([]);
+    expect(messagesInvalidated).toEqual([]);
+    expect(conversationLookups).toEqual(["conv-source-1", "conv-source-1"]);
   });
 
   test("isAsyncBackground hint writes even when sourceContextId does not resolve", async () => {
@@ -402,6 +419,139 @@ describe("writeHomeFeedItemForSignal", () => {
     expect(appendCalls[0]!.conversationId).toBe("paired-delivery-conv-id");
   });
 
+  describe("assistant-initiated thread deliveries", () => {
+    // Under the assistant-initiated-threads flag, conversation pairing
+    // promotes a background assistant.share into a standard conversation
+    // stamped `assistant_initiated`, which the sidebar's assistant section
+    // renders. That thread is the share's surface; a feed item for the
+    // same signal put it in the bell a second time.
+    const assistantThreadDelivery = () =>
+      makeVellumDelivery({ conversationId: "assistant-thread-1" });
+
+    function stampAssistantThread(): void {
+      conversationRowsById.set("assistant-thread-1", {
+        conversationType: "standard",
+        source: "assistant_initiated",
+      });
+    }
+
+    function shareFromHeartbeat(): NotificationSignal {
+      return makeSignal({
+        sourceChannel: "assistant_tool",
+        sourceEventName: "assistant.share",
+        sourceContextId: "conv-source-1",
+        contextPayload: { title: "Doctor checklist built" },
+      });
+    }
+
+    const shareDecision = () =>
+      makeDecision({
+        selectedChannels: ["vellum"],
+        renderedCopy: {
+          vellum: {
+            title: "Doctor checklist built",
+            body: "Your doctor-visit one-pager is ready.",
+          },
+        },
+      });
+
+    test("a background share promoted into an assistant thread does not mirror", async () => {
+      conversationRow = { conversationType: "background" };
+      stampAssistantThread();
+
+      const item = await writeHomeFeedItemForSignal(
+        shareFromHeartbeat(),
+        shareDecision(),
+        assistantThreadDelivery(),
+      );
+
+      expect(item).toBeNull();
+      expect(appendCalls).toHaveLength(0);
+      expect(messageAppends).toHaveLength(0);
+    });
+
+    test("the async-background hint does not override the assistant-thread suppression", async () => {
+      conversationRow = null;
+      stampAssistantThread();
+      const signal = makeSignal({
+        sourceChannel: "assistant_tool",
+        sourceEventName: "assistant.share",
+        sourceContextId: "heartbeat",
+        contextPayload: { title: "Bilbao solo trip is planned" },
+        attentionHints: {
+          requiresAction: false,
+          urgency: "medium",
+          isAsyncBackground: true,
+          visibleInSourceNow: false,
+        },
+      });
+
+      const item = await writeHomeFeedItemForSignal(
+        signal,
+        shareDecision(),
+        assistantThreadDelivery(),
+      );
+
+      expect(item).toBeNull();
+      expect(appendCalls).toHaveLength(0);
+    });
+
+    test("a share paired with an ordinary notification thread still mirrors", async () => {
+      // Flag off, or any producer that did not promote: pairing writes a
+      // `notification`-sourced row, which stays in Chats and the bell.
+      conversationRow = { conversationType: "background" };
+      conversationRowsById.set("assistant-thread-1", {
+        conversationType: "standard",
+        source: "notification",
+      });
+
+      const item = await writeHomeFeedItemForSignal(
+        shareFromHeartbeat(),
+        shareDecision(),
+        assistantThreadDelivery(),
+      );
+
+      expect(item).not.toBeNull();
+      expect(appendCalls).toHaveLength(1);
+    });
+
+    test("a guardian request keeps its bell item even when paired with an assistant thread", async () => {
+      // The bell is the request's canonical home: nothing else renders the
+      // pending card, so the assistant-thread suppression must not reach it.
+      conversationRow = { conversationType: "standard" };
+      stampAssistantThread();
+      const signal = makeSignal({
+        sourceChannel: "assistant_tool",
+        sourceEventName: "guardian.question",
+        contextPayload: {
+          title: "Approve this?",
+          questionText: "May I send the email?",
+          requestId: "req-1",
+        },
+        attentionHints: {
+          requiresAction: true,
+          urgency: "medium",
+          isAsyncBackground: false,
+          visibleInSourceNow: false,
+        },
+      });
+
+      const item = await writeHomeFeedItemForSignal(
+        signal,
+        makeDecision({
+          selectedChannels: ["vellum"],
+          renderedCopy: {
+            vellum: { title: "Approve this?", body: "May I send the email?" },
+          },
+        }),
+        assistantThreadDelivery(),
+      );
+
+      expect(item).not.toBeNull();
+      expect(appendCalls).toHaveLength(1);
+    });
+  });
+
   test("source conversation id wins over the paired delivery fallback when both are available", async () => {
     // When the producer's `sourceContextId` already points at a real
     // conversation (the canonical "where the work happened"), prefer it