@vellumai/assistant 0.12.3-staging.1 → 0.12.3-staging.2

package/src/__tests__/db-mode-sessions-migration.test.ts

@@ -0,0 +1,175 @@
+import { Database } from "bun:sqlite";
+import { describe, expect, test } from "bun:test";
+
+import { drizzle } from "drizzle-orm/bun-sqlite";
+
+import {
+  downCreateConversationModeSessions,
+  migrateCreateConversationModeSessions,
+} from "../persistence/migrations/381-create-conversation-mode-sessions.js";
+import * as schema from "../persistence/schema.js";
+
+function createPreMigrationDb() {
+  const sqlite = new Database(":memory:");
+  sqlite.exec(/* sql */ `
+    PRAGMA foreign_keys = ON;
+    CREATE TABLE conversations (
+      id TEXT PRIMARY KEY
+    );
+  `);
+  return { sqlite, db: drizzle(sqlite, { schema }) };
+}
+
+function tableExists(sqlite: Database): boolean {
+  return (
+    sqlite
+      .query(
+        "SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'conversation_mode_sessions'",
+      )
+      .get() != null
+  );
+}
+
+describe("migration 380: conversation mode sessions", () => {
+  test("creates the table and indexed conversation lookup", () => {
+    const { sqlite, db } = createPreMigrationDb();
+    migrateCreateConversationModeSessions(db);
+
+    expect(tableExists(sqlite)).toBe(true);
+    const indexes = sqlite
+      .query("PRAGMA index_list(conversation_mode_sessions)")
+      .all() as Array<{ name: string }>;
+    expect(indexes.map((index) => index.name)).toContain(
+      "idx_conversation_mode_sessions_conversation_status",
+    );
+  });
+
+  test("is idempotent on an existing migrated database", () => {
+    const { sqlite, db } = createPreMigrationDb();
+    migrateCreateConversationModeSessions(db);
+    expect(() => migrateCreateConversationModeSessions(db)).not.toThrow();
+
+    expect(tableExists(sqlite)).toBe(true);
+  });
+
+  test("supports rollback and reapply", () => {
+    const { sqlite, db } = createPreMigrationDb();
+    migrateCreateConversationModeSessions(db);
+    downCreateConversationModeSessions(db);
+    expect(tableExists(sqlite)).toBe(false);
+
+    migrateCreateConversationModeSessions(db);
+    expect(tableExists(sqlite)).toBe(true);
+  });
+
+  test("enforces status values and deletes rows with their conversation", () => {
+    const { sqlite, db } = createPreMigrationDb();
+    migrateCreateConversationModeSessions(db);
+    sqlite.exec(/* sql */ `
+      INSERT INTO conversations (id) VALUES ('conv-123');
+      INSERT INTO conversation_mode_sessions (
+        id, conversation_id, mode, status, source_started_at, last_activity_at
+      ) VALUES (
+        'session-123', 'conv-123', 'browser', 'active', 100, 100
+      );
+    `);
+
+    expect(() =>
+      sqlite
+        .query(
+          /* sql */ `
+        INSERT INTO conversation_mode_sessions (
+          id, conversation_id, mode, status, source_started_at, last_activity_at
+        ) VALUES (
+          'session-456', 'conv-123', 'browser', 'waiting', 100, 100
+        )
+      `,
+        )
+        .run(),
+    ).toThrow();
+
+    expect(() =>
+      sqlite
+        .query(
+          /* sql */ `
+        INSERT INTO conversation_mode_sessions (
+          id, conversation_id, mode, status, source_started_at, last_activity_at,
+          ended_at, end_reason
+        ) VALUES (
+          'session-completed-without-end', 'conv-123', 'browser', 'completed',
+          100, 100, NULL, 'settled'
+        )
+      `,
+        )
+        .run(),
+    ).toThrow();
+
+    expect(() =>
+      sqlite
+        .query(
+          /* sql */ `
+        INSERT INTO conversation_mode_sessions (
+          id, conversation_id, mode, status, source_started_at, last_activity_at,
+          ended_at, end_reason
+        ) VALUES (
+          'session-empty-reason', 'conv-123', 'browser', 'completed',
+          100, 100, 125, ''
+        )
+      `,
+        )
+        .run(),
+    ).toThrow();
+
+    expect(() =>
+      sqlite
+        .query(
+          /* sql */ `
+        INSERT INTO conversation_mode_sessions (
+          id, conversation_id, mode, status, source_started_at, last_activity_at,
+          ended_at, end_reason
+        ) VALUES (
+          'session-null-reason', 'conv-123', 'browser', 'completed',
+          100, 100, 125, NULL
+        )
+      `,
+        )
+        .run(),
+    ).toThrow();
+
+    expect(() =>
+      sqlite
+        .query(
+          /* sql */ `
+        INSERT INTO conversation_mode_sessions (
+          id, conversation_id, mode, status, source_started_at, last_activity_at,
+          ended_at, end_reason
+        ) VALUES (
+          'session-backwards-end', 'conv-123', 'browser', 'interrupted',
+          100, 150, 125, 'connection_lost'
+        )
+      `,
+        )
+        .run(),
+    ).toThrow();
+
+    expect(() =>
+      sqlite
+        .query(
+          /* sql */ `
+        INSERT INTO conversation_mode_sessions (
+          id, conversation_id, mode, status, source_started_at,
+          first_included_at, last_activity_at
+        ) VALUES (
+          'session-half-boundary', 'conv-123', 'browser', 'active', 100, 110, 110
+        )
+      `,
+        )
+        .run(),
+    ).toThrow();
+
+    sqlite.exec("DELETE FROM conversations WHERE id = 'conv-123'");
+    expect(
+      sqlite.query("SELECT id FROM conversation_mode_sessions").all(),
+    ).toEqual([]);
+  });
+});

package/src/__tests__/deterministic-verification-control-plane.test.ts

@@ -153,6 +153,7 @@ describe("Call session mode metadata", () => {
 
     const { conversationId } = getOrCreateConversation("test-conv-mode");
     const session = createCallSession({
+      direction: "inbound",
       conversationId,
       provider: "twilio",
       fromNumber: "+15551234567",
@@ -181,6 +182,7 @@ describe("Call session mode metadata", () => {
       "test-conv-mode-default",
     );
     const session = createCallSession({
+      direction: "inbound",
       conversationId,
       provider: "twilio",
       fromNumber: "+15551234567",

package/src/__tests__/dm-backfill.test.ts

@@ -11,7 +11,15 @@
  *  - When `backfillDm` throws, the turn proceeds without a crash and
  *    nothing extra is persisted.
  */
-import { beforeEach, describe, expect, mock, test } from "bun:test";
+import {
+  afterAll,
+  beforeEach,
+  describe,
+  expect,
+  mock,
+  spyOn,
+  test,
+} from "bun:test";
 
 // ---------------------------------------------------------------------------
 // Mocks (must precede module imports under test)
@@ -68,6 +76,7 @@ mock.module("../messaging/providers/slack/backfill.js", () => ({
   backfillThread: () => backfillThreadMock(),
 }));
 
+import * as inboundTrustReader from "../calls/inbound-trust-reader.js";
 import {
   loadRawConfig,
   saveRawConfig,
@@ -87,6 +96,15 @@ import {
 
 await initializeDb();
 
+// Backfilled senders are classified by the gateway verdict; with no gateway
+// in the test process the read reports unreachable unless a test says so.
+// A spy rather than mock.module, so the stub does not leak into other files.
+const readInboundTrustMock = spyOn(inboundTrustReader, "readInboundTrust");
+
+afterAll(() => {
+  readInboundTrustMock.mockRestore();
+});
+
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
@@ -180,6 +198,8 @@ function readPersistedSlackRows(): Array<{
   provenanceSourceChannel: string | undefined;
   provenanceGuardianExternalUserId: string | undefined;
   provenanceRequesterIdentifier: string | undefined;
+  provenanceContactId: string | undefined;
+  provenanceLookupFailed: boolean | undefined;
   sentAt: number | undefined;
   createdAt: number;
 }> {
@@ -234,6 +254,14 @@ function readPersistedSlackRows(): Array<{
           typeof envelope.provenanceRequesterIdentifier === "string"
             ? envelope.provenanceRequesterIdentifier
             : undefined,
+        provenanceContactId:
+          typeof envelope.provenanceContactId === "string"
+            ? envelope.provenanceContactId
+            : undefined,
+        provenanceLookupFailed:
+          typeof envelope.provenanceLookupFailed === "boolean"
+            ? envelope.provenanceLookupFailed
+            : undefined,
         sentAt:
           typeof envelope.sentAt === "number" ? envelope.sentAt : undefined,
         createdAt: row.createdAt,
@@ -279,6 +307,8 @@ describe("PR 23 — Slack DM cold-start backfill", () => {
     backfillDmMock.mockReset();
     backfillDmMock.mockImplementation(async () => []);
     backfillThreadMock.mockReset();
+    readInboundTrustMock.mockReset();
+    readInboundTrustMock.mockImplementation(async () => ({ ok: false }));
   });
 
   test("first DM in cold conversation triggers backfill exactly once and persists history", async () => {
@@ -335,6 +365,8 @@ describe("PR 23 — Slack DM cold-start backfill", () => {
       expect(meta!.channelId).toBe(SLACK_DM_CHANNEL_ID);
       expect(meta!.actorExternalUserId).toBe(SLACK_DM_USER_ID);
       expect(r.provenanceTrustClass).toBe("unknown");
+      // No gateway in the test process: the lookup failed, and the row says so.
+      expect(r.provenanceLookupFailed).toBe(true);
       expect(r.provenanceSourceChannel).toBe("slack");
       expect(r.provenanceRequesterIdentifier).toBe(SLACK_DM_USER_ID);
       return meta!.channelTs;
@@ -523,6 +555,64 @@ describe("PR 23 — Slack DM cold-start backfill", () => {
     expect(botRow?.provenanceRequesterIdentifier).toBe("B_BOT");
   });
 
+  test("backfilled rows record the sender's gateway trust class and contact id", async () => {
+    readInboundTrustMock.mockImplementation(async (input) =>
+      input.actorExternalId === SLACK_DM_USER_ID
+        ? {
+            ok: true,
+            verdict: {
+              trustClass: "trusted_contact",
+              canonicalSenderId: SLACK_DM_USER_ID,
+              contactId: "contact-dm-user",
+              channelId: "channel-dm-user",
+              status: "active",
+              policy: "allow",
+            },
+            admissionPolicy: null,
+          }
+        : { ok: false },
+    );
+    backfillDmMock.mockImplementation(async () => [
+      makeBackfilledMessage({
+        id: "1700000000.000001",
+        text: "first from member",
+      }),
+      makeBackfilledMessage({
+        id: "1700000000.000002",
+        text: "assistant's own post",
+        sender: { id: "U_BOT", name: "assistant-bot" },
+        metadata: { isBot: true },
+      }),
+      makeBackfilledMessage({
+        id: "1700000000.000003",
+        text: "second from member",
+      }),
+    ]);
+
+    await handleChannelInbound(
+      buildDmRequest("live new DM"),
+      noopProcessMessage,
+      TEST_BEARER_TOKEN,
+    );
+
+    const rows = readPersistedSlackRows();
+    const memberRows = rows.filter((r) => r.role === "user");
+    expect(memberRows.map((r) => r.content).sort()).toEqual([
+      "first from member",
+      "second from member",
+    ]);
+    for (const row of memberRows) {
+      expect(row.provenanceTrustClass).toBe("trusted_contact");
+      expect(row.provenanceContactId).toBe("contact-dm-user");
+      expect(row.provenanceLookupFailed).toBeUndefined();
+    }
+    const ownPost = rows.find((r) => r.role === "assistant");
+    expect(ownPost?.provenanceTrustClass).toBe("unknown");
+    expect(ownPost?.provenanceContactId).toBeUndefined();
+    // One read per distinct sender, the member's rows sharing theirs.
+    expect(readInboundTrustMock).toHaveBeenCalledTimes(2);
+  });
+
   test("skips Slack assistant new-thread placeholder during DM backfill", async () => {
     backfillDmMock.mockImplementation(async () => [
       makeBackfilledMessage({

package/src/__tests__/document-create-route.test.ts

@@ -0,0 +1,88 @@
+import { afterAll, beforeEach, describe, expect, test } from "bun:test";
+
+import {
+  DEFAULT_DOCUMENT_TITLE,
+  getDocumentsForConversation,
+} from "../documents/document-store.js";
+import { createConversation } from "../persistence/conversation-crud.js";
+import { getDb } from "../persistence/db-connection.js";
+import { initializeDb } from "../persistence/db-init.js";
+import { ROUTES as DOCUMENT_ROUTES } from "../runtime/routes/documents-routes.js";
+import type { RouteDefinition } from "../runtime/routes/types.js";
+import { resetDbForTesting } from "./db-test-helpers.js";
+
+await initializeDb();
+
+const CONVERSATION_ID = "conv-doc-create";
+
+async function create(body: Record<string, unknown>): Promise<unknown> {
+  const route = DOCUMENT_ROUTES.find(
+    (r: RouteDefinition) => r.operationId === "createDocument",
+  )!;
+  return await route.handler({ body });
+}
+
+beforeEach(() => {
+  const db = getDb();
+  db.run("DELETE FROM document_conversations");
+  db.run("DELETE FROM documents");
+  db.run("DELETE FROM conversations");
+  createConversation({ id: CONVERSATION_ID });
+});
+
+afterAll(() => {
+  resetDbForTesting();
+});
+
+describe("createDocument route", () => {
+  test("creates an empty document under a new surface ID and returns it", async () => {
+    const result = await create({
+      conversationId: CONVERSATION_ID,
+      title: "Trip plan",
+    });
+
+    expect(result).toMatchObject({
+      success: true,
+      conversationId: CONVERSATION_ID,
+      title: "Trip plan",
+      content: "",
+      wordCount: 0,
+    });
+    const { surfaceId } = result as { surfaceId: string };
+    expect(surfaceId).toMatch(/^doc-[0-9a-f-]{36}$/);
+    expect(
+      getDocumentsForConversation(CONVERSATION_ID).map((d) => d.surfaceId),
+    ).toEqual([surfaceId]);
+  });
+
+  test("a missing or blank title falls back to the default", async () => {
+    await expect(
+      create({ conversationId: CONVERSATION_ID }),
+    ).resolves.toMatchObject({ title: DEFAULT_DOCUMENT_TITLE });
+    await expect(
+      create({ conversationId: CONVERSATION_ID, title: "   " }),
+    ).resolves.toMatchObject({ title: DEFAULT_DOCUMENT_TITLE });
+  });
+
+  test("each create mints a distinct document", async () => {
+    const first = (await create({ conversationId: CONVERSATION_ID })) as {
+      surfaceId: string;
+    };
+    const second = (await create({ conversationId: CONVERSATION_ID })) as {
+      surfaceId: string;
+    };
+
+    expect(first.surfaceId).not.toBe(second.surfaceId);
+    expect(getDocumentsForConversation(CONVERSATION_ID)).toHaveLength(2);
+  });
+
+  test("rejects a request without a conversation", async () => {
+    await expect(create({})).rejects.toThrow(/conversationId is required/);
+  });
+
+  test("rejects a conversation that does not exist", async () => {
+    await expect(create({ conversationId: "conv-missing" })).rejects.toThrow(
+      /Conversation not found/,
+    );
+  });
+});

package/src/__tests__/document-sync-tags.test.ts

@@ -203,6 +203,22 @@ describe("document write routes publish documents:list", () => {
     });
   });
 
+  test("creating a document publishes with the caller's client id", async () => {
+    const events = await captureSyncEvents(() =>
+      invoke("createDocument", {
+        body: { conversationId: CONVERSATION_ID },
+        headers: { "x-vellum-client-id": "client-abc" },
+      }),
+    );
+
+    expect(events).toHaveLength(1);
+    expect(events[0].message).toMatchObject({
+      type: "sync_changed",
+      tags: [SYNC_TAGS.documentsList],
+      originClientId: "client-abc",
+    });
+  });
+
   test("linking a document to a conversation publishes", async () => {
     await saveViaRoute();
 
@@ -251,6 +267,17 @@ describe("document routes that change nothing the list shows stay silent", () =>
     expect(events).toEqual([]);
   });
 
+  test("a create for a conversation that does not exist publishes nothing", async () => {
+    const events = await captureSyncEvents(async () => {
+      await expect(
+        invoke("createDocument", {
+          body: { conversationId: MISSING_CONVERSATION_ID },
+        }),
+      ).rejects.toThrow(/Conversation not found/);
+    });
+    expect(events).toEqual([]);
+  });
+
   test("a link to a document that does not exist publishes nothing", async () => {
     const events = await captureSyncEvents(async () => {
       await expect(

package/src/__tests__/emit-signal-routing-intent.test.ts

@@ -95,7 +95,10 @@ mock.module("../platform/client.js", () => ({
   isPlatformClientConfigured: () => isPlatformClientConfiguredMock(),
 }));
 
-import { emitNotificationSignal } from "../notifications/emit-signal.js";
+import {
+  classifyNotificationReceipt,
+  emitNotificationSignal,
+} from "../notifications/emit-signal.js";
 
 beforeEach(() => {
   evaluateSignalMock.mockReset();
@@ -662,7 +665,7 @@ describe("high/critical urgency channel force", () => {
       sourceChannel: "watcher" | "assistant_tool",
     ) {
       return emitNotificationSignal({
-        sourceEventName: "watcher.escalation",
+        sourceEventName: "watcher.notification",
         sourceChannel,
         sourceContextId: "watch-1",
         routingIntent: "single_channel",
@@ -707,3 +710,140 @@ describe("high/critical urgency channel force", () => {
     });
   });
 });
+
+describe("exclusive channelAllowlist policy", () => {
+  function makeDecision(overrides: Record<string, unknown>) {
+    return {
+      shouldNotify: true,
+      selectedChannels: ["telegram"],
+      reasoningSummary: "LLM selected telegram only",
+      renderedCopy: {},
+      dedupeKey: "dedupe-allow-1",
+      confidence: 0.9,
+      fallbackUsed: false,
+      persistedDecisionId: "dec-allow-1",
+      ...overrides,
+    };
+  }
+
+  test("skips urgent vellum and platform force", async () => {
+    evaluateSignalMock.mockResolvedValue(
+      makeDecision({ selectedChannels: ["vellum"] }),
+    );
+
+    const result = await emitNotificationSignal({
+      sourceEventName: "user.send_notification",
+      sourceChannel: "assistant_tool",
+      sourceContextId: "cli-allowlist-1",
+      attentionHints: {
+        requiresAction: true,
+        urgency: "critical",
+        isAsyncBackground: false,
+        visibleInSourceNow: false,
+      },
+      contextPayload: {
+        requestedMessage: "telegram only",
+        channelAllowlist: ["vellum"],
+      },
+    });
+
+    expect(enforceRoutingIntentMock).not.toHaveBeenCalled();
+    const dispatched = dispatchDecisionMock.mock.calls[0][1] as {
+      selectedChannels: string[];
+      reasoningSummary: string;
+    };
+    expect(dispatched.selectedChannels).toEqual(["vellum"]);
+    expect(dispatched.reasoningSummary).not.toContain("forced");
+    expect(result.selectedChannels).toEqual(["vellum"]);
+    expect(result.receiptClass).toBe("unknown");
+  });
+
+  test("replaces an LLM selection with the connected allowlist", async () => {
+    evaluateSignalMock.mockResolvedValue(
+      makeDecision({ selectedChannels: ["vellum", "telegram", "platform"] }),
+    );
+
+    await emitNotificationSignal({
+      sourceEventName: "user.send_notification",
+      sourceChannel: "assistant_tool",
+      sourceContextId: "cli-allowlist-2",
+      attentionHints: {
+        requiresAction: true,
+        urgency: "high",
+        isAsyncBackground: false,
+        visibleInSourceNow: false,
+      },
+      contextPayload: { channelAllowlist: ["vellum"] },
+    });
+
+    const dispatched = dispatchDecisionMock.mock.calls[0][1] as {
+      selectedChannels: string[];
+      shouldNotify: boolean;
+      reasoningSummary: string;
+    };
+    expect(dispatched.selectedChannels).toEqual(["vellum"]);
+    expect(dispatched.shouldNotify).toBe(true);
+    expect(dispatched.reasoningSummary).toContain("channelAllowlist: vellum");
+  });
+
+  test("access-request floor still adds vellum when the allowlist omitted it", async () => {
+    evaluateSignalMock.mockResolvedValue(
+      makeDecision({ shouldNotify: false, selectedChannels: [] }),
+    );
+
+    await emitNotificationSignal<string>({
+      sourceEventName: "ingress.access_request",
+      sourceChannel: "telegram",
+      sourceContextId: "access-req-allowlist-1",
+      requiresConversation: true,
+      attentionHints: {
+        requiresAction: true,
+        urgency: "high",
+        isAsyncBackground: false,
+        visibleInSourceNow: false,
+      },
+      contextPayload: {
+        requestId: "req-allowlist-1",
+        channelAllowlist: ["telegram"],
+      },
+    });
+
+    const dispatched = dispatchDecisionMock.mock.calls[0][1] as {
+      shouldNotify: boolean;
+      selectedChannels: string[];
+      reasoningSummary: string;
+    };
+    expect(dispatched.shouldNotify).toBe(true);
+    expect(dispatched.selectedChannels).toContain("vellum");
+    expect(dispatched.reasoningSummary).toContain(
+      "vellum forced: decisionable access request",
+    );
+  });
+});
+
+describe("classifyNotificationReceipt", () => {
+  test("reports provider_accepted when an external channel is sent", () => {
+    expect(
+      classifyNotificationReceipt([
+        { channel: "telegram", destination: "chat-1", status: "sent" },
+        { channel: "vellum", destination: "vellum", status: "sent" },
+      ]),
+    ).toBe("provider_accepted");
+  });
+
+  test("reports gateway_accepted when only platform is accepted", () => {
+    expect(
+      classifyNotificationReceipt([
+        { channel: "platform", destination: "push", status: "pending" },
+      ]),
+    ).toBe("gateway_accepted");
+  });
+
+  test("does not claim client_os_posted from a vellum sent row", () => {
+    expect(
+      classifyNotificationReceipt([
+        { channel: "vellum", destination: "vellum", status: "sent" },
+      ]),
+    ).toBe("unknown");
+  });
+});

package/src/__tests__/events-tail-route.test.ts

@@ -170,6 +170,31 @@ describe("GET events/tail", () => {
     expect(other.events.map((e) => e.seq)).toEqual([1, 2]);
   });
 
+  test("returns a principal-targeted event only to that principal's client", () => {
+    stampAndBuffer(mkEvent()); // seq 1, untargeted
+    stampAndBuffer(mkEvent(), {
+      targeting: { targetActorPrincipalId: "principal-g" },
+    }); // seq 2
+
+    const client = {
+      "x-vellum-client-id": "c",
+      "x-vellum-interface-id": "web",
+    };
+    const guardian = callTail(
+      { conversationId: CONV, fromSeq: "0" },
+      { ...client, "x-vellum-actor-principal-id": "principal-g" },
+    );
+    const other = callTail(
+      { conversationId: CONV, fromSeq: "0" },
+      { ...client, "x-vellum-actor-principal-id": "principal-x" },
+    );
+    const anonymous = callTail({ conversationId: CONV, fromSeq: "0" });
+
+    expect(guardian.events.map((e) => e.seq)).toEqual([1, 2]);
+    expect(other.events.map((e) => e.seq)).toEqual([1]);
+    expect(anonymous.events.map((e) => e.seq)).toEqual([1]);
+  });
+
   test("toSeq bounds the window inclusively and moves the frontier", () => {
     // GIVEN five buffered events for the conversation (seq 1..5)
     for (let i = 0; i < 5; i++) {