@vellumai/assistant 0.8.4 → 0.8.5

package/src/runtime/assistant-event-hub.ts

@@ -247,6 +247,10 @@ export class AssistantEventHub {
    * Publish an event to all matching subscribers.
    *
    * Matching rules:
+   * - if `excludeClientId` is set, the subscriber with that clientId is
+   *   skipped regardless of every other rule (self-echo suppression — the
+   *   client that originated the mutation does not receive its own
+   *   invalidation back through the hub).
    * - if `targetClientId` is set, deliver only to the subscriber with that
    *   clientId, bypassing the conversation-id filter entirely (the web-origin
    *   event's conversationId differs from the macOS client's subscribed
@@ -255,6 +259,11 @@ export class AssistantEventHub {
    *   `event.conversationId` must equal it
    * - if `targetCapability` is set, only subscribers whose capabilities include
    *   it receive the event; untargeted events go to all
+   * - if `targetInterfaceId` is set, only client subscribers whose
+   *   `interfaceId` matches receive the event; process subscribers and
+   *   non-matching clients are skipped. Used to narrow legacy
+   *   broadcasts (e.g. `conversation_list_invalidated`) to a specific
+   *   client surface during a migration window.
    *
    * Fanout is isolated: a throwing or rejecting subscriber does not abort
    * delivery to remaining subscribers.
@@ -264,6 +273,15 @@ export class AssistantEventHub {
     options?: {
       targetCapability?: HostProxyCapability;
       targetClientId?: string;
+      targetInterfaceId?: InterfaceId;
+      /**
+       * Skip the subscriber with this `clientId`. Used for self-echo
+       * suppression on `sync_changed`: the route handler echoes the
+       * originating tab's `X-Vellum-Client-Id` back on the event, and the
+       * hub uses it here to avoid re-delivering the invalidation to the
+       * tab that already mutated its own optimistic state.
+       */
+      excludeClientId?: string;
     },
   ): Promise<void> {
     if (event.conversationId) {
@@ -276,12 +294,33 @@ export class AssistantEventHub {
 
     const targetCapability = options?.targetCapability;
     const targetClientId = options?.targetClientId;
+    const targetInterfaceId = options?.targetInterfaceId;
+    const excludeClientId = options?.excludeClientId;
     const snapshot = Array.from(this.subscribers);
     const errors: unknown[] = [];
 
     for (const entry of snapshot) {
       if (!entry.active) continue;
 
+      // Self-echo suppression: the originating client never receives the
+      // event back. Checked before every other rule so it composes with
+      // both targeted and untargeted broadcasts.
+      if (
+        excludeClientId != null &&
+        entry.type === "client" &&
+        entry.clientId === excludeClientId
+      ) {
+        continue;
+      }
+
+      // Interface targeting: skip any subscriber that is not a client of
+      // the requested interface. Composes with `targetClientId` and
+      // `targetCapability` below.
+      if (targetInterfaceId != null) {
+        if (entry.type !== "client" || entry.interfaceId !== targetInterfaceId)
+          continue;
+      }
+
       if (targetClientId != null) {
         // Targeted: bypass conversation filter, deliver only to the named client.
         if (entry.type !== "client" || entry.clientId !== targetClientId)
@@ -519,10 +558,11 @@ let _hubChain = Promise.resolve();
 export function broadcastMessage(
   msg: ServerMessage,
   conversationId?: string,
-  options?: { targetClientId?: string },
+  options?: { targetClientId?: string; targetInterfaceId?: InterfaceId },
 ): void {
   const resolvedConversationId = conversationId ?? extractConversationId(msg);
   const targetClientId = options?.targetClientId;
+  const targetInterfaceId = options?.targetInterfaceId;
 
   // Confirmation-request side effects: canonical guardian request creation.
   // The home-feed `activity.failed` notification side-effect lives in the
@@ -539,16 +579,45 @@ export function broadcastMessage(
       : resolvedConversationId;
   const event = buildAssistantEvent(msg, scopedConversationId);
   const targetCapability = capabilityForMessageType(msg.type);
+  // Self-echo suppression: a `sync_changed` carrying an `originClientId`
+  // means a specific client just mutated the resource. The hub must not
+  // re-deliver the invalidation to that client — it already updated its
+  // optimistic state locally and a redundant invalidation would clobber it
+  // with a flash of stale-then-fresh data. Assistant-internal emits (agent
+  // loop, FS watcher, cron) leave `originClientId` unset and the event
+  // fans out to every subscriber as before.
+  const excludeClientId =
+    msg.type === "sync_changed" &&
+    typeof msg.originClientId === "string" &&
+    msg.originClientId.length > 0
+      ? msg.originClientId
+      : undefined;
   const publishOptions =
-    targetCapability != null || targetClientId != null
-      ? { targetCapability, targetClientId }
+    targetCapability != null ||
+    targetClientId != null ||
+    targetInterfaceId != null ||
+    excludeClientId != null
+      ? {
+          targetCapability,
+          targetClientId,
+          targetInterfaceId,
+          excludeClientId,
+        }
       : undefined;
   _hubChain = _hubChain
     .then(() => assistantEventHub.publish(event, publishOptions))
     .then(() => {
-      // When a conversation title changes, also broadcast an unscoped
-      // `conversation_list_invalidated` so every connected client's sidebar
-      // refreshes — not just the client viewing this conversation.
+      // When a conversation title changes, also publish a
+      // `conversation_list_invalidated` so the macOS sidebar refreshes
+      // its row ordering for the renamed conversation. Web consumes the
+      // paired `sync_changed` with `conversation:<id>:metadata` tag
+      // emitted by `publishConversationTitleChanged` and patches the
+      // single row in place, so the broadcast is scoped to macOS only.
+      //
+      // TODO(electron-cutover): remove this emission once macOS migrates
+      // to the Electron client and consumes `sync_changed` directly. At
+      // that point `conversation_list_invalidated` has no remaining
+      // consumers and the message type can be retired.
       if (msg.type === "conversation_title_updated") {
         return assistantEventHub
           .publish(
@@ -556,6 +625,7 @@ export function broadcastMessage(
               type: "conversation_list_invalidated",
               reason: "renamed",
             }),
+            { targetInterfaceId: "macos" },
           )
           .catch((err: unknown) => {
             log.warn(

package/src/runtime/auth/route-policy.ts

@@ -417,6 +417,7 @@ const ACTOR_ENDPOINTS: Array<{ endpoint: string; scopes: Scope[] }> = [
 
   // LLM call site catalog
   { endpoint: "config/llm/call-sites:GET", scopes: ["settings.read"] },
+  { endpoint: "config/llm/profiles:GET", scopes: ["settings.read"] },
 
   // Conversation management
   { endpoint: "conversations:DELETE", scopes: ["chat.write"] },
@@ -440,6 +441,7 @@ const ACTOR_ENDPOINTS: Array<{ endpoint: string; scopes: Scope[] }> = [
   // Message content
   { endpoint: "messages/content", scopes: ["chat.read"] },
   { endpoint: "messages/llm-context", scopes: ["chat.read"] },
+  { endpoint: "conversations/llm-context", scopes: ["chat.read"] },
   { endpoint: "llm-request-logs/payload", scopes: ["chat.read"] },
   { endpoint: "messages/tts", scopes: ["chat.read"] },
   { endpoint: "tts/synthesize", scopes: ["chat.read"] },
@@ -458,6 +460,11 @@ const ACTOR_ENDPOINTS: Array<{ endpoint: string; scopes: Scope[] }> = [
   { endpoint: "skills:DELETE", scopes: ["settings.write"] },
   { endpoint: "skills:PATCH", scopes: ["settings.write"] },
 
+  // Plugins (read-only for now — install / uninstall stay CLI-side)
+  { endpoint: "plugins:GET", scopes: ["settings.read"] },
+  { endpoint: "plugins/search:GET", scopes: ["settings.read"] },
+  { endpoint: "plugins:DELETE", scopes: ["settings.write"] },
+
   // Memory items
   { endpoint: "memory-items:GET", scopes: ["settings.read"] },
   { endpoint: "memory-items:POST", scopes: ["settings.write"] },
@@ -471,6 +478,18 @@ const ACTOR_ENDPOINTS: Array<{ endpoint: string; scopes: Scope[] }> = [
   { endpoint: "memory/v2/concept-frequency:POST", scopes: ["settings.read"] },
   { endpoint: "memory/v2/ema-scores:POST", scopes: ["settings.read"] },
   { endpoint: "memory/v2/simulate-router:POST", scopes: ["settings.read"] },
+  {
+    endpoint: "memory/v2/compare-retrievers:POST",
+    scopes: ["settings.read"],
+  },
+  {
+    endpoint: "memory/v2/router-prompt-template:GET",
+    scopes: ["settings.read"],
+  },
+  { endpoint: "memory/v2/now-text:GET", scopes: ["settings.read"] },
+  { endpoint: "memory/v3/validate:POST", scopes: ["settings.read"] },
+  { endpoint: "memory/v3/tree:POST", scopes: ["settings.read"] },
+  { endpoint: "memory/v3/simulate:POST", scopes: ["settings.read"] },
 
   // Trust rule listing
   { endpoint: "trust-rules/manage:GET", scopes: ["settings.read"] },
@@ -665,6 +684,12 @@ registerPolicy("channels/inbound", {
   allowedPrincipalTypes: ["svc_gateway"],
 });
 
+// Background wake control-plane calls from the platform.
+registerPolicy("background-wake", {
+  requiredScopes: ["internal.write"],
+  allowedPrincipalTypes: ["svc_gateway"],
+});
+
 // Internal forwarding endpoints: gateway-only
 const INTERNAL_ENDPOINTS = [
   "internal/twilio/voice-webhook",
@@ -887,6 +912,12 @@ registerPolicy("browser/execute", {
   allowedPrincipalTypes: ["local"],
 });
 
+// Browser tabs operations (list/select/new/close): local-only (CLI / IPC callers)
+registerPolicy("browser/tabs", {
+  requiredScopes: ["settings.write"],
+  allowedPrincipalTypes: ["local"],
+});
+
 // Background tools: local-only (CLI / IPC callers)
 registerPolicy("background-tools", {
   requiredScopes: ["settings.read"],
@@ -922,6 +953,11 @@ registerPolicy("domain/status", {
   allowedPrincipalTypes: ["local"],
 });
 
+registerPolicy("domain/verification-status", {
+  requiredScopes: ["settings.read"],
+  allowedPrincipalTypes: ["local"],
+});
+
 // Email management (IPC-local)
 registerPolicy("email/register", {
   requiredScopes: ["settings.write"],

package/src/runtime/btw-sidechain.ts

@@ -40,9 +40,6 @@ export interface RunBtwSidechainParams {
   signal?: AbortSignal;
   timeoutMs?: number;
   onEvent?: (event: ProviderEvent) => void;
-  userPersona?: string | null;
-  channelPersona?: string | null;
-  userSlug?: string | null;
 }
 
 export interface RunBtwSidechainResult {
@@ -79,9 +76,6 @@ export async function runBtwSidechain(
       : buildSystemPrompt({
           excludeBootstrap: true,
           excludeCustomPrefix: true,
-          userPersona: params.userPersona,
-          channelPersona: params.channelPersona,
-          userSlug: params.userSlug,
         }));
 
   const { signal: timeoutSignal, cleanup } = createTimeout(

package/src/runtime/http-types.ts

@@ -148,8 +148,6 @@ export interface RuntimeAttachmentMetadata {
 
 export interface RuntimeMessagePayload {
   id: string;
-  /** Concrete persisted assistant row id for row-scoped actions. */
-  daemonMessageId?: string;
   role: string;
   content: string;
   timestamp: string;

package/src/runtime/migrations/vbundle-builder.ts

@@ -681,8 +681,13 @@ export interface BuildExportVBundleOptions {
    * flushed to the main .db file. Callers should pass a function that runs
    * PRAGMA wal_checkpoint(TRUNCATE) on the live database connection.
    * Called before the workspace walk so the DB file is up to date.
+   *
+   * May return a Promise — `streamExportVBundle` awaits the result so an
+   * async-dispatched checkpoint (e.g. via `runAsyncSqlite`) does not race
+   * with the file walk. The synchronous `buildExportVBundle` path does
+   * not await; pass a sync callback there.
    */
-  checkpoint?: () => void;
+  checkpoint?: () => void | Promise<void>;
   /** Optional credential entries to include in the archive under credentials/ prefix. */
   credentials?: Array<{ account: string; value: string }>;
 }
@@ -1120,9 +1125,11 @@ export async function streamExportVBundle(
     credentials,
   } = options;
 
-  // Flush WAL to the main database file before reading
+  // Flush WAL to the main database file before reading. Awaiting allows
+  // the callback to dispatch the checkpoint via `runAsyncSqlite` so the
+  // daemon event loop stays responsive while SQLite truncates the WAL.
   if (checkpoint) {
-    checkpoint();
+    await checkpoint();
   }
 
   const allFileMetadata: FileMetadata[] = [];

package/src/runtime/pending-interactions.ts

@@ -143,7 +143,6 @@ function emitResolved(
     type: "interaction_resolved",
     requestId,
     conversationId: interaction.conversationId,
-    conversationKey: interaction.conversationId,
     kind: interaction.kind,
     state,
   });

package/src/runtime/routes/__tests__/conversation-query-routes.test.ts

@@ -66,6 +66,7 @@ import {
   recordMemoryV2ActivationLog,
 } from "../../../memory/memory-v2-activation-log-store.js";
 import {
+  conversationKeys,
   conversations,
   llmRequestLogs,
   memoryV2ActivationLogs,
@@ -89,6 +90,10 @@ const llmContextRoute = ROUTES.find(
   (r) => r.method === "GET" && r.endpoint === "messages/:id/llm-context",
 )!;
 
+const conversationLlmContextRoute = ROUTES.find(
+  (r) => r.method === "GET" && r.endpoint === "conversations/llm-context",
+)!;
+
 const replaceProfileRoute = ROUTES.find(
   (r) => r.operationId === "config_llm_profiles_replace",
 )!;
@@ -97,11 +102,16 @@ function dispatchLlmContext(messageId: string) {
   return llmContextRoute.handler({ pathParams: { id: messageId } });
 }
 
+function dispatchConversationLlmContext(queryParams: Record<string, string>) {
+  return conversationLlmContextRoute.handler({ queryParams });
+}
+
 function clearTables(): void {
   const db = getDb();
   db.delete(llmRequestLogs).run();
   db.delete(memoryV2ActivationLogs).run();
   db.delete(messages).run();
+  db.delete(conversationKeys).run();
   db.delete(conversations).run();
 }
 
@@ -165,6 +175,102 @@ function seedRequestLog(
     .run();
 }
 
+function seedConversationKey(conversationKey: string, conversationId: string): void {
+  getDb()
+    .insert(conversationKeys)
+    .values({
+      id: `key-${conversationKey}`,
+      conversationKey,
+      conversationId,
+      createdAt: Date.now(),
+    })
+    .run();
+}
+
+describe("GET /v1/conversations/llm-context", () => {
+  beforeEach(() => {
+    clearTables();
+  });
+
+  test("returns all LLM calls for a resolved conversation key", async () => {
+    seedConversationAndMessage({
+      conversationId: "conv-1",
+      messageId: "msg-1",
+      source: "user",
+      conversationType: "standard",
+      totalEstimatedCost: 0.42,
+    });
+    getDb()
+      .insert(messages)
+      .values({
+        id: "msg-2",
+        conversationId: "conv-1",
+        role: "assistant",
+        content: "",
+        createdAt: Date.now() + 1,
+        metadata: null,
+      })
+      .run();
+    seedConversationAndMessage({
+      conversationId: "conv-other",
+      messageId: "msg-other",
+      source: "user",
+      conversationType: "standard",
+    });
+    seedConversationKey("conv-key", "conv-1");
+    seedRequestLog("msg-2", "log-b");
+    seedRequestLog("msg-1", "log-a");
+    getDb()
+      .insert(llmRequestLogs)
+      .values({
+        id: "log-other",
+        conversationId: "conv-other",
+        messageId: "msg-other",
+        provider: "openai",
+        requestPayload: JSON.stringify({ model: "gpt-4.1", messages: [] }),
+        responsePayload: JSON.stringify({
+          choices: [{ message: { content: "other" } }],
+        }),
+        createdAt: 1_700_000_000_001,
+      })
+      .run();
+
+    const body = (await dispatchConversationLlmContext({
+      conversationKey: "conv-key",
+    })) as {
+      conversationId: string;
+      conversationKey: string;
+      conversationKind: string;
+      conversationTotalEstimatedCostUsd: number | null;
+      logs: Array<{ id: string }>;
+      memoryRecall: null;
+      memoryV2Activation: null;
+    };
+
+    expect(body.conversationId).toBe("conv-1");
+    expect(body.conversationKey).toBe("conv-key");
+    expect(body.conversationKind).toBe("user");
+    expect(body.conversationTotalEstimatedCostUsd).toBe(0.42);
+    expect(body.logs.map((log) => log.id)).toEqual(["log-a", "log-b"]);
+    expect(body.memoryRecall).toBeNull();
+    expect(body.memoryV2Activation).toBeNull();
+  });
+
+  test("returns an empty inspector response for an unresolved conversation key", async () => {
+    const body = (await dispatchConversationLlmContext({
+      conversationKey: "missing-key",
+    })) as {
+      conversationId: string | null;
+      conversationKey: string;
+      logs: unknown[];
+    };
+
+    expect(body.conversationId).toBeNull();
+    expect(body.conversationKey).toBe("missing-key");
+    expect(body.logs).toEqual([]);
+  });
+});
+
 describe("GET /v1/messages/:id/llm-context — memoryV2Activation", () => {
   beforeEach(() => {
     clearTables();

package/src/runtime/routes/__tests__/memory-v2-simulate-route.test.ts

@@ -210,7 +210,11 @@ describe("handleSimulateRouter", () => {
     providerStub = makeProvider([3, 1]);
 
     const result = await handleSimulateRouter({
-      body: { query: "what's relevant?" },
+      body: {
+        recentTurnPairs: [
+          { assistantMessage: "", userMessage: "what's relevant?" },
+        ],
+      },
     });
 
     expect(result.failureReason).toBeNull();
@@ -228,7 +232,7 @@ describe("handleSimulateRouter", () => {
 
     const result = await handleSimulateRouter({
       body: {
-        query: "test",
+        recentTurnPairs: [{ assistantMessage: "", userMessage: "test" }],
         configOverrides: {
           tier1_size: 50,
           batch_size: 25,
@@ -249,22 +253,37 @@ describe("handleSimulateRouter", () => {
     providerStub = makeProvider([1, 2]);
 
     await handleSimulateRouter({
-      body: { query: "should not record" },
+      body: {
+        recentTurnPairs: [
+          { assistantMessage: "", userMessage: "should not record" },
+        ],
+      },
     });
 
     expect(recordCalls).toEqual([]);
   });
 
-  test("rejects an empty query at the schema layer", async () => {
+  test("rejects an empty last-pair userMessage at the schema layer", async () => {
     await expect(
-      handleSimulateRouter({ body: { query: "" } }),
+      handleSimulateRouter({
+        body: { recentTurnPairs: [{ assistantMessage: "", userMessage: "" }] },
+      }),
+    ).rejects.toThrow();
+  });
+
+  test("rejects an empty recentTurnPairs array at the schema layer", async () => {
+    await expect(
+      handleSimulateRouter({ body: { recentTurnPairs: [] } }),
     ).rejects.toThrow();
   });
 
   test("rejects negative tier size at the schema layer", async () => {
     await expect(
       handleSimulateRouter({
-        body: { query: "test", configOverrides: { tier1_size: -5 } },
+        body: {
+          recentTurnPairs: [{ assistantMessage: "", userMessage: "test" }],
+          configOverrides: { tier1_size: -5 },
+        },
       }),
     ).rejects.toThrow();
   });