@vellumai/assistant 0.12.2 → 0.12.3-staging.2

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

@@ -20,6 +20,7 @@ import { tmpdir } from "node:os";
 import { join, resolve } from "node:path";
 import { describe, expect, test } from "bun:test";
 
+import { resolveIpcEndpoint } from "@vellumai/ipc-server-utils";
 import { CES_PROTOCOL_VERSION } from "@vellumai/service-contracts/credential-rpc";
 
 import {
@@ -30,8 +31,8 @@ import {
   createCesClient,
 } from "../credential-execution/client.js";
 import {
+  discoverCes,
   discoverCesWithRetry,
-  discoverManagedCes,
 } from "../credential-execution/executable-discovery.js";
 
 // ---------------------------------------------------------------------------
@@ -79,44 +80,83 @@ function createMockTransport(): CesTransport & {
 }
 
 // ---------------------------------------------------------------------------
-// Managed discovery — fail closed when socket is missing or handshake fails
+// CES discovery — CES_BOOTSTRAP_SOCKET_DIR, not workspace
 // ---------------------------------------------------------------------------
 
-describe("managed CES discovery", () => {
-  test("returns unavailable when bootstrap socket does not exist", async () => {
-    // In a non-containerized test environment, the managed socket path
-    // does not exist. Verify fail-closed behavior.
-    const saved = process.env["CES_BOOTSTRAP_SOCKET"];
+function withBootstrapDir(dir: string): () => void {
+  const savedDir = process.env["CES_BOOTSTRAP_SOCKET_DIR"];
+  process.env["CES_BOOTSTRAP_SOCKET_DIR"] = dir;
+  return () => {
+    if (savedDir !== undefined) {
+      process.env["CES_BOOTSTRAP_SOCKET_DIR"] = savedDir;
+    } else {
+      delete process.env["CES_BOOTSTRAP_SOCKET_DIR"];
+    }
+  };
+}
+
+describe("CES discovery", () => {
+  test("returns unavailable when bootstrap socket does not exist", () => {
+    const bootstrapDir = mkdtempSync(join(tmpdir(), "ces-missing-"));
+    const restore = withBootstrapDir(bootstrapDir);
     try {
-      // Point at a non-existent path to ensure predictable behavior
-      process.env["CES_BOOTSTRAP_SOCKET"] = "/tmp/ces-test-nonexistent.sock";
-      const result = await discoverManagedCes();
+      const result = discoverCes();
       expect(result.mode).toBe("unavailable");
       expect((result as { reason: string }).reason).toContain(
         "CES bootstrap socket not found",
       );
     } finally {
-      if (saved !== undefined) {
-        process.env["CES_BOOTSTRAP_SOCKET"] = saved;
-      } else {
-        delete process.env["CES_BOOTSTRAP_SOCKET"];
-      }
+      restore();
+      rmSync(bootstrapDir, { recursive: true, force: true });
     }
   });
 
-  test("never returns a fallback or in-process mode", async () => {
-    const saved = process.env["CES_BOOTSTRAP_SOCKET"];
+  test("never returns a fallback or in-process mode", () => {
+    const bootstrapDir = mkdtempSync(join(tmpdir(), "ces-missing-"));
+    const restore = withBootstrapDir(bootstrapDir);
     try {
-      process.env["CES_BOOTSTRAP_SOCKET"] = "/tmp/ces-test-nonexistent.sock";
-      const result = await discoverManagedCes();
-      // Must be "managed" or "unavailable" — no fallback modes.
+      const result = discoverCes();
       expect(["managed", "unavailable"]).toContain(result.mode);
     } finally {
-      if (saved !== undefined) {
-        process.env["CES_BOOTSTRAP_SOCKET"] = saved;
-      } else {
-        delete process.env["CES_BOOTSTRAP_SOCKET"];
-      }
+      restore();
+      rmSync(bootstrapDir, { recursive: true, force: true });
+    }
+  });
+});
+
+describe("CES bootstrap socket discovery", () => {
+  test("looks for the socket under CES_BOOTSTRAP_SOCKET_DIR", () => {
+    const bootstrapDir = mkdtempSync(join(tmpdir(), "ces-bootstrap-"));
+    const restore = withBootstrapDir(bootstrapDir);
+    try {
+      const socketPath = resolveIpcEndpoint("ces", {
+        workspaceDir: bootstrapDir,
+      }).path;
+      const result = discoverCes();
+      expect(result.mode).toBe("unavailable");
+      expect((result as { reason: string }).reason).toContain(socketPath);
+    } finally {
+      restore();
+      rmSync(bootstrapDir, { recursive: true, force: true });
+    }
+  });
+
+  test("does not discover CES from VELLUM_WORKSPACE_DIR", () => {
+    const bootstrapDir = mkdtempSync(join(tmpdir(), "ces-bootstrap-"));
+    const restore = withBootstrapDir(bootstrapDir);
+    try {
+      const result = discoverCes();
+      const workspaceDir = process.env.VELLUM_WORKSPACE_DIR;
+      expect(workspaceDir).toBeDefined();
+      const workspaceSocket = resolveIpcEndpoint("ces", {
+        workspaceDir: workspaceDir!,
+      }).path;
+      expect((result as { reason: string }).reason).not.toContain(
+        workspaceSocket,
+      );
+    } finally {
+      restore();
+      rmSync(bootstrapDir, { recursive: true, force: true });
     }
   });
 });
@@ -126,30 +166,9 @@ describe("managed CES discovery", () => {
 // ---------------------------------------------------------------------------
 
 describe("discoverCesWithRetry", () => {
-  function withManagedEnv(socketPath: string): () => void {
-    const savedSocket = process.env["CES_BOOTSTRAP_SOCKET"];
-    const savedSocketDir = process.env["CES_BOOTSTRAP_SOCKET_DIR"];
-    const savedContainerized = process.env["IS_CONTAINERIZED"];
-    delete process.env["CES_BOOTSTRAP_SOCKET_DIR"];
-    process.env["CES_BOOTSTRAP_SOCKET"] = socketPath;
-    process.env["IS_CONTAINERIZED"] = "true";
-    return () => {
-      const restore = (key: string, value: string | undefined) => {
-        if (value !== undefined) {
-          process.env[key] = value;
-        } else {
-          delete process.env[key];
-        }
-      };
-      restore("CES_BOOTSTRAP_SOCKET", savedSocket);
-      restore("CES_BOOTSTRAP_SOCKET_DIR", savedSocketDir);
-      restore("IS_CONTAINERIZED", savedContainerized);
-    };
-  }
-
   test("returns unavailable after polling when the socket never appears", async () => {
-    const socketPath = join(tmpdir(), `ces-retry-missing-${Date.now()}.sock`);
-    const restore = withManagedEnv(socketPath);
+    const bootstrapDir = mkdtempSync(join(tmpdir(), "ces-retry-missing-"));
+    const restore = withBootstrapDir(bootstrapDir);
     try {
       const start = Date.now();
       const result = await discoverCesWithRetry({
@@ -157,22 +176,19 @@ describe("discoverCesWithRetry", () => {
         intervalMs: 20,
       });
       expect(result.mode).toBe("unavailable");
-      // It must actually have waited rather than failing on the first probe.
       expect(Date.now() - start).toBeGreaterThanOrEqual(150);
     } finally {
       restore();
+      rmSync(bootstrapDir, { recursive: true, force: true });
     }
   });
 
   test("resolves to managed once the socket is re-bound mid-poll", async () => {
     const dir = mkdtempSync(join(tmpdir(), "ces-retry-"));
-    const socketPath = join(dir, "ces.sock");
-    const restore = withManagedEnv(socketPath);
+    const socketPath = resolveIpcEndpoint("ces", { workspaceDir: dir }).path;
+    const restore = withBootstrapDir(dir);
+    const timer = setTimeout(() => writeFileSync(socketPath, ""), 80);
     try {
-      // Simulate the sidecar re-binding its bootstrap socket shortly after
-      // the assistant begins probing.
-      setTimeout(() => writeFileSync(socketPath, ""), 80);
-
       const result = await discoverCesWithRetry({
         timeoutMs: 2_000,
         intervalMs: 20,
@@ -180,6 +196,7 @@ describe("discoverCesWithRetry", () => {
       expect(result.mode).toBe("managed");
       expect((result as { socketPath: string }).socketPath).toBe(socketPath);
     } finally {
+      clearTimeout(timer);
       restore();
       rmSync(dir, { recursive: true, force: true });
     }

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;