@vellumai/assistant 0.7.0 → 0.7.2

package/src/__tests__/conversation-attention-telegram.test.ts

@@ -2,6 +2,14 @@ import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
 
 mock.module("../config/env.js", () => ({ isHttpAuthDisabled: () => true }));
 
+const _conversationMocks = new Map<string, unknown>();
+mock.module("../daemon/conversation-store.js", () => ({
+  findConversation: (id: string) => _conversationMocks.get(id),
+  findConversationBySurfaceId: () => undefined,
+  getActiveConversations: () => [],
+  createConversation: () => undefined,
+}));
+
 // ---------------------------------------------------------------------------
 // Test isolation: in-memory SQLite via temp directory
 // ---------------------------------------------------------------------------
@@ -241,12 +249,12 @@ describe("Telegram callback seen signals", () => {
 
     // Register a pending interaction so the approval interception handles it
     const handleConfirmationResponse = mock(() => {});
-    const mockSession = {
+    const _mockSession = {
       handleConfirmationResponse,
       ensureActorScopedHistory: async () => {},
     } as unknown as import("../daemon/conversation.js").Conversation;
+    _conversationMocks.set(conversationId, _mockSession);
     pendingInteractions.register("req-cb-test", {
-      conversation: mockSession,
       conversationId,
       kind: "confirmation",
       confirmationDetails: {
@@ -266,7 +274,7 @@ describe("Telegram callback seen signals", () => {
 
     // Create a guardian binding (via contacts) so approval can be handled
     const { createGuardianBinding } =
-      await import("../contacts/contacts-write.js");
+      await import("./helpers/create-guardian-binding.js");
     createGuardianBinding({
       channel: "telegram",
       guardianExternalUserId: "telegram-user-default",

package/src/__tests__/conversation-confirmation-signals.test.ts

@@ -239,8 +239,6 @@ mock.module("../memory/canonical-guardian-store.js", () => ({
 // ---------------------------------------------------------------------------
 
 import { Conversation } from "../daemon/conversation.js";
-import { HostBashProxy } from "../daemon/host-bash-proxy.js";
-import { HostBrowserProxy } from "../daemon/host-browser-proxy.js";
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -408,7 +406,6 @@ describe("centralized confirmation emissions", () => {
       decisionText: "yes please",
     });
   });
-
 });
 
 describe("activity version ordering", () => {
@@ -548,291 +545,3 @@ describe("sendToClient receives state signals", () => {
     });
   });
 });
-
-describe("restoreBrowserProxyAvailability", () => {
-  test("re-enables only the host browser proxy after clearProxyAvailability", () => {
-    const conversation = makeConversation();
-    const browserProxy = new HostBrowserProxy(() => {});
-    const bashProxy = new HostBashProxy(() => {});
-    conversation.setHostBrowserProxy(browserProxy);
-    conversation.setHostBashProxy(bashProxy);
-
-    // Mark as having a connected client (interactive desktop path).
-    conversation.updateClient(() => {}, false);
-    expect(browserProxy.isAvailable()).toBe(true);
-    expect(bashProxy.isAvailable()).toBe(true);
-
-    // The drain queue clears all proxies for non-interactive turns.
-    conversation.clearProxyAvailability();
-    expect(browserProxy.isAvailable()).toBe(false);
-    expect(bashProxy.isAvailable()).toBe(false);
-
-    // restoreBrowserProxyAvailability should bring back ONLY the browser proxy.
-    conversation.restoreBrowserProxyAvailability();
-    expect(browserProxy.isAvailable()).toBe(true);
-    expect(bashProxy.isAvailable()).toBe(false);
-  });
-
-  test("re-enables the browser proxy even when hasNoClient is true (chrome-extension)", () => {
-    // Regression: chrome-extension is non-interactive (hasNoClient stays
-    // true so host_bash/host_file tools remain gated), but we still need
-    // to provision the hostBrowserProxy so it can service CDP commands.
-    // The helper must NOT gate on hasNoClient.
-    const conversation = makeConversation();
-    const browserProxy = new HostBrowserProxy(() => {});
-    conversation.setHostBrowserProxy(browserProxy);
-
-    // updateClient with hasNoClient=true emulates the non-interactive
-    // chrome-extension turn. Host proxies start disabled because
-    // updateClient propagates hasNoClient through to updateSender.
-    conversation.updateClient(() => {}, true);
-    expect(browserProxy.isAvailable()).toBe(false);
-    expect(conversation["hasNoClient"]).toBe(true);
-
-    // The targeted helper bypasses the hasNoClient gate so the
-    // single-capability chrome-extension turn can drive the browser
-    // via CDP without flipping hasNoClient (which would also enable
-    // host_bash/host_file gating downstream).
-    conversation.restoreBrowserProxyAvailability();
-    expect(browserProxy.isAvailable()).toBe(true);
-    // hasNoClient itself MUST remain true so that
-    // isToolActiveForContext keeps host_bash/host_file/host_cu gated.
-    expect(conversation["hasNoClient"]).toBe(true);
-  });
-
-  test("leaves bash/file/cu proxies disabled when called for chrome-extension", () => {
-    // Regression: the targeted helper must not accidentally re-enable
-    // proxies other than host_browser, even when called from a path that
-    // owns multiple proxies (e.g. macOS holdover state with hasNoClient
-    // forced true for an explicit non-interactive run).
-    const conversation = makeConversation();
-    const browserProxy = new HostBrowserProxy(() => {});
-    const bashProxy = new HostBashProxy(() => {});
-    conversation.setHostBrowserProxy(browserProxy);
-    conversation.setHostBashProxy(bashProxy);
-
-    conversation.updateClient(() => {}, true);
-    expect(browserProxy.isAvailable()).toBe(false);
-    expect(bashProxy.isAvailable()).toBe(false);
-
-    conversation.restoreBrowserProxyAvailability();
-    expect(browserProxy.isAvailable()).toBe(true);
-    // Crucial: bash proxy stays disabled. The helper must touch ONLY the
-    // browser proxy.
-    expect(bashProxy.isAvailable()).toBe(false);
-  });
-
-  test("uses hostBrowserSenderOverride when set so drain-queue restores preserve the registry-routed sender", () => {
-    // Regression (PR #24129 cycle 2): the queue-drain path calls
-    // `restoreBrowserProxyAvailability()` on dequeue, which used to pass
-    // `this.sendToClient` (the SSE hub emitter) to the proxy, clobbering the
-    // chrome-extension registry-routed sender established by the POST
-    // /messages handler. The override field lets the HTTP handler pin the
-    // registry-routed sender so the drain path preserves it.
-    const sseHub: ServerMessage[] = [];
-    const registry: ServerMessage[] = [];
-    const conversation = makeConversation((msg) => sseHub.push(msg));
-    const browserProxy = new HostBrowserProxy(() => {});
-    conversation.setHostBrowserProxy(browserProxy);
-
-    // Simulate updateClient setting sendToClient to the SSE hub and
-    // marking the conversation as client-less (chrome-extension is
-    // non-interactive).
-    conversation.updateClient((msg) => sseHub.push(msg), true);
-    expect(browserProxy.isAvailable()).toBe(false);
-
-    // The HTTP handler stashes the registry-routed sender as the override.
-    const registrySender = (msg: ServerMessage) => registry.push(msg);
-    conversation.hostBrowserSenderOverride = registrySender;
-
-    // Drain-queue path calls restoreBrowserProxyAvailability — it must now
-    // prefer the override over sendToClient.
-    conversation.restoreBrowserProxyAvailability();
-    expect(browserProxy.isAvailable()).toBe(true);
-
-    // Send a frame through the proxy and verify it flows through the
-    // registry sender, not the SSE hub.
-    const internalSend = (
-      browserProxy as unknown as {
-        sendToClient: (msg: ServerMessage) => void;
-      }
-    ).sendToClient;
-    const probe: ServerMessage = {
-      type: "host_browser_cancel",
-      requestId: "probe-1",
-    } as ServerMessage;
-    internalSend(probe);
-    expect(registry).toHaveLength(1);
-    expect(sseHub.some((m) => m === probe)).toBe(false);
-  });
-
-  test("falls back to sendToClient when hostBrowserSenderOverride is cleared", () => {
-    // When a non-chrome-extension turn takes over, the HTTP handler clears
-    // the override and restoreBrowserProxyAvailability must fall back to
-    // sendToClient (the SSE hub), otherwise macOS turns would route their
-    // host_browser frames through the stale chrome-extension registry.
-    const sseHub: ServerMessage[] = [];
-    const conversation = makeConversation((msg) => sseHub.push(msg));
-    const browserProxy = new HostBrowserProxy(() => {});
-    conversation.setHostBrowserProxy(browserProxy);
-
-    // First the chrome-extension path pins the override.
-    const registry: ServerMessage[] = [];
-    conversation.hostBrowserSenderOverride = (msg) => registry.push(msg);
-    conversation.updateClient((msg) => sseHub.push(msg), true);
-    conversation.restoreBrowserProxyAvailability();
-
-    // Then a macOS handoff clears the override.
-    conversation.hostBrowserSenderOverride = undefined;
-    conversation.updateClient((msg) => sseHub.push(msg), false);
-    conversation.restoreBrowserProxyAvailability();
-
-    const internalSend = (
-      browserProxy as unknown as {
-        sendToClient: (msg: ServerMessage) => void;
-      }
-    ).sendToClient;
-    const probe: ServerMessage = {
-      type: "host_browser_cancel",
-      requestId: "probe-2",
-    } as ServerMessage;
-    internalSend(probe);
-    expect(sseHub).toContain(probe);
-    expect(registry).not.toContain(probe);
-  });
-});
-
-describe("hostBrowserSenderOverride is sender-mode based, not interface-string based", () => {
-  test("macOS turn with registry override routes browser frames through the registry sender", () => {
-    // When a macOS turn sets hostBrowserSenderOverride (because the
-    // guardian has an active extension connection), the browser proxy
-    // must route through the registry sender, not the SSE hub — the
-    // same behavior chrome-extension turns have always used.
-    const sseHub: ServerMessage[] = [];
-    const registry: ServerMessage[] = [];
-    const conversation = makeConversation((msg) => sseHub.push(msg));
-    const browserProxy = new HostBrowserProxy(() => {});
-    conversation.setHostBrowserProxy(browserProxy);
-
-    // macOS is interactive — hasNoClient is false.
-    conversation.updateClient((msg) => sseHub.push(msg), false);
-
-    // The POST /messages handler detected an active extension connection
-    // and set the registry-routed sender override.
-    const registrySender = (msg: ServerMessage) => registry.push(msg);
-    conversation.hostBrowserSenderOverride = registrySender;
-
-    // restoreBrowserProxyAvailability (called after updateClient in the
-    // POST handler) must prefer the override.
-    conversation.restoreBrowserProxyAvailability();
-    expect(browserProxy.isAvailable()).toBe(true);
-
-    // Verify frames flow through the registry, not the SSE hub.
-    const internalSend = (
-      browserProxy as unknown as {
-        sendToClient: (msg: ServerMessage) => void;
-      }
-    ).sendToClient;
-    const probe: ServerMessage = {
-      type: "host_browser_cancel",
-      requestId: "probe-macos-registry",
-    } as ServerMessage;
-    internalSend(probe);
-    expect(registry).toHaveLength(1);
-    expect(sseHub.some((m) => m === probe)).toBe(false);
-  });
-
-  test("macOS turn without registry override clears the browser proxy on restore", () => {
-    // When a macOS turn has no active extension connection, the override
-    // is cleared and restoreBrowserProxyAvailability falls back to the
-    // SSE hub sender. The proxy should not be stuck on an unavailable
-    // registry-routed sender from a prior chrome-extension turn.
-    const sseHub: ServerMessage[] = [];
-    const conversation = makeConversation((msg) => sseHub.push(msg));
-    const browserProxy = new HostBrowserProxy(() => {});
-    conversation.setHostBrowserProxy(browserProxy);
-
-    // Interactive macOS turn without extension connectivity.
-    conversation.updateClient((msg) => sseHub.push(msg), false);
-    conversation.hostBrowserSenderOverride = undefined;
-    conversation.restoreBrowserProxyAvailability();
-
-    // The proxy should be available and routed through SSE.
-    expect(browserProxy.isAvailable()).toBe(true);
-    const internalSend = (
-      browserProxy as unknown as {
-        sendToClient: (msg: ServerMessage) => void;
-      }
-    ).sendToClient;
-    const probe: ServerMessage = {
-      type: "host_browser_cancel",
-      requestId: "probe-macos-sse",
-    } as ServerMessage;
-    internalSend(probe);
-    expect(sseHub).toContain(probe);
-  });
-
-  test("override semantics are symmetric: chrome-extension and macOS both set override when registry-routed", () => {
-    // The override field must be set for ANY interface that uses a
-    // registry-routed sender, and cleared for any that does not.
-    // This test verifies the field is not gated on interface strings.
-    const conversation = makeConversation();
-    const registrySender = () => {};
-
-    // Simulate chrome-extension setting the override.
-    conversation.hostBrowserSenderOverride = registrySender;
-    expect(conversation.hostBrowserSenderOverride).toBe(registrySender);
-
-    // Simulate macOS-with-extension setting the same override.
-    // The field value is the same registry sender, not gated by interface.
-    const macosRegistrySender = () => {};
-    conversation.hostBrowserSenderOverride = macosRegistrySender;
-    expect(conversation.hostBrowserSenderOverride).toBe(macosRegistrySender);
-
-    // Simulate macOS-without-extension clearing the override.
-    conversation.hostBrowserSenderOverride = undefined;
-    expect(conversation.hostBrowserSenderOverride).toBeUndefined();
-  });
-
-  test("queue-drain restore path preserves registry-routed sender for macOS turns", () => {
-    // When a macOS turn with an active extension connection has its
-    // messages queued and later drained, the drain-queue path calls
-    // restoreBrowserProxyAvailability(). With the override set, the
-    // proxy must be restored with the registry sender, not the SSE hub.
-    const sseHub: ServerMessage[] = [];
-    const registry: ServerMessage[] = [];
-    const conversation = makeConversation((msg) => sseHub.push(msg));
-    const browserProxy = new HostBrowserProxy(() => {});
-    conversation.setHostBrowserProxy(browserProxy);
-
-    // macOS interactive turn with extension connectivity.
-    conversation.updateClient((msg) => sseHub.push(msg), false);
-    const registrySender = (msg: ServerMessage) => registry.push(msg);
-    conversation.hostBrowserSenderOverride = registrySender;
-    conversation.restoreBrowserProxyAvailability();
-    expect(browserProxy.isAvailable()).toBe(true);
-
-    // Simulate drain-queue clearing all proxies for a non-interactive
-    // queued message, then restoring for the next macOS turn.
-    conversation.clearProxyAvailability();
-    expect(browserProxy.isAvailable()).toBe(false);
-
-    // Drain restore — override is still set from the POST handler.
-    conversation.restoreBrowserProxyAvailability();
-    expect(browserProxy.isAvailable()).toBe(true);
-
-    // Verify the registry sender was preserved, not the SSE hub.
-    const internalSend = (
-      browserProxy as unknown as {
-        sendToClient: (msg: ServerMessage) => void;
-      }
-    ).sendToClient;
-    const probe: ServerMessage = {
-      type: "host_browser_cancel",
-      requestId: "probe-drain-macos",
-    } as ServerMessage;
-    internalSend(probe);
-    expect(registry).toHaveLength(1);
-    expect(sseHub.some((m) => m === probe)).toBe(false);
-  });
-});

package/src/__tests__/conversation-history-web-search.test.ts

@@ -438,11 +438,14 @@ describe("regenerate with web_search_tool_result", () => {
     let agentLoopContent = "";
     let agentLoopUserMessageId = "";
 
+    const events: Array<{ type: string; message?: string }> = [];
+
     const session: HistoryConversationContext = {
       conversationId,
       traceEmitter: {
         emit: () => {},
       } as unknown as HistoryConversationContext["traceEmitter"],
+      sendToClient: (msg) => events.push(msg),
       messages: [...inMemoryMessages],
       processing: false,
       abortController: null,
@@ -453,9 +456,7 @@ describe("regenerate with web_search_tool_result", () => {
       },
     };
 
-    const events: Array<{ type: string; message?: string }> = [];
-
-    await regenerate(session, (msg) => events.push(msg));
+    await regenerate(session);
 
     // regenerate should find the real user message (msg-u1) and skip the
     // web_search_tool_result-only message (msg-ws).

package/src/__tests__/conversation-inference-profile-route.test.ts

@@ -28,7 +28,6 @@ import {
 import { getDb, resetDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 import { assistantEventHub } from "../runtime/assistant-event-hub.js";
-import { DAEMON_INTERNAL_ASSISTANT_ID } from "../runtime/assistant-scope.js";
 import { ROUTES } from "../runtime/routes/conversation-management-routes.js";
 import { BadRequestError, NotFoundError } from "../runtime/routes/errors.js";
 
@@ -61,16 +60,14 @@ describe("PUT /v1/conversations/:id/inference-profile", () => {
     const conversation = createConversation("inference-profile-route");
 
     const received: Array<{
-      assistantId: string;
       type: string;
       conversationId?: string;
       profile?: string | null;
     }> = [];
-    const subscription = assistantEventHub.subscribe(
-      { assistantId: DAEMON_INTERNAL_ASSISTANT_ID },
-      (event) => {
+    const subscription = assistantEventHub.subscribe({
+      type: "process",
+      callback: (event) => {
         received.push({
-          assistantId: event.assistantId,
           type: event.message.type,
           conversationId: event.conversationId,
           profile:
@@ -79,13 +76,12 @@ describe("PUT /v1/conversations/:id/inference-profile", () => {
               : undefined,
         });
       },
-    );
+    });
 
     const result = profileRoute.handler({
       pathParams: { id: conversation.id },
       body: { profile: "quality-optimized" },
       headers: {},
-
     });
 
     await Promise.resolve();
@@ -99,7 +95,6 @@ describe("PUT /v1/conversations/:id/inference-profile", () => {
     );
     expect(received).toEqual([
       {
-        assistantId: DAEMON_INTERNAL_ASSISTANT_ID,
         type: "conversation_inference_profile_updated",
         conversationId: conversation.id,
         profile: "quality-optimized",
@@ -117,7 +112,6 @@ describe("PUT /v1/conversations/:id/inference-profile", () => {
         pathParams: { id: conversation.id },
         body: { profile: "does-not-exist" },
         headers: {},
-  
       }),
     ).toThrow(BadRequestError);
     expect(getConversation(conversation.id)?.inferenceProfile).toBeNull();
@@ -130,25 +124,23 @@ describe("PUT /v1/conversations/:id/inference-profile", () => {
       pathParams: { id: conversation.id },
       body: { profile: "balanced" },
       headers: {},
-
     });
     expect(getConversation(conversation.id)?.inferenceProfile).toBe("balanced");
 
     const received: Array<{ profile?: string | null }> = [];
-    const subscription = assistantEventHub.subscribe(
-      { assistantId: DAEMON_INTERNAL_ASSISTANT_ID },
-      (event) => {
+    const subscription = assistantEventHub.subscribe({
+      type: "process",
+      callback: (event) => {
         if (event.message.type === "conversation_inference_profile_updated") {
           received.push({ profile: event.message.profile });
         }
       },
-    );
+    });
 
     const result = profileRoute.handler({
       pathParams: { id: conversation.id },
       body: { profile: null },
       headers: {},
-
     });
 
     await Promise.resolve();
@@ -170,25 +162,23 @@ describe("PUT /v1/conversations/:id/inference-profile", () => {
       pathParams: { id: conversation.id },
       body: { profile: "balanced" },
       headers: {},
-
     });
     const updatedAtAfterSet = getConversation(conversation.id)?.updatedAt;
 
     const received: Array<{ profile?: string | null }> = [];
-    const subscription = assistantEventHub.subscribe(
-      { assistantId: DAEMON_INTERNAL_ASSISTANT_ID },
-      (event) => {
+    const subscription = assistantEventHub.subscribe({
+      type: "process",
+      callback: (event) => {
         if (event.message.type === "conversation_inference_profile_updated") {
           received.push({ profile: event.message.profile });
         }
       },
-    );
+    });
 
     const result = profileRoute.handler({
       pathParams: { id: conversation.id },
       body: { profile: "balanced" },
       headers: {},
-
     });
 
     await Promise.resolve();
@@ -209,7 +199,6 @@ describe("PUT /v1/conversations/:id/inference-profile", () => {
         pathParams: { id: "missing" },
         body: { profile: "balanced" },
         headers: {},
-  
       }),
     ).toThrow(NotFoundError);
   });

package/src/__tests__/conversation-init.benchmark.test.ts

@@ -140,14 +140,12 @@ mock.module("../config/loader.js", () => ({
   getConfig: () => mockConfig,
   getConfigReadOnly: () => mockConfig,
   loadConfig: () => mockConfig,
-  saveConfig: () => {},
   invalidateConfigCache: () => {},
   loadRawConfig: () => ({}),
   saveRawConfig: () => {},
   getNestedValue: () => undefined,
   setNestedValue: () => {},
   applyNestedDefaults: (c: unknown) => c,
-  deepMergeMissing: () => {},
   deepMergeOverwrite: () => {},
   mergeDefaultWorkspaceConfig: () => {},
 }));

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

@@ -177,7 +177,7 @@ describe("loadFromDb metadata injection rehydration", () => {
     expect(messages[0].content).toEqual([
       {
         type: "text",
-        text: "<memory __injected>\nremember: alice\n</memory>",
+        text: "<memory>\nremember: alice\n</memory>",
       },
       { type: "text", text: "Hi" },
     ]);
@@ -215,7 +215,7 @@ describe("loadFromDb metadata injection rehydration", () => {
 
     expect(messages).toHaveLength(3);
     // m1 is historical (not tail) — all three blocks should rehydrate in the
-    // documented shape: [<turn_context>, <memory __injected>, <system_reminder>, ...original]
+    // documented shape: [<turn_context>, <memory>, <system_reminder>, ...original]
     expect(messages[0].role).toBe("user");
     expect(messages[0].content).toEqual([
       {
@@ -224,7 +224,7 @@ describe("loadFromDb metadata injection rehydration", () => {
       },
       {
         type: "text",
-        text: "<memory __injected>\nmem payload\n</memory>",
+        text: "<memory>\nmem payload\n</memory>",
       },
       {
         type: "text",
@@ -271,7 +271,7 @@ describe("loadFromDb metadata injection rehydration", () => {
     expect(messages[2].content).toEqual([
       {
         type: "text",
-        text: "<memory __injected>\nmem payload\n</memory>",
+        text: "<memory>\nmem payload\n</memory>",
       },
       { type: "text", text: "Tail turn" },
     ]);
@@ -308,6 +308,42 @@ describe("loadFromDb metadata injection rehydration", () => {
     expect(messages[2].content).toEqual([{ type: "text", text: "Second" }]);
   });
 
+  test("historical wrapped memoryInjectedBlock rehydrates singly-wrapped", async () => {
+    // Historical v2 rows persisted `injectedBlockText` already wrapped in
+    // `<memory>...</memory>`. After unifying v2's storage with v1's
+    // unwrapped contract, the rehydrate path must defensively strip any
+    // pre-existing wrapper so old rows don't render double-wrapped.
+    mockConversation = defaultConv();
+    mockDbMessages = [
+      {
+        id: "m1",
+        role: "user",
+        content: JSON.stringify([{ type: "text", text: "Hi" }]),
+        metadata: JSON.stringify({
+          memoryInjectedBlock: "<memory>\nremember: alice\n</memory>",
+        }),
+      },
+      {
+        id: "m2",
+        role: "assistant",
+        content: JSON.stringify([{ type: "text", text: "Hello" }]),
+      },
+    ];
+
+    const conversation = makeConversation();
+    await conversation.loadFromDb();
+    const messages = conversation.getMessages();
+
+    expect(messages).toHaveLength(2);
+    const firstBlock = messages[0].content[0];
+    expect(firstBlock).toEqual({
+      type: "text",
+      text: "<memory>\nremember: alice\n</memory>",
+    });
+    if (firstBlock.type !== "text") throw new Error("unexpected block type");
+    expect(firstBlock.text.match(/<memory>/g)?.length).toBe(1);
+  });
+
   test("malformed metadata is tolerated: load does not throw, content unchanged", async () => {
     mockConversation = defaultConv();
     mockDbMessages = [