@vellumai/assistant 0.12.2 → 0.12.3-staging.2

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

@@ -85,6 +85,39 @@ describe("GET events/tail", () => {
     expect(body.frontier).toBe(5);
   });
 
+  test("returns terminal attachment provenance without rewriting the event", () => {
+    stampAndBuffer(
+      mkEvent({
+        message: {
+          type: "message_complete",
+          conversationId: CONV,
+          messageId: "reply-1",
+          attachments: [
+            {
+              id: "screenshot-1",
+              filename: "computer-use-click.png",
+              mimeType: "image/png",
+              data: "c2NyZWVuc2hvdA==",
+              computerUseScreenshot: true,
+            },
+          ],
+        },
+      }),
+    );
+
+    const body = callTail({ conversationId: CONV, fromSeq: "0" });
+
+    expect(body.events[0]?.message).toMatchObject({
+      type: "message_complete",
+      attachments: [
+        {
+          id: "screenshot-1",
+          computerUseScreenshot: true,
+        },
+      ],
+    });
+  });
+
   test("an up-to-date anchor yields an empty but complete tail", () => {
     // GIVEN three buffered events (seq 1..3)
     for (let i = 0; i < 3; i++) {
@@ -137,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++) {

package/src/__tests__/evict-conversations-for-reload.test.ts

@@ -6,10 +6,10 @@
  * has to hold here: `isProcessing()` reads false in the window between a turn
  * releasing and its queued successor being dispatched.
  *
- * In-flight subagents are the other non-idle case: an async spawn leaves the
- * parent idle between its own tool calls while children are still running.
- * Reload marks that parent stale without aborting the children, then
- * `getOrCreateConversation` rebuilds it once every child is terminal.
+ * In-flight subagents and resident mode-session state are other non-idle
+ * cases. Reload marks the conversation stale without discarding that state,
+ * then `getOrCreateConversation` rebuilds it once every retained lifecycle is
+ * settled.
  */
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
@@ -26,7 +26,7 @@ mock.module("../subagent/index.js", () => ({
   }),
 }));
 
-import type { Conversation } from "../daemon/conversation.js";
+import { Conversation } from "../daemon/conversation.js";
 import {
   clearConversations,
   conversationIds,
@@ -45,17 +45,29 @@ interface FakeConversation {
 
 function register(
   id: string,
-  state: { processing: boolean; queued: boolean; stale?: boolean },
+  state: {
+    processing: boolean;
+    queued: boolean;
+    modeSessionWork?: boolean;
+    stale?: boolean;
+  },
 ): FakeConversation {
   const fake: FakeConversation & Record<string, unknown> = {
     disposed: false,
     markedStale: false,
     conversationId: id,
+    liveVoiceResidencyLeases: 0,
     isProcessing: () => state.processing,
     hasQueuedMessages: () => state.queued,
+    modeSessions: {
+      hasResidentWork: () => state.modeSessionWork === true,
+    },
     isStale: () => state.stale === true || fake.markedStale,
-    hasInFlightWork: () =>
-      state.processing || state.queued || activeParents.has(id),
+    hasInFlightWork() {
+      return Conversation.prototype.hasInFlightWork.call(
+        fake as unknown as Conversation,
+      );
+    },
     dispose() {
       fake.disposed = true;
     },
@@ -125,6 +137,43 @@ describe("evictConversationsForReload", () => {
     expect(abortedParents).toEqual([]);
   });
 
+  test("keeps resident mode-session ownership usable across reload eviction", () => {
+    const resident = register("reload-mode-active", {
+      processing: false,
+      queued: false,
+      modeSessionWork: true,
+    });
+
+    evictConversationsForReload();
+
+    expect(resident.disposed).toBe(false);
+    expect(resident.markedStale).toBe(true);
+    expect(findConversation("reload-mode-active")).toBeDefined();
+    expect(abortedParents).toEqual([]);
+  });
+
+  test("keeps a Live voice residency lease until the socket releases it", () => {
+    const resident = register("reload-live-voice", {
+      processing: false,
+      queued: false,
+    });
+    const release = Conversation.prototype.acquireLiveVoiceResidency.call(
+      resident as unknown as Conversation,
+    );
+
+    evictConversationsForReload();
+
+    expect(resident.disposed).toBe(false);
+    expect(resident.markedStale).toBe(true);
+    expect(findConversation("reload-live-voice")).toBeDefined();
+
+    release();
+    evictConversationsForReload();
+
+    expect(resident.disposed).toBe(true);
+    expect(findConversation("reload-live-voice")).toBeUndefined();
+  });
+
   test("still evicts other idle conversations when one parent is protected", () => {
     const protectedParent = register("reload-protected", {
       processing: false,

package/src/__tests__/guardian-action-sweep.test.ts

@@ -73,6 +73,22 @@ describe("sendGuardianExpiryNotices", () => {
     expect(deliveredMessages[1].body.chatId).toBe("chat-456");
   });
 
+  test("opens the guardian's DM for a Discord delivery addressed to their user id", async () => {
+    await sendGuardianExpiryNotices(
+      [
+        makeDelivery({
+          destinationChannel: "discord",
+          destinationChatId: "111111111111111111",
+        }),
+      ],
+      "assistant-1",
+    );
+
+    expect(deliveredMessages).toHaveLength(1);
+    expect(deliveredMessages[0].url).toBe("/deliver/discord?dm=1");
+    expect(deliveredMessages[0].body.chatId).toBe("111111111111111111");
+  });
+
   test("skips deliveries that are not sent or pending", async () => {
     await sendGuardianExpiryNotices(
       [

package/src/__tests__/guardian-dispatch.test.ts

@@ -158,6 +158,7 @@ describe("guardian-dispatch", () => {
     ensureConversation(convId);
 
     const session = createCallSession({
+      direction: "inbound",
       conversationId: convId,
       provider: "twilio",
       fromNumber: "+15550001111",
@@ -209,6 +210,7 @@ describe("guardian-dispatch", () => {
     ensureConversation(convId);
 
     const session = createCallSession({
+      direction: "inbound",
       conversationId: convId,
       provider: "twilio",
       fromNumber: "+15550001111",
@@ -238,6 +240,7 @@ describe("guardian-dispatch", () => {
     ensureConversation(convId);
 
     const session = createCallSession({
+      direction: "inbound",
       conversationId: convId,
       provider: "twilio",
       fromNumber: "+15550001111",
@@ -282,6 +285,7 @@ describe("guardian-dispatch", () => {
     };
 
     const session = createCallSession({
+      direction: "inbound",
       conversationId: convId,
       provider: "twilio",
       fromNumber: "+15550001111",
@@ -324,6 +328,7 @@ describe("guardian-dispatch", () => {
     };
 
     const session = createCallSession({
+      direction: "inbound",
       conversationId: convId,
       provider: "twilio",
       fromNumber: "+15550001111",
@@ -369,6 +374,7 @@ describe("guardian-dispatch", () => {
     };
 
     const session = createCallSession({
+      direction: "inbound",
       conversationId: convId,
       provider: "twilio",
       fromNumber: "+15550001111",
@@ -396,6 +402,7 @@ describe("guardian-dispatch", () => {
     ensureConversation(convId);
 
     const session = createCallSession({
+      direction: "inbound",
       conversationId: convId,
       provider: "twilio",
       fromNumber: "+15550001111",
@@ -431,6 +438,7 @@ describe("guardian-dispatch", () => {
     ensureConversation(convId);
 
     const session = createCallSession({
+      direction: "inbound",
       conversationId: convId,
       provider: "twilio",
       fromNumber: "+15550001111",
@@ -456,6 +464,7 @@ describe("guardian-dispatch", () => {
     ensureConversation(convId);
 
     const session = createCallSession({
+      direction: "inbound",
       conversationId: convId,
       provider: "twilio",
       fromNumber: "+15550001111",
@@ -488,6 +497,7 @@ describe("guardian-dispatch", () => {
     const sharedConversationId = "conv-shared-guardian";
 
     const session = createCallSession({
+      direction: "inbound",
       conversationId: convId,
       provider: "twilio",
       fromNumber: "+15550001111",
@@ -576,6 +586,7 @@ describe("guardian-dispatch", () => {
     const sharedConversationId = "conv-affinity-guardian";
 
     const session = createCallSession({
+      direction: "inbound",
       conversationId: convId,
       provider: "twilio",
       fromNumber: "+15550001111",
@@ -648,6 +659,7 @@ describe("guardian-dispatch", () => {
     const sharedConversationId = "conv-affinity-tool-guardian";
 
     const session = createCallSession({
+      direction: "inbound",
       conversationId: convId,
       provider: "twilio",
       fromNumber: "+15550001111",
@@ -727,6 +739,7 @@ describe("guardian-dispatch", () => {
     const sharedConversationId = "conv-affinity-triple";
 
     const session = createCallSession({
+      direction: "inbound",
       conversationId: convId,
       provider: "twilio",
       fromNumber: "+15550001111",