@vellumai/assistant 0.10.12 → 0.11.0-staging.2

package/src/__tests__/log-redact.test.ts

@@ -26,6 +26,24 @@ describe("redactLogString", () => {
     expect(redactLogString(input)).toBe(input);
   });
 
+  test("redacts a whole PEM private-key block — body and footer, not just the header", () => {
+    // Synthetic fake PEM material only — never a real key. `redactLogString`
+    // replaces the matched span in place, so the match must cover
+    // header→body→footer or the base64 body and END footer leak into logs.
+    const fakeBody =
+      "MIIFAKEfakefakefakefakefakefakefakefakefake\n" +
+      "FAKEfakefakefakefakefakefakefakefakefake==";
+    const block = `-----BEGIN RSA PRIVATE KEY-----\n${fakeBody}\n-----END RSA PRIVATE KEY-----`;
+    const result = redactLogString(`error dumping key: ${block} <eol>`);
+    expect(result).toContain("[REDACTED]");
+    expect(result).not.toContain("MIIFAKE");
+    expect(result).not.toContain("FAKEfake");
+    expect(result).not.toContain("-----BEGIN");
+    expect(result).not.toContain("-----END");
+    expect(result).toContain("error dumping key:");
+    expect(result).toContain("<eol>");
+  });
+
   describe("plugin-declared patterns", () => {
     // Synthetic token mirroring the incident's shape (never a real credential).
     const pluginKey = "virlo_tkn_Qm7pW2xLbV9sKjR4tNcY8dZh3Fg";

package/src/__tests__/managed-profile-guard.test.ts

@@ -1298,3 +1298,30 @@ describe("code-owned default profiles — echoes over stale on-disk bodies", ()
     expectNothingCommitted();
   });
 });
+
+// ---------------------------------------------------------------------------
+// PATCH /v1/config — legacy service-mode scrub
+// ---------------------------------------------------------------------------
+
+describe("PATCH /v1/config — provider-only services scrub legacy mode", () => {
+  test("a paired provider+mode write persists without the mode key", async () => {
+    // Web clients pair provider writes with `mode` so their saves stay valid
+    // on daemons whose schemas still carry it; the raw config must not
+    // resurrect the removed field on every save.
+    await patchRoute.handler({
+      body: {
+        services: {
+          "image-generation": { provider: "vellum", mode: "managed" },
+          "web-search": { provider: "vellum", mode: "managed" },
+        },
+      },
+    } as never);
+
+    const raw = committedRaw() as Record<
+      string,
+      Record<string, Record<string, unknown>>
+    >;
+    expect(raw.services["image-generation"]).toEqual({ provider: "vellum" });
+    expect(raw.services["web-search"]).toEqual({ provider: "vellum" });
+  });
+});

package/src/__tests__/managed-skill-lifecycle.test.ts

@@ -25,7 +25,7 @@ mock.module("../persistence/embeddings/embedding-backend.js", () => ({
   generateSparseEmbedding: () => ({ indices: [1], values: [1] }),
 }));
 
-mock.module("../plugins/defaults/memory/v3/substrate/qdrant.js", () => ({
+mock.module("../plugins/defaults/memory/substrate/qdrant.js", () => ({
   upsertConceptPageEmbedding: async (params: { slug: string }) => {
     seedUpsertSlugs.push(params.slug);
   },
@@ -41,7 +41,7 @@ import {
   _resetSkillStoreForTests,
   getSkillCapability,
   seedV2SkillEntries,
-} from "../plugins/defaults/memory/v3/substrate/skill-store.js";
+} from "../plugins/defaults/memory/substrate/skill-store.js";
 import { executeDeleteManagedSkill } from "../tools/skills/delete-managed.js";
 import { skillLoadTool } from "../tools/skills/load.js";
 import { executeScaffoldManagedSkill } from "../tools/skills/scaffold-managed.js";

package/src/__tests__/media-generate-image.test.ts

@@ -24,13 +24,13 @@ let lastGenerateCredentials: unknown = null;
 
 /**
  * Seed the image-generation service entry in the real workspace config.
- * Omitted fields fall back to the schema defaults (`mode: "your-own"`,
- * `provider: "gemini"`, model `gemini-3.1-flash-image-preview`).
+ * Omitted fields fall back to the schema defaults (`provider: "gemini"`,
+ * model `gemini-3.1-flash-image-preview`).
  */
 function seedImageGenService(
   overrides: {
-    mode?: "your-own" | "managed";
-    provider?: "gemini" | "openai";
+    provider?: "vellum" | "gemini" | "openai";
+    model?: string;
   } = {},
 ): void {
   setConfig("services", { "image-generation": overrides });
@@ -151,8 +151,8 @@ describe("image-studio skill script wrapper", () => {
     expect(result.content).toContain("No Gemini API key");
   });
 
-  test("managed mode uses managed proxy credentials", async () => {
-    seedImageGenService({ mode: "managed" });
+  test("provider vellum uses managed proxy credentials", async () => {
+    seedImageGenService({ provider: "vellum" });
     mockManagedBaseUrl = "https://platform.example.com/v1/runtime-proxy/gemini";
     mockManagedProxyContext = {
       enabled: true,
@@ -172,8 +172,59 @@ describe("image-studio skill script wrapper", () => {
     });
   });
 
-  test("managed mode returns error when managed proxy is unavailable", async () => {
-    seedImageGenService({ mode: "managed" });
+  test("provider vellum routes managed to the gemini proxy for gemini models", async () => {
+    seedImageGenService({ provider: "vellum" });
+    mockManagedProxyContext = {
+      enabled: true,
+      platformBaseUrl: "https://platform.example.com",
+      assistantApiKey: "managed-key-123",
+    };
+
+    const result = await run({ prompt: "a hippo" }, fakeContext);
+
+    expect(result.isError).toBe(false);
+    expect(lastGenerateProvider).toBe("gemini");
+    expect(lastGenerateCredentials).toEqual({
+      type: "managed-proxy",
+      assistantApiKey: "managed-key-123",
+      baseUrl: "https://platform.example.com/v1/runtime-proxy/gemini",
+    });
+  });
+
+  test("provider vellum routes a gpt model to the openai proxy", async () => {
+    seedImageGenService({ provider: "vellum", model: "gpt-image-2" });
+    mockManagedProxyContext = {
+      enabled: true,
+      platformBaseUrl: "https://platform.example.com",
+      assistantApiKey: "managed-key-123",
+    };
+
+    const result = await run({ prompt: "a hippo" }, fakeContext);
+
+    expect(result.isError).toBe(false);
+    expect(lastGenerateProvider).toBe("openai");
+    expect(lastGenerateCredentials).toEqual({
+      type: "managed-proxy",
+      assistantApiKey: "managed-key-123",
+      baseUrl: "https://platform.example.com/v1/runtime-proxy/openai",
+    });
+  });
+
+  test("provider vellum with no platform is a hard error, not a BYOK fallback", async () => {
+    // Billing rule: an explicit vellum choice never silently spends a stored
+    // provider key.
+    seedImageGenService({ provider: "vellum" });
+    mockGeminiKey = "gemini-key-should-not-be-used";
+
+    const result = await run({ prompt: "a hippo" }, fakeContext);
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain("Managed proxy is not available");
+    expect(lastGenerateProvider).toBeNull();
+  });
+
+  test("provider vellum returns error when managed proxy is unavailable", async () => {
+    seedImageGenService({ provider: "vellum" });
     mockGeminiKey = "direct-key"; // should be ignored in managed mode
     mockManagedBaseUrl = undefined;
 
@@ -184,7 +235,7 @@ describe("image-studio skill script wrapper", () => {
   });
 
   test("your-own mode uses direct API key", async () => {
-    seedImageGenService({ mode: "your-own" });
+    seedImageGenService({ provider: "gemini" });
     mockGeminiKey = "direct-key";
     mockManagedBaseUrl = "https://platform.example.com/v1/runtime-proxy/gemini";
     mockManagedProxyContext = {
@@ -365,8 +416,8 @@ describe("image-studio skill script wrapper", () => {
     );
   });
 
-  test("managed mode credential error includes guidance not to change service config", async () => {
-    seedImageGenService({ mode: "managed" });
+  test("provider vellum credential error includes guidance not to change service config", async () => {
+    seedImageGenService({ provider: "vellum" });
     mockManagedBaseUrl = undefined;
 
     const result = await run({ prompt: "a cat" }, fakeContext);

package/src/__tests__/memory-identity-context-parity.test.ts

@@ -27,7 +27,7 @@ mock.module("../prompts/persona-resolver.js", () => ({
 const { buildCoreIdentityContext } =
   await import("../prompts/system-prompt.js");
 const { buildIdentityContext } =
-  await import("../plugins/defaults/memory/identity-context.js");
+  await import("../plugins/defaults/memory/v1/identity-context.js");
 
 // ── Workspace fixtures ─────────────────────────────────────────────────
 

package/src/__tests__/memory-jobs-worker-lanes.test.ts

@@ -40,8 +40,13 @@ setDefaultTimeout(30_000);
 // claimed jobs without lane awareness and ran them through a single
 // workerConcurrency-sized pool — would pin its slots on the first claimed
 // slow jobs and force the fast jobs to queue behind a 200ms LLM call.
+// `memory.v2.enabled` is off so v1 is the active memory tier: the slow-lane
+// job here is `graph_consolidate`, whose handler completes v1 graph rows as
+// a no-op while concept-page memory is active — this test needs it to
+// genuinely run.
 // Everything else (including `memory.enabled: true`) is the schema default.
 setConfig("memory", {
+  v2: { enabled: false },
   jobs: {
     slowLlmConcurrency: 1,
     fastConcurrency: 5,
@@ -63,7 +68,7 @@ const completions: CompletionRecord[] = [];
 // job completes before any slow job — a single 200ms window is plenty.
 const SLOW_DELAY_MS = 200;
 
-mock.module("../plugins/defaults/memory/graph/consolidation.js", () => ({
+mock.module("../plugins/defaults/memory/v1/graph/consolidation.js", () => ({
   runConsolidation: async (
     scopeId: string,
   ): Promise<{
@@ -95,6 +100,9 @@ mock.module("../plugins/defaults/memory/v2/backfill-jobs.js", () => ({
     return 0;
   },
   memoryV2MigrateJob: async (): Promise<void> => {},
+}));
+
+mock.module("../plugins/defaults/memory/substrate/reembed-job.js", () => ({
   memoryV2ReembedJob: async (): Promise<void> => {},
 }));
 

package/src/__tests__/memory-retrieval-hook.test.ts

@@ -66,9 +66,9 @@ mock.module("../runtime/assistant-event-hub.js", () => ({
 
 import type { UserPromptSubmitContext } from "@vellumai/plugin-api";
 
+import type { AssistantEvent } from "../api/index.js";
 import type { AssistantConfig } from "../config/schema.js";
 import type { Conversation } from "../daemon/conversation.js";
-import type { ServerMessage } from "../daemon/message-protocol.js";
 import type { QdrantSparseVector } from "../persistence/embeddings/qdrant-client.js";
 import type { ConversationGraphMemory } from "../plugins/defaults/memory/graph/conversation-graph-memory.js";
 import userPromptSubmitMemoryRetrieval from "../plugins/defaults/memory/hooks/user-prompt-submit.js";
@@ -337,7 +337,7 @@ describe("user-prompt-submit hook (memory retrieval)", () => {
     expect(logEntry.reason).toBe("graph:none");
     // The `memory_recalled` summary publishes through the shared broadcast hub.
     expect(broadcastMessageMock).toHaveBeenCalledTimes(1);
-    const emitted = broadcastMessageMock.mock.calls[0]?.[0] as ServerMessage;
+    const emitted = broadcastMessageMock.mock.calls[0]?.[0] as AssistantEvent;
     expect(emitted.type).toBe("memory_recalled");
   });
 
@@ -449,7 +449,7 @@ describe("user-prompt-submit hook (memory retrieval)", () => {
         _msgs: Message[],
         _cfg: AssistantConfig,
         _signal: AbortSignal,
-        _onEvent: (msg: ServerMessage) => void,
+        _onEvent: (msg: AssistantEvent) => void,
       ) => Promise.reject(new Error("retrieval failed")),
     );
     const graphMemory = {
@@ -472,7 +472,7 @@ describe("user-prompt-submit hook (memory retrieval)", () => {
         _msgs: Message[],
         _cfg: AssistantConfig,
         signal: AbortSignal,
-        _onEvent: (msg: ServerMessage) => void,
+        _onEvent: (msg: AssistantEvent) => void,
       ) => {
         capturedSignal = signal;
         return {

package/src/__tests__/notification-decision-strategy.test.ts

@@ -19,7 +19,7 @@ import {
 import type { ConversationCandidateSet } from "../notifications/conversation-candidates.js";
 import { composeFallbackCopy } from "../notifications/copy-composer.js";
 import {
-  enforceGuardianCallConversationAffinity,
+  enforceGuardianRequestConversationAffinity,
   validateConversationActions,
 } from "../notifications/decision-engine.js";
 import {
@@ -945,9 +945,9 @@ describe("notification decision strategy", () => {
     });
   });
 
-  // -- Guardian call conversation affinity enforcement --------------------------------
+  // -- Guardian request conversation affinity enforcement -----------------------------
 
-  describe("guardian call conversation affinity enforcement", () => {
+  describe("guardian request conversation affinity enforcement", () => {
     function makeDecision(
       overrides?: Partial<NotificationDecision>,
     ): NotificationDecision {
@@ -979,7 +979,10 @@ describe("notification decision strategy", () => {
         },
       });
 
-      const result = enforceGuardianCallConversationAffinity(decision, signal);
+      const result = enforceGuardianRequestConversationAffinity(
+        decision,
+        signal,
+      );
       expect(result.conversationActions?.vellum).toEqual({
         action: "start_new",
       });
@@ -1004,7 +1007,10 @@ describe("notification decision strategy", () => {
         conversationAffinityHint: { vellum: "conv-123" },
       });
 
-      const result = enforceGuardianCallConversationAffinity(decision, signal);
+      const result = enforceGuardianRequestConversationAffinity(
+        decision,
+        signal,
+      );
       // Should remain unchanged — the affinity hint takes precedence
       expect(result.conversationActions?.vellum).toEqual({
         action: "reuse_existing",
@@ -1023,15 +1029,22 @@ describe("notification decision strategy", () => {
         contextPayload: { message: "Take out the trash" },
       });
 
-      const result = enforceGuardianCallConversationAffinity(decision, signal);
+      const result = enforceGuardianRequestConversationAffinity(
+        decision,
+        signal,
+      );
       expect(result.conversationActions?.vellum).toEqual({
         action: "reuse_existing",
         conversationId: "conv-456",
       });
     });
 
-    test("guardian.question without callSessionId is not affected", () => {
-      const decision = makeDecision();
+    test("guardian.question without callSessionId and no hint still forces start_new", () => {
+      const decision = makeDecision({
+        conversationActions: {
+          vellum: { action: "reuse_existing", conversationId: "conv-catchall" },
+        },
+      });
       const signal = makeSignal({
         sourceEventName: "guardian.question",
         contextPayload: {
@@ -1043,9 +1056,100 @@ describe("notification decision strategy", () => {
         },
       });
 
-      const result = enforceGuardianCallConversationAffinity(decision, signal);
-      // No callSessionId → no enforcement
-      expect(result.conversationActions).toBeUndefined();
+      const result = enforceGuardianRequestConversationAffinity(
+        decision,
+        signal,
+      );
+      // Un-pinned guardian requests must never reuse an LLM-chosen conversation
+      expect(result.conversationActions?.vellum).toEqual({
+        action: "start_new",
+      });
+    });
+
+    test("ingress.access_request without hint forces start_new over LLM reuse", () => {
+      const decision = makeDecision({
+        conversationActions: {
+          vellum: { action: "reuse_existing", conversationId: "conv-catchall" },
+        },
+      });
+      const signal = makeSignal({
+        sourceEventName: "ingress.access_request",
+        contextPayload: {
+          requestId: "access-req-1",
+          senderIdentifier: "Alice",
+        },
+      });
+
+      const result = enforceGuardianRequestConversationAffinity(
+        decision,
+        signal,
+      );
+      expect(result.conversationActions?.vellum).toEqual({
+        action: "start_new",
+      });
+    });
+
+    test("ingress.access_request with affinity hint is left to affinity enforcement", () => {
+      const decision = makeDecision({
+        conversationActions: {
+          vellum: { action: "reuse_existing", conversationId: "conv-origin" },
+        },
+      });
+      const signal = makeSignal({
+        sourceEventName: "ingress.access_request",
+        contextPayload: {
+          requestId: "access-req-2",
+          senderIdentifier: "Bob",
+        },
+        conversationAffinityHint: { vellum: "conv-origin" },
+      });
+
+      const result = enforceGuardianRequestConversationAffinity(
+        decision,
+        signal,
+      );
+      expect(result.conversationActions?.vellum).toEqual({
+        action: "reuse_existing",
+        conversationId: "conv-origin",
+      });
+    });
+
+    test("two unrelated un-pinned guardian requests never share a reuse target", () => {
+      // Simulates the LUM-2870 catch-all: the LLM offers the same recent
+      // guardian conversation as a reuse candidate for two unrelated
+      // requests. The guard must force each to start its own conversation.
+      const llmDecisionForRequest = () =>
+        makeDecision({
+          conversationActions: {
+            vellum: {
+              action: "reuse_existing",
+              conversationId: "conv-catchall",
+            },
+          },
+        });
+
+      const accessRequest = makeSignal({
+        sourceEventName: "ingress.access_request",
+        contextPayload: { requestId: "access-req-3" },
+      });
+      const toolGrant = makeSignal({
+        sourceEventName: "guardian.question",
+        contextPayload: {
+          requestId: "tool-grant-9",
+          requestKind: "tool_grant_request",
+          toolName: "host_bash",
+        },
+      });
+
+      for (const signal of [accessRequest, toolGrant]) {
+        const result = enforceGuardianRequestConversationAffinity(
+          llmDecisionForRequest(),
+          signal,
+        );
+        expect(result.conversationActions?.vellum).toEqual({
+          action: "start_new",
+        });
+      }
     });
   });
 });

package/src/__tests__/notification-deep-link.test.ts

@@ -98,7 +98,7 @@ mock.module("../notifications/conversation-pairing.js", () => ({
   },
 }));
 
-import type { ServerMessage } from "../daemon/message-protocol.js";
+import type { AssistantEvent } from "../api/index.js";
 import { VellumAdapter } from "../notifications/adapters/macos.js";
 import { NotificationBroadcaster } from "../notifications/broadcaster.js";
 import type { NotificationSignal } from "../notifications/signal.js";
@@ -179,7 +179,7 @@ describe("notification deep-link metadata", () => {
 
   describe("VellumAdapter", () => {
     test("broadcasts notification_intent with deepLinkMetadata from payload", async () => {
-      const messages: ServerMessage[] = [];
+      const messages: AssistantEvent[] = [];
       const adapter = new VellumAdapter((msg) => messages.push(msg));
 
       await adapter.send(
@@ -207,7 +207,7 @@ describe("notification deep-link metadata", () => {
     });
 
     test("broadcasts notification_intent without deepLinkMetadata when absent", async () => {
-      const messages: ServerMessage[] = [];
+      const messages: AssistantEvent[] = [];
       const adapter = new VellumAdapter((msg) => messages.push(msg));
 
       await adapter.send(
@@ -226,7 +226,7 @@ describe("notification deep-link metadata", () => {
     });
 
     test("includes conversationId in deepLinkMetadata for navigation", async () => {
-      const messages: ServerMessage[] = [];
+      const messages: AssistantEvent[] = [];
       const adapter = new VellumAdapter((msg) => messages.push(msg));
 
       const conversationId = "conv-deep-link-test";
@@ -279,7 +279,7 @@ describe("notification deep-link metadata", () => {
     });
 
     test("sourceEventName is included in the event payload", async () => {
-      const messages: ServerMessage[] = [];
+      const messages: AssistantEvent[] = [];
       const adapter = new VellumAdapter((msg) => messages.push(msg));
 
       await adapter.send(
@@ -296,7 +296,7 @@ describe("notification deep-link metadata", () => {
     });
 
     test("deepLinkMetadata with conversationId enables client-side navigation", async () => {
-      const messages: ServerMessage[] = [];
+      const messages: AssistantEvent[] = [];
       const adapter = new VellumAdapter((msg) => messages.push(msg));
 
       // Simulate a notification that should deep-link to a specific conversation
@@ -320,7 +320,7 @@ describe("notification deep-link metadata", () => {
     });
 
     test("deep-link payload includes messageId when present", async () => {
-      const messages: ServerMessage[] = [];
+      const messages: AssistantEvent[] = [];
       const adapter = new VellumAdapter((msg) => messages.push(msg));
 
       await adapter.send(
@@ -341,7 +341,7 @@ describe("notification deep-link metadata", () => {
     // ── Deep-link conversationId present regardless of reuse/new ──────
 
     test("deep-link payload includes conversationId for a newly created conversation", async () => {
-      const messages: ServerMessage[] = [];
+      const messages: AssistantEvent[] = [];
       const adapter = new VellumAdapter((msg) => messages.push(msg));
 
       // Simulates the broadcaster merging pairing.conversationId into deep-link
@@ -362,7 +362,7 @@ describe("notification deep-link metadata", () => {
     });
 
     test("deep-link payload includes conversationId for a reused conversation", async () => {
-      const messages: ServerMessage[] = [];
+      const messages: AssistantEvent[] = [];
       const adapter = new VellumAdapter((msg) => messages.push(msg));
 
       // Simulates the broadcaster merging pairing.conversationId into deep-link
@@ -388,7 +388,7 @@ describe("notification deep-link metadata", () => {
     // ── Reused conversation deep-link stability regressions ─────────────────
 
     test("reused conversation preserves the same conversationId across follow-up notifications", async () => {
-      const messages: ServerMessage[] = [];
+      const messages: AssistantEvent[] = [];
       const adapter = new VellumAdapter((msg) => messages.push(msg));
 
       const stableConversationId = "conv-bound-telegram-dest-001";
@@ -438,7 +438,7 @@ describe("notification deep-link metadata", () => {
     });
 
     test("reused conversation deep-link messageId changes per delivery for scroll targeting", async () => {
-      const messages: ServerMessage[] = [];
+      const messages: AssistantEvent[] = [];
       const adapter = new VellumAdapter((msg) => messages.push(msg));
 
       const conversationId = "conv-reused-scroll-test";
@@ -475,7 +475,7 @@ describe("notification deep-link metadata", () => {
     });
 
     test("deep-link metadata is stable when conversation is reused via binding-key continuation", async () => {
-      const messages: ServerMessage[] = [];
+      const messages: AssistantEvent[] = [];
       const adapter = new VellumAdapter((msg) => messages.push(msg));
 
       // Simulates the binding-key continuation path: multiple notifications

package/src/__tests__/notification-vellum-adapter.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, test } from "bun:test";
 
-import type { ServerMessage } from "../daemon/message-protocol.js";
+import type { AssistantEvent } from "../api/index.js";
 import { VellumAdapter } from "../notifications/adapters/macos.js";
 import type {
   ChannelDeliveryPayload,
@@ -30,9 +30,9 @@ function makeDestination(
 
 function captureBroadcast(): {
   adapter: VellumAdapter;
-  sent: ServerMessage[];
+  sent: AssistantEvent[];
 } {
-  const sent: ServerMessage[] = [];
+  const sent: AssistantEvent[] = [];
   const adapter = new VellumAdapter((msg) => sent.push(msg));
   return { adapter, sent };
 }
@@ -48,7 +48,7 @@ describe("VellumAdapter silent flag", () => {
     expect(result.success).toBe(true);
     expect(sent).toHaveLength(1);
     const intent = sent[0] as Extract<
-      ServerMessage,
+      AssistantEvent,
       { type: "notification_intent" }
     >;
     expect(intent.type).toBe("notification_intent");
@@ -60,7 +60,7 @@ describe("VellumAdapter silent flag", () => {
     await adapter.send(makePayload({ urgency: "medium" }), makeDestination());
 
     const intent = sent[0] as Extract<
-      ServerMessage,
+      AssistantEvent,
       { type: "notification_intent" }
     >;
     expect(intent.silent).toBe(true);
@@ -71,7 +71,7 @@ describe("VellumAdapter silent flag", () => {
     await adapter.send(makePayload({ urgency: "high" }), makeDestination());
 
     const intent = sent[0] as Extract<
-      ServerMessage,
+      AssistantEvent,
       { type: "notification_intent" }
     >;
     expect(intent.silent).toBe(false);
@@ -82,7 +82,7 @@ describe("VellumAdapter silent flag", () => {
     await adapter.send(makePayload({ urgency: "critical" }), makeDestination());
 
     const intent = sent[0] as Extract<
-      ServerMessage,
+      AssistantEvent,
       { type: "notification_intent" }
     >;
     expect(intent.silent).toBe(false);
@@ -101,7 +101,7 @@ describe("VellumAdapter silent flag", () => {
     );
 
     const intent = sent[0] as Extract<
-      ServerMessage,
+      AssistantEvent,
       { type: "notification_intent" }
     >;
     expect(intent.deliveryId).toBe("delivery-xyz");