@vellumai/assistant 0.7.0 → 0.7.1

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,21 +203,7 @@ 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;
     },
@@ -371,7 +349,6 @@ beforeEach(() => {
   resetConversationsDir();
   conversationInstances.clear();
   pendingInteractions.clear();
-  __resetChromeExtensionRegistryForTests();
 });
 
 // ── macOS browser backend fallback regression ─────────────────────────
@@ -443,21 +420,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 +492,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()}`;

package/src/__tests__/conversation-routes-guardian-reply.test.ts

@@ -170,11 +170,7 @@ describe("handleSendMessage canonical guardian reply interception", () => {
       assistantId: "self",
       trustContext: undefined,
       hasPendingConfirmation: () => false,
-      setHostBashProxy: () => {},
       setHostBrowserProxy: () => {},
-      setHostFileProxy: () => {},
-      setHostTransferProxy: () => {},
-      getHostTransferProxy: () => undefined,
       setHostCuProxy: () => {},
       restoreBrowserProxyAvailability: () => {},
       addPreactivatedSkillId: () => {},
@@ -252,11 +248,7 @@ describe("handleSendMessage canonical guardian reply interception", () => {
       assistantId: "self",
       trustContext: undefined,
       hasPendingConfirmation: () => false,
-      setHostBashProxy: () => {},
       setHostBrowserProxy: () => {},
-      setHostFileProxy: () => {},
-      setHostTransferProxy: () => {},
-      getHostTransferProxy: () => undefined,
       setHostCuProxy: () => {},
       restoreBrowserProxyAvailability: () => {},
       addPreactivatedSkillId: () => {},
@@ -330,11 +322,7 @@ describe("handleSendMessage canonical guardian reply interception", () => {
       trustContext: undefined,
       hasPendingConfirmation: (requestId: string) =>
         requestId === "tool-approval-live",
-      setHostBashProxy: () => {},
       setHostBrowserProxy: () => {},
-      setHostFileProxy: () => {},
-      setHostTransferProxy: () => {},
-      getHostTransferProxy: () => undefined,
       setHostCuProxy: () => {},
       restoreBrowserProxyAvailability: () => {},
       addPreactivatedSkillId: () => {},
@@ -412,11 +400,7 @@ describe("handleSendMessage canonical guardian reply interception", () => {
       assistantId: "self",
       trustContext: undefined,
       hasPendingConfirmation: (id: string) => id === "tool-req-code-1",
-      setHostBashProxy: () => {},
       setHostBrowserProxy: () => {},
-      setHostFileProxy: () => {},
-      setHostTransferProxy: () => {},
-      getHostTransferProxy: () => undefined,
       setHostCuProxy: () => {},
       restoreBrowserProxyAvailability: () => {},
       addPreactivatedSkillId: () => {},
@@ -490,11 +474,7 @@ describe("handleSendMessage canonical guardian reply interception", () => {
       assistantId: "self",
       trustContext: undefined,
       hasPendingConfirmation: (id: string) => id === "pending-reject-1",
-      setHostBashProxy: () => {},
       setHostBrowserProxy: () => {},
-      setHostFileProxy: () => {},
-      setHostTransferProxy: () => {},
-      getHostTransferProxy: () => undefined,
       setHostCuProxy: () => {},
       restoreBrowserProxyAvailability: () => {},
       addPreactivatedSkillId: () => {},
@@ -562,11 +542,7 @@ describe("handleSendMessage canonical guardian reply interception", () => {
       assistantId: "self",
       trustContext: undefined,
       hasPendingConfirmation: (id: string) => id === "pending-1",
-      setHostBashProxy: () => {},
       setHostBrowserProxy: () => {},
-      setHostFileProxy: () => {},
-      setHostTransferProxy: () => {},
-      getHostTransferProxy: () => undefined,
       setHostCuProxy: () => {},
       restoreBrowserProxyAvailability: () => {},
       addPreactivatedSkillId: () => {},
@@ -636,11 +612,7 @@ describe("handleSendMessage canonical guardian reply interception", () => {
       assistantId: "self",
       trustContext: undefined,
       hasPendingConfirmation: () => false,
-      setHostBashProxy: () => {},
       setHostBrowserProxy: () => {},
-      setHostFileProxy: () => {},
-      setHostTransferProxy: () => {},
-      getHostTransferProxy: () => undefined,
       setHostCuProxy: () => {},
       restoreBrowserProxyAvailability: () => {},
       addPreactivatedSkillId: () => {},
@@ -711,11 +683,7 @@ describe("handleSendMessage canonical guardian reply interception", () => {
       assistantId: "self",
       trustContext: undefined,
       hasPendingConfirmation: () => false,
-      setHostBashProxy: () => {},
       setHostBrowserProxy: () => {},
-      setHostFileProxy: () => {},
-      setHostTransferProxy: () => {},
-      getHostTransferProxy: () => undefined,
       setHostCuProxy: () => {},
       restoreBrowserProxyAvailability: () => {},
       addPreactivatedSkillId: () => {},