@vellumai/assistant 0.12.1-dev.202609141913.5e16607 → 0.12.1-staging.2

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

@@ -2,7 +2,6 @@ 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,
@@ -67,25 +66,6 @@ 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,6 +5,8 @@
  */
 
 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";
@@ -16,7 +18,10 @@ 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> {
@@ -36,7 +41,7 @@ export const whatsappMessagingProvider: MessagingProvider = {
   id: "whatsapp",
   displayName: "WhatsApp",
   credentialService: "whatsapp",
-  capabilities: new Set(),
+  capabilities: new Set(["send"]),
 
   async isConnected(): Promise<boolean> {
     return hasWhatsAppCredentials();
@@ -69,6 +74,48 @@ 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/client.ts

@@ -0,0 +1,29 @@
+/**
+ * Low-level WhatsApp operations.
+ *
+ * Calls the Meta Cloud API directly via ./api.ts — no gateway proxy hop.
+ */
+
+import { sendWhatsAppTextMessage } from "./api.js";
+
+/** Result returned by sendMessage. */
+export interface WhatsAppSendResult {
+  ok: boolean;
+  /**
+   * The id the Cloud API assigned to the message (`messages[0].id`). Meta
+   * returns it on every accepted send, so this is absent only when the API
+   * answered with an unexpected shape.
+   */
+  messageId?: string;
+}
+
+/**
+ * Send a WhatsApp text message via the Meta Cloud API.
+ */
+export async function sendMessage(
+  to: string,
+  text: string,
+): Promise<WhatsAppSendResult> {
+  const result = await sendWhatsAppTextMessage(to, text);
+  return { ok: true, messageId: result.messages?.[0]?.id };
+}

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

@@ -1,7 +1,6 @@
 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";
 
@@ -10,23 +9,6 @@ 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,12 +54,4 @@ 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,7 +5,6 @@
 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,
@@ -590,60 +589,6 @@ 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,35 +39,15 @@ 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,
-  patchFeedItemStatus,
-  readHomeFeed,
-} = await import("../../home/feed-writer.js");
+const { appendFeedItem, bulkSetFeedItemStatus, getHomeFeedPath, 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;
@@ -81,7 +61,6 @@ beforeEach(() => {
   process.env.VELLUM_WORKSPACE_DIR = workspaceDir;
   listGuardianRequestsStub = async () => [];
   getGuardianRequestStub = async () => null;
-  checkpointStore.clear();
 });
 
 afterEach(() => {
@@ -125,72 +104,6 @@ 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);
@@ -351,75 +264,6 @@ 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,15 +26,6 @@ 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;
@@ -80,7 +71,7 @@ mock.module("../../persistence/conversation-crud.js", () => ({
     if (conversationLookupShouldThrow) {
       throw new Error("simulated conversation lookup failure");
     }
-    return conversationRowsById.get(id) ?? conversationRow;
+    return conversationRow;
   },
   addMessage: async (
     conversationId: string,
@@ -173,7 +164,6 @@ beforeEach(() => {
   messageRewrites.length = 0;
   messageOwners.clear();
   conversationRow = null;
-  conversationRowsById.clear();
   conversationLookupShouldThrow = false;
   messageAppendShouldThrow = false;
   messageRewriteShouldThrow = false;
@@ -268,11 +258,7 @@ describe("writeHomeFeedItemForSignal", () => {
       },
     });
 
-    const item = await writeHomeFeedItemForSignal(
-      signal,
-      decision,
-      makeVellumDelivery(),
-    );
+    const item = await writeHomeFeedItemForSignal(signal, decision);
 
     expect(item).not.toBeNull();
     expect(appendCalls).toHaveLength(1);
@@ -281,10 +267,7 @@ describe("writeHomeFeedItemForSignal", () => {
       "The deployment completed successfully.",
     );
     expect(appendCalls[0]!.conversationId).toBe("conv-source-1");
-    expect(appendCalls[0]!.metadata?.notificationConversationMessageId).toBeUndefined();
-    expect(messageAppends).toEqual([]);
-    expect(messagesInvalidated).toEqual([]);
-    expect(conversationLookups).toEqual(["conv-source-1", "conv-source-1"]);
+    expect(conversationLookups).toEqual(["conv-source-1"]);
   });
 
   test("isAsyncBackground hint writes even when sourceContextId does not resolve", async () => {
@@ -419,139 +402,6 @@ 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