@vellumai/assistant 0.12.1-staging.1 → 0.12.1

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__/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

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

@@ -22,7 +22,6 @@ import {
   getMessageById,
   parseMessageMetadata,
 } from "../persistence/conversation-crud.js";
-import { isReplaceableTitle } from "../persistence/conversation-title-placeholders.js";
 import {
   isDesktopOriginatedUserMessage,
   isReplyPushIneligibleUserMessage,
@@ -248,13 +247,9 @@ export async function emitAssistantReplyNotification(params: {
     // lock screen. Absent `requestedTitle` lets the decision branch derive a
     // title from the body, which reads better than an empty or placeholder
     // conversation title.
-    //
-    // Placeholder titles are plausible non-empty strings and survive
-    // sanitizing. They count as absent so the body supplies the title instead.
-    const storedTitle = conversation.title?.trim() ?? "";
-    const requestedTitle = isReplaceableTitle(storedTitle)
-      ? ""
-      : sanitizeNotificationTitle(flattenTitleWhitespace(storedTitle));
+    const requestedTitle = sanitizeNotificationTitle(
+      flattenTitleWhitespace(conversation.title ?? ""),
+    );
 
     // Read as close to the emit as possible: nothing short-circuits on it.
     // Presence only speaks for a turn the desktop itself opened, on that row's

package/src/notifications/conversation-pairing.ts

@@ -130,7 +130,6 @@ export interface PairingOptions {
  * transactional request or a system alert.
  */
 const ASSISTANT_SHARE_EVENT = "assistant.share";
-const ASSISTANT_REPLY_EVENT = "chat.assistant_reply";
 
 /**
  * Promote a background share into an assistant-initiated thread, under the
@@ -264,25 +263,7 @@ export async function pairDeliveryWithConversation(
     // notification can appear. The home feed aims its "Go to Conversation"
     // button at the same row whenever it mirrors the signal.
     //
-    // `chat.assistant_reply` already has its complete reply in that transcript.
-    // Its notification body is a lock-screen preview, so appending it would
-    // create a second, truncated assistant row. Keep the conversation target
-    // for deep links without writing the preview into the transcript.
-    if (
-      strategy === "start_new_conversation" &&
-      !signal.requiresConversation &&
-      signal.sourceEventName === ASSISTANT_REPLY_EVENT
-    ) {
-      return {
-        conversationId: resolveSourceConversationId(signal),
-        messageId: null,
-        strategy,
-        createdNewConversation: false,
-        conversationFallbackUsed: false,
-      };
-    }
-
-    // This is deliberately not gated on home-feed eligibility: a signal the
+    // So this is deliberately not gated on home-feed eligibility: a signal the
     // feed declines to mirror still reaches the user through the banner, and
     // this row is what makes that landing honest.
     if (strategy === "start_new_conversation" && !signal.requiresConversation) {
@@ -767,45 +748,44 @@ async function resolveChannelDeliveryHome(params: {
  * Indexing is skipped for parity with the other notification write paths:
  * notification copy is delivery audit, not conversational memory.
  */
-function resolveSourceConversationId(signal: NotificationSignal): string | null {
-  if (!signal.sourceContextId) {
+async function appendBodyToSourceConversation(
+  signal: NotificationSignal,
+  channel: NotificationChannel,
+  messageContent: string,
+): Promise<{ conversationId: string; messageId: string } | null> {
+  const sourceContextId = signal.sourceContextId;
+  if (!sourceContextId) {
     return null;
   }
+
+  let existing: ReturnType<typeof getConversation>;
   try {
-    return getConversation(signal.sourceContextId)?.id ?? null;
+    existing = getConversation(sourceContextId);
   } catch {
     return null;
   }
-}
-
-async function appendBodyToSourceConversation(
-  signal: NotificationSignal,
-  channel: NotificationChannel,
-  messageContent: string,
-): Promise<{ conversationId: string; messageId: string } | null> {
-  const conversationId = resolveSourceConversationId(signal);
-  if (!conversationId) {
+  if (!existing) {
     return null;
   }
 
-  const message = await addMessage(conversationId, "assistant", messageContent, {
+  const message = await addMessage(existing.id, "assistant", messageContent, {
     skipIndexing: true,
   });
   // `addMessage` projects attention metadata alone, so a client with this
   // conversation open needs the messages tag to refetch the transcript. A
   // notification the user taps through to has every chance of landing on an
   // already-open conversation.
-  publishConversationMessagesChanged(conversationId);
+  publishConversationMessagesChanged(existing.id);
 
   log.info(
     {
       signalId: signal.signalId,
       channel,
-      conversationId,
+      conversationId: existing.id,
       messageId: message.id,
     },
     "Appended notification body to producing conversation",
   );
 
-  return { conversationId, messageId: message.id };
+  return { conversationId: existing.id, messageId: message.id };
 }

package/src/notifications/delivered-post-record.ts

@@ -39,12 +39,6 @@ export interface DeliveredChannelPost {
   text: string;
   /** The message id the channel assigned when it acknowledged the post. */
   providerMessageId: string;
-  /**
-   * The ids of the further posts the same text became when the channel
-   * split it, in send order. Each is reconciled onto the row like the first,
-   * so a reaction, edit, or delete naming any chunk resolves to this row.
-   */
-  additionalProviderMessageIds?: readonly string[];
   /**
    * The conversation whose turn made the post, when a different one from
    * the home it is recorded in (the messaging tool sending from a scheduled
@@ -81,11 +75,7 @@ export async function recordDeliveredChannelPost(
         : {}),
     },
   });
-  const reconcile = makeSentMessageIdReconciler(row.id);
-  await reconcile(post.providerMessageId);
-  for (const id of post.additionalProviderMessageIds ?? []) {
-    await reconcile(id);
-  }
+  await makeSentMessageIdReconciler(row.id)(post.providerMessageId);
   // A resident conversation reloads its history on the next turn so the
   // post is in context; the client refetches the transcript.
   findConversation(post.conversationId)?.markHistoryStale();