@vellumai/assistant 0.12.0-dev.202609110918.dd3fa5e → 0.12.0-dev.202609111417.417f7af

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.12.0-dev.202609110918.dd3fa5e",
+  "version": "0.12.0-dev.202609111417.417f7af",
   "license": "MIT",
   "type": "module",
   "exports": {

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;
@@ -402,6 +412,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

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

@@ -23,7 +23,10 @@ import {
   getMessageById,
   updateMessageContent,
 } from "../persistence/conversation-crud.js";
-import { isBackgroundConversationType } from "../persistence/conversation-types.js";
+import {
+  ASSISTANT_INITIATED_SOURCE,
+  isBackgroundConversationType,
+} from "../persistence/conversation-types.js";
 import { publishConversationMessagesChanged } from "../runtime/sync/resource-sync-events.js";
 import { getLogger } from "../util/logger.js";
 import { normalizeTitle, stripMarkdown } from "../util/short-title.js";
@@ -495,6 +498,18 @@ function deriveDetailPanelKind(
  * `isAsyncBackground` hint. `chat.assistant_reply` also mirrors: it is the
  * durable in-app record for the push sent after a user leaves a chat, while
  * retaining the normal interactive conversation as its navigation target.
+ *
+ * A delivery that materialized an assistant-initiated thread never mirrors.
+ * Under the `assistant-initiated-threads` flag, `conversation-pairing.ts`
+ * promotes a background `assistant.share` into a standard conversation
+ * stamped {@link ASSISTANT_INITIATED_SOURCE}, and that thread's row in the
+ * sidebar's assistant section is the share's one surface. Mirroring it here
+ * as well put the same share in the bell a second time, labeled by its
+ * source channel ("Heartbeat"). The check reads the paired conversation's
+ * `source` rather than re-deriving the promotion rule, so it holds however
+ * that rule narrows or widens. Guardian requests are checked first on
+ * purpose: the bell is their canonical home whatever conversation they pair
+ * with.
  */
 function resolveHomeFeedMirror(
   signal: NotificationSignal,
@@ -525,6 +540,15 @@ function resolveHomeFeedMirror(
     : fallbackConversationId;
   const sourceScheduleJobId = sourceRow?.scheduleJobId ?? undefined;
 
+  // Guardian requests always project into the feed: the "Needs
+  // attention" item is the request's canonical home, and the request
+  // blocks on the guardian whatever kind of conversation raised it.
+  if (isGuardianRequestSignalEvent(signal.sourceEventName)) {
+    return { mirror: true, sourceConversationId, sourceScheduleJobId };
+  }
+  if (isAssistantInitiatedThreadDelivery(fallbackConversationId)) {
+    return { mirror: false };
+  }
   if (
     signal.sourceChannel === "assistant_tool" ||
     signal.sourceEventName === "chat.assistant_reply"
@@ -534,18 +558,37 @@ function resolveHomeFeedMirror(
   if (signal.attentionHints.isAsyncBackground) {
     return { mirror: true, sourceConversationId, sourceScheduleJobId };
   }
-  // Guardian requests always project into the feed: the "Needs
-  // attention" item is the request's canonical home, and the request
-  // blocks on the guardian whatever kind of conversation raised it.
-  if (isGuardianRequestSignalEvent(signal.sourceEventName)) {
-    return { mirror: true, sourceConversationId, sourceScheduleJobId };
-  }
   if (isBackgroundConversationType(sourceRow?.conversationType)) {
     return { mirror: true, sourceConversationId, sourceScheduleJobId };
   }
   return { mirror: false };
 }
 
+/**
+ * Whether the vellum delivery this signal produced landed in a thread the
+ * sidebar's assistant section already shows.
+ *
+ * Best-effort like the source lookup above: a missing id, a missing row, or
+ * a lookup failure all read as "not an assistant thread", so a storage
+ * hiccup degrades to the pre-existing behavior (a bell row) rather than
+ * dropping the notification everywhere.
+ */
+function isAssistantInitiatedThreadDelivery(
+  deliveryConversationId: string | undefined,
+): boolean {
+  if (!deliveryConversationId) {
+    return false;
+  }
+  try {
+    return (
+      getConversation(deliveryConversationId)?.source ===
+      ASSISTANT_INITIATED_SOURCE
+    );
+  } catch {
+    return false;
+  }
+}
+
 /**
  * Routing-intent enforcement can prune `selectedChannels` without also
  * pruning `renderedCopy`, so iterating `renderedCopy` directly risks

package/src/persistence/migrations/157-invite-contact-id.ts

@@ -1,4 +1,5 @@
 import { type DrizzleDb, getSqliteFrom } from "../db-connection.js";
+import { tableExists } from "./schema-introspection.js";
 
 /**
  * Add a required contact_id column to assistant_ingress_invites.
@@ -10,8 +11,16 @@ import { type DrizzleDb, getSqliteFrom } from "../db-connection.js";
  *  1. Add the column as nullable.
  *  2. Delete legacy rows that have no contact binding (NULL).
  *  3. Rebuild the table to enforce NOT NULL (SQLite cannot ALTER COLUMN).
+ *
+ * The rebuild copies whichever session-id column is live:
+ * `source_conversation_id` (after migrateRenameCreatedBySessionIdColumns)
+ * or `created_by_session_id`.
  */
 export function migrateInviteContactId(database: DrizzleDb): void {
+  if (!tableExists(database, "assistant_ingress_invites")) {
+    return;
+  }
+
   const raw = getSqliteFrom(database);
 
   const cols = (
@@ -20,25 +29,28 @@ export function migrateInviteContactId(database: DrizzleDb): void {
       notnull: number;
     }>
   ).map((c) => ({ name: c.name, notnull: c.notnull }));
+  const colNames = new Set(cols.map((c) => c.name));
 
   const col = cols.find((c) => c.name === "contact_id");
 
-  // Step 1: Add the column as nullable
   if (!col) {
     raw.exec(
       /*sql*/ `ALTER TABLE assistant_ingress_invites ADD COLUMN contact_id TEXT`,
     );
   }
 
-  // Step 2: Delete legacy rows with no contact binding
   raw.exec(
     /*sql*/ `DELETE FROM assistant_ingress_invites WHERE contact_id IS NULL OR contact_id = ''`,
   );
 
-  // Step 3: Rebuild the table with NOT NULL on contact_id
   if (col && col.notnull === 1) {
     return;
-  } // already NOT NULL
+  }
+
+  const sessionCol = colNames.has("source_conversation_id")
+    ? "source_conversation_id"
+    : "created_by_session_id";
+  const sessionSelect = colNames.has(sessionCol) ? sessionCol : "NULL";
 
   raw.exec("PRAGMA foreign_keys = OFF");
   try {
@@ -49,7 +61,7 @@ export function migrateInviteContactId(database: DrizzleDb): void {
           id TEXT PRIMARY KEY,
           source_channel TEXT NOT NULL,
           token_hash TEXT NOT NULL,
-          created_by_session_id TEXT,
+          ${sessionCol} TEXT,
           note TEXT,
           max_uses INTEGER NOT NULL DEFAULT 1 CHECK (max_uses > 0),
           use_count INTEGER NOT NULL DEFAULT 0 CHECK (use_count >= 0),
@@ -70,7 +82,7 @@ export function migrateInviteContactId(database: DrizzleDb): void {
         );
 
         INSERT INTO assistant_ingress_invites_new
-        SELECT id, source_channel, token_hash, created_by_session_id, note,
+        SELECT id, source_channel, token_hash, ${sessionSelect}, note,
                max_uses, use_count, expires_at, status,
                redeemed_by_external_user_id, redeemed_by_external_chat_id,
                redeemed_at, expected_external_user_id, voice_code_hash,

package/src/persistence/migrations/__tests__/157-invite-contact-id.test.ts

@@ -0,0 +1,149 @@
+import { Database } from "bun:sqlite";
+import { describe, expect, test } from "bun:test";
+
+import { drizzle } from "drizzle-orm/bun-sqlite";
+
+import { getSqliteFrom } from "../../db-connection.js";
+import * as schema from "../../schema.js";
+import { migrateInviteContactId } from "../157-invite-contact-id.js";
+import { tableExists, tableHasColumn } from "../schema-introspection.js";
+
+function createTestDb() {
+  const sqlite = new Database(":memory:");
+  sqlite.exec("PRAGMA journal_mode=WAL");
+  return drizzle(sqlite, { schema });
+}
+
+function columnNotNull(raw: Database, name: string): boolean {
+  const cols = raw.query(`PRAGMA table_info(assistant_ingress_invites)`).all() as Array<{
+    name: string;
+    notnull: number;
+  }>;
+  return cols.some((c) => c.name === name && c.notnull === 1);
+}
+
+describe("migrateInviteContactId", () => {
+  test("rebuilds a legacy created_by_session_id table with NOT NULL contact_id", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    raw.exec(/*sql*/ `
+      CREATE TABLE assistant_ingress_invites (
+        id TEXT PRIMARY KEY,
+        source_channel TEXT NOT NULL,
+        token_hash TEXT NOT NULL,
+        created_by_session_id TEXT,
+        note TEXT,
+        max_uses INTEGER NOT NULL DEFAULT 1,
+        use_count INTEGER NOT NULL DEFAULT 0,
+        expires_at INTEGER NOT NULL,
+        status TEXT NOT NULL DEFAULT 'active',
+        redeemed_by_external_user_id TEXT,
+        redeemed_by_external_chat_id TEXT,
+        redeemed_at INTEGER,
+        expected_external_user_id TEXT,
+        voice_code_hash TEXT,
+        voice_code_digits INTEGER,
+        invite_code_hash TEXT,
+        friend_name TEXT,
+        guardian_name TEXT,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL
+      )
+    `);
+    raw.run(
+      `INSERT INTO assistant_ingress_invites
+         (id, source_channel, token_hash, created_by_session_id, max_uses, use_count,
+          expires_at, status, created_at, updated_at)
+       VALUES ('inv-keep', 'slack', 'hash-keep', 'conv-1', 1, 0, 9, 'active', 1, 1)`,
+    );
+    raw.exec(
+      `ALTER TABLE assistant_ingress_invites ADD COLUMN contact_id TEXT`,
+    );
+    raw.run(
+      `UPDATE assistant_ingress_invites SET contact_id = 'contact-keep' WHERE id = 'inv-keep'`,
+    );
+    raw.run(
+      `INSERT INTO assistant_ingress_invites
+         (id, source_channel, token_hash, max_uses, use_count, expires_at, status,
+          created_at, updated_at)
+       VALUES ('inv-drop', 'slack', 'hash-drop', 1, 0, 9, 'active', 1, 1)`,
+    );
+
+    migrateInviteContactId(db);
+
+    expect(tableHasColumn(db, "assistant_ingress_invites", "contact_id")).toBe(
+      true,
+    );
+    expect(columnNotNull(raw, "contact_id")).toBe(true);
+    expect(
+      tableHasColumn(db, "assistant_ingress_invites", "created_by_session_id"),
+    ).toBe(true);
+    const rows = raw
+      .query(`SELECT id, contact_id FROM assistant_ingress_invites ORDER BY id`)
+      .all() as Array<{ id: string; contact_id: string }>;
+    expect(rows).toEqual([{ id: "inv-keep", contact_id: "contact-keep" }]);
+  });
+
+  test("rebuilds after created_by_session_id was renamed to source_conversation_id", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    raw.exec(/*sql*/ `
+      CREATE TABLE assistant_ingress_invites (
+        id TEXT PRIMARY KEY,
+        source_channel TEXT NOT NULL,
+        token_hash TEXT NOT NULL,
+        source_conversation_id TEXT,
+        note TEXT,
+        max_uses INTEGER NOT NULL DEFAULT 1,
+        use_count INTEGER NOT NULL DEFAULT 0,
+        expires_at INTEGER NOT NULL,
+        status TEXT NOT NULL DEFAULT 'active',
+        redeemed_by_external_user_id TEXT,
+        redeemed_by_external_chat_id TEXT,
+        redeemed_at INTEGER,
+        expected_external_user_id TEXT,
+        voice_code_hash TEXT,
+        voice_code_digits INTEGER,
+        invite_code_hash TEXT,
+        friend_name TEXT,
+        guardian_name TEXT,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL
+      )
+    `);
+    raw.exec(
+      `ALTER TABLE assistant_ingress_invites ADD COLUMN contact_id TEXT`,
+    );
+    raw.run(
+      `INSERT INTO assistant_ingress_invites
+         (id, source_channel, token_hash, source_conversation_id, contact_id,
+          max_uses, use_count, expires_at, status, created_at, updated_at)
+       VALUES ('inv-1', 'slack', 'hash-1', 'conv-9', 'contact-1', 1, 0, 9, 'active', 1, 1)`,
+    );
+
+    migrateInviteContactId(db);
+
+    expect(columnNotNull(raw, "contact_id")).toBe(true);
+    expect(
+      tableHasColumn(db, "assistant_ingress_invites", "source_conversation_id"),
+    ).toBe(true);
+    expect(
+      tableHasColumn(db, "assistant_ingress_invites", "created_by_session_id"),
+    ).toBe(false);
+    const row = raw
+      .query(
+        `SELECT source_conversation_id, contact_id FROM assistant_ingress_invites WHERE id = 'inv-1'`,
+      )
+      .get() as { source_conversation_id: string; contact_id: string };
+    expect(row).toEqual({
+      source_conversation_id: "conv-9",
+      contact_id: "contact-1",
+    });
+  });
+
+  test("is a no-op when the table does not exist", () => {
+    const db = createTestDb();
+    migrateInviteContactId(db);
+    expect(tableExists(db, "assistant_ingress_invites")).toBe(false);
+  });
+});