@vellumai/assistant 0.10.12 → 0.11.0-staging.2

package/src/__tests__/tool-execution-pipeline.benchmark.test.ts

@@ -19,6 +19,7 @@
 import { beforeAll, describe, expect, mock, test } from "bun:test";
 
 import * as realPlatform from "../util/platform.js";
+import { installThresholdReaderMock } from "./gateway-threshold-reader-mock.js";
 
 // Local registry for ToolExecutor tests — the mock delegates to this map
 // so that registerTool/getTool/getAllTools work for our benchmark tools.
@@ -54,13 +55,15 @@ mock.module("../util/platform.js", () => ({
   getDeprecatedDir: () => "/tmp/deprecated",
 }));
 
-mock.module("../permissions/gateway-threshold-reader.js", () => ({
-  getAutoApproveThreshold: async () => undefined,
-  refreshAutoApproveThreshold: async () => null,
-}));
+// Mock defaults: no threshold, and no cell at any cascade level — the
+// benchmark measures the pipeline, not the channel matrix.
+installThresholdReaderMock();
 
+const realWorkspacePolicy = await import("../permissions/workspace-policy.js");
 mock.module("../permissions/workspace-policy.js", () => ({
+  ...realWorkspacePolicy,
   isWorkspaceScopedInvocation: () => false,
+  isOutOfWorkspaceFileInvocation: () => false,
   isPathWithinWorkspaceRoot: () => false,
 }));
 

package/src/__tests__/tool-executor.test.ts

@@ -128,6 +128,7 @@ mock.module("../tools/registry.js", () => ({
 
 mock.module("../tools/shared/filesystem/path-policy.js", () => ({
   sandboxPolicy: () => ({ ok: false }),
+  sandboxPolicyWithHostFallback: () => ({ ok: false }),
   hostPolicy: () => ({ ok: false }),
 }));
 
@@ -1397,3 +1398,118 @@ describe("ToolExecutor thrown-value rendering", () => {
     expect(result.content).toContain("unexpected error: boom");
   });
 });
+
+describe("ToolExecutor input-schema validation gate", () => {
+  beforeEach(() => {
+    fakeToolResult = { content: "ok", isError: false };
+    getToolOverride = undefined;
+    getAllToolsOverride = undefined;
+    checkResultOverride = undefined;
+    checkFnOverride = undefined;
+    cachedAssessmentOverride = undefined;
+  });
+
+  /**
+   * Registry-shaped tool with an explicit owner and an execute that records
+   * the input it actually received (undefined until the tool runs).
+   */
+  function ownedTool(
+    name: string,
+    ownerKind: string,
+  ): { seenInput: () => Record<string, unknown> | undefined } {
+    let seen: Record<string, unknown> | undefined;
+    getToolOverride = (n: string) =>
+      n === name
+        ? ({
+            name,
+            description: "owned tool",
+            category: "test",
+            defaultRiskLevel: RiskLevel.Low,
+            executionTarget: "sandbox" as const,
+            input_schema: { type: "object" as const, properties: {} },
+            execute: async (input: Record<string, unknown>) => {
+              seen = input;
+              return fakeToolResult;
+            },
+            owner: { kind: ownerKind, id: ownerKind },
+          } as unknown as Tool)
+        : undefined;
+    return { seenInput: () => seen };
+  }
+
+  test("malformed input for a built-in tool returns a clean error without executing", async () => {
+    const probe = ownedTool("file_write", "default");
+    const executor = new ToolExecutor(makePrompter());
+    const result = await executor.execute(
+      "file_write",
+      { path: 42, content: "hello" },
+      makeContext(),
+    );
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('Invalid input for tool "file_write"');
+    expect(result.content).toContain("path:");
+    expect(probe.seenInput()).toBeUndefined();
+  });
+
+  test("valid input executes with catch-recovered data, unknown keys intact", async () => {
+    const probe = ownedTool("file_read", "default");
+    const executor = new ToolExecutor(makePrompter());
+    const result = await executor.execute(
+      "file_read",
+      { path: "a.txt", offset: "not-a-number", activity: "Reading a file" },
+      makeContext(),
+    );
+
+    expect(result.isError).toBe(false);
+    expect(probe.seenInput()).toEqual({
+      path: "a.txt",
+      activity: "Reading a file",
+    });
+  });
+
+  test("a non-default owner shadowing a registered name skips registry validation", async () => {
+    const probe = ownedTool("file_write", "workspace");
+    const executor = new ToolExecutor(makePrompter());
+    const result = await executor.execute(
+      "file_write",
+      { path: 42 },
+      makeContext(),
+    );
+
+    expect(result.isError).toBe(false);
+    expect(probe.seenInput()).toEqual({ path: 42 });
+  });
+
+  test("a built-in tool with no registered schema executes unchanged", async () => {
+    const probe = ownedTool("web_search", "default");
+    const executor = new ToolExecutor(makePrompter());
+    const result = await executor.execute(
+      "web_search",
+      { query: 42 },
+      makeContext(),
+    );
+
+    expect(result.isError).toBe(false);
+    expect(probe.seenInput()).toEqual({ query: 42 });
+  });
+
+  test("malformed input for a sensitive tool fails validation before any grant flow", async () => {
+    // An unknown actor invoking a sensitive built-in normally routes into the
+    // scoped-grant machinery inside checkPreExecutionGates. Malformed input
+    // must short-circuit BEFORE that point — the validation error proves the
+    // call never reached grant consumption or guardian escalation.
+    const probe = ownedTool("file_write", "default");
+    const executor = new ToolExecutor(makePrompter());
+    const result = await executor.execute(
+      "file_write",
+      { path: 42 },
+      makeContext({ trustClass: "unknown" }),
+    );
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('Invalid input for tool "file_write"');
+    expect(result.content).not.toContain("guardian");
+    expect(probe.seenInput()).toBeUndefined();
+  });
+});

package/src/__tests__/tool-grant-request-escalation.test.ts

@@ -228,6 +228,11 @@ describe("ToolApprovalHandler / grant-miss escalation", () => {
 
     // The guardian-facing question asks about the tool, never about the person.
     expect(emittedSignals.length).toBe(1);
+    // The in-app card is pinned to the conversation the escalated tool runs
+    // in — never left to LLM conversation routing.
+    expect(emittedSignals[0].conversationAffinityHint).toEqual({
+      vellum: "conv-1",
+    });
     const payload = emittedSignals[0].contextPayload as Record<string, unknown>;
     const questionText = payload.questionText as string;
     expect(questionText.startsWith("Approve tool: bash")).toBe(true);

package/src/__tests__/tool-preview-lifecycle.test.ts

@@ -48,9 +48,13 @@ mock.module("../persistence/conversation-crud.js", () => ({
   provenanceFromTrustContext: () => ({}),
   reserveMessage: reserveMessageMock,
   recordConversationPersistedSeq: (id: string, seq: number) => {
-    if (!Number.isFinite(seq) || seq <= 0) return;
+    if (!Number.isFinite(seq) || seq <= 0) {
+      return;
+    }
     const prev = persistedSeqByConversation.get(id);
-    if (prev == null || prev < seq) persistedSeqByConversation.set(id, seq);
+    if (prev == null || prev < seq) {
+      persistedSeqByConversation.set(id, seq);
+    }
   },
   getConversationPersistedSeq: (id: string) =>
     persistedSeqByConversation.get(id) ?? null,
@@ -70,7 +74,7 @@ mock.module("../plugins/defaults/memory/memory-recall-log-store.js", () => ({
 }));
 
 mock.module(
-  "../plugins/defaults/memory/memory-v2-activation-log-store.js",
+  "../plugins/defaults/memory/v2/activation-log-store.js",
   () => ({
     backfillMemoryV2ActivationMessageId: () => {},
   }),
@@ -78,6 +82,7 @@ mock.module(
 
 // ── Imports (after mocks) ─────────────────────────────────────────────────────
 import type { AgentEvent } from "../agent/loop.js";
+import type { AssistantEvent, AssistantEventEnvelope } from "../api/index.js";
 import type {
   EventHandlerDeps,
   EventHandlerState,
@@ -91,9 +96,7 @@ import {
   handleToolUse,
   handleToolUsePreviewStart,
 } from "../daemon/conversation-agent-loop-handlers.js";
-import type { ServerMessage } from "../daemon/message-protocol.js";
 import { getConversationPersistedSeq } from "../persistence/conversation-crud.js";
-import type { AssistantEvent } from "../runtime/assistant-event.js";
 import {
   _resetStreamStateForTesting,
   getCurrentSeq,
@@ -105,7 +108,7 @@ import {
 function createMockDeps(
   overrides: Partial<EventHandlerDeps> = {},
 ): EventHandlerDeps {
-  const emittedEvents: ServerMessage[] = [];
+  const emittedEvents: AssistantEvent[] = [];
   const emittedActivityStates: Array<{
     phase: string;
     reason: string;
@@ -135,7 +138,7 @@ function createMockDeps(
       markWorkspaceTopLevelDirty: () => {},
       currentTurnSurfaces: [],
     } as unknown as EventHandlerDeps["ctx"],
-    onEvent: (msg: ServerMessage) => {
+    onEvent: (msg: AssistantEvent) => {
       emittedEvents.push(msg);
     },
     reqId: "test-req-id",
@@ -158,7 +161,7 @@ function createMockDeps(
 
 /** Collect events by wrapping onEvent. */
 function createEventCollector(): {
-  events: ServerMessage[];
+  events: AssistantEvent[];
   activityStates: Array<{
     phase: string;
     reason: string;
@@ -166,14 +169,14 @@ function createEventCollector(): {
     requestId?: string;
     statusText?: string;
   }>;
-  onEvent: (msg: ServerMessage) => void;
+  onEvent: (msg: AssistantEvent) => void;
   emitActivityState: (
     phase: string,
     reason: string,
     options?: { anchor?: string; requestId?: string; statusText?: string },
   ) => void;
 } {
-  const events: ServerMessage[] = [];
+  const events: AssistantEvent[] = [];
   const activityStates: Array<{
     phase: string;
     reason: string;
@@ -184,7 +187,7 @@ function createEventCollector(): {
   return {
     events,
     activityStates,
-    onEvent: (msg: ServerMessage) => events.push(msg),
+    onEvent: (msg: AssistantEvent) => events.push(msg),
     emitActivityState: (phase, reason, options) =>
       activityStates.push({
         phase,
@@ -392,9 +395,9 @@ describe("tool preview lifecycle", () => {
       const collector = createEventCollector();
       const conversationId = "test-session-id";
       const deps = createMockDeps({
-        onEvent: (msg: ServerMessage) => {
+        onEvent: (msg: AssistantEvent) => {
           collector.events.push(msg);
-          stampAndBuffer(msg as unknown as AssistantEvent);
+          stampAndBuffer(msg as unknown as AssistantEventEnvelope);
         },
         ctx: {
           ...createMockDeps().ctx,
@@ -408,12 +411,12 @@ describe("tool preview lifecycle", () => {
         type: "assistant_text_delta",
         text: "hello",
         conversationId,
-      } as unknown as AssistantEvent);
+      } as unknown as AssistantEventEnvelope);
       stampAndBuffer({
         type: "assistant_text_delta",
         text: " world",
         conversationId,
-      } as unknown as AssistantEvent);
+      } as unknown as AssistantEventEnvelope);
 
       // WHEN a tool_use is handled (its block is already durable)
       handleToolUse(state, deps, {
@@ -430,7 +433,7 @@ describe("tool preview lifecycle", () => {
       expect(toolUseStart).toBeDefined();
       expect(getConversationPersistedSeq(conversationId)).toBe(getCurrentSeq());
       expect(getConversationPersistedSeq(conversationId)).toBe(
-        (toolUseStart as unknown as AssistantEvent).seq ?? null,
+        (toolUseStart as unknown as AssistantEventEnvelope).seq ?? null,
       );
     });
   });
@@ -446,12 +449,12 @@ describe("tool preview lifecycle", () => {
     /** onEvent that stamps conversation-scoped events like the runtime hub. */
     function makeStampingDeps(
       overrides: Partial<EventHandlerDeps["ctx"]> = {},
-    ): { deps: EventHandlerDeps; events: ServerMessage[] } {
-      const events: ServerMessage[] = [];
+    ): { deps: EventHandlerDeps; events: AssistantEvent[] } {
+      const events: AssistantEvent[] = [];
       const deps = createMockDeps({
-        onEvent: (msg: ServerMessage) => {
+        onEvent: (msg: AssistantEvent) => {
           events.push(msg);
-          stampAndBuffer(msg as unknown as AssistantEvent);
+          stampAndBuffer(msg as unknown as AssistantEventEnvelope);
         },
         ctx: {
           ...createMockDeps().ctx,
@@ -494,7 +497,7 @@ describe("tool preview lifecycle", () => {
         },
       ]);
       expect(state.lastStreamedContentSeq).toBe(
-        (thinkingDelta as unknown as AssistantEvent).seq ?? undefined,
+        (thinkingDelta as unknown as AssistantEventEnvelope).seq ?? undefined,
       );
     });
 
@@ -531,7 +534,7 @@ describe("tool preview lifecycle", () => {
       expect(thinkingDelta).toBeDefined();
       expect(getConversationPersistedSeq(conversationId)).toBe(getCurrentSeq());
       expect(getConversationPersistedSeq(conversationId)).toBe(
-        (thinkingDelta as unknown as AssistantEvent).seq ?? null,
+        (thinkingDelta as unknown as AssistantEventEnvelope).seq ?? null,
       );
     });
 
@@ -562,7 +565,7 @@ describe("tool preview lifecycle", () => {
       expect(toolResult).toBeDefined();
       expect(getConversationPersistedSeq(conversationId)).toBe(getCurrentSeq());
       expect(getConversationPersistedSeq(conversationId)).toBe(
-        (toolResult as unknown as AssistantEvent).seq ?? null,
+        (toolResult as unknown as AssistantEventEnvelope).seq ?? null,
       );
     });
 
@@ -611,13 +614,13 @@ describe("tool preview lifecycle", () => {
     /** onEvent that stamps conversation-scoped events like the runtime hub. */
     function makeStampingDeps(): {
       deps: EventHandlerDeps;
-      events: ServerMessage[];
+      events: AssistantEvent[];
     } {
-      const events: ServerMessage[] = [];
+      const events: AssistantEvent[] = [];
       const deps = createMockDeps({
-        onEvent: (msg: ServerMessage) => {
+        onEvent: (msg: AssistantEvent) => {
           events.push(msg);
-          stampAndBuffer(msg as unknown as AssistantEvent);
+          stampAndBuffer(msg as unknown as AssistantEventEnvelope);
         },
         ctx: {
           ...createMockDeps().ctx,
@@ -803,7 +806,7 @@ describe("tool preview lifecycle", () => {
     /** Deps wired to a fresh collector. */
     function makeCollectingDeps(): {
       deps: EventHandlerDeps;
-      events: ServerMessage[];
+      events: AssistantEvent[];
     } {
       const collector = createEventCollector();
       const deps = createMockDeps({
@@ -817,7 +820,7 @@ describe("tool preview lifecycle", () => {
     }
 
     function emittedToolResult(
-      events: ServerMessage[],
+      events: AssistantEvent[],
     ): Record<string, unknown> {
       const toolResult = events.find((e) => e.type === "tool_result");
       expect(toolResult).toBeDefined();

package/src/__tests__/tool-result-metadata-plumbing.test.ts

@@ -26,6 +26,7 @@ mock.module("../persistence/llm-request-log-store.js", () => ({
 }));
 
 // ── Imports (after mocks) ─────────────────────────────────────────────────────
+import type { AssistantEvent } from "../api/index.js";
 import type {
   EventHandlerDeps,
   EventHandlerState,
@@ -34,18 +35,17 @@ import {
   createEventHandlerState,
   handleToolResult,
 } from "../daemon/conversation-agent-loop-handlers.js";
-import type { ServerMessage } from "../daemon/message-protocol.js";
 import type { ToolActivityMetadata } from "../daemon/message-types/web-activity.js";
 
-type ToolResultEvent = Extract<ServerMessage, { type: "tool_result" }>;
+type ToolResultEvent = Extract<AssistantEvent, { type: "tool_result" }>;
 
 // ── Helpers ───────────────────────────────────────────────────────────────────
 
 function createCollectorDeps(): {
   deps: EventHandlerDeps;
-  events: ServerMessage[];
+  events: AssistantEvent[];
 } {
-  const events: ServerMessage[] = [];
+  const events: AssistantEvent[] = [];
   const deps = {
     ctx: {
       conversationId: "conv-meta",
@@ -55,7 +55,7 @@ function createCollectorDeps(): {
       markWorkspaceTopLevelDirty: () => {},
       currentTurnSurfaces: [],
     } as unknown as EventHandlerDeps["ctx"],
-    onEvent: (msg: ServerMessage) => events.push(msg),
+    onEvent: (msg: AssistantEvent) => events.push(msg),
     reqId: "req-meta",
     isFirstMessage: false,
     shouldGenerateTitle: false,

package/src/__tests__/tool-side-effects-slack-dm.test.ts

@@ -54,6 +54,7 @@ mock.module("../apps/app-store.js", () => ({
   editAppFile: mock(() => ({})),
   inlineDistAssets: mock((_, html: string) => html),
   addAppConversationId: mock(() => false),
+  linkAppToConversationLineage: mock(() => {}),
 }));
 mock.module("../services/published-app-updater.js", () => ({
   updatePublishedAppDeployment: mock(() => Promise.resolve()),

package/src/__tests__/tool-start-timestamp.test.ts

@@ -39,6 +39,7 @@ mock.module("../runtime/assistant-stream-state.js", () => ({
 
 // ── Imports (after mocks) ─────────────────────────────────────────────────────
 import type { AgentEvent } from "../agent/loop.js";
+import type { AssistantEvent } from "../api/index.js";
 import type {
   EventHandlerDeps,
   EventHandlerState,
@@ -47,11 +48,10 @@ import {
   createEventHandlerState,
   handleToolUse,
 } from "../daemon/conversation-agent-loop-handlers.js";
-import type { ServerMessage } from "../daemon/message-protocol.js";
 
 // ── Helpers ───────────────────────────────────────────────────────────────────
 
-function makeDeps(onEvent: (event: ServerMessage) => void): EventHandlerDeps {
+function makeDeps(onEvent: (event: AssistantEvent) => void): EventHandlerDeps {
   return {
     ctx: {
       conversationId: "test-conv",
@@ -120,7 +120,7 @@ describe("handleToolUse — tool start timestamp", () => {
         input: { command: "ls" },
       },
     ]);
-    const events: ServerMessage[] = [];
+    const events: AssistantEvent[] = [];
     const before = Date.now();
 
     // WHEN the tool begins
@@ -155,7 +155,7 @@ describe("handleToolUse — tool start timestamp", () => {
         input: { command: "ls" },
       },
     ]);
-    const events: ServerMessage[] = [];
+    const events: AssistantEvent[] = [];
 
     // WHEN the tool begins
     handleToolUse(

package/src/__tests__/trusted-contact-lifecycle-notifications.test.ts

@@ -206,8 +206,9 @@ describe("trusted contact lifecycle notification signals", () => {
 
     await handleChannelInbound(guardianReq, undefined, TEST_BEARER_TOKEN);
 
-    // Should emit guardian_decision and denied signals
-
+    // A denial emits exactly one lifecycle signal — guardian_decision with
+    // decision: "denied". A second event for the same verdict would escape
+    // dedupe (distinct keys) and duplicate the guardian-facing notification.
     const guardianDecisionSignals = emitSignalCalls.filter(
       (c) => c.sourceEventName === "ingress.trusted_contact.guardian_decision",
     );
@@ -216,7 +217,7 @@ describe("trusted contact lifecycle notification signals", () => {
     );
 
     expect(guardianDecisionSignals.length).toBe(1);
-    expect(deniedSignals.length).toBe(1);
+    expect(deniedSignals.length).toBe(0);
 
     // Verify guardian_decision payload
     const gdPayload = guardianDecisionSignals[0].contextPayload as Record<
@@ -229,18 +230,9 @@ describe("trusted contact lifecycle notification signals", () => {
     expect(gdPayload.requesterDisplayName).toBe("Alice Requester");
     expect(gdPayload.decidedByDisplayName).toBe("Guardian Bob");
 
-    // Verify denied payload
-    const dPayload = deniedSignals[0].contextPayload as Record<string, unknown>;
-    expect(dPayload.decision).toBe("denied");
-    expect(dPayload.requesterExternalUserId).toBe("requester-user-456");
-    expect(dPayload.requesterDisplayName).toBe("Alice Requester");
-    expect(dPayload.decidedByDisplayName).toBe("Guardian Bob");
-
-    // Verify deduplication keys are distinct
     expect(guardianDecisionSignals[0].dedupeKey).toContain(
       "trusted-contact:guardian-decision:",
     );
-    expect(deniedSignals[0].dedupeKey).toContain("trusted-contact:denied:");
   });
 
   test("guardian approve emits guardian_decision and verification_sent signals with display names", async () => {
@@ -381,8 +373,11 @@ describe("trusted contact lifecycle notification signals", () => {
         typeof c.dedupeKey === "string" &&
         (c.dedupeKey as string).includes(approval.id),
     );
-    // guardian_decision and denied — both keyed on approval.id
-    expect(signals.length).toBe(2);
+    // Exactly one lifecycle signal per denial, keyed on the request id.
+    expect(signals.length).toBe(1);
+    expect(signals[0].sourceEventName).toBe(
+      "ingress.trusted_contact.guardian_decision",
+    );
   });
 
   test("display name fields fall back to null when contacts have no display name", async () => {
@@ -451,12 +446,8 @@ describe("trusted contact lifecycle notification signals", () => {
     const guardianDecisionSignals = emitSignalCalls.filter(
       (c) => c.sourceEventName === "ingress.trusted_contact.guardian_decision",
     );
-    const deniedSignals = emitSignalCalls.filter(
-      (c) => c.sourceEventName === "ingress.trusted_contact.denied",
-    );
 
     expect(guardianDecisionSignals.length).toBe(1);
-    expect(deniedSignals.length).toBe(1);
 
     // Verify display names fall back to null/empty when contacts have no
     // display name set.
@@ -469,10 +460,6 @@ describe("trusted contact lifecycle notification signals", () => {
     // The signal enrichment resolves displayName from the contact record,
     // so decidedByDisplayName will be "" (empty string) rather than null.
     expect(gdPayload.decidedByDisplayName).toBe("");
-
-    const dPayload = deniedSignals[0].contextPayload as Record<string, unknown>;
-    expect(dPayload.requesterDisplayName).toBeNull();
-    expect(dPayload.decidedByDisplayName).toBe("");
   });
 });
 

package/src/__tests__/ui-choice-copy-surfaces.test.ts

@@ -1,5 +1,6 @@
 import { describe, expect, test } from "bun:test";
 
+import type { AssistantEvent } from "../api/index.js";
 import {
   buildCompletionSummary,
   createSurfaceMutex,
@@ -10,7 +11,6 @@ import type {
   ChoiceSurfaceData,
   CopyBlockSurfaceData,
   OAuthConnectSurfaceData,
-  ServerMessage,
   SurfaceType,
   UiSurfaceShow,
 } from "../daemon/message-protocol.js";
@@ -18,7 +18,7 @@ import { INTERACTIVE_SURFACE_TYPES } from "../daemon/message-protocol.js";
 import { uiShowTool } from "../tools/ui-surface/definitions.js";
 import { uiShowTeachingError } from "../tools/ui-surface/surface-shape-docs.js";
 
-function makeContext(sent: ServerMessage[] = []): SurfaceConversationContext {
+function makeContext(sent: AssistantEvent[] = []): SurfaceConversationContext {
   return {
     conversationId: "session-1",
     sendToClient: (msg) => sent.push(msg),
@@ -67,7 +67,7 @@ describe("choice and copy_block surface definitions", () => {
 
 describe("choice and copy_block surface proxying", () => {
   test("ui_show normalizes choice options and creates recommended action payloads", async () => {
-    const sent: ServerMessage[] = [];
+    const sent: AssistantEvent[] = [];
     const ctx = makeContext(sent);
 
     const result = await surfaceProxyResolver(ctx, "ui_show", {
@@ -126,7 +126,7 @@ describe("choice and copy_block surface proxying", () => {
   });
 
   test("ui_show rejects choice surfaces without valid options", async () => {
-    const sent: ServerMessage[] = [];
+    const sent: AssistantEvent[] = [];
     const ctx = makeContext(sent);
 
     const result = await surfaceProxyResolver(ctx, "ui_show", {
@@ -142,7 +142,7 @@ describe("choice and copy_block surface proxying", () => {
   });
 
   test("ui_show passes copy_block data through without awaiting action", async () => {
-    const sent: ServerMessage[] = [];
+    const sent: AssistantEvent[] = [];
     const ctx = makeContext(sent);
 
     const result = await surfaceProxyResolver(ctx, "ui_show", {
@@ -174,7 +174,7 @@ describe("choice and copy_block surface proxying", () => {
   });
 
   test("ui_show passes oauth_connect data through and awaits action", async () => {
-    const sent: ServerMessage[] = [];
+    const sent: AssistantEvent[] = [];
     const ctx = makeContext(sent);
 
     const result = await surfaceProxyResolver(ctx, "ui_show", {
@@ -211,7 +211,7 @@ describe("choice and copy_block surface proxying", () => {
   });
 
   test("ui_show rejects oauth_connect without providerKey", async () => {
-    const sent: ServerMessage[] = [];
+    const sent: AssistantEvent[] = [];
     const ctx = makeContext(sent);
 
     const result = await surfaceProxyResolver(ctx, "ui_show", {
@@ -225,7 +225,7 @@ describe("choice and copy_block surface proxying", () => {
   });
 
   test("ui_show recovers copy_block data sent as a JSON-encoded string", async () => {
-    const sent: ServerMessage[] = [];
+    const sent: AssistantEvent[] = [];
     const ctx = makeContext(sent);
 
     const result = await surfaceProxyResolver(ctx, "ui_show", {
@@ -249,7 +249,7 @@ describe("choice and copy_block surface proxying", () => {
   });
 
   test("ui_show recovers copy_block fields placed at the top level of the input", async () => {
-    const sent: ServerMessage[] = [];
+    const sent: AssistantEvent[] = [];
     const ctx = makeContext(sent);
 
     const result = await surfaceProxyResolver(ctx, "ui_show", {
@@ -275,7 +275,7 @@ describe("choice and copy_block surface proxying", () => {
   });
 
   test("ui_show rejects an unknown surface_type with the valid values", async () => {
-    const sent: ServerMessage[] = [];
+    const sent: AssistantEvent[] = [];
     const ctx = makeContext(sent);
 
     const result = await surfaceProxyResolver(ctx, "ui_show", {
@@ -291,7 +291,7 @@ describe("choice and copy_block surface proxying", () => {
 
   test("ui_show rejects daemon-internal surface types and omits them from the valid list", async () => {
     for (const internalType of ["skill_card", "call_summary"]) {
-      const sent: ServerMessage[] = [];
+      const sent: AssistantEvent[] = [];
       const ctx = makeContext(sent);
 
       const result = await surfaceProxyResolver(ctx, "ui_show", {
@@ -325,7 +325,7 @@ describe("choice and copy_block surface proxying", () => {
   });
 
   test("uiShowTool.execute renders a copy_block whose text is at the top level", async () => {
-    const sent: ServerMessage[] = [];
+    const sent: AssistantEvent[] = [];
     const ctx = makeContext(sent);
     const result = await uiShowTool.execute(
       { surface_type: "copy_block", text: "bunx vellum doctor", data: {} },
@@ -347,7 +347,7 @@ describe("choice and copy_block surface proxying", () => {
   });
 
   test("uiShowTool.execute renders a dynamic_page whose html is at the top level", async () => {
-    const sent: ServerMessage[] = [];
+    const sent: AssistantEvent[] = [];
     const ctx = makeContext(sent);
     const result = await uiShowTool.execute(
       { surface_type: "dynamic_page", html: "<p>hello</p>", data: {} },