@vellumai/assistant 0.8.6 → 0.8.7-dev.202606052118.34cd356

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

@@ -62,22 +62,13 @@ function makeContext(sent: ServerMessage[] = []): SurfaceConversationContext & {
     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,
-    ) => {
+    processMessage: async (options) => {
       processMessageCalls.push({
-        content,
-        attachments,
-        requestId,
-        activeSurfaceId,
-        displayContent,
+        content: options.content,
+        attachments: options.attachments,
+        requestId: options.requestId,
+        activeSurfaceId: options.activeSurfaceId,
+        displayContent: options.displayContent,
       });
       return "msg-1";
     },
@@ -375,6 +366,90 @@ describe("surface action delivery to assistant", () => {
     expect(JSON.stringify(completeMsg)).not.toContain(largeBase64);
   });
 
+  test("choice surface broadcasts ui_surface_complete on action", async () => {
+    const sent: ServerMessage[] = [];
+    const ctx = makeContext(sent);
+
+    const showResult = await surfaceProxyResolver(ctx, "ui_show", {
+      surface_type: "choice",
+      title: "Pick an outcome",
+      data: {
+        options: [
+          { id: "inbox", title: "Clean up my inbox" },
+          { id: "calendar", title: "Plan my week" },
+        ],
+      },
+    });
+
+    expect(showResult.isError).toBe(false);
+    expect(showResult.yieldToUser).toBe(true);
+
+    const showMessage = sent.find(
+      (msg): msg is UiSurfaceShow => msg.type === "ui_surface_show",
+    ) as UiSurfaceShow;
+    const surfaceId = showMessage.surfaceId;
+    expect(ctx.pendingSurfaceActions.has(surfaceId)).toBe(true);
+
+    await handleSurfaceAction(ctx, surfaceId, "inbox", {
+      choiceId: "inbox",
+      choiceTitle: "Clean up my inbox",
+      selectedIds: ["inbox"],
+      selectedTitles: ["Clean up my inbox"],
+    });
+
+    const completeMsg = broadcastedMessages.find(
+      (m) =>
+        (m as unknown as Record<string, unknown>).type ===
+          "ui_surface_complete" &&
+        (m as unknown as Record<string, unknown>).surfaceId === surfaceId,
+    ) as unknown as Record<string, unknown> | undefined;
+    expect(completeMsg).toBeDefined();
+    expect(completeMsg?.conversationId).toBe("conv-1");
+    expect(completeMsg?.summary).toBe('User chose: "Clean up my inbox"');
+    expect(ctx.pendingSurfaceActions.has(surfaceId)).toBe(false);
+  });
+
+  test("oauth_connect surface broadcasts ui_surface_complete on action", async () => {
+    const sent: ServerMessage[] = [];
+    const ctx = makeContext(sent);
+
+    const showResult = await surfaceProxyResolver(ctx, "ui_show", {
+      surface_type: "oauth_connect",
+      title: "Connect Google",
+      data: {
+        providerKey: "google",
+        displayName: "Google",
+      },
+    });
+
+    expect(showResult.isError).toBe(false);
+    expect(showResult.yieldToUser).toBe(true);
+
+    const showMessage = sent.find(
+      (msg): msg is UiSurfaceShow => msg.type === "ui_surface_show",
+    ) as UiSurfaceShow;
+    const surfaceId = showMessage.surfaceId;
+    expect(ctx.pendingSurfaceActions.has(surfaceId)).toBe(true);
+
+    await handleSurfaceAction(ctx, surfaceId, "connect", {
+      status: "connected",
+      providerKey: "google",
+      providerLabel: "Google",
+      accountLabel: "user@example.com",
+    });
+
+    const completeMsg = broadcastedMessages.find(
+      (m) =>
+        (m as unknown as Record<string, unknown>).type ===
+          "ui_surface_complete" &&
+        (m as unknown as Record<string, unknown>).surfaceId === surfaceId,
+    ) as unknown as Record<string, unknown> | undefined;
+    expect(completeMsg).toBeDefined();
+    expect(completeMsg?.conversationId).toBe("conv-1");
+    expect(completeMsg?.summary).toBe("Connected Google: user@example.com");
+    expect(ctx.pendingSurfaceActions.has(surfaceId)).toBe(false);
+  });
+
   test("table surface does NOT broadcast ui_surface_complete (not one-shot)", async () => {
     const sent: ServerMessage[] = [];
     const ctx = makeContext(sent);

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

@@ -216,6 +216,34 @@ describe("surfaceProxyResolver — app-control tool routing", () => {
 
       proxy.dispose();
     });
+
+    test("app_control_observe rejects when only another actor has a capable client", async () => {
+      mockHubClients = [
+        {
+          clientId: "client-other",
+          capabilities: ["host_app_control"],
+          actorPrincipalId: "user-other",
+        },
+      ];
+      const proxy = new HostAppControlProxy("conv-1");
+      const ctx = buildMockContext(proxy, "conv-1");
+      _setActiveAppControlSession({
+        conversationId: "conv-1",
+        app: "com.example.editor",
+      });
+
+      const result = await surfaceProxyResolver(ctx, "app_control_observe", {
+        tool: "observe",
+        app: "com.example.editor",
+      });
+
+      expect(result.isError).toBe(true);
+      expect(result.content).toContain("current actor");
+      // No envelope dispatched.
+      expect(sentMessages).toHaveLength(0);
+
+      proxy.dispose();
+    });
   });
 
   // -------------------------------------------------------------------------
@@ -496,7 +524,7 @@ describe("surfaceProxyResolver — app-control tool routing", () => {
 
       expect(result.isError).toBe(true);
       expect(result.content).toContain(
-        "multiple clients support host_app_control",
+        "Multiple host_app_control clients",
       );
       expect(result.content).toContain("target_client_id");
       // No envelope dispatched.
@@ -566,9 +594,9 @@ describe("surfaceProxyResolver — app-control tool routing", () => {
 
       expect(sentMessages).toHaveLength(1);
       const sent = sentMessages[0] as Record<string, unknown>;
-      // No cross-user ambiguity → resolver leaves targetClientId undefined,
-      // letting the proxy use its existing single-client routing.
-      expect(sent.targetClientId).toBeUndefined();
+      // Single same-user client → auto-resolved by pickSameUserAutoResolve.
+      // targetClientId may be set to the resolved client id.
+      expect(sent.type).toBe("host_app_control_request");
 
       proxy.resolve(sent.requestId as string, {
         requestId: "ignored-by-proxy",

package/src/__tests__/conversation-surfaces-state-update.test.ts

@@ -51,8 +51,11 @@ function makeContext(opts?: {
       return { queued: false, requestId: resolvedId };
     },
     getQueueDepth: () => 0,
-    processMessage: async (content, _attachments, _onEvent, requestId) => {
-      processCalls.push({ content, requestId });
+    processMessage: async (options) => {
+      processCalls.push({
+        content: options.content,
+        requestId: options.requestId,
+      });
       return "ok";
     },
     withSurface: createSurfaceMutex(),

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

@@ -75,22 +75,13 @@ function makeContext(): SurfaceConversationContext & {
       return { queued: false, requestId: options.requestId ?? "enq-req" };
     },
     getQueueDepth: () => 0,
-    processMessage: async (
-      content,
-      attachments,
-      _onEvent,
-      requestId,
-      surfaceId,
-      _currentPage,
-      _options,
-      displayContent,
-    ) => {
+    processMessage: async (options) => {
       processCalls.push({
-        content,
-        requestId,
-        attachments,
-        surfaceId,
-        displayContent,
+        content: options.content,
+        requestId: options.requestId,
+        attachments: options.attachments,
+        surfaceId: options.activeSurfaceId,
+        displayContent: options.displayContent,
       });
       return "ok";
     },

package/src/__tests__/conversation-sync-tags.test.ts

@@ -1,5 +1,3 @@
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
 import { afterAll, beforeEach, describe, expect, test } from "bun:test";
 
 import {
@@ -18,6 +16,7 @@ import { assistantEventHub } from "../runtime/assistant-event-hub.js";
 import { ROUTES as CONVERSATION_LIST_ROUTES } from "../runtime/routes/conversation-list-routes.js";
 import { ROUTES as CONVERSATION_MANAGEMENT_ROUTES } from "../runtime/routes/conversation-management-routes.js";
 import type { RouteDefinition } from "../runtime/routes/types.js";
+import { publishConversationTitleChanged } from "../runtime/sync/resource-sync-events.js";
 import { resetDbForTesting } from "./db-test-helpers.js";
 import { waitFor } from "./helpers/wait-for.js";
 
@@ -122,20 +121,33 @@ describe("conversation sync tags", () => {
     ).toBe(false);
   });
 
-  test("agent-loop title updates emit metadata-only sync tags (no list umbrella)", () => {
-    const source = readFileSync(
-      join(import.meta.dir, "..", "daemon", "conversation-agent-loop.ts"),
-      "utf-8",
+  test("auto-title generation emits the typed title event and a metadata-only sync tag (no list umbrella)", async () => {
+    // Auto-title generation (first-pass on prompt submit, second-pass
+    // regeneration, bootstrap, and voice) persists via the title service and
+    // broadcasts through `publishConversationTitleChanged` — the same helper
+    // the rename route uses. Like a rename, generation is content-only: the
+    // row stays in place and only the title flips, so web patches the cached
+    // row from the typed `conversation_title_updated` event and the per-
+    // conversation metadata tag is the belt-and-suspenders signal. The list
+    // umbrella is deliberately omitted so web never redrains the paginated
+    // list for a title change.
+    const conversation = createConversation("Generating…");
+
+    const received = await captureEvents(() => {
+      publishConversationTitleChanged(conversation.id, "Generated title");
+    }, 2);
+
+    expect(received.map((event) => event.message.type)).toEqual([
+      "conversation_title_updated",
+      "sync_changed",
+    ]);
+    expect(received[1]!.message).toEqual({
+      type: "sync_changed",
+      tags: [conversationMetadataSyncTag(conversation.id)],
+    });
+    expect((received[1]!.message as { tags: string[] }).tags).not.toContain(
+      SYNC_TAGS.conversationsList,
     );
-    const titleUpdateBlocks =
-      source.match(
-        /type: "conversation_title_updated"[\s\S]{0,500}?type: "sync_changed"[\s\S]{0,250}?tags: \[[\s\S]*?\]/g,
-      ) ?? [];
-
-    expect(titleUpdateBlocks.length).toBeGreaterThanOrEqual(2);
-    for (const block of titleUpdateBlocks) {
-      expect(block).not.toContain("SYNC_TAGS.conversationsList");
-    }
   });
 
   test("create emits a sync_changed with the conversationsList umbrella tag", async () => {

package/src/__tests__/conversation-title-service.test.ts

@@ -51,9 +51,18 @@ mock.module("../util/logger.js", () => ({
     }),
 }));
 
+const mockPublishConversationTitleChanged = mock(
+  (_conversationId: string, _title: string) => {},
+);
+mock.module("../runtime/sync/resource-sync-events.js", () => ({
+  publishConversationTitleChanged: mockPublishConversationTitleChanged,
+}));
+
 import {
   generateAndPersistConversationTitle,
+  queueGenerateConversationTitle,
   regenerateConversationTitle,
+  titleMutex,
 } from "../memory/conversation-title-service.js";
 
 describe("conversation-title-service", () => {
@@ -63,6 +72,7 @@ describe("conversation-title-service", () => {
     mockGetMessages.mockClear();
     mockUpdateConversationTitle.mockClear();
     mockGetConfiguredProvider.mockClear();
+    mockPublishConversationTitleChanged.mockClear();
   });
 
   test("uses the BTW side-chain helper for initial title generation", async () => {
@@ -87,7 +97,7 @@ describe("conversation-title-service", () => {
         systemPrompt: expect.stringContaining("conversation titles"),
         tools: [],
         callSite: "conversationTitle",
-        timeoutMs: 10_000,
+        timeoutMs: 15_000,
       }),
     );
     expect(mockUpdateConversationTitle).toHaveBeenCalledWith(
@@ -95,6 +105,12 @@ describe("conversation-title-service", () => {
       "Project kickoff",
       1,
     );
+    // Emit is service-native: persisting a title broadcasts the update so
+    // every title origin (agent loop, bootstrap, voice) updates clients live.
+    expect(mockPublishConversationTitleChanged).toHaveBeenCalledWith(
+      "conv-1",
+      "Project kickoff",
+    );
   });
 
   test("regeneration extracts text from JSON content blocks", async () => {
@@ -205,7 +221,7 @@ describe("conversation-title-service", () => {
         systemPrompt: expect.stringContaining("conversation titles"),
         tools: [],
         callSite: "conversationTitle",
-        timeoutMs: 10_000,
+        timeoutMs: 15_000,
       }),
     );
     expect(mockUpdateConversationTitle).toHaveBeenCalledWith(
@@ -354,4 +370,121 @@ describe("conversation-title-service", () => {
     expect(call.content).not.toContain("do NOT respond");
     expect(call.systemPrompt).toContain("Do NOT respond");
   });
+
+  test("queueGenerateConversationTitle serializes concurrent calls", async () => {
+    const callOrder: string[] = [];
+    let resolveFirst!: () => void;
+    const firstBlocked = new Promise<void>((r) => {
+      resolveFirst = r;
+    });
+
+    // First call: blocks until we release it
+    mockRunBtwSidechain.mockImplementationOnce(async () => {
+      callOrder.push("first:start");
+      await firstBlocked;
+      callOrder.push("first:end");
+      return {
+        text: "Title One",
+        hadTextDeltas: true,
+        response: {
+          content: [{ type: "text", text: "Title One" }],
+          model: "test-model",
+          usage: { inputTokens: 10, outputTokens: 5 },
+          stopReason: "end_turn",
+        },
+      };
+    });
+
+    // Second call: resolves immediately
+    mockRunBtwSidechain.mockImplementationOnce(async () => {
+      callOrder.push("second:start");
+      return {
+        text: "Title Two",
+        hadTextDeltas: true,
+        response: {
+          content: [{ type: "text", text: "Title Two" }],
+          model: "test-model",
+          usage: { inputTokens: 10, outputTokens: 5 },
+          stopReason: "end_turn",
+        },
+      };
+    });
+
+    const provider = {
+      name: "test-provider",
+      sendMessage: mock(async () => {
+        throw new Error("should not call directly");
+      }),
+    };
+
+    // Fire both calls — without serialization both would start immediately
+    queueGenerateConversationTitle({
+      conversationId: "conv-1",
+      provider,
+      userMessage: "first message",
+    });
+    queueGenerateConversationTitle({
+      conversationId: "conv-2",
+      provider,
+      userMessage: "second message",
+    });
+
+    // Let microtasks settle — only the first call should have started
+    await new Promise((r) => setTimeout(r, 10));
+    expect(callOrder).toEqual(["first:start"]);
+
+    // Release the first call
+    resolveFirst();
+    await titleMutex.withLock(async () => {});
+
+    // Second should have started only after first finished
+    expect(callOrder).toEqual(["first:start", "first:end", "second:start"]);
+  });
+
+  test("queue continues processing after a failed call", async () => {
+    // First call: throws
+    mockRunBtwSidechain.mockImplementationOnce(async () => {
+      throw new Error("provider timeout");
+    });
+
+    // Second call: succeeds
+    mockRunBtwSidechain.mockImplementationOnce(async () => ({
+      text: "Recovery Title",
+      hadTextDeltas: true,
+      response: {
+        content: [{ type: "text", text: "Recovery Title" }],
+        model: "test-model",
+        usage: { inputTokens: 10, outputTokens: 5 },
+        stopReason: "end_turn",
+      },
+    }));
+
+    const provider = {
+      name: "test-provider",
+      sendMessage: mock(async () => {
+        throw new Error("should not call directly");
+      }),
+    };
+
+    queueGenerateConversationTitle({
+      conversationId: "conv-1",
+      provider,
+      userMessage: "will fail",
+    });
+    queueGenerateConversationTitle({
+      conversationId: "conv-2",
+      provider,
+      userMessage: "will succeed",
+    });
+
+    await titleMutex.withLock(async () => {});
+
+    // Both calls went through — failure didn't break the chain
+    expect(mockRunBtwSidechain).toHaveBeenCalledTimes(2);
+    // Second conversation got a proper title
+    const secondUpdate = (
+      mockUpdateConversationTitle.mock.calls as unknown as string[][]
+    ).find((c) => c[0] === "conv-2" && c[1] === "Recovery Title");
+    expect(secondUpdate).toBeTruthy();
+  });
 });

package/src/__tests__/conversation-tool-setup-app-refresh.test.ts

@@ -14,6 +14,7 @@ import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 import type { ToolSetupContext } from "../daemon/conversation-tool-setup.js";
 import type { SurfaceData, SurfaceType } from "../daemon/message-protocol.js";
+import { SYNC_TAGS } from "../daemon/message-types/sync.js";
 import type { PermissionPrompter } from "../permissions/prompter.js";
 import type { SecretPrompter } from "../permissions/secret-prompter.js";
 import type { ToolExecutor } from "../tools/executor.js";
@@ -71,6 +72,19 @@ import { createToolExecutor } from "../daemon/conversation-tool-setup.js";
 // Helpers
 // ---------------------------------------------------------------------------
 
+function broadcastPayloads(): unknown[] {
+  return (broadcastSpy.mock.calls as unknown[][]).map(([payload]) => payload);
+}
+
+function expectAppChangeBroadcast(appId: string): void {
+  expect(broadcastPayloads()).toEqual(
+    expect.arrayContaining([
+      { type: "app_files_changed", appId },
+      { type: "sync_changed", tags: [SYNC_TAGS.appsList] },
+    ]) as never,
+  );
+}
+
 /** Build a minimal ToolSetupContext stub. */
 function makeCtx(overrides: Partial<ToolSetupContext> = {}): ToolSetupContext {
   return {
@@ -167,11 +181,8 @@ describe("session-tool-setup app refresh side effects", () => {
 
       await toolFn("app_refresh", { app_id: "app-42" });
 
-      expect(broadcastSpy).toHaveBeenCalledTimes(1);
-      expect((broadcastSpy.mock.calls as unknown[][])[0][0]).toEqual({
-        type: "app_files_changed",
-        appId: "app-42",
-      });
+      expect(broadcastSpy).toHaveBeenCalledTimes(2);
+      expectAppChangeBroadcast("app-42");
     });
 
     test("calls updatePublishedAppDeployment", async () => {
@@ -262,6 +273,7 @@ describe("session-tool-setup app refresh side effects", () => {
         type: "app_files_changed",
         appId: "new-app-1",
       });
+      expectAppChangeBroadcast("new-app-1");
     });
 
     test("canonicalizes create_app skill_execute alias before hooks run", async () => {
@@ -293,6 +305,7 @@ describe("session-tool-setup app refresh side effects", () => {
         type: "app_files_changed",
         appId: "alias-app-1",
       });
+      expectAppChangeBroadcast("alias-app-1");
     });
 
     test("canonicalizes legacy computer_use_press_key skill_execute alias before dispatch", async () => {
@@ -403,6 +416,7 @@ describe("session-tool-setup app refresh side effects", () => {
         type: "app_files_changed",
         appId: "new-app-err",
       });
+      expectAppChangeBroadcast("new-app-err");
       expect(updatePublishedSpy).toHaveBeenCalledTimes(1);
     });
   });
@@ -424,11 +438,8 @@ describe("session-tool-setup app refresh side effects", () => {
 
       await toolFn("app_delete", { app_id: "del-app-1" });
 
-      expect(broadcastSpy).toHaveBeenCalledTimes(1);
-      expect((broadcastSpy.mock.calls as unknown[][])[0][0]).toEqual({
-        type: "app_files_changed",
-        appId: "del-app-1",
-      });
+      expect(broadcastSpy).toHaveBeenCalledTimes(2);
+      expectAppChangeBroadcast("del-app-1");
     });
 
     test("skips side effects when app_delete result is an error", async () => {
@@ -480,7 +491,8 @@ describe("session-tool-setup app refresh side effects", () => {
         });
 
         expect(refreshSpy).toHaveBeenCalledTimes(1);
-        expect(broadcastSpy).toHaveBeenCalledTimes(1);
+        expect(broadcastSpy).toHaveBeenCalledTimes(2);
+        expectAppChangeBroadcast("skill-app");
         expect(updatePublishedSpy).toHaveBeenCalledTimes(1);
       }
     });

package/src/__tests__/conversation-unread-route.test.ts

@@ -31,7 +31,19 @@ mock.module("../memory/conversation-key-store.js", () => ({
   resolveConversationId: (id: string) => id,
 }));
 
-import { getPolicy } from "../runtime/auth/route-policy.js";
+import { ROUTES } from "../runtime/routes/index.js";
+
+/**
+ * Look up the policy on a route by endpoint+method. Returns null when
+ * the route isn't found or has no policy declared — both surface as
+ * test failures via the explicit assertion below.
+ */
+function routePolicy(endpoint: string, method?: string) {
+  const route = ROUTES.find(
+    (r) => r.endpoint === endpoint && (!method || r.method === method),
+  );
+  return route?.policy ?? null;
+}
 import { RuntimeHttpServer } from "../runtime/http-server.js";
 import { UserError } from "../util/errors.js";
 
@@ -62,7 +74,7 @@ describe("POST /v1/conversations/unread", () => {
   }
 
   test("registers the unread route with chat.write policy", () => {
-    expect(getPolicy("conversations/unread")).toEqual({
+    expect(routePolicy("conversations/unread")).toEqual({
       requiredScopes: ["chat.write"],
       allowedPrincipalTypes: ["actor", "svc_gateway", "svc_daemon", "local"],
     });

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

@@ -284,8 +284,6 @@ describe("recordUsage", () => {
 
     await wrapped.sendMessage(
       [{ role: "user", content: [{ type: "text", text: "Hello" }] }],
-      undefined,
-      undefined,
       {
         config: {
           callSite: "mainAgent",

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

@@ -94,7 +94,7 @@ describe("wipeConversation", () => {
 
   test("cancels pending memory jobs", async () => {
     const conv = createConversation("test");
-    await addMessage(conv.id, "user", "hello", undefined, {
+    await addMessage(conv.id, "user", "hello", {
       skipIndexing: true,
     });