@vellumai/assistant 0.7.1 → 0.7.2

package/src/__tests__/conversation-slash-commands.test.ts

@@ -115,8 +115,6 @@ describe("resolveSlash command contract", () => {
       "/context foo",
       "/models foo",
       "/status foo",
-      "/pair foo",
-      "/pair",
       "/btw",
     ];
 
@@ -138,7 +136,6 @@ describe("classifySlash is a pure classifier matching resolveSlash kinds", () =>
     input: string;
     kind: "passthrough" | "compact" | "unknown";
   }> = [
-    { input: "/pair", kind: "passthrough" },
     { input: "/models", kind: "unknown" },
     { input: "/context", kind: "unknown" },
     { input: "/status", kind: "unknown" },
@@ -149,7 +146,6 @@ describe("classifySlash is a pure classifier matching resolveSlash kinds", () =>
     { input: "/opus", kind: "unknown" },
     { input: "hello", kind: "passthrough" },
     { input: "  /compact  ", kind: "compact" },
-    { input: "/pair foo", kind: "passthrough" },
     { input: "/models foo", kind: "passthrough" },
   ];
 

package/src/__tests__/conversation-surfaces-action-delivery.test.ts

@@ -0,0 +1,202 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+  createSurfaceMutex,
+  handleSurfaceAction,
+  type SurfaceConversationContext,
+  surfaceProxyResolver,
+} from "../daemon/conversation-surfaces.js";
+import type {
+  ServerMessage,
+  SurfaceData,
+  SurfaceType,
+  UiSurfaceShow,
+} from "../daemon/message-protocol.js";
+import type { UserMessageAttachment } from "../daemon/message-types/shared.js";
+
+interface ProcessMessageCall {
+  content: string;
+  attachments: UserMessageAttachment[];
+  requestId?: string;
+  activeSurfaceId?: string;
+  displayContent?: string;
+}
+
+function makeContext(sent: ServerMessage[] = []): SurfaceConversationContext & {
+  processMessageCalls: ProcessMessageCall[];
+} {
+  const processMessageCalls: ProcessMessageCall[] = [];
+  return {
+    conversationId: "conv-1",
+    traceEmitter: { emit: () => {} },
+    sendToClient: (msg: ServerMessage) => sent.push(msg),
+    pendingSurfaceActions: new Map<string, { surfaceType: SurfaceType }>(),
+    lastSurfaceAction: new Map<
+      string,
+      { actionId: string; data?: Record<string, unknown> }
+    >(),
+    surfaceState: new Map<
+      string,
+      {
+        surfaceType: SurfaceType;
+        data: SurfaceData;
+        title?: string;
+        actions?: Array<{
+          id: string;
+          label: string;
+          style?: string;
+          data?: Record<string, unknown>;
+        }>;
+      }
+    >(),
+    surfaceUndoStacks: new Map<string, string[]>(),
+    accumulatedSurfaceState: new Map<string, Record<string, unknown>>(),
+    surfaceActionRequestIds: new Set<string>(),
+    currentTurnSurfaces: [],
+    isProcessing: () => false,
+    enqueueMessage: () => ({ queued: false, requestId: "req-1" }),
+    getQueueDepth: () => 0,
+    processMessage: async (
+      content: string,
+      attachments: UserMessageAttachment[],
+      _onEvent: (msg: ServerMessage) => void,
+      requestId?: string,
+      activeSurfaceId?: string,
+      _currentPage?: string,
+      _options?: { isInteractive?: boolean },
+      displayContent?: string,
+    ) => {
+      processMessageCalls.push({
+        content,
+        attachments,
+        requestId,
+        activeSurfaceId,
+        displayContent,
+      });
+      return "msg-1";
+    },
+    withSurface: createSurfaceMutex(),
+    processMessageCalls,
+  };
+}
+
+describe("surface action delivery to assistant", () => {
+  test("table action button click triggers processMessage with action content", async () => {
+    const sent: ServerMessage[] = [];
+    const ctx = makeContext(sent);
+
+    // Step 1: Show a table surface with actions
+    const showResult = await surfaceProxyResolver(ctx, "ui_show", {
+      surface_type: "table",
+      title: "Newsletters",
+      data: {
+        columns: [
+          { id: "sender", label: "Sender" },
+          { id: "count", label: "Count" },
+        ],
+        rows: [
+          { id: "row-1", cells: { sender: "Newsletter A", count: "5" } },
+          { id: "row-2", cells: { sender: "Newsletter B", count: "3" } },
+        ],
+        selectionMode: "multiple",
+      },
+      actions: [
+        { id: "archive", label: "Archive", style: "primary" },
+        { id: "unsubscribe", label: "Unsubscribe", style: "destructive" },
+      ],
+    });
+
+    expect(showResult.isError).toBe(false);
+    expect(showResult.yieldToUser).toBe(true);
+
+    // Verify surface was shown and pending action was registered
+    const showMessage = sent.find(
+      (msg): msg is UiSurfaceShow => msg.type === "ui_surface_show",
+    ) as UiSurfaceShow;
+    expect(showMessage).toBeDefined();
+    const surfaceId = showMessage.surfaceId;
+    expect(ctx.pendingSurfaceActions.has(surfaceId)).toBe(true);
+    expect(ctx.surfaceState.has(surfaceId)).toBe(true);
+
+    // Step 2: Simulate user clicking "Archive" with selected rows
+    const actionData = {
+      selectedIds: ["row-1", "row-2"],
+    };
+
+    await handleSurfaceAction(ctx, surfaceId, "archive", actionData);
+
+    // Step 3: Verify processMessage was called
+    expect(ctx.processMessageCalls.length).toBe(1);
+    const call = ctx.processMessageCalls[0];
+    expect(call.content).toContain("[User action on table surface:");
+    expect(call.content).toContain("archive");
+    expect(call.content).toContain("selectedIds");
+    expect(call.content).toContain("row-1");
+    expect(call.content).toContain("row-2");
+    expect(call.activeSurfaceId).toBe(surfaceId);
+
+    // Verify pending action was cleared
+    expect(ctx.pendingSurfaceActions.has(surfaceId)).toBe(false);
+
+    // Verify the requestId was tracked as a surface action
+    expect(ctx.surfaceActionRequestIds.size).toBe(1);
+  });
+
+  test("table action without selection data still triggers processMessage", async () => {
+    const sent: ServerMessage[] = [];
+    const ctx = makeContext(sent);
+
+    // Show table surface
+    await surfaceProxyResolver(ctx, "ui_show", {
+      surface_type: "table",
+      title: "Emails",
+      data: {
+        columns: [{ id: "subject", label: "Subject" }],
+        rows: [{ id: "r1", cells: { subject: "Hello" } }],
+      },
+      actions: [{ id: "archive", label: "Archive" }],
+    });
+
+    const showMessage = sent.find(
+      (msg): msg is UiSurfaceShow => msg.type === "ui_surface_show",
+    ) as UiSurfaceShow;
+    const surfaceId = showMessage.surfaceId;
+
+    // Click action WITHOUT selection data (data is undefined)
+    await handleSurfaceAction(ctx, surfaceId, "archive", undefined);
+
+    // processMessage must still be called
+    expect(ctx.processMessageCalls.length).toBe(1);
+    expect(ctx.processMessageCalls[0].content).toContain(
+      "[User action on table surface:",
+    );
+  });
+
+  test("action on history-restored surface (no pending) still processes", async () => {
+    const sent: ServerMessage[] = [];
+    const ctx = makeContext(sent);
+
+    // Simulate a history-restored surface: surfaceState exists, but
+    // pendingSurfaceActions does NOT have an entry.
+    ctx.surfaceState.set("hist-surface-1", {
+      surfaceType: "table",
+      data: {
+        columns: [{ id: "col", label: "Col" }],
+        rows: [],
+      } as unknown as SurfaceData,
+      title: "History Table",
+      actions: [{ id: "delete", label: "Delete" }],
+    });
+
+    // Click the action — should go through the history-restored path
+    await handleSurfaceAction(ctx, "hist-surface-1", "delete", {
+      selectedIds: ["row-1"],
+    });
+
+    // processMessage should still be called
+    expect(ctx.processMessageCalls.length).toBe(1);
+    expect(ctx.processMessageCalls[0].content).toContain(
+      "[User action on app:",
+    );
+  });
+});

package/src/__tests__/conversation-surfaces-app-control.test.ts

@@ -0,0 +1,317 @@
+/**
+ * Tests for the surfaceProxyResolver's app_control_* dispatch branch.
+ *
+ * Mirrors the structure of cu-unified-flow.test.ts but exercises the
+ * sibling branch added for app-control: unavailability when no proxy is
+ * attached, end-to-end dispatch through HostAppControlProxy.request, and
+ * the local short-circuit for app_control_stop (no client round-trip).
+ */
+
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+
+const sentMessages: unknown[] = [];
+let mockHasClient = true;
+
+mock.module("../runtime/assistant-event-hub.js", () => ({
+  broadcastMessage: (msg: unknown) => sentMessages.push(msg),
+  assistantEventHub: {
+    getMostRecentClientByCapability: (cap: string) =>
+      cap === "host_app_control" && mockHasClient
+        ? { id: "mock-client" }
+        : null,
+  },
+}));
+
+mock.module("../runtime/pending-interactions.js", () => ({
+  register: () => undefined,
+  resolve: () => undefined,
+  get: () => undefined,
+  getByKind: () => [],
+  getByConversation: () => [],
+  removeByConversation: () => {},
+}));
+
+const { surfaceProxyResolver } =
+  await import("../daemon/conversation-surfaces.js");
+const { HostAppControlProxy, _resetActiveAppControlConversationId } =
+  await import("../daemon/host-app-control-proxy.js");
+type SurfaceConversationContext =
+  import("../daemon/conversation-surfaces.js").SurfaceConversationContext;
+
+// ---------------------------------------------------------------------------
+// Test helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Build a minimal SurfaceConversationContext with an optional
+ * hostAppControlProxy. Only the fields required by the app-control routing
+ * path are populated.
+ */
+function buildMockContext(
+  hostAppControlProxy?: InstanceType<typeof HostAppControlProxy>,
+  conversationId = "test-session",
+  setHostAppControlProxy?: (
+    proxy: InstanceType<typeof HostAppControlProxy> | undefined,
+  ) => void,
+): SurfaceConversationContext {
+  return {
+    conversationId,
+    traceEmitter: { emit: () => {} },
+    sendToClient: () => {},
+    pendingSurfaceActions: new Map(),
+    lastSurfaceAction: new Map(),
+    surfaceState: new Map(),
+    surfaceUndoStacks: new Map(),
+    accumulatedSurfaceState: new Map(),
+    surfaceActionRequestIds: new Set(),
+    currentTurnSurfaces: [],
+    hostAppControlProxy,
+    setHostAppControlProxy,
+    isProcessing: () => false,
+    enqueueMessage: () => ({ queued: false, requestId: "r1" }),
+    getQueueDepth: () => 0,
+    processMessage: async () => "",
+    withSurface: async (_id, fn) => fn(),
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("surfaceProxyResolver — app-control tool routing", () => {
+  beforeEach(() => {
+    sentMessages.length = 0;
+    mockHasClient = true;
+    _resetActiveAppControlConversationId();
+  });
+
+  afterEach(() => {
+    _resetActiveAppControlConversationId();
+  });
+
+  // -------------------------------------------------------------------------
+  // Unavailability
+  // -------------------------------------------------------------------------
+
+  describe("no app-control proxy attached", () => {
+    test("returns isError result when ctx.hostAppControlProxy is undefined", async () => {
+      const ctx = buildMockContext(/* no proxy */);
+
+      const result = await surfaceProxyResolver(ctx, "app_control_observe", {
+        tool: "observe",
+        app: "com.example.editor",
+      });
+
+      expect(result.isError).toBe(true);
+      expect(result.content).toContain("not available");
+      expect(result.content).toContain("app-control");
+      // No envelope dispatched.
+      expect(sentMessages).toHaveLength(0);
+    });
+
+    test("returns isError when proxy exists but no client is connected", async () => {
+      mockHasClient = false;
+      const proxy = new HostAppControlProxy("conv-1");
+      const ctx = buildMockContext(proxy);
+
+      const result = await surfaceProxyResolver(ctx, "app_control_observe", {
+        tool: "observe",
+        app: "com.example.editor",
+      });
+
+      expect(result.isError).toBe(true);
+      expect(result.content).toContain("not available");
+      expect(sentMessages).toHaveLength(0);
+
+      proxy.dispose();
+    });
+
+    test("returns isError for app_control_stop when no proxy is attached", async () => {
+      const ctx = buildMockContext();
+
+      const result = await surfaceProxyResolver(ctx, "app_control_stop", {
+        tool: "stop",
+      });
+
+      expect(result.isError).toBe(true);
+      expect(result.content).toContain("not available");
+      expect(sentMessages).toHaveLength(0);
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // Dispatch through proxy.request
+  // -------------------------------------------------------------------------
+
+  describe("non-stop tools dispatch through proxy.request", () => {
+    test("app_control_observe routes through proxy and returns observation", async () => {
+      const proxy = new HostAppControlProxy("conv-1");
+      const ctx = buildMockContext(proxy, "conv-1");
+
+      const resultPromise = surfaceProxyResolver(ctx, "app_control_observe", {
+        tool: "observe",
+        app: "com.example.editor",
+      });
+
+      // The proxy fired exactly one host_app_control_request envelope.
+      expect(sentMessages).toHaveLength(1);
+      const sent = sentMessages[0] as Record<string, unknown>;
+      expect(sent.type).toBe("host_app_control_request");
+      expect(sent.toolName).toBe("app_control_observe");
+      expect(sent.conversationId).toBe("conv-1");
+      expect(sent.input).toEqual({
+        tool: "observe",
+        app: "com.example.editor",
+      });
+
+      const requestId = sent.requestId as string;
+      proxy.resolve(requestId, {
+        requestId: "ignored-by-proxy",
+        state: "running",
+        executionResult: "Window observed",
+      });
+
+      const result = await resultPromise;
+      expect(result.isError).toBe(false);
+      expect(result.content).toContain("State: running");
+      expect(result.content).toContain("Window observed");
+
+      proxy.dispose();
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // Local short-circuit on app_control_stop
+  // -------------------------------------------------------------------------
+
+  describe("app_control_stop short-circuits locally", () => {
+    test("calls proxy.dispose() and returns a stopped summary without a client round-trip", async () => {
+      const proxy = new HostAppControlProxy("conv-1");
+      const ctx = buildMockContext(proxy);
+
+      let disposeCalls = 0;
+      const realDispose = proxy.dispose.bind(proxy);
+      proxy.dispose = () => {
+        disposeCalls++;
+        realDispose();
+      };
+
+      let requestCalls = 0;
+      const realRequest = proxy.request.bind(proxy);
+      proxy.request = (...args) => {
+        requestCalls++;
+        return realRequest(...args);
+      };
+
+      const result = await surfaceProxyResolver(ctx, "app_control_stop", {
+        tool: "stop",
+      });
+
+      expect(result.isError).toBe(false);
+      expect(result.content.toLowerCase()).toContain("stopped");
+      expect(disposeCalls).toBe(1);
+      expect(requestCalls).toBe(0);
+      // No envelope dispatched for the local short-circuit.
+      expect(sentMessages).toHaveLength(0);
+    });
+
+    test("clears the conversation reference via setHostAppControlProxy(undefined) when the setter is provided", async () => {
+      const proxy = new HostAppControlProxy("conv-1");
+
+      // Capture how the resolver clears the proxy reference. The setter
+      // mirrors Conversation.setHostAppControlProxy: dispose the existing
+      // proxy when transitioning to undefined.
+      const setterCalls: Array<unknown> = [];
+      let attached: InstanceType<typeof HostAppControlProxy> | undefined =
+        proxy;
+      const setter = (
+        next: InstanceType<typeof HostAppControlProxy> | undefined,
+      ) => {
+        setterCalls.push(next);
+        if (attached && attached !== next) attached.dispose();
+        attached = next;
+      };
+
+      const ctx = buildMockContext(proxy, "conv-1", setter);
+
+      const result = await surfaceProxyResolver(ctx, "app_control_stop", {
+        tool: "stop",
+      });
+
+      expect(result.isError).toBe(false);
+      // The resolver invoked the setter with undefined exactly once.
+      expect(setterCalls).toEqual([undefined]);
+      expect(attached).toBeUndefined();
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // Discriminator injection (Gap A)
+  // -------------------------------------------------------------------------
+
+  describe("tool discriminator injection", () => {
+    test("injects `tool` derived from toolName when the agent input omits it", async () => {
+      const proxy = new HostAppControlProxy("conv-1");
+      const ctx = buildMockContext(proxy, "conv-1");
+
+      // Agent inputs do not carry the discriminator — the resolver has to
+      // synthesize it from `toolName` ("app_control_observe" → "observe")
+      // before forwarding to the proxy / desktop client.
+      const resultPromise = surfaceProxyResolver(ctx, "app_control_observe", {
+        app: "com.example.editor",
+      });
+
+      expect(sentMessages).toHaveLength(1);
+      const sent = sentMessages[0] as Record<string, unknown>;
+      expect(sent.input).toEqual({
+        tool: "observe",
+        app: "com.example.editor",
+      });
+
+      const requestId = sent.requestId as string;
+      proxy.resolve(requestId, {
+        requestId: "ignored-by-proxy",
+        state: "running",
+      });
+      await resultPromise;
+
+      proxy.dispose();
+    });
+
+    test('injects `tool: "start"` so the singleton-lock guard fires', async () => {
+      // Establish a lock owned by conv-other.
+      const ownerProxy = new HostAppControlProxy("conv-other");
+      const ownerCtrl = new AbortController();
+      const ownerPromise = ownerProxy.request(
+        "app_control_start",
+        { tool: "start", app: "com.example.editor" },
+        "conv-other",
+        ownerCtrl.signal,
+      );
+      const ownerSent = sentMessages[0] as Record<string, unknown>;
+      ownerProxy.resolve(ownerSent.requestId as string, {
+        requestId: "ignored-by-proxy",
+        state: "running",
+      });
+      await ownerPromise;
+      sentMessages.length = 0;
+
+      // conv-1 attempts to start without a discriminator in its input. The
+      // resolver must inject `tool: "start"`, which causes the proxy's
+      // singleton-lock guard to fire and reject without dispatching.
+      const proxy = new HostAppControlProxy("conv-1");
+      const ctx = buildMockContext(proxy, "conv-1");
+      const result = await surfaceProxyResolver(ctx, "app_control_start", {
+        app: "com.example.editor",
+      });
+
+      expect(result.isError).toBe(true);
+      expect(result.content).toContain("conv-other");
+      expect(sentMessages).toHaveLength(0); // No envelope dispatched.
+
+      proxy.dispose();
+      ownerProxy.dispose();
+    });
+  });
+});

package/src/__tests__/credential-execution-feature-gates.test.ts

@@ -17,12 +17,10 @@ import {
 import type { AssistantConfig } from "../config/schema.js";
 import {
   CES_GRANT_AUDIT_FLAG_KEY,
-  CES_MANAGED_SIDECAR_FLAG_KEY,
   CES_SECURE_INSTALL_FLAG_KEY,
   CES_SHELL_LOCKDOWN_FLAG_KEY,
   CES_TOOLS_FLAG_KEY,
   isCesGrantAuditEnabled,
-  isCesManagedSidecarEnabled,
   isCesSecureInstallEnabled,
   isCesShellLockdownEnabled,
   isCesToolsEnabled,
@@ -51,7 +49,6 @@ const ALL_CES_FLAG_KEYS = [
   CES_SHELL_LOCKDOWN_FLAG_KEY,
   CES_SECURE_INSTALL_FLAG_KEY,
   CES_GRANT_AUDIT_FLAG_KEY,
-  CES_MANAGED_SIDECAR_FLAG_KEY,
 ] as const;
 
 /** All CES predicate functions paired with their flag keys and expected defaults. */
@@ -80,12 +77,6 @@ const ALL_CES_PREDICATES = [
     key: CES_GRANT_AUDIT_FLAG_KEY,
     defaultEnabled: false,
   },
-  {
-    name: "isCesManagedSidecarEnabled",
-    fn: isCesManagedSidecarEnabled,
-    key: CES_MANAGED_SIDECAR_FLAG_KEY,
-    defaultEnabled: true,
-  },
 ] as const;
 
 // ---------------------------------------------------------------------------
@@ -180,7 +171,7 @@ describe("CES flags do not affect unrelated flags", () => {
     expect(isAssistantFeatureFlagEnabled("browser", config)).toBe(true);
   });
 
-  test("enabling all CES flags does not change sounds flag (defaultEnabled: true)", () => {
+  test("enabling all CES flags does not change unrelated default-open flags", () => {
     const overrides: Record<string, boolean> = {};
     for (const key of ALL_CES_FLAG_KEYS) {
       overrides[key] = true;
@@ -188,7 +179,9 @@ describe("CES flags do not affect unrelated flags", () => {
     _setOverridesForTesting(overrides);
     const config = makeConfig();
 
-    // sounds defaults to true in the registry and should stay true
-    expect(isAssistantFeatureFlagEnabled("sounds", config)).toBe(true);
+    // Unknown flags default open unless explicitly overridden.
+    expect(
+      isAssistantFeatureFlagEnabled("unrelated-default-open", config),
+    ).toBe(true);
   });
 });