@vellumai/assistant 0.12.3-staging.1 → 0.12.3

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

@@ -38,8 +38,16 @@ interface ProcessMessageCall {
 
 function makeContext(sent: AssistantEvent[] = []): Conversation & {
   processMessageCalls: ProcessMessageCall[];
+  acceptedSurfaceResponses: Array<{
+    requestId: string;
+    response: { kind: "surface"; responseId: string };
+  }>;
 } {
   const processMessageCalls: ProcessMessageCall[] = [];
+  const acceptedSurfaceResponses: Array<{
+    requestId: string;
+    response: { kind: "surface"; responseId: string };
+  }> = [];
   return asConversation({
     conversationId: "conv-1",
     sendToClient: (msg: AssistantEvent) => sent.push(msg),
@@ -54,6 +62,18 @@ function makeContext(sent: AssistantEvent[] = []): Conversation & {
     accumulatedSurfaceState: new Map<string, Record<string, unknown>>(),
     surfaceActionRequestIds: new Set<string>(),
     currentTurnSurfaces: [],
+    modeSessions: {
+      acceptTurn: (
+        requestId: string,
+        response?: { kind: "surface"; responseId: string },
+      ) => {
+        if (response?.kind === "surface") {
+          acceptedSurfaceResponses.push({ requestId, response });
+        }
+        return undefined;
+      },
+      getTurnOwner: () => undefined,
+    } as unknown as Conversation["modeSessions"],
     isProcessing: () => false,
     enqueueMessage: () => ({ queued: false, requestId: "req-1" }),
     getQueueDepth: () => 0,
@@ -70,6 +90,7 @@ function makeContext(sent: AssistantEvent[] = []): Conversation & {
     },
     withSurface: createSurfaceMutex(),
     processMessageCalls,
+    acceptedSurfaceResponses,
   });
 }
 
@@ -78,6 +99,129 @@ describe("surface action delivery to assistant", () => {
     broadcastedMessages = [];
   });
 
+  test.each([true, false])(
+    "matching surface answers retain their session across cleanup (pending=%s)",
+    async (hasPending) => {
+      const { initializeDb } = await import("../persistence/db-init.js");
+      const { createConversation } =
+        await import("../persistence/conversation-crud.js");
+      const { ConversationModeSessionCoordinator } =
+        await import("../daemon/conversation-mode-session.js");
+      const { cleanupStandaloneSurface } =
+        await import("../daemon/conversation-surfaces.js");
+      await initializeDb();
+      const conversation = createConversation();
+      const coordinator = new ConversationModeSessionCoordinator(
+        conversation.id,
+      );
+      const handle = coordinator.activateSource({
+        sourceId: "browser-source",
+        generation: 1,
+        mode: "browser",
+        sourceStartedAt: 100,
+      })!;
+      coordinator.claimTurn("turn-origin", handle, 110);
+      coordinator.recordStructuralWait("turn-origin", {
+        kind: "surface",
+        responseId: "surface-123",
+      });
+      coordinator.releaseTurn("turn-origin");
+      const ctx = Object.assign(makeContext(), {
+        conversationId: conversation.id,
+        modeSessions: coordinator,
+      });
+      ctx.surfaceState.set("surface-123", {
+        surfaceType: "form",
+        data: { fields: [] },
+      });
+      if (hasPending) {
+        ctx.pendingSurfaceActions.set("surface-123", { surfaceType: "form" });
+      }
+
+      await handleSurfaceAction(ctx, "surface-123", "submit", {});
+
+      expect(ctx.processMessageCalls).toHaveLength(1);
+      const acceptedTurnId = ctx.processMessageCalls[0]!.requestId!;
+      expect(coordinator.getTurnOwner(acceptedTurnId)?.id).toBe(handle.id);
+      expect(ctx.pendingSurfaceActions.has("surface-123")).toBe(false);
+      cleanupStandaloneSurface(ctx, "surface-123");
+      expect(
+        coordinator.getTerminalDisposition(acceptedTurnId),
+      ).toBeUndefined();
+      expect(coordinator.getTurnOwner(acceptedTurnId)?.id).toBe(handle.id);
+      expect(
+        coordinator.acceptTurn("turn-replayed", {
+          kind: "surface",
+          responseId: "surface-123",
+        }),
+      ).toBeUndefined();
+      coordinator.releaseTurn(acceptedTurnId, {
+        status: "completed",
+        endReason: "turn_settled",
+      });
+      expect(coordinator.hasResidentWork()).toBe(false);
+    },
+  );
+
+  test.each([false, true])(
+    "queued surface answers retain handoff ownership without pinning the old turn (wait=%s)",
+    async (hasRecordedWait) => {
+      const { initializeDb } = await import("../persistence/db-init.js");
+      const { createConversation } =
+        await import("../persistence/conversation-crud.js");
+      const { ConversationModeSessionCoordinator } =
+        await import("../daemon/conversation-mode-session.js");
+      await initializeDb();
+      const conversation = createConversation();
+      const coordinator = new ConversationModeSessionCoordinator(
+        conversation.id,
+      );
+      const handle = coordinator.activateSource({
+        sourceId: "browser-source",
+        generation: 1,
+        mode: "browser",
+        sourceStartedAt: 100,
+      })!;
+      coordinator.claimTurn("turn-origin", handle, 110);
+      if (hasRecordedWait) {
+        coordinator.recordStructuralWait("turn-origin", {
+          kind: "surface",
+          responseId: "surface-123",
+        });
+      }
+      const ctx = Object.assign(makeContext(), {
+        conversationId: conversation.id,
+        modeSessions: coordinator,
+      });
+      let queuedRequestId: string | undefined;
+      ctx.enqueueMessage = (message) => {
+        queuedRequestId = message.requestId;
+        return { queued: true, requestId: message.requestId! };
+      };
+      ctx.surfaceState.set("surface-123", {
+        surfaceType: "form",
+        data: { fields: [] },
+      });
+      ctx.pendingSurfaceActions.set("surface-123", { surfaceType: "form" });
+
+      await handleSurfaceAction(ctx, "surface-123", "submit", {});
+
+      expect(ctx.processMessageCalls).toHaveLength(0);
+      expect(queuedRequestId).toBeDefined();
+      expect(coordinator.getTurnOwner(queuedRequestId!)?.id).toBe(
+        hasRecordedWait ? handle.id : undefined,
+      );
+      coordinator.transferTurn("turn-origin", queuedRequestId!);
+      expect(coordinator.getTurnOwner("turn-origin")).toBeUndefined();
+      expect(coordinator.getTurnOwner(queuedRequestId!)?.id).toBe(handle.id);
+      coordinator.releaseTurn(queuedRequestId!, {
+        status: "completed",
+        endReason: "turn_settled",
+      });
+      expect(coordinator.hasResidentWork()).toBe(false);
+    },
+  );
+
   test("table action button click triggers processMessage with action content", async () => {
     const sent: AssistantEvent[] = [];
     const ctx = makeContext(sent);
@@ -131,6 +275,13 @@ describe("surface action delivery to assistant", () => {
     expect(call.content).toContain("row-1");
     expect(call.content).toContain("row-2");
     expect(call.activeSurfaceId).toBe(surfaceId);
+    expect(call.requestId).toBeDefined();
+    expect(ctx.acceptedSurfaceResponses).toEqual([
+      {
+        requestId: call.requestId!,
+        response: { kind: "surface", responseId: surfaceId },
+      },
+    ]);
 
     // Verify pending action was cleared
     expect(ctx.pendingSurfaceActions.has(surfaceId)).toBe(false);

package/src/__tests__/conversation-surfaces-point-at-budget.test.ts

@@ -15,12 +15,20 @@ const { assistantEventHub } = await import("../runtime/assistant-event-hub.js");
  */
 function proxyDouble() {
   const recordAction = mock(() => {});
-  const request = mock(async () => ({ content: "ok", isError: false }));
+  const request = mock(async (...args: unknown[]) => {
+    const onValidatedDispatch = args[8];
+    if (typeof onValidatedDispatch === "function") {
+      onValidatedDispatch();
+    }
+    return { content: "ok", isError: false };
+  });
   return {
     recordAction,
     request,
     proxy: {
       isAvailable: () => true,
+      sourceId: "proxy-123",
+      resetGeneration: 4,
       recordAction,
       request,
       reset: () => {},
@@ -39,6 +47,22 @@ const context = (proxy: unknown) =>
     currentTurnSourceActorPrincipalId: ACTOR,
   });
 
+function modeSessionContext(proxy: unknown) {
+  const recordAction = mock(() => undefined);
+  const endTask = mock(() => true);
+  return {
+    recordAction,
+    endTask,
+    ctx: asConversation({
+      conversationId: "conv-1",
+      currentRequestId: "turn-123",
+      hostCuProxy: proxy as never,
+      currentTurnSourceActorPrincipalId: ACTOR,
+      computerUseModeSessions: { recordAction, endTask } as never,
+    }),
+  };
+}
+
 /**
  * A client that can actually draw. Pointing resolves on `host_cu_annotate`
  * and refuses outright when nothing holds it, so without this the requests
@@ -148,4 +172,42 @@ describe("the computer-use step budget", () => {
 
     expect(recordAction).toHaveBeenCalledTimes(1);
   });
+
+  test("claims a mode session only after target validation", async () => {
+    const { proxy } = proxyDouble();
+    const valid = modeSessionContext(proxy);
+
+    await surfaceProxyResolver(valid.ctx, "computer_use_click", {
+      element_id: 3,
+    });
+    expect(valid.recordAction).toHaveBeenCalledWith({
+      turnId: "turn-123",
+      source: { sourceId: "proxy-123", generation: 4 },
+      at: expect.any(Number),
+    });
+
+    const rejected = modeSessionContext(proxy);
+    await surfaceProxyResolver(rejected.ctx, "computer_use_click", {
+      element_id: 3,
+      target_client_id: "missing-client",
+    });
+    expect(rejected.recordAction).not.toHaveBeenCalled();
+  });
+
+  test("terminal respond retires the exact run and begins draining", async () => {
+    const { proxy } = proxyDouble();
+    const state = modeSessionContext(proxy);
+
+    const result = await surfaceProxyResolver(
+      state.ctx,
+      "computer_use_respond",
+      { answer: "Finished" },
+    );
+
+    expect(result).toEqual({ content: "Finished", isError: false });
+    expect(state.endTask).toHaveBeenCalledWith({
+      turnId: "turn-123",
+      source: { sourceId: "proxy-123", generation: 4 },
+    });
+  });
 });

package/src/__tests__/conversation-tool-setup-attribution.test.ts

@@ -10,6 +10,7 @@
 import { beforeEach, describe, expect, mock, spyOn, test } from "bun:test";
 
 import type { Conversation } from "../daemon/conversation.js";
+import { shouldUseVirtualDesktop } from "../desktop/virtual-desktop-feature.js";
 import type { PermissionPrompter } from "../permissions/prompter.js";
 import type { SecretPrompter } from "../permissions/secret-prompter.js";
 import type { ToolExecutor } from "../tools/executor.js";
@@ -307,6 +308,28 @@ describe("createToolExecutor attribution threading", () => {
   });
 });
 
+test("desktop routing honors the pinned interface when the live client changes", async () => {
+  for (const transportInterface of ["web", "macos"] as const) {
+    const { executor, calls } = makeCapturingExecutor();
+    await makeToolFn(
+      executor,
+      makeCtx({
+        transportInterface: transportInterface === "web" ? "macos" : "web",
+        toolContextPin: { hasNoClient: false, transportInterface },
+        getTurnActorPrincipalId: () => "user-123",
+        currentTurnTrustContext: {
+          sourceChannel: "vellum",
+          trustClass: "guardian",
+        },
+      }),
+    )("computer_use_observe", {});
+
+    expect(shouldUseVirtualDesktop(calls[0].context, true)).toBe(
+      transportInterface === "web",
+    );
+  }
+});
+
 describe("createToolExecutor isInteractive threading", () => {
   test("uses the resolved turn-level interactivity over live client state", async () => {
     // A scheduled/background turn (currentTurnIsNonInteractive=true) must read

package/src/__tests__/conversation-undo.test.ts

@@ -87,3 +87,64 @@ describe("findLastUndoableUserMessageIndex", () => {
     expect(findLastUndoableUserMessageIndex([spoofMessage])).toBe(0);
   });
 });
+
+describe("undo mode-session cleanup", () => {
+  test.each([false, true])(
+    "undo completes when tracking failure is %s",
+    async (trackingFails) => {
+      const { initializeDb } = await import("../persistence/db-init.js");
+      const { createConversation, addMessage, getMessages } =
+        await import("../persistence/conversation-crud.js");
+      const { ConversationModeSessionCoordinator } =
+        await import("../daemon/conversation-mode-session.js");
+      const { undo } = await import("../daemon/conversation-history.js");
+      await initializeDb();
+      const conversation = createConversation();
+      const messages = [
+        textMessage("user", "Choose an option"),
+        textMessage("assistant", "Please choose"),
+      ];
+      for (const message of messages) {
+        await addMessage(
+          conversation.id,
+          message.role,
+          JSON.stringify(message.content),
+          { skipIndexing: true },
+        );
+      }
+      const coordinator = new ConversationModeSessionCoordinator(
+        conversation.id,
+      );
+      const source = coordinator.activateSource({
+        sourceId: "browser-source",
+        generation: 1,
+        mode: "browser",
+        sourceStartedAt: 100,
+      })!;
+      coordinator.claimTurn("turn-origin", source, 110);
+      coordinator.recordStructuralWait("turn-origin", {
+        kind: "surface",
+        responseId: "surface-123",
+      });
+      coordinator.releaseTurn("turn-origin");
+      const context = {
+        conversationId: conversation.id,
+        messages,
+        isProcessing: () => false,
+        modeSessions: {
+          invalidateAllStructuralWaits: () => {
+            const count = coordinator.invalidateAllStructuralWaits();
+            if (trackingFails) {
+              throw new Error("session tracking unavailable");
+            }
+            return count;
+          },
+        },
+      };
+      expect(undo(context)).toBe(2);
+      expect(context.messages).toEqual([]);
+      expect(getMessages(conversation.id)).toEqual([]);
+      expect(coordinator.hasResidentWork()).toBe(false);
+    },
+  );
+});

package/src/__tests__/credential-execution-client.test.ts

@@ -31,8 +31,8 @@ import {
   createCesClient,
 } from "../credential-execution/client.js";
 import {
+  discoverCes,
   discoverCesWithRetry,
-  discoverManagedCes,
 } from "../credential-execution/executable-discovery.js";
 
 // ---------------------------------------------------------------------------
@@ -95,12 +95,12 @@ function withBootstrapDir(dir: string): () => void {
   };
 }
 
-describe("managed CES discovery", () => {
+describe("CES discovery", () => {
   test("returns unavailable when bootstrap socket does not exist", () => {
     const bootstrapDir = mkdtempSync(join(tmpdir(), "ces-missing-"));
     const restore = withBootstrapDir(bootstrapDir);
     try {
-      const result = discoverManagedCes();
+      const result = discoverCes();
       expect(result.mode).toBe("unavailable");
       expect((result as { reason: string }).reason).toContain(
         "CES bootstrap socket not found",
@@ -115,7 +115,7 @@ describe("managed CES discovery", () => {
     const bootstrapDir = mkdtempSync(join(tmpdir(), "ces-missing-"));
     const restore = withBootstrapDir(bootstrapDir);
     try {
-      const result = discoverManagedCes();
+      const result = discoverCes();
       expect(["managed", "unavailable"]).toContain(result.mode);
     } finally {
       restore();
@@ -132,7 +132,7 @@ describe("CES bootstrap socket discovery", () => {
       const socketPath = resolveIpcEndpoint("ces", {
         workspaceDir: bootstrapDir,
       }).path;
-      const result = discoverManagedCes();
+      const result = discoverCes();
       expect(result.mode).toBe("unavailable");
       expect((result as { reason: string }).reason).toContain(socketPath);
     } finally {
@@ -145,7 +145,7 @@ describe("CES bootstrap socket discovery", () => {
     const bootstrapDir = mkdtempSync(join(tmpdir(), "ces-bootstrap-"));
     const restore = withBootstrapDir(bootstrapDir);
     try {
-      const result = discoverManagedCes();
+      const result = discoverCes();
       const workspaceDir = process.env.VELLUM_WORKSPACE_DIR;
       expect(workspaceDir).toBeDefined();
       const workspaceSocket = resolveIpcEndpoint("ces", {

package/src/__tests__/credential-prompt-route.test.ts

@@ -509,9 +509,14 @@ describe("credentials/prompt route", () => {
       error: "unsupported_channel",
     };
 
-    // WHEN the route handles the prompt
+    // WHEN the route handles a conversation-scoped prompt
     const result = (await promptRoute!.handler({
-      body: { service: "stripe", field: "api_key", label: "Stripe API Key" },
+      body: {
+        service: "stripe",
+        field: "api_key",
+        label: "Stripe API Key",
+        conversationId: "conv-1",
+      },
     })) as PromptResponse;
 
     // THEN it is a plain failure with no cancel flag
@@ -522,6 +527,32 @@ describe("credentials/prompt route", () => {
     );
   });
 
+  test("names the missing conversation when a headless prompt cannot be delivered", async () => {
+    /**
+     * With no conversationId the failure is not about a channel: no client can
+     * render the card at all. The model-facing text must say so and steer to
+     * the in-app credentials page, never to pasting the value into chat.
+     */
+    // GIVEN a conversation-less prompt that could not mint a collection link
+    secretResult = {
+      value: null,
+      delivery: "store",
+      error: "unsupported_channel",
+    };
+
+    // WHEN the route handles a prompt with no conversationId
+    const result = (await promptRoute!.handler({
+      body: { service: "stripe", field: "api_key", label: "Stripe API Key" },
+    })) as PromptResponse;
+
+    // THEN it fails fast with headless-specific guidance
+    expect(result.ok).toBe(false);
+    expect(result.cancelled).toBeUndefined();
+    expect(result.error).toContain("No conversation is attached");
+    expect(result.error).toContain("Settings > Credentials");
+    expect(result.error).toContain("Never ask them to paste it into chat");
+  });
+
   test("returns a pending collection link for unsupported channels when minted", async () => {
     /**
      * When the channel cannot render the secure prompt but the gateway minted
@@ -721,7 +752,8 @@ describe("credentials/prompt route", () => {
   test("still prompts for the ACP Claude token outside any conversation (headless CLI)", async () => {
     /**
      * A bare CLI `credentials prompt` with no conversation (headless) can't show
-     * an inline card, so the guard must not fire and the prompt proceeds.
+     * an inline card, so the guard must not fire and the prompt proceeds (where
+     * `requestSecretStandalone` fails fast into the collection-link fallback).
      */
     // GIVEN no conversation resolves (headless CLI, no conversationId)
     conversationExists = false;

package/src/__tests__/cu-unified-flow.test.ts

@@ -5,8 +5,11 @@
  * point between the agent loop and the HostCuProxy.
  */
 
-import { afterEach, describe, expect, mock, test } from "bun:test";
+import { afterEach, describe, expect, mock, spyOn, test } from "bun:test";
 
+import { isSessionGroupsEnabled } from "../config/session-groups-gate.js";
+import { ComputerUseModeSessionProducer } from "../daemon/computer-use-mode-session.js";
+import { setOverridesForTesting } from "./feature-flag-test-helpers.js";
 import { asConversation } from "./helpers/mock-conversation.js";
 
 const sentMessages: unknown[] = [];
@@ -76,6 +79,10 @@ function buildMockContext(
   // attach one (the gate denies, or the context predates the hook).
   ensureHostProxiesForTurn?: () => void,
 ): Conversation {
+  const computerUseModeSessions = {
+    recordAction: () => false,
+    endTask: () => false,
+  } as unknown as Conversation["computerUseModeSessions"];
   const ctx: Conversation = asConversation({
     conversationId: "test-session",
     trustContext:
@@ -105,6 +112,7 @@ function buildMockContext(
     accumulatedSurfaceState: new Map(),
     surfaceActionRequestIds: new Set(),
     currentTurnSurfaces: [],
+    computerUseModeSessions,
     hostCuProxy,
     transportInterface: "web",
     ensureHostProxiesForTurn,
@@ -139,6 +147,7 @@ describe("surfaceProxyResolver — CU tool routing", () => {
   }
 
   afterEach(() => {
+    setOverridesForTesting({});
     proxy?.dispose();
   });
 
@@ -337,6 +346,78 @@ describe("surfaceProxyResolver — CU tool routing", () => {
   // -------------------------------------------------------------------------
 
   describe("action tools proxy to client", () => {
+    test("dispatches without mode-session side effects while session groups are disabled", async () => {
+      setOverridesForTesting({ "session-groups": false });
+      const ctx = setupProxy();
+      ctx.currentRequestId = "turn-123";
+      const activateSource = mock(() => {
+        throw new Error("disabled tracking must not activate a source");
+      });
+      (
+        ctx as unknown as {
+          computerUseModeSessions: Conversation["computerUseModeSessions"];
+        }
+      ).computerUseModeSessions = new ComputerUseModeSessionProducer(
+        {
+          activateSource,
+          beginDraining: mock(() => false),
+          claimTurn: mock(() => undefined),
+          getTurnOwner: mock(() => undefined),
+          recordActivity: mock(() => false),
+          retireSource: mock(() => false),
+        },
+        isSessionGroupsEnabled,
+      );
+
+      const resultPromise = surfaceProxyResolver(ctx, "computer_use_click", {
+        element_id: 42,
+      });
+      const sent = sentMessages[0] as { requestId: string; type: string };
+      expect(sent.type).toBe("host_cu_request");
+      expect(activateSource).not.toHaveBeenCalled();
+
+      proxy.processObservation(sent.requestId, { executionResult: "clicked" });
+      const result = await resultPromise;
+      expect(result.isError).toBe(false);
+    });
+
+    test("dispatches once after tracking admission throws and still cleans up the task", async () => {
+      const ctx = setupProxy();
+      ctx.currentRequestId = "turn-123";
+      const recordAction = spyOn(
+        ctx.computerUseModeSessions,
+        "recordAction",
+      ).mockImplementation(() => {
+        throw new Error("tracking unavailable");
+      });
+      const endTask = spyOn(
+        ctx.computerUseModeSessions,
+        "endTask",
+      ).mockImplementation(() => {
+        throw new Error("tracking unavailable");
+      });
+      try {
+        const resultPromise = surfaceProxyResolver(ctx, "computer_use_click", {
+          element_id: 42,
+        });
+        expect(sentMessages).toHaveLength(1);
+        const sent = sentMessages[0] as { requestId: string };
+        proxy.processObservation(sent.requestId, {
+          executionResult: "clicked",
+        });
+        expect((await resultPromise).isError).toBe(false);
+        expect(recordAction).toHaveBeenCalledTimes(1);
+        expect(
+          (await surfaceProxyResolver(ctx, "computer_use_done", {})).isError,
+        ).toBe(false);
+        expect(endTask).toHaveBeenCalledTimes(1);
+        expect(proxy.stepCount).toBe(0);
+      } finally {
+        recordAction.mockRestore();
+        endTask.mockRestore();
+      }
+    });
+
     test("computer_use_click routes through proxy and returns observation", async () => {
       const ctx = setupProxy();