@vellumai/assistant 0.7.0 → 0.7.2

package/src/__tests__/conversation-process-app-control-preactivation.test.ts

@@ -0,0 +1,283 @@
+/**
+ * Verifies that the queue-drain paths in `conversation-process.ts` re-add
+ * the `app-control` skill to the conversation's preactivated set when the
+ * dequeued message's `userMessageInterface` supports the `host_app_control`
+ * proxy capability.
+ *
+ * Both `drainSingleMessage` (single-message path) and `drainBatch`
+ * (batched path) reset `preactivatedSkillIds = undefined` at the top of
+ * each drain. Without an explicit re-add, queued messages 2+ would lose
+ * the `app-control` skill — its tools wouldn't be projected to the LLM —
+ * even though the `HostAppControlProxy` is still attached to the
+ * conversation. This mirrors the existing parallel re-add for
+ * `computer-use` and uses the same `supportsHostProxy(_, "host_app_control")`
+ * gate that `prepareConversationForMessage` and the `conversation-routes`
+ * instantiation block use at first-message time.
+ */
+
+import { describe, expect, mock, test } from "bun:test";
+
+// ---------------------------------------------------------------------------
+// Module mocks for downstream side effects (DB writes, slash resolution,
+// notification preference extraction). The drain paths must be allowed to
+// reach the preactivation block; they must not be allowed to touch a real DB.
+// ---------------------------------------------------------------------------
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, { get: () => () => {} }),
+}));
+
+mock.module("../memory/conversation-crud.js", () => ({
+  setConversationOriginChannelIfUnset: () => {},
+  setConversationOriginInterfaceIfUnset: () => {},
+  provenanceFromTrustContext: () => ({
+    source: "user",
+    trustContext: undefined,
+  }),
+  addMessage: () => ({ id: "msg-mock" }),
+}));
+
+mock.module("../memory/canonical-guardian-store.js", () => ({
+  listPendingRequestsByConversationScope: () => [],
+}));
+
+mock.module("../memory/trace-event-store.js", () => ({
+  persistTraceEvent: () => {},
+  getMaxSequence: () => 0,
+}));
+
+mock.module("../notifications/preference-extractor.js", () => ({
+  extractPreferences: async () => ({ detected: false, preferences: [] }),
+}));
+
+mock.module("../notifications/preferences-store.js", () => ({
+  createPreference: () => {},
+}));
+
+mock.module("../agent/attachments.ts", () => ({
+  enrichMessageWithSourcePaths: <T>(msg: T) => msg,
+}));
+
+// Stub the batched-drain helper so the test doesn't fall through to real
+// SQLite paths after the preactivation block has already run. The drain
+// chain doesn't recurse here because our stubbed `runAgentLoop` is a no-op.
+mock.module("../daemon/conversation-messaging.js", () => ({
+  persistQueuedMessageBody: async () => "user-msg-id",
+}));
+
+// ---------------------------------------------------------------------------
+// Imports under test (after mocks)
+// ---------------------------------------------------------------------------
+
+import type { TurnInterfaceContext } from "../channels/types.js";
+import type { ProcessConversationContext } from "../daemon/conversation-process.js";
+import { drainQueue } from "../daemon/conversation-process.js";
+import {
+  MessageQueue,
+  type QueuedMessage,
+} from "../daemon/conversation-queue-manager.js";
+import { TraceEmitter } from "../daemon/trace-emitter.js";
+
+// ---------------------------------------------------------------------------
+// Fake context — captures preactivation calls, satisfies the bare minimum
+// of `ProcessConversationContext`. `runAgentLoop` resolves immediately so
+// the drain-chain does not recurse forever.
+// ---------------------------------------------------------------------------
+
+interface FakeRecord {
+  preactivatedSkillIdCalls: string[];
+}
+
+function makeFakeContext(opts: {
+  queue: MessageQueue;
+  turnInterfaceContext?: TurnInterfaceContext;
+}): ProcessConversationContext & FakeRecord {
+  const calls: string[] = [];
+  let preactivatedSkillIds: string[] | undefined = undefined;
+  const ctx = {
+    conversationId: "conv-app-control-preactivation",
+    messages: [],
+    processing: false,
+    abortController: null,
+    queue: opts.queue,
+    traceEmitter: new TraceEmitter("conv-app-control-preactivation", () => {}),
+    surfaceActionRequestIds: new Set<string>(),
+    usageStats: { inputTokens: 0, outputTokens: 0, estimatedCost: 0 },
+    get preactivatedSkillIds(): string[] | undefined {
+      return preactivatedSkillIds;
+    },
+    set preactivatedSkillIds(value: string[] | undefined) {
+      preactivatedSkillIds = value;
+    },
+    preactivatedSkillIdCalls: calls,
+    addPreactivatedSkillId(id: string) {
+      calls.push(id);
+      if (!preactivatedSkillIds) {
+        preactivatedSkillIds = [id];
+      } else if (!preactivatedSkillIds.includes(id)) {
+        preactivatedSkillIds.push(id);
+      }
+    },
+    async ensureActorScopedHistory() {},
+    async persistUserMessage() {
+      return "user-msg-id";
+    },
+    async runAgentLoop() {
+      // No-op: the drain path's finally block would normally call drainQueue
+      // recursively. We intentionally do not chain another drain here so the
+      // test asserts on what the FIRST dequeue produced.
+    },
+    getTurnChannelContext: () => null,
+    setTurnChannelContext() {},
+    getTurnInterfaceContext: () => opts.turnInterfaceContext ?? null,
+    setTurnInterfaceContext() {},
+    emitActivityState() {},
+    async forceCompact() {
+      return {
+        compacted: false,
+        reason: "no-op",
+        estimatedInputTokens: 0,
+        previousEstimatedInputTokens: 0,
+        maxInputTokens: 100000,
+        compactedMessages: 0,
+      } as never;
+    },
+    setTransportHints() {},
+    applyHostEnvFromTransport() {},
+  } as unknown as ProcessConversationContext & FakeRecord;
+  return ctx;
+}
+
+function makeQueuedMessage(opts: {
+  requestId: string;
+  content?: string;
+  turnInterfaceContext?: TurnInterfaceContext;
+}): QueuedMessage {
+  return {
+    content: opts.content ?? "follow up",
+    attachments: [],
+    requestId: opts.requestId,
+    onEvent: () => {},
+    metadata: {},
+    sentAt: Date.now(),
+    turnInterfaceContext: opts.turnInterfaceContext,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("drainQueue preactivation re-add for host-proxy interfaces", () => {
+  test("drainSingleMessage re-adds 'app-control' for macOS-sourced queued message", async () => {
+    const queue = new MessageQueue();
+    const ifCtx: TurnInterfaceContext = {
+      userMessageInterface: "macos",
+      assistantMessageInterface: "macos",
+    };
+    queue.push(
+      makeQueuedMessage({ requestId: "req-2", turnInterfaceContext: ifCtx }),
+    );
+    const ctx = makeFakeContext({ queue, turnInterfaceContext: ifCtx });
+
+    await drainQueue(ctx);
+
+    // Both CU and app-control must be re-preactivated for queued macOS turns.
+    expect(ctx.preactivatedSkillIdCalls).toContain("computer-use");
+    expect(ctx.preactivatedSkillIdCalls).toContain("app-control");
+    expect(ctx.preactivatedSkillIds).toContain("app-control");
+  });
+
+  test("drainSingleMessage does not re-add 'app-control' for chrome-extension (host_app_control unsupported)", async () => {
+    const queue = new MessageQueue();
+    // chrome-extension supports host_browser but NOT host_app_control. The
+    // CU re-add (no-arg form) also returns false for chrome-extension, so
+    // neither skill should be re-preactivated.
+    const ifCtx: TurnInterfaceContext = {
+      userMessageInterface: "chrome-extension",
+      assistantMessageInterface: "chrome-extension",
+    };
+    queue.push(
+      makeQueuedMessage({ requestId: "req-2", turnInterfaceContext: ifCtx }),
+    );
+    const ctx = makeFakeContext({ queue, turnInterfaceContext: ifCtx });
+
+    await drainQueue(ctx);
+
+    expect(ctx.preactivatedSkillIdCalls).not.toContain("computer-use");
+    expect(ctx.preactivatedSkillIdCalls).not.toContain("app-control");
+  });
+
+  test("drainSingleMessage does not re-add 'app-control' for non-host-proxy interface (slack)", async () => {
+    const queue = new MessageQueue();
+    const ifCtx: TurnInterfaceContext = {
+      userMessageInterface: "slack",
+      assistantMessageInterface: "slack",
+    };
+    queue.push(
+      makeQueuedMessage({ requestId: "req-2", turnInterfaceContext: ifCtx }),
+    );
+    const ctx = makeFakeContext({ queue, turnInterfaceContext: ifCtx });
+
+    await drainQueue(ctx);
+
+    expect(ctx.preactivatedSkillIdCalls).not.toContain("computer-use");
+    expect(ctx.preactivatedSkillIdCalls).not.toContain("app-control");
+  });
+
+  test("drainBatch re-adds 'app-control' for macOS-sourced batched queue", async () => {
+    const queue = new MessageQueue();
+    const ifCtx: TurnInterfaceContext = {
+      userMessageInterface: "macos",
+      assistantMessageInterface: "macos",
+    };
+    // Two passthrough siblings with matching interface — buildPassthroughBatch
+    // groups them into a batch, exercising drainBatch.
+    queue.push(
+      makeQueuedMessage({
+        requestId: "req-2",
+        content: "msg-2",
+        turnInterfaceContext: ifCtx,
+      }),
+    );
+    queue.push(
+      makeQueuedMessage({
+        requestId: "req-3",
+        content: "msg-3",
+        turnInterfaceContext: ifCtx,
+      }),
+    );
+    const ctx = makeFakeContext({ queue, turnInterfaceContext: ifCtx });
+
+    await drainQueue(ctx);
+
+    // Batched path mirrors the single-message preactivation block.
+    expect(ctx.preactivatedSkillIdCalls).toContain("computer-use");
+    expect(ctx.preactivatedSkillIdCalls).toContain("app-control");
+    expect(ctx.preactivatedSkillIds).toContain("app-control");
+  });
+
+  test("drainSingleMessage skips 'app-control' re-add when isInteractive=false", async () => {
+    const queue = new MessageQueue();
+    const ifCtx: TurnInterfaceContext = {
+      userMessageInterface: "macos",
+      assistantMessageInterface: "macos",
+    };
+    const qm = makeQueuedMessage({
+      requestId: "req-2",
+      turnInterfaceContext: ifCtx,
+    });
+    qm.isInteractive = false;
+    queue.push(qm);
+    const ctx = makeFakeContext({ queue, turnInterfaceContext: ifCtx });
+
+    await drainQueue(ctx);
+
+    // Both branches share the outer `isInteractive !== false` gate, so
+    // app-control follows CU's behavior and is skipped for non-interactive
+    // turns even on macOS.
+    expect(ctx.preactivatedSkillIdCalls).not.toContain("computer-use");
+    expect(ctx.preactivatedSkillIdCalls).not.toContain("app-control");
+  });
+});

package/src/__tests__/conversation-process-callsite.test.ts

@@ -16,10 +16,18 @@ import type { Message, ProviderResponse } from "../providers/types.js";
 
 // Use an object wrapper so TypeScript doesn't narrow the captured type to
 // `undefined` based on the initial assignment in the test setup.
-const captured: { callSite?: string } = {};
+const captured: {
+  callSite?: string;
+  constructorMaxTokens?: unknown;
+  resolvedMaxTokens?: unknown;
+  resolvedHasMaxTokens?: boolean;
+} = {};
 
 function clearCaptured(): void {
   captured.callSite = undefined;
+  captured.constructorMaxTokens = undefined;
+  captured.resolvedMaxTokens = undefined;
+  captured.resolvedHasMaxTokens = undefined;
 }
 
 mock.module("../util/logger.js", () => ({
@@ -97,6 +105,14 @@ mock.module("../prompts/system-prompt.js", () => ({
   buildSystemPrompt: () => "system prompt",
 }));
 
+mock.module("../prompts/persona-resolver.js", () => ({
+  resolvePersonaContext: () => ({
+    userPersona: undefined,
+    channelPersona: undefined,
+    userSlug: undefined,
+  }),
+}));
+
 mock.module("../permissions/trust-store.js", () => ({
   clearCache: () => {},
 }));
@@ -165,7 +181,22 @@ mock.module("../memory/retriever.js", () => ({
 // The 6th positional parameter is `callSite` (see assistant/src/agent/loop.ts).
 mock.module("../agent/loop.js", () => ({
   AgentLoop: class {
-    constructor() {}
+    constructor(
+      _provider: unknown,
+      _systemPrompt: string,
+      config?: Record<string, unknown>,
+      _tools?: unknown,
+      _toolExecutor?: unknown,
+      _resolveTools?: unknown,
+      resolveSystemPrompt?: (history: Message[]) => Record<string, unknown>,
+    ) {
+      captured.constructorMaxTokens = config?.maxTokens;
+      const resolved = resolveSystemPrompt?.([]);
+      captured.resolvedMaxTokens = resolved?.maxTokens;
+      captured.resolvedHasMaxTokens =
+        resolved !== undefined &&
+        Object.prototype.hasOwnProperty.call(resolved, "maxTokens");
+    }
     getToolTokenBudget() {
       return 0;
     }
@@ -234,6 +265,10 @@ mock.module("../memory/canonical-guardian-store.js", () => ({
 }));
 
 import { Conversation } from "../daemon/conversation.js";
+import {
+  clearAllActiveConversations,
+  getOrCreateConversation,
+} from "../daemon/conversation-store.js";
 
 function makeConversation(): Conversation {
   const provider = {
@@ -305,4 +340,46 @@ describe("processMessage callSite threading", () => {
 
     expect(captured.callSite).toBe("mainAgent");
   });
+
+  test("does not pin default maxTokens when maxResponseTokens is absent", async () => {
+    mockConversation = {
+      id: "conv-store-default",
+      contextSummary: null,
+      contextCompactedMessageCount: 0,
+      totalInputTokens: 0,
+      totalOutputTokens: 0,
+      totalEstimatedCost: 0,
+    };
+    mockDbMessages = [];
+    clearCaptured();
+    clearAllActiveConversations();
+
+    await getOrCreateConversation("conv-store-default");
+
+    expect(captured.constructorMaxTokens).toBeUndefined();
+    expect(captured.resolvedMaxTokens).toBeUndefined();
+    expect(captured.resolvedHasMaxTokens).toBe(false);
+  });
+
+  test("preserves explicit maxResponseTokens at conversation creation", async () => {
+    mockConversation = {
+      id: "conv-store-explicit",
+      contextSummary: null,
+      contextCompactedMessageCount: 0,
+      totalInputTokens: 0,
+      totalOutputTokens: 0,
+      totalEstimatedCost: 0,
+    };
+    mockDbMessages = [];
+    clearCaptured();
+    clearAllActiveConversations();
+
+    await getOrCreateConversation("conv-store-explicit", {
+      maxResponseTokens: 1234,
+    });
+
+    expect(captured.constructorMaxTokens).toBe(1234);
+    expect(captured.resolvedMaxTokens).toBe(1234);
+    expect(captured.resolvedHasMaxTokens).toBe(true);
+  });
 });

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

@@ -1,12 +1,5 @@
 import { rmSync, writeFileSync } from "node:fs";
-import {
-  afterAll,
-  beforeEach,
-  describe,
-  expect,
-  mock,
-  test,
-} from "bun:test";
+import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
 
 import type {
   AgentEvent,
@@ -84,6 +77,8 @@ mock.module("../config/loader.js", () => ({
       pricingOverrides: [],
     },
     rateLimit: { maxRequestsPerMinute: 0 },
+    memory: { v2: { enabled: false } },
+    conversations: { skipAutoRetitling: false },
     timeouts: { permissionTimeoutSec: 1 },
     skills: { entries: {}, allowBundled: true },
     permissions: { mode: "workspace" },

package/src/__tests__/conversation-routes-disk-view.test.ts

@@ -22,11 +22,6 @@ import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 import { AssistantEventHub } from "../runtime/assistant-event-hub.js";
 import type { AuthContext } from "../runtime/auth/types.js";
-import {
-  __resetChromeExtensionRegistryForTests,
-  type ChromeExtensionConnection,
-  getChromeExtensionRegistry,
-} from "../runtime/chrome-extension-registry.js";
 import * as pendingInteractions from "../runtime/pending-interactions.js";
 import { handleSendMessage } from "../runtime/routes/conversation-routes.js";
 import { callHandler } from "./helpers/call-route-handler.js";
@@ -149,9 +144,6 @@ function createFakeConversation(conversationId: string): Conversation {
       assistantMessageInterface: string;
     } | null,
     messages: [] as Array<unknown>,
-    hostBashProxy: undefined as unknown,
-    hostBrowserProxy: undefined as unknown,
-    hostFileProxy: undefined as unknown,
     hostCuProxy: undefined as unknown,
     usageStats: { inputTokens: 0, outputTokens: 0, estimatedCost: 0 },
     memoryPolicy: {
@@ -211,24 +203,16 @@ function createFakeConversation(conversationId: string): Conversation {
     },
     ensureActorScopedHistory: async () => {},
     updateClient: () => {},
-    setHostBashProxy(this: { hostBashProxy: unknown }, proxy: unknown) {
-      this.hostBashProxy = proxy;
-    },
-    setHostBrowserProxy(this: { hostBrowserProxy: unknown }, proxy: unknown) {
-      this.hostBrowserProxy = proxy;
-    },
-    setHostFileProxy(this: { hostFileProxy: unknown }, proxy: unknown) {
-      this.hostFileProxy = proxy;
-    },
-    setHostTransferProxy(this: { hostTransferProxy: unknown }, proxy: unknown) {
-      this.hostTransferProxy = proxy;
-    },
-    getHostTransferProxy() {
-      return undefined;
-    },
+
     setHostCuProxy(this: { hostCuProxy: unknown }, proxy: unknown) {
       this.hostCuProxy = proxy;
     },
+    setHostAppControlProxy(
+      this: { hostAppControlProxy: unknown },
+      proxy: unknown,
+    ) {
+      this.hostAppControlProxy = proxy;
+    },
     restoreBrowserProxyAvailability: () => {},
     addPreactivatedSkillId: () => {},
     hasAnyPendingConfirmation: () => false,
@@ -371,7 +355,6 @@ beforeEach(() => {
   resetConversationsDir();
   conversationInstances.clear();
   pendingInteractions.clear();
-  __resetChromeExtensionRegistryForTests();
 });
 
 // ── macOS browser backend fallback regression ─────────────────────────
@@ -443,21 +426,6 @@ describe("macOS browser backend fallback (no extension, no cdp-inspect)", () =>
     expect(interfaceCtx).not.toBeNull();
     expect(interfaceCtx!.userMessageInterface).toBe("macos");
     expect(interfaceCtx!.assistantMessageInterface).toBe("macos");
-
-    // macOS now natively supports host_browser, so the conversation gets a
-    // hostBrowserProxy provisioned via the SSE sender path even without an
-    // extension connection. The proxy routes host_browser_request frames to
-    // the macOS desktop client over SSE. The hostBrowserSenderOverride
-    // remains undefined because no registry-routed extension connection is
-    // present — the proxy uses the default SSE sender.
-    expect(
-      (capturedConversation as unknown as Record<string, unknown>)
-        .hostBrowserProxy,
-    ).toBeDefined();
-    expect(
-      (capturedConversation as unknown as Record<string, unknown>)
-        .hostBrowserSenderOverride,
-    ).toBeUndefined();
   });
 
   test("macOS turn correctly persists interface metadata through the agent loop", async () => {
@@ -530,128 +498,6 @@ describe("macOS browser backend fallback (no extension, no cdp-inspect)", () =>
   });
 });
 
-describe("chrome-extension host_browser pending registration", () => {
-  test("registers pending interaction before registry-routed host_browser send", async () => {
-    const guardianId = `guardian-${crypto.randomUUID()}`;
-    let pendingRegisteredAtSend: boolean | undefined;
-    let observedRequestId: string | undefined;
-
-    const connection: ChromeExtensionConnection = {
-      id: `conn-${crypto.randomUUID()}`,
-      guardianId,
-      ws: {
-        send(payload: string) {
-          const frame = JSON.parse(payload) as {
-            type?: string;
-            requestId?: string;
-          };
-          if (
-            frame.type === "host_browser_request" &&
-            typeof frame.requestId === "string"
-          ) {
-            observedRequestId = frame.requestId;
-            pendingRegisteredAtSend =
-              pendingInteractions.get(frame.requestId)?.kind === "host_browser";
-          }
-        },
-        close() {},
-      } as unknown as ChromeExtensionConnection["ws"],
-      connectedAt: Date.now(),
-      lastActiveAt: Date.now(),
-    };
-    getChromeExtensionRegistry().register(connection);
-
-    const actorAuthContext: AuthContext = {
-      ...authContext,
-      subject: `actor:self:${guardianId}`,
-      principalType: "actor",
-      scopeProfile: "actor_client_v1",
-      actorPrincipalId: guardianId,
-    };
-
-    const conversationKey = `chrome-ext-pending-${crypto.randomUUID()}`;
-    const chromeDeps = {
-      sendMessageDeps: {
-        getOrCreateConversation: async (conversationId: string) => {
-          const conversation = createFakeConversation(
-            conversationId,
-          ) as unknown as {
-            hostBrowserProxy?: {
-              request: (
-                input: { cdpMethod: string; timeout_seconds?: number },
-                conversationId: string,
-              ) => Promise<{ content: string; isError: boolean }>;
-            };
-            processing: boolean;
-            abortController: AbortController | null;
-            currentRequestId?: string;
-            runAgentLoop: (
-              content: string,
-              userMessageId: string,
-              onEvent: (msg: Record<string, unknown>) => void,
-            ) => Promise<void>;
-            conversationId: string;
-          };
-
-          conversation.runAgentLoop = async function (
-            _content: string,
-            _userMessageId: string,
-            _onEvent: (msg: Record<string, unknown>) => void,
-          ): Promise<void> {
-            if (!this.hostBrowserProxy) {
-              throw new Error(
-                "Expected hostBrowserProxy to be provisioned for chrome-extension turn",
-              );
-            }
-            await this.hostBrowserProxy.request(
-              {
-                cdpMethod: "Browser.getVersion",
-                timeout_seconds: 0.05,
-              },
-              this.conversationId,
-            );
-            this.processing = false;
-            this.abortController = null;
-            this.currentRequestId = undefined;
-          };
-
-          conversationInstances.set(
-            conversationId,
-            conversation as unknown as Conversation,
-          );
-          return conversation as unknown as Conversation;
-        },
-        assistantEventHub: new AssistantEventHub(),
-        resolveAttachments: () => [],
-      },
-    };
-    const response = await callHandler(
-      (args) => handleSendMessage(args, chromeDeps),
-      new Request("http://localhost/v1/messages", {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          "x-vellum-actor-principal-id": actorAuthContext.actorPrincipalId!,
-          "x-vellum-principal-type": actorAuthContext.principalType,
-        },
-        body: JSON.stringify({
-          conversationKey,
-          content: "Trigger host browser request via registry sender.",
-          sourceChannel: "vellum",
-          interface: "chrome-extension",
-        }),
-      }),
-      undefined,
-      202,
-    );
-
-    expect(response.status).toBe(202);
-    const registered = await waitFor(() => pendingRegisteredAtSend, 1000);
-    expect(observedRequestId).toBeDefined();
-    expect(registered).toBe(true);
-  });
-});
-
 describe("conversationKey send path disk-view regression", () => {
   test("first send on a fresh conversationKey creates disk-view dir and writes user+assistant records", async () => {
     const conversationKey = `fresh-conv-key-${crypto.randomUUID()}`;