@vellumai/assistant 0.11.2 → 0.11.3-staging.2

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

@@ -9,7 +9,7 @@
 
 import { beforeEach, describe, expect, mock, spyOn, test } from "bun:test";
 
-import type { ToolSetupContext } from "../daemon/conversation-tool-setup.js";
+import type { Conversation } from "../daemon/conversation.js";
 import type { PermissionPrompter } from "../permissions/prompter.js";
 import type { SecretPrompter } from "../permissions/secret-prompter.js";
 import type { ToolExecutor } from "../tools/executor.js";
@@ -65,10 +65,12 @@ mock.module("../persistence/external-conversation-store.js", () => ({
 // ---------------------------------------------------------------------------
 
 import * as configLoader from "../config/loader.js";
+import { createSurfaceMutex } from "../daemon/conversation-surfaces.js";
 import {
   createToolExecutor,
   resolveConversationAttribution,
 } from "../daemon/conversation-tool-setup.js";
+import { asConversation } from "./helpers/mock-conversation.js";
 import { setConfig } from "./helpers/set-config.js";
 
 // ---------------------------------------------------------------------------
@@ -91,12 +93,13 @@ function makeGetConfigThrow(): ReturnType<typeof spyOn> {
   });
 }
 
-/** Build a minimal ToolSetupContext stub. */
-function makeCtx(overrides: Partial<ToolSetupContext> = {}): ToolSetupContext {
-  return {
+/** Build a minimal Conversation stub. */
+function makeCtx(overrides: Partial<Conversation> = {}): Conversation {
+  return asConversation({
     conversationId: "conv-test",
     currentRequestId: "req-1",
     workingDir: "/tmp/test",
+    getTurnActorPrincipalId: () => undefined,
     abortController: null,
     sendToClient: mock(() => {}),
     pendingSurfaceActions: new Map(),
@@ -110,9 +113,9 @@ function makeCtx(overrides: Partial<ToolSetupContext> = {}): ToolSetupContext {
     enqueueMessage: () => ({ queued: false, requestId: "r" }),
     getQueueDepth: () => 0,
     processMessage: async () => "",
-    withSurface: async <T>(_id: string, fn: () => T | Promise<T>) => fn(),
+    withSurface: createSurfaceMutex(),
     ...overrides,
-  };
+  });
 }
 
 /** Fake ToolExecutor that captures the context of each execute() call. */
@@ -138,7 +141,7 @@ const noopSecretPrompter = {
   prompt: mock(async () => ({ cancelled: true })),
 } as unknown as SecretPrompter;
 
-function makeToolFn(executor: ToolExecutor, ctx: ToolSetupContext) {
+function makeToolFn(executor: ToolExecutor, ctx: Conversation) {
   return createToolExecutor(executor, noopPrompter, noopSecretPrompter, ctx);
 }
 
@@ -400,3 +403,63 @@ describe("createToolExecutor channel-permission coordinate threading", () => {
     expect(bindingLookups).toEqual([]);
   });
 });
+
+describe("createToolExecutor source-actor threading", () => {
+  test("submits the turn's actor principal, not the trust context's guardian", async () => {
+    // `ToolContext.sourceActorPrincipalId` is compared against the principal a
+    // client registered with on its SSE stream, so it has to be the turn's
+    // actor. Reading `trustContext.guardianPrincipalId` instead meant any turn
+    // whose trust resolution degraded submitted nothing, and the same-actor
+    // gate rejected it as a user mismatch.
+    const { executor, calls } = makeCapturingExecutor();
+    await makeToolFn(
+      executor,
+      makeCtx({
+        getTurnActorPrincipalId: () => "actor-1",
+        currentTurnTrustContext: {
+          sourceChannel: "vellum",
+          trustClass: "guardian",
+          guardianPrincipalId: "guardian-1",
+        },
+      }),
+    )("file_read", { path: "/tmp/a" });
+
+    expect(calls[0].context.sourceActorPrincipalId).toBe("actor-1");
+  });
+
+  test("carries the actor through even when trust resolved without a guardian principal", async () => {
+    // The regression: degraded trust resolution (unreachable gateway, binding
+    // drift) or a service-principal turn leaves `guardianPrincipalId` unset
+    // while the turn's actor is perfectly well known.
+    const { executor, calls } = makeCapturingExecutor();
+    await makeToolFn(
+      executor,
+      makeCtx({
+        getTurnActorPrincipalId: () => "actor-1",
+        currentTurnTrustContext: {
+          sourceChannel: "vellum",
+          trustClass: "unknown",
+        },
+      }),
+    )("file_read", { path: "/tmp/a" });
+
+    expect(calls[0].context.sourceActorPrincipalId).toBe("actor-1");
+  });
+
+  test("submits nothing when the turn has no actor identity at all", async () => {
+    const { executor, calls } = makeCapturingExecutor();
+    await makeToolFn(
+      executor,
+      makeCtx({
+        getTurnActorPrincipalId: () => undefined,
+        currentTurnTrustContext: {
+          sourceChannel: "vellum",
+          trustClass: "guardian",
+          guardianPrincipalId: "guardian-1",
+        },
+      }),
+    )("file_read", { path: "/tmp/a" });
+
+    expect(calls[0].context.sourceActorPrincipalId).toBeUndefined();
+  });
+});

package/src/__tests__/conversation-wait-for-idle.test.ts

@@ -306,25 +306,20 @@ describe("Conversation.waitForIdle", () => {
     expect(second.value).toBe(true);
   });
 
-  test("a clear whose persisted write throws does not release waiters", async () => {
+  test("a clear whose persisted write throws still releases waiters", async () => {
     const conversation = makeConversation();
     conversation.setProcessing(true);
 
     const waiter = observe(conversation.waitForIdle({ timeoutMs: 60_000 }));
 
     failNextProcessingWrite = true;
-    expect(() => conversation.setProcessing(false)).toThrow(
-      "database is locked",
-    );
+    expect(() => conversation.setProcessing(false)).not.toThrow();
     await flushMicrotasks();
-    // The write failed, so the flag reverted to processing — the waiter must
-    // still be pending.
-    expect(conversation.isProcessing()).toBe(true);
-    expect(waiter.settled).toBe(false);
 
-    // The retried clear commits and releases the waiter.
-    conversation.setProcessing(false);
-    await flushMicrotasks();
+    // The persisted column is advisory and the boot-time stale-processing
+    // sweep recovers it; the in-memory flag is the release every waiter (voice
+    // barge-in, drain) is parked on, so it has to stick.
+    expect(conversation.isProcessing()).toBe(false);
     expect(waiter.value).toBe(true);
   });
 });

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

@@ -206,11 +206,12 @@ describe("credentials/prompt route", () => {
     expect(capturedMetadata?.usageDescription).toBeUndefined();
   });
 
-  test("stores a non-slack credential to secure storage without a message", async () => {
+  test("stores a non-slack credential to secure storage and reports the value as received", async () => {
     /**
      * The default delivery persists the value to secure storage and runs the
-     * manual-token connection sync, returning no message so the CLI prints its
-     * generic "Stored credential" line.
+     * manual-token connection sync. The message must name the outcome — the
+     * value is in hand — so a bare `ok: true` cannot be misread as "the prompt
+     * opened".
      */
     // GIVEN a standard store-delivery prompt for a non-slack credential
     // WHEN the route handles it
@@ -227,8 +228,55 @@ describe("credentials/prompt route", () => {
     // AND the manual token connection is synced for the service
     expect(syncedServices).toEqual(["stripe"]);
 
-    // AND no message is returned (the CLI falls back to its default line)
-    expect(result.message).toBeUndefined();
+    // AND the message reports the credential as received and stored
+    expect(result.message).toContain(
+      "Credential received from the user and stored as stripe/api_key.",
+    );
+  });
+
+  test("every successful outcome states that the prompt has closed", async () => {
+    /**
+     * The prompt blocks until answered, so a caller reads the result only after
+     * the secure input is gone. Without an explicit close signal a model
+     * follows up with "the prompt is open, paste it there" and the user
+     * re-submits into a surface that never reappears — the loop reported in
+     * the Aug 2026 Claude Code auth feedback. Every success path must say so,
+     * not just the plain vault write.
+     */
+    const closed =
+      "The secure prompt has closed — do not ask the user to enter this value again.";
+
+    // GIVEN a plain vault write
+    const stored = (await promptRoute!.handler({
+      body: { service: "stripe", field: "api_key", label: "Stripe API Key" },
+    })) as PromptResponse;
+
+    // THEN it reports the prompt as closed
+    expect(stored.message).toContain(closed);
+
+    // GIVEN a one-time send instead
+    secretResult = { value: "secret-value", delivery: "transient_send" };
+    const transient = (await promptRoute!.handler({
+      body: { service: "stripe", field: "api_key", label: "Stripe API Key" },
+    })) as PromptResponse;
+
+    // THEN it reports the prompt as closed too
+    expect(transient.message).toContain(closed);
+
+    // GIVEN a Slack channel token, whose status line owns the outcome summary
+    secretResult = { value: "secret-value", delivery: "store" };
+    slackConfigResult = slackResult({ connected: true, teamName: "Acme" });
+    const slack = (await promptRoute!.handler({
+      body: {
+        service: "slack_channel",
+        field: "bot_token",
+        label: "Slack Bot Token",
+      },
+    })) as PromptResponse;
+
+    // THEN the close notice rides along with the connection status
+    expect(slack.message).toContain("Slack channel connected to Acme.");
+    expect(slack.message).toContain(closed);
   });
 
   test("connects the channel when a slack_channel token is provided", async () => {
@@ -259,7 +307,9 @@ describe("credentials/prompt route", () => {
 
     // AND the connection status is surfaced as the response message
     expect(result.ok).toBe(true);
-    expect(result.message).toBe("Slack channel connected to Acme (@acmebot).");
+    expect(result.message).toContain(
+      "Slack channel connected to Acme (@acmebot).",
+    );
   });
 
   test("surfaces the warning when a slack_channel connection is incomplete", async () => {
@@ -284,7 +334,7 @@ describe("credentials/prompt route", () => {
 
     // THEN the warning is surfaced as the response message
     expect(result.ok).toBe(true);
-    expect(result.message).toBe(
+    expect(result.message).toContain(
       "Slack channel connection incomplete; provide the app token.",
     );
   });

package/src/__tests__/credential-security-invariants.test.ts

@@ -169,6 +169,7 @@ describe("Invariant 2: no generic plaintext secret read API", () => {
       "messaging/providers/telegram-bot/adapter.ts", // Telegram bot token lookup for connectivity check
       "messaging/providers/slack/api.ts", // Slack Web API client (bot token for direct sends)
       "messaging/providers/telegram-bot/api.ts", // Telegram Bot API client (bot token for direct sends)
+      "messaging/providers/discord/api.ts", // Discord REST client (bot token for direct sends)
       "runtime/channel-readiness-service.ts", // channel readiness probes for Telegram connectivity
       "telegram/webhook-health.ts", // Telegram webhook health sweep — reads bot_token to call getWebhookInfo (Bot API authenticates via the token in the URL path) and checks webhook_secret for existence only; neither value is logged, persisted, or returned
       "messaging/providers/whatsapp/adapter.ts", // WhatsApp credential lookup for connectivity check

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

@@ -7,11 +7,13 @@
 
 import { afterEach, describe, expect, mock, test } from "bun:test";
 
+import { asConversation } from "./helpers/mock-conversation.js";
+
 const sentMessages: unknown[] = [];
 let mockHasClient = true; // Default to true for CU unified flow tests
 // Default principal id used for both ctx.trustContext and clients in the
 // existing single-user tests. Tests that exercise cross-user behaviour
-// override this on individual clients and on the SurfaceConversationContext.
+// override this on individual clients and on the Conversation.
 const DEFAULT_PRINCIPAL = "user-1";
 let mockCuClients: Array<{
   clientId: string;
@@ -48,18 +50,17 @@ mock.module("../runtime/assistant-event-hub.js", () => ({
   },
 }));
 
-const { surfaceProxyResolver } =
+const { createSurfaceMutex, surfaceProxyResolver } =
   await import("../daemon/conversation-surfaces.js");
 const { HostCuProxy } = await import("../daemon/host-cu-proxy.js");
-type SurfaceConversationContext =
-  import("../daemon/conversation-surfaces.js").SurfaceConversationContext;
+type Conversation = import("../daemon/conversation.js").Conversation;
 
 // ---------------------------------------------------------------------------
 // Test helpers
 // ---------------------------------------------------------------------------
 
 /**
- * Build a minimal SurfaceConversationContext with optional hostCuProxy.
+ * Build a minimal Conversation with optional hostCuProxy.
  * Only the fields required by the CU routing path are populated.
  *
  * `trustContext` defaults to a guardian context owned by `DEFAULT_PRINCIPAL`.
@@ -70,8 +71,12 @@ function buildMockContext(
   hostCuProxy?: InstanceType<typeof HostCuProxy>,
   trustGuardianPrincipalId: string | null = DEFAULT_PRINCIPAL,
   actorPrincipalId: string | null = trustGuardianPrincipalId,
-): SurfaceConversationContext {
-  return {
+  // Mirrors `Conversation.ensureHostProxiesForTurn`: attaches a CU proxy when
+  // the gate passes. Left undefined to model a conversation that cannot
+  // attach one (the gate denies, or the context predates the hook).
+  ensureHostProxiesForTurn?: () => void,
+): Conversation {
+  const ctx: Conversation = asConversation({
     conversationId: "test-session",
     trustContext:
       trustGuardianPrincipalId != null
@@ -83,13 +88,13 @@ function buildMockContext(
         : undefined,
     authContext:
       actorPrincipalId != null
-        ? ({ actorPrincipalId } as SurfaceConversationContext["authContext"])
+        ? ({ actorPrincipalId } as Conversation["authContext"])
         : undefined,
     currentTurnAuthContext:
       actorPrincipalId != null
         ? ({
             actorPrincipalId,
-          } as SurfaceConversationContext["currentTurnAuthContext"])
+          } as Conversation["currentTurnAuthContext"])
         : undefined,
     sendToClient: () => {},
     pendingSurfaceActions: new Map(),
@@ -100,12 +105,15 @@ function buildMockContext(
     surfaceActionRequestIds: new Set(),
     currentTurnSurfaces: [],
     hostCuProxy,
+    transportInterface: "web",
+    ensureHostProxiesForTurn,
     isProcessing: () => false,
     enqueueMessage: () => ({ queued: false, requestId: "r1" }),
     getQueueDepth: () => 0,
     processMessage: async () => "",
-    withSurface: async (_id, fn) => fn(),
-  };
+    withSurface: createSurfaceMutex(),
+  });
+  return ctx;
 }
 
 // ---------------------------------------------------------------------------
@@ -115,7 +123,7 @@ function buildMockContext(
 describe("surfaceProxyResolver — CU tool routing", () => {
   let proxy: InstanceType<typeof HostCuProxy>;
 
-  function setupProxy(maxSteps?: number): SurfaceConversationContext {
+  function setupProxy(maxSteps?: number): Conversation {
     sentMessages.length = 0;
     mockHasClient = true;
     mockCuClients = [
@@ -137,21 +145,77 @@ describe("surfaceProxyResolver — CU tool routing", () => {
   // No desktop client connected
   // -------------------------------------------------------------------------
 
-  describe("no desktop client connected", () => {
-    test("returns error when hostCuProxy is undefined", async () => {
-      const ctx = buildMockContext(/* no proxy */);
-      const result = await surfaceProxyResolver(ctx, "computer_use_click", {
+  describe("attaching the proxy at tool-call time", () => {
+    test("attaches a proxy when the conversation has none and dispatches", async () => {
+      // The reported bug: `assistant clients list` showed the desktop
+      // connected and usable, while every computer_use_* call answered "no
+      // desktop client connected" — because attachment was decided at turn
+      // start, before the desktop was reachable, and never revisited.
+      sentMessages.length = 0;
+      mockHasClient = true;
+      mockCuClients = [
+        {
+          clientId: "mock-client-1",
+          capabilities: ["host_cu"],
+          actorPrincipalId: DEFAULT_PRINCIPAL,
+        },
+      ];
+
+      let attachCalls = 0;
+      const ctx: Conversation = buildMockContext(
+        /* no proxy */ undefined,
+        DEFAULT_PRINCIPAL,
+        DEFAULT_PRINCIPAL,
+        () => {
+          attachCalls++;
+          proxy = new HostCuProxy();
+          (ctx as { hostCuProxy?: unknown }).hostCuProxy = proxy;
+        },
+      );
+
+      const resultPromise = surfaceProxyResolver(ctx, "computer_use_click", {
         element_id: 42,
         reasoning: "click the button",
       });
 
+      expect(attachCalls).toBe(1);
+      expect(ctx.hostCuProxy).toBeDefined();
+      // Dispatched for real: the request reached the wire, not an error result.
+      expect(sentMessages).toHaveLength(1);
+      const sent = sentMessages[0] as { type?: string; requestId?: string };
+      expect(sent.type).toBe("host_cu_request");
+
+      proxy.processObservation(sent.requestId!, { axTree: "window Safari" });
+      const result = await resultPromise;
+      expect(result.isError).toBe(false);
+    });
+
+    test("reports the interface, not a missing desktop, when the gate still denies", async () => {
+      // The gate ran and refused (e.g. a chrome-extension source, or a
+      // desktop signed in as someone else). Saying "no desktop client
+      // connected" here contradicts a listing that plainly shows one.
+      mockCuClients = [
+        {
+          clientId: "mock-client-other",
+          capabilities: ["host_cu"],
+          actorPrincipalId: "someone-else",
+        },
+      ];
+      const ctx = buildMockContext(/* no proxy, no attach hook */);
+      const result = await surfaceProxyResolver(
+        ctx,
+        "computer_use_screenshot",
+        {},
+      );
+
       expect(result.isError).toBe(true);
-      expect(result.content).toContain("not available");
-      expect(result.content).toContain("no desktop client");
+      expect(result.content).toContain("not available for this conversation");
+      expect(result.content).not.toContain("no desktop client connected");
     });
 
-    test("returns error for screenshot tool when no proxy", async () => {
-      const ctx = buildMockContext();
+    test("reports no connected client when the hub has none", async () => {
+      mockCuClients = [];
+      const ctx = buildMockContext(/* no proxy */);
       const result = await surfaceProxyResolver(
         ctx,
         "computer_use_screenshot",
@@ -159,11 +223,12 @@ describe("surfaceProxyResolver — CU tool routing", () => {
       );
 
       expect(result.isError).toBe(true);
-      expect(result.content).toContain("not available");
+      expect(result.content).toContain("no desktop client connected");
     });
 
     test("returns error when proxy exists but client not connected", async () => {
       mockHasClient = false;
+      mockCuClients = [];
       const proxyObj = new HostCuProxy();
       const ctx = buildMockContext(proxyObj);
       const result = await surfaceProxyResolver(ctx, "computer_use_click", {
@@ -171,7 +236,7 @@ describe("surfaceProxyResolver — CU tool routing", () => {
       });
 
       expect(result.isError).toBe(true);
-      expect(result.content).toContain("not available");
+      expect(result.content).toContain("no desktop client connected");
       proxyObj.dispose();
     });
 
@@ -640,9 +705,7 @@ describe("surfaceProxyResolver — CU tool routing", () => {
       });
 
       expect(result.isError).toBe(true);
-      expect(result.content).toContain(
-        "Submitting actor does not match the target client's actor",
-      );
+      expect(result.content).toContain("signed in as a different user");
       // No state mutation, no dispatch.
       expect(proxy.stepCount).toBe(0);
       expect(proxy.actionHistory).toHaveLength(0);
@@ -669,9 +732,7 @@ describe("surfaceProxyResolver — CU tool routing", () => {
       });
 
       expect(result.isError).toBe(true);
-      expect(result.content).toContain(
-        "Submitting actor does not match the target client's actor",
-      );
+      expect(result.content).toContain("no authenticated actor");
       expect(sentMessages).toHaveLength(0);
     });
 

package/src/__tests__/custom-group-listing-visibility.test.ts

@@ -33,7 +33,7 @@ describe("custom-group standard-listing visibility", () => {
   });
 
   function listedIds(): string[] {
-    return listConversations(undefined, "standard").map((c) => c.id);
+    return listConversations({ conversationType: "standard" }).map((c) => c.id);
   }
 
   test("scheduled conversation in a custom group is listed", () => {

package/src/__tests__/db-schedule-syntax-migration.test.ts

@@ -58,7 +58,10 @@ describe("schedule_syntax column migration", () => {
         capabilities_json TEXT,
         description TEXT NOT NULL DEFAULT '',
         created_at INTEGER NOT NULL,
-        updated_at INTEGER NOT NULL
+        updated_at INTEGER NOT NULL,
+        source_key TEXT,
+        definition_hash TEXT,
+        user_enabled INTEGER
       )
     `);