@vellumai/assistant 0.12.2 → 0.12.3-dev.202609220419.f870d95

package/src/__tests__/approval-message-composer.test.ts

@@ -17,21 +17,10 @@ const ALL_SCENARIOS: ApprovalMessageScenario[] = [
   "standard_prompt",
   "guardian_prompt",
   "reminder_prompt",
-  "guardian_delivery_failed",
-  "guardian_request_forwarded",
-  "guardian_disambiguation",
   "guardian_identity_mismatch",
   "request_pending_guardian",
-  "guardian_decision_outcome",
-  "guardian_expired_requester",
-  "guardian_expired_guardian",
-  "guardian_verify_success",
   "guardian_verify_failed",
   "guardian_verify_challenge_setup",
-  "guardian_verify_status_bound",
-  "guardian_verify_status_unbound",
-  "guardian_deny_no_identity",
-  "guardian_deny_no_binding",
 ];
 
 describe("approval-message-composer", () => {
@@ -66,59 +55,6 @@ describe("approval-message-composer", () => {
       expect(msg).toContain("write_file");
     });
 
-    test("guardian_delivery_failed includes toolName when provided", () => {
-      const msg = getFallbackMessage({
-        scenario: "guardian_delivery_failed",
-        toolName: "execute_shell",
-      });
-      expect(msg).toContain("execute_shell");
-    });
-
-    test("guardian_request_forwarded includes toolName", () => {
-      const msg = getFallbackMessage({
-        scenario: "guardian_request_forwarded",
-        toolName: "execute_shell",
-      });
-      expect(msg).toContain("execute_shell");
-    });
-
-    test("guardian_disambiguation includes pendingCount", () => {
-      const msg = getFallbackMessage({
-        scenario: "guardian_disambiguation",
-        pendingCount: 3,
-      });
-      expect(msg).toContain("3");
-    });
-
-    test("guardian_decision_outcome includes decision and toolName", () => {
-      const msg = getFallbackMessage({
-        scenario: "guardian_decision_outcome",
-        decision: "approved",
-        toolName: "read_file",
-      });
-      expect(msg).toContain("approved");
-      expect(msg).toContain("read_file");
-    });
-
-    test("guardian_expired_requester includes toolName", () => {
-      const msg = getFallbackMessage({
-        scenario: "guardian_expired_requester",
-        toolName: "deploy",
-      });
-      expect(msg).toContain("deploy");
-      expect(msg).toContain("expired");
-    });
-
-    test("guardian_expired_guardian includes requester and toolName", () => {
-      const msg = getFallbackMessage({
-        scenario: "guardian_expired_guardian",
-        requesterIdentifier: "bob",
-        toolName: "delete_file",
-      });
-      expect(msg).toContain("bob");
-      expect(msg).toContain("delete_file");
-    });
-
     test("guardian_verify_failed includes failureReason", () => {
       const msg = getFallbackMessage({
         scenario: "guardian_verify_failed",
@@ -141,36 +77,7 @@ describe("approval-message-composer", () => {
   // -----------------------------------------------------------------------
 
   describe("composeApprovalMessage", () => {
-    test("returns assistantPreface when provided (primary source)", () => {
-      const preface = "The assistant already said something helpful.";
-      const msg = composeApprovalMessage({
-        scenario: "standard_prompt",
-        toolName: "execute_shell",
-        assistantPreface: preface,
-      });
-      expect(msg).toBe(preface);
-    });
-
-    test("ignores empty assistantPreface and falls back to template", () => {
-      const msg = composeApprovalMessage({
-        scenario: "standard_prompt",
-        toolName: "execute_shell",
-        assistantPreface: "",
-      });
-      expect(msg).toContain("execute_shell");
-      expect(msg).not.toBe("");
-    });
-
-    test("ignores whitespace-only assistantPreface", () => {
-      const msg = composeApprovalMessage({
-        scenario: "standard_prompt",
-        toolName: "execute_shell",
-        assistantPreface: "   ",
-      });
-      expect(msg).toContain("execute_shell");
-    });
-
-    test("falls back to deterministic template when no assistantPreface", () => {
+    test("returns the deterministic template", () => {
       const msg = composeApprovalMessage({
         scenario: "guardian_prompt",
         toolName: "write_file",
@@ -222,29 +129,5 @@ describe("approval-message-composer", () => {
       expect(msg.length).toBeGreaterThan(0);
       expect(msg).toContain("invalid or has expired");
     });
-
-    test("guardian_verify_success produces a non-empty success message", () => {
-      const msg = composeApprovalMessage({
-        scenario: "guardian_verify_success",
-      });
-      expect(typeof msg).toBe("string");
-      expect(msg.length).toBeGreaterThan(0);
-    });
-
-    test("guardian_verify_status_bound produces a non-empty message", () => {
-      const msg = composeApprovalMessage({
-        scenario: "guardian_verify_status_bound",
-      });
-      expect(typeof msg).toBe("string");
-      expect(msg.length).toBeGreaterThan(0);
-    });
-
-    test("guardian_verify_status_unbound produces a non-empty message", () => {
-      const msg = composeApprovalMessage({
-        scenario: "guardian_verify_status_unbound",
-      });
-      expect(typeof msg).toBe("string");
-      expect(msg.length).toBeGreaterThan(0);
-    });
   });
 });

package/src/__tests__/approval-routes-http.test.ts

@@ -9,6 +9,7 @@ import { beforeEach, describe, expect, mock, test } from "bun:test";
 import type { AssistantEvent } from "../api/index.js";
 import type { Conversation } from "../daemon/conversation.js";
 import type { SecretPromptResult } from "../permissions/secret-prompt-types.js";
+import { mockUnownedModeSessions } from "./helpers/mock-conversation.js";
 
 mock.module("../config/env.js", () => ({
   isHttpAuthDisabled: () => true,
@@ -120,6 +121,7 @@ function makeIdleSession(opts?: {
     addPreactivatedSkillId: () => {},
     enqueueMessage: () => ({ queued: false, requestId: "noop" }),
     hasAnyPendingConfirmation: () => false,
+    modeSessions: mockUnownedModeSessions(),
     runAgentLoop: async (
       _content: string,
       _messageId: string,
@@ -183,6 +185,7 @@ function makeConfirmationEmittingSession(opts?: {
     addPreactivatedSkillId: () => {},
     enqueueMessage: () => ({ queued: false, requestId: "noop" }),
     hasAnyPendingConfirmation: () => false,
+    modeSessions: mockUnownedModeSessions(),
     runAgentLoop: async (
       _content: string,
       _messageId: string,
@@ -238,8 +241,10 @@ function makeConfirmationEmittingSession(opts?: {
 // Tests
 // ---------------------------------------------------------------------------
 
-const TEST_TOKEN = "test-bearer-token-approvals";
-const AUTH_HEADERS = { Authorization: `Bearer ${TEST_TOKEN}` };
+// This suite mocks isHttpAuthDisabled() to true, so a request carrying no
+// bearer authenticates through the dev bypass. A bearer that is present is
+// verified against the signing key, which these tests do not set up.
+const AUTH_HEADERS: Record<string, string> = {};
 
 describe("standalone approval endpoints — HTTP layer", () => {
   let server: RuntimeHttpServer;

package/src/__tests__/assistant-event-hub-connection-history.test.ts

@@ -0,0 +1,111 @@
+import { beforeEach, describe, expect, test } from "bun:test";
+
+import type { ClientConnectionEventInput } from "../persistence/client-connection-events-store.js";
+import { AssistantEventHub } from "../runtime/assistant-event-hub.js";
+
+describe("AssistantEventHub connection history", () => {
+  const recorded: Array<Pick<ClientConnectionEventInput, "clientId" | "reason">> =
+    [];
+
+  beforeEach(() => {
+    recorded.length = 0;
+  });
+
+  function hub(options?: { maxSubscribers?: number }): AssistantEventHub {
+    return new AssistantEventHub({
+      ...options,
+      recordConnection: (input) => {
+        recorded.push({ clientId: input.clientId, reason: input.reason });
+        return null;
+      },
+    });
+  }
+
+  test("records sse_open on client subscribe and sse_close on dispose", () => {
+    const sub = hub().subscribe({
+      type: "client",
+      clientId: "client-123",
+      interfaceId: "chrome-extension",
+      capabilities: ["host_browser"],
+      callback: () => {},
+    });
+
+    expect(recorded.map((row) => row.reason)).toEqual(["sse_open"]);
+    sub.dispose();
+    expect(recorded.map((row) => row.reason)).toEqual(["sse_open", "sse_close"]);
+  });
+
+  test("records stale_replaced then sse_open on reconnect", () => {
+    const instance = hub();
+    instance.subscribe({
+      type: "client",
+      clientId: "client-123",
+      interfaceId: "chrome-extension",
+      capabilities: ["host_browser"],
+      callback: () => {},
+    });
+    instance.subscribe({
+      type: "client",
+      clientId: "client-123",
+      interfaceId: "chrome-extension",
+      capabilities: ["host_browser"],
+      callback: () => {},
+    });
+
+    expect(recorded.map((row) => row.reason)).toEqual([
+      "sse_open",
+      "stale_replaced",
+      "sse_open",
+    ]);
+  });
+
+  test("records force_disconnect from disposeClient", () => {
+    const instance = hub();
+    instance.subscribe({
+      type: "client",
+      clientId: "client-123",
+      interfaceId: "chrome-extension",
+      capabilities: ["host_browser"],
+      callback: () => {},
+    });
+    recorded.length = 0;
+
+    expect(instance.disposeClient("client-123")).toBe(1);
+    expect(recorded.map((row) => row.reason)).toEqual(["force_disconnect"]);
+  });
+
+  test("records cap_evicted when the oldest subscriber is shed", () => {
+    const instance = hub({ maxSubscribers: 1 });
+    instance.subscribe({
+      type: "client",
+      clientId: "client-old",
+      interfaceId: "web",
+      capabilities: [],
+      callback: () => {},
+    });
+    recorded.length = 0;
+
+    instance.subscribe({
+      type: "client",
+      clientId: "client-new",
+      interfaceId: "web",
+      capabilities: [],
+      callback: () => {},
+    });
+
+    expect(recorded.map((row) => row.reason)).toEqual([
+      "cap_evicted",
+      "sse_open",
+    ]);
+    expect(recorded[0].clientId).toBe("client-old");
+  });
+
+  test("does not record process subscribers", () => {
+    const sub = hub().subscribe({
+      type: "process",
+      callback: () => {},
+    });
+    sub.dispose();
+    expect(recorded).toEqual([]);
+  });
+});

package/src/__tests__/assistant-event-hub-targeted.test.ts

@@ -257,3 +257,53 @@ describe("AssistantEventHub — getClientById()", () => {
     expect(hub.getClientById("client-x")).toBeUndefined();
   });
 });
+
+// ── Principal targeting ───────────────────────────────────────────────────────
+
+describe("AssistantEventHub principal targeting (targetActorPrincipalId)", () => {
+  test("delivers only to clients authenticated as that principal", async () => {
+    const hub = new AssistantEventHub();
+    const received: Record<string, number> = {
+      guardianMac: 0,
+      guardianWeb: 0,
+      otherUser: 0,
+      noPrincipal: 0,
+      process: 0,
+    };
+    const client = (
+      clientId: string,
+      key: string,
+      actorPrincipalId: string | undefined,
+    ) =>
+      hub.subscribe({
+        type: "client",
+        clientId,
+        interfaceId: "web",
+        capabilities: [],
+        ...(actorPrincipalId ? { actorPrincipalId } : {}),
+        callback: () => {
+          received[key]! += 1;
+        },
+      });
+    client("mac", "guardianMac", "principal-g");
+    client("web", "guardianWeb", "principal-g");
+    client("other", "otherUser", "principal-x");
+    client("legacy", "noPrincipal", undefined);
+    hub.subscribe({
+      type: "process",
+      callback: () => {
+        received.process! += 1;
+      },
+    });
+
+    await hub.publish(makeEvent(), { targetActorPrincipalId: "principal-g" });
+
+    expect(received).toEqual({
+      guardianMac: 1,
+      guardianWeb: 1,
+      otherUser: 0,
+      noPrincipal: 0,
+      process: 0,
+    });
+  });
+});

package/src/__tests__/assistant-event-targeting.test.ts

@@ -0,0 +1,186 @@
+/**
+ * Tests for `matchesTargeting`, the one targeting check behind live fanout
+ * (`AssistantEventHub.publish`) and replay (`getReplayWindow`).
+ *
+ * The parity block runs every case through both paths and requires them to
+ * agree, so a rule added to one path alone fails here.
+ */
+import { beforeEach, describe, expect, test } from "bun:test";
+
+import type { AssistantEventEnvelope } from "../api/index.js";
+import type { HostProxyCapability, InterfaceId } from "../channels/types.js";
+import { AssistantEventHub } from "../runtime/assistant-event-hub.js";
+import type { AssistantEventPublishOptions } from "../runtime/assistant-event-publish-options.js";
+import { matchesTargeting } from "../runtime/assistant-event-targeting.js";
+import {
+  _resetStreamStateForTesting,
+  getReplayWindow,
+  stampAndBuffer,
+} from "../runtime/assistant-stream-state.js";
+
+const CONV = "conv-targeting";
+
+interface ClientIdentity {
+  type: "client";
+  clientId: string;
+  interfaceId: InterfaceId;
+  capabilities: HostProxyCapability[];
+  actorPrincipalId?: string;
+}
+
+const MAC: ClientIdentity = {
+  type: "client",
+  clientId: "mac-1",
+  interfaceId: "macos",
+  capabilities: ["host_bash", "host_browser"],
+  actorPrincipalId: "principal-g",
+};
+const WEB: ClientIdentity = {
+  type: "client",
+  clientId: "web-1",
+  interfaceId: "web",
+  capabilities: [],
+  actorPrincipalId: "principal-g",
+};
+const OTHER_USER: ClientIdentity = {
+  type: "client",
+  clientId: "web-2",
+  interfaceId: "web",
+  capabilities: [],
+  actorPrincipalId: "principal-x",
+};
+const NO_PRINCIPAL: ClientIdentity = {
+  type: "client",
+  clientId: "legacy-1",
+  interfaceId: "web",
+  capabilities: [],
+};
+interface ProcessIdentity {
+  type: "process";
+}
+
+const PROCESS: ProcessIdentity = { type: "process" };
+
+const SUBSCRIBERS: Array<[string, ClientIdentity | ProcessIdentity]> = [
+  ["mac", MAC],
+  ["web", WEB],
+  ["other user", OTHER_USER],
+  ["no principal", NO_PRINCIPAL],
+  ["process", PROCESS],
+];
+
+/** Each targeting case with the subscribers it must reach, by label. */
+const CASES: Array<{
+  name: string;
+  targeting: AssistantEventPublishOptions | undefined;
+  reaches: string[];
+}> = [
+  {
+    name: "untargeted",
+    targeting: undefined,
+    reaches: ["mac", "web", "other user", "no principal", "process"],
+  },
+  {
+    name: "self-echo exclusion",
+    targeting: { excludeClientId: "web-1" },
+    reaches: ["mac", "other user", "no principal", "process"],
+  },
+  {
+    name: "interface",
+    targeting: { targetInterfaceId: "web" },
+    reaches: ["web", "other user", "no principal"],
+  },
+  {
+    name: "principal",
+    targeting: { targetActorPrincipalId: "principal-g" },
+    reaches: ["mac", "web"],
+  },
+  {
+    name: "client",
+    targeting: { targetClientId: "mac-1" },
+    reaches: ["mac"],
+  },
+  {
+    name: "capability",
+    targeting: { targetCapability: "host_browser" },
+    reaches: ["mac"],
+  },
+  {
+    name: "client without the capability",
+    targeting: { targetClientId: "web-1", targetCapability: "host_browser" },
+    reaches: [],
+  },
+  {
+    name: "principal and interface together",
+    targeting: {
+      targetActorPrincipalId: "principal-g",
+      targetInterfaceId: "web",
+    },
+    reaches: ["web"],
+  },
+];
+
+function makeEvent(): AssistantEventEnvelope {
+  return {
+    id: `evt-${Math.random().toString(36).slice(2, 10)}`,
+    conversationId: CONV,
+    emittedAt: new Date().toISOString(),
+    message: { type: "assistant_text_delta", conversationId: CONV, text: "x" },
+  };
+}
+
+async function reachedLive(
+  targeting: AssistantEventPublishOptions | undefined,
+): Promise<string[]> {
+  const hub = new AssistantEventHub();
+  const reached: string[] = [];
+  for (const [label, identity] of SUBSCRIBERS) {
+    const callback = () => {
+      reached.push(label);
+    };
+    if (identity.type === "process") {
+      hub.subscribe({ type: "process", callback });
+    } else {
+      hub.subscribe({ ...identity, callback });
+    }
+  }
+  await hub.publish(makeEvent(), targeting);
+  return reached.sort();
+}
+
+function reachedOnReplay(
+  targeting: AssistantEventPublishOptions | undefined,
+): string[] {
+  _resetStreamStateForTesting();
+  stampAndBuffer(makeEvent(), targeting ? { targeting } : undefined);
+  return SUBSCRIBERS.filter(
+    ([, identity]) => (getReplayWindow(0, identity) ?? []).length > 0,
+  )
+    .map(([label]) => label)
+    .sort();
+}
+
+describe("matchesTargeting", () => {
+  for (const { name, targeting, reaches } of CASES) {
+    test(`${name}: reaches exactly its subscribers`, () => {
+      const reached = SUBSCRIBERS.filter(([, identity]) =>
+        matchesTargeting(targeting, identity),
+      ).map(([label]) => label);
+      expect(reached.sort()).toEqual([...reaches].sort());
+    });
+  }
+});
+
+describe("live fanout and replay agree", () => {
+  beforeEach(() => {
+    _resetStreamStateForTesting();
+  });
+
+  for (const { name, targeting, reaches } of CASES) {
+    test(`${name}: both paths deliver to the same subscribers`, async () => {
+      const expected = [...reaches].sort();
+      expect(await reachedLive(targeting)).toEqual(expected);
+      expect(reachedOnReplay(targeting)).toEqual(expected);
+    });
+  }
+});

package/src/__tests__/assistant-stream-state.test.ts

@@ -9,10 +9,8 @@ import { dirname, join } from "node:path";
 import { beforeEach, describe, expect, test } from "bun:test";
 
 import type { AssistantEventEnvelope } from "../api/index.js";
-import type {
-  EventTargeting,
-  ReplaySubscriber,
-} from "../runtime/assistant-stream-state.js";
+import type { AssistantEventPublishOptions } from "../runtime/assistant-event-publish-options.js";
+import type { SubscriberIdentity } from "../runtime/assistant-event-targeting.js";
 import {
   _peekStreamForTesting,
   _resetStreamStateForTesting,
@@ -103,7 +101,7 @@ describe("assistant-stream-state", () => {
       /** Targeted events stay in the ring so replay can filter them. */
 
       // GIVEN a targeting modifier
-      const targeting: EventTargeting = {
+      const targeting: AssistantEventPublishOptions = {
         targetCapability: "host_bash",
       };
 
@@ -334,28 +332,28 @@ describe("assistant-stream-state", () => {
   });
 
   describe("getReplayWindow — targeting filter", () => {
-    const MACOS_CLIENT: ReplaySubscriber = {
+    const MACOS_CLIENT: SubscriberIdentity = {
       type: "client",
       clientId: "mac-1",
       interfaceId: "macos",
       capabilities: ["host_bash", "host_file", "host_cu", "host_browser"],
     };
 
-    const WEB_CLIENT: ReplaySubscriber = {
+    const WEB_CLIENT: SubscriberIdentity = {
       type: "client",
       clientId: "web-1",
       interfaceId: "web",
       capabilities: [],
     };
 
-    const CHROME_EXT_CLIENT: ReplaySubscriber = {
+    const CHROME_EXT_CLIENT: SubscriberIdentity = {
       type: "client",
       clientId: "ext-1",
       interfaceId: "chrome-extension",
       capabilities: ["host_browser"],
     };
 
-    const PROCESS_SUB: ReplaySubscriber = { type: "process" };
+    const PROCESS_SUB: SubscriberIdentity = { type: "process" };
 
     test("untargeted events are replayed to all subscriber types", () => {
       /** Events without targeting metadata go to everyone. */
@@ -491,6 +489,28 @@ describe("assistant-stream-state", () => {
       expect(procReplay).toEqual([]);
     });
 
+    test("principal-targeted events only replay to that principal's clients", () => {
+      stampAndBuffer(mkEvent(), {
+        targeting: { targetActorPrincipalId: "principal-g" },
+      });
+
+      const guardian = getReplayWindow(0, {
+        ...WEB_CLIENT,
+        actorPrincipalId: "principal-g",
+      });
+      const other = getReplayWindow(0, {
+        ...WEB_CLIENT,
+        actorPrincipalId: "principal-x",
+      });
+      const noPrincipal = getReplayWindow(0, WEB_CLIENT);
+      const proc = getReplayWindow(0, PROCESS_SUB);
+
+      expect(guardian!.map((e) => e.seq)).toEqual([1]);
+      expect(other).toEqual([]);
+      expect(noPrincipal).toEqual([]);
+      expect(proc).toEqual([]);
+    });
+
     test("mixed targeting across events filters per-entry", () => {
       /**
        * A ring with untargeted, capability-targeted, and excluded events

package/src/__tests__/attachments-store.test.ts

@@ -478,9 +478,9 @@ describe("createInlineAttachment (workspace_ref persistence)", () => {
     expect(filePath).toBeTruthy();
     expect(result.filename).toBeDefined();
     expect(filePath!.endsWith(result.filename!)).toBe(true);
-    expect(result.filename!.startsWith(`${OVERSIZED_CONTENT_FILENAME_PREFIX}-`)).toBe(
-      true,
-    );
+    expect(
+      result.filename!.startsWith(`${OVERSIZED_CONTENT_FILENAME_PREFIX}-`),
+    ).toBe(true);
     expect(readFileSync(filePath!).toString("utf8")).toBe(original);
   });
 });
@@ -598,6 +598,25 @@ describe("linkAttachmentToMessage + getAttachmentsForMessage", () => {
     expect(linked[1].originalFilename).toBe("second.txt");
   });
 
+  test("reuses a repeated message attachment link with its original position", async () => {
+    const conv = createConversation();
+    const msg = await addMessage(conv.id, "assistant", "One file");
+    const stored = await uploadAttachment("frame.png", "image/png", "AAAA");
+
+    expect(linkAttachmentToMessage(msg.id, stored.id, 4)).toBe(stored.id);
+    expect(linkAttachmentToMessage(msg.id, stored.id, 0)).toBe(stored.id);
+
+    const links = rawGet<{ count: number; position: number }>(
+      "test:repeatedAttachmentLink",
+      `SELECT COUNT(*) AS count, MIN(position) AS position
+       FROM message_attachments
+       WHERE message_id = ? AND attachment_id = ?`,
+      msg.id,
+      stored.id,
+    );
+    expect(links).toEqual({ count: 1, position: 4 });
+  });
+
   test("returns empty for message with no attachments", async () => {
     const conv = createConversation();
     const msg = await addMessage(conv.id, "assistant", "No attachments");