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

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,

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__/browser-fill-credential.test.ts

@@ -244,42 +244,32 @@ describe("executeBrowserFillCredential", () => {
     expect(detachCalls).toBe(1);
   });
 
-  test("clears pre-populated field BEFORE inserting credential text", async () => {
-    // Regression: previously, fillCredential called focus + insertText
-    // directly, which APPENDED the credential to any existing value
-    // (autofill, prior typing, etc.) — corrupting the password and
-    // leaking partial state. The fix routes through the shared
-    // clearAndInsertText helper.
+  test("selects pre-populated content before inserting credential text", async () => {
     snapshotBackendNodeMaps.set("test-conversation", new Map([["e1", 555]]));
     await executeBrowserFillCredential(
       { service: "gmail", field: "password", element_id: "e1" },
       ctx,
     );
 
-    // The clear must happen BEFORE the insertText. Specifically, the
-    // Runtime.callFunctionOn that runs the clearing function declaration
-    // must precede Input.insertText.
+    // Selection must happen before Input.insertText so the credential replaces
+    // existing content without mutating framework-owned editor state directly.
     const methodSeq = sendCalls.map((c) => c.method);
     const clearIdx = methodSeq.indexOf("Runtime.callFunctionOn");
     const insertIdx = methodSeq.indexOf("Input.insertText");
     expect(clearIdx).toBeGreaterThanOrEqual(0);
     expect(insertIdx).toBeGreaterThan(clearIdx);
 
-    // The clearing function must reset both `value` and
-    // `textContent` so input/textarea AND contenteditable targets
-    // are handled.
+    // Form fields and contenteditable targets use their native selection APIs.
     const clearCall = sendCalls[clearIdx]!;
     const fnDecl = (clearCall.params as { functionDeclaration: string })
       .functionDeclaration;
-    expect(fnDecl).toContain('this.value = ""');
-    expect(fnDecl).toContain("this.textContent");
-    expect(fnDecl).toContain('new Event("input"');
+    expect(fnDecl).toContain("this.select()");
+    expect(fnDecl).toContain("range.selectNodeContents(this)");
+    expect(fnDecl).not.toContain('this.value = ""');
+    expect(fnDecl).not.toContain("this.textContent =");
 
-    // After the clear, the helper re-focuses the element (some sites
-    // blur on programmatic value reset) before inserting text — so we
-    // expect at least 2 DOM.focus calls in total.
     const focusCount = methodSeq.filter((m) => m === "DOM.focus").length;
-    expect(focusCount).toBeGreaterThanOrEqual(2);
+    expect(focusCount).toBe(1);
   });
 
   test("fills credential by CSS selector", async () => {
@@ -364,14 +354,13 @@ describe("executeBrowserFillCredential", () => {
     expect(result.isError).toBe(false);
     const methods = sendCalls.map((c) => c.method);
     expect(methods).toContain("Input.insertText");
-    // dispatchKeyPress for "Enter" dispatches keyDown + char + keyUp
-    // (Enter has text "\r" so it now produces a char event too).
+    // Enter dispatches rawKeyDown + char + keyUp.
     const keyEvents = sendCalls.filter(
       (c) => c.method === "Input.dispatchKeyEvent",
     );
     expect(keyEvents).toHaveLength(3);
     expect((keyEvents[0]!.params as { type: string; key: string }).type).toBe(
-      "keyDown",
+      "rawKeyDown",
     );
     expect((keyEvents[0]!.params as { type: string; key: string }).key).toBe(
       "Enter",

package/src/__tests__/btw-routes.test.ts

@@ -338,7 +338,7 @@ describe("POST /v1/btw", () => {
     expect(options!.config!.modelIntent).toBeUndefined();
   });
 
-  test("greeting requests pass callSite: 'emptyStateGreeting'", async () => {
+  test("greeting requests pass callSite: 'emptyStateGreeting' and send no tools", async () => {
     const provider = makeMockProvider();
     const session = makeMockSession(provider);
     mockGetOrCreateConversation.mockImplementationOnce(async () => session);
@@ -352,6 +352,9 @@ describe("POST /v1/btw", () => {
     expect(provider.sendMessage).toHaveBeenCalledTimes(1);
     const [, options] = provider.sendMessage.mock.calls[0];
     expect(options!.config!.callSite).toBe("emptyStateGreeting");
+    // The greeting targets no real conversation, so there is no cache prefix
+    // for tool definitions to share; they would only cost tokens.
+    expect(options!.tools).toEqual([]);
   });
 
   test("greeting requests include fresh turn context using the client timezone", async () => {

package/src/__tests__/build-persisted-content.test.ts

@@ -29,12 +29,12 @@ mock.module("../persistence/llm-request-log-store.js", () => ({
 // ── Imports (after mocks) ─────────────────────────────────────────────────────
 import { REDACTED_SENTINEL_OPEN } from "@vellumai/service-contracts/redacted-credential";
 
+import type { ToolActivityMetadata } from "../api/events/tool-result.js";
 import type { ResolvedRevealCandidate } from "../daemon/chat-credential-redaction.js";
 import {
   buildPersistedAssistantContent,
   stampThinkingTiming,
 } from "../daemon/conversation-agent-loop-handlers.js";
-import type { ToolActivityMetadata } from "../daemon/message-types/web-activity.js";
 import type { ContentBlock } from "../providers/types.js";
 import {
   OPENAI_PROJECT_KEY_REDACTION_MARKER,

package/src/__tests__/call-conversation-messages.test.ts

@@ -102,6 +102,7 @@ describe("call-conversation-messages", () => {
     const conversationId = "conv-call-msg-failed";
     ensureConversation(conversationId);
     const session = createCallSession({
+      direction: "inbound",
       conversationId,
       provider: "twilio",
       fromNumber: "+15550001111",
@@ -122,6 +123,7 @@ describe("call-conversation-messages", () => {
     const conversationId = "conv-call-msg-cancelled";
     ensureConversation(conversationId);
     const session = createCallSession({
+      direction: "inbound",
       conversationId,
       provider: "twilio",
       fromNumber: "+15550001111",
@@ -142,6 +144,7 @@ describe("call-conversation-messages", () => {
     const conversationId = "conv-call-msg-completed";
     ensureConversation(conversationId);
     const session = createCallSession({
+      direction: "inbound",
       conversationId,
       provider: "twilio",
       fromNumber: "+15550001111",
@@ -171,6 +174,7 @@ describe("call-conversation-messages", () => {
     const conversationId = "conv-call-msg-fallback";
     ensureConversation(conversationId);
     const session = createCallSession({
+      direction: "inbound",
       conversationId,
       provider: "twilio",
       fromNumber: "+12025550101",
@@ -208,6 +212,7 @@ describe("call-conversation-messages", () => {
     const conversationId = "conv-call-msg-schema";
     ensureConversation(conversationId);
     const session = createCallSession({
+      direction: "inbound",
       conversationId,
       provider: "twilio",
       fromNumber: "+12025550101",

package/src/__tests__/call-recovery.test.ts

@@ -54,9 +54,14 @@ function resetTables() {
   ensuredConvIds = new Set();
 }
 
-function createTestCallSession(opts: Parameters<typeof createCallSession>[0]) {
+function createTestCallSession(
+  opts: Omit<Parameters<typeof createCallSession>[0], "direction"> & {
+    direction?: Parameters<typeof createCallSession>[0]["direction"];
+  },
+) {
   ensureConversation(opts.conversationId);
-  return createCallSession(opts);
+  // Direction only shapes the funnel stamp; these suites test other things.
+  return createCallSession({ direction: "inbound", ...opts });
 }
 
 /** Backdate a session's createdAt so it appears older than the grace period. */