@vellumai/assistant 0.10.12 → 0.11.0-staging.1

package/src/daemon/conversation-process.ts

@@ -11,6 +11,7 @@ import {
   createAssistantMessage,
   createUserMessage,
 } from "../agent/message-types.js";
+import type { AssistantEvent } from "../api/index.js";
 import { listPendingRequestsByScopeOrEmpty } from "../channels/gateway-guardian-requests.js";
 import {
   parseChannelId,
@@ -56,10 +57,7 @@ import {
 } from "./conversation-slash.js";
 import { getModelInfo } from "./handlers/config-model.js";
 import { preactivateHostProxySkills } from "./host-proxy-preactivation.js";
-import type {
-  ServerMessage,
-  UserMessageAttachment,
-} from "./message-protocol.js";
+import type { UserMessageAttachment } from "./message-protocol.js";
 import { buildTransportHints } from "./transport-hints.js";
 import { resolveVerificationSessionIntent } from "./verification-session-intent.js";
 
@@ -192,7 +190,7 @@ export function formatCleanResult(result: CleanResult): string {
 /** Build a model_info event with fresh config data. */
 export async function buildModelInfoEvent(
   conversationId?: string,
-): Promise<ServerMessage> {
+): Promise<AssistantEvent> {
   return { type: "model_info", conversationId, ...(await getModelInfo()) };
 }
 
@@ -438,13 +436,15 @@ function repairPendingToolUseBlocks(conversation: Conversation): void {
 
 /**
  * Restore drained messages to the front of the queue, in their original
- * order, when another turn (e.g. a barged-in voice turn woken by the idle
- * transition) owns the processing lock. The lock holder's own finally block
- * re-drains the queue. A steered drain also re-arms `pendingSteerRepair` so
- * the re-drain promotes the steered head on its own instead of batching it
- * with tails; the tool-use repair it re-triggers is idempotent.
+ * order, when the drain cannot run them: another turn (e.g. a barged-in
+ * voice turn woken by the idle transition) owns the processing lock, or the
+ * dispatch threw before the turn took over. The next drain trigger (the lock
+ * holder's own finally block, or `kickQueueDrain`'s retry) picks them back
+ * up. A steered drain also re-arms `pendingSteerRepair` so the re-drain
+ * promotes the steered head on its own instead of batching it with tails;
+ * the tool-use repair it re-triggers is idempotent.
  */
-function requeueOnLockContention(
+function requeueDrainedMessages(
   conversation: Conversation,
   messages: QueuedMessage[],
   steered: boolean,
@@ -493,7 +493,9 @@ export async function drainQueue(
     if (!next) {
       return;
     }
-    return drainSingleMessage(conversation, next, reason, true);
+    return dispatchDrainWithRestore(conversation, [next], true, () =>
+      drainSingleMessage(conversation, next, reason, true),
+    );
   }
 
   const batch = await buildPassthroughBatch(conversation);
@@ -505,12 +507,122 @@ export async function drainQueue(
     if (!next) {
       return;
     }
-    return drainSingleMessage(conversation, next, reason);
+    return dispatchDrainWithRestore(conversation, [next], false, () =>
+      drainSingleMessage(conversation, next, reason),
+    );
   }
   if (batch.length === 1) {
-    return drainSingleMessage(conversation, batch[0], reason);
+    return dispatchDrainWithRestore(conversation, batch, false, () =>
+      drainSingleMessage(conversation, batch[0], reason),
+    );
+  }
+  return dispatchDrainWithRestore(conversation, batch, false, () =>
+    drainBatch(conversation, batch, reason),
+  );
+}
+
+/**
+ * Errors that already triggered a queue restore on their way up. Drains
+ * recurse (a dropped message's error path re-drains the remaining queue), so
+ * without the marker an inner dispatch failure would also restore the outer
+ * dispatch's messages — resurrecting a message whose sender was already told
+ * it failed.
+ */
+const restoredDrainErrors = new WeakSet<object>();
+
+/**
+ * Run a drain dispatch whose messages are already removed from the queue,
+ * restoring them to the front if the dispatch throws. `drainQueue` pops
+ * messages before the throw-prone turn-start steps (slash resolution,
+ * per-turn context application), so without the restore a retry would skip
+ * the failed message entirely: it drains the NEXT item, succeeds, and the
+ * removed message is silently lost with no `queue_drain_failed` event.
+ */
+async function dispatchDrainWithRestore(
+  conversation: Conversation,
+  messages: QueuedMessage[],
+  steered: boolean,
+  dispatch: () => Promise<void>,
+): Promise<void> {
+  try {
+    return await dispatch();
+  } catch (err) {
+    const alreadyRestored =
+      typeof err === "object" && err !== null && restoredDrainErrors.has(err);
+    if (!alreadyRestored) {
+      if (typeof err === "object" && err !== null) {
+        restoredDrainErrors.add(err);
+      }
+      requeueDrainedMessages(
+        conversation,
+        messages,
+        steered,
+        "Requeueing drained messages: drain dispatch threw",
+      );
+    }
+    throw err;
+  }
+}
+
+/**
+ * Fire-and-forget entry point for drain triggers that sit outside the drain
+ * promise chain (the agent loop's `finally`, route handlers releasing the
+ * processing lock). `drainQueue` is async — batch building awaits slash
+ * resolution and can throw — and nothing re-triggers a drain whose promise
+ * rejects: the queued messages would sit stranded until an unrelated later
+ * turn completes. This wrapper never rejects. A failed drain is retried
+ * once — `dispatchDrainWithRestore` has already returned any popped
+ * messages to the queue head, so the retry retries the same messages. If
+ * the retry also fails, every queued sender is notified so the stall is
+ * visible to the user instead of silent, and the messages remain queued
+ * for the next drain trigger.
+ *
+ * `origin` names the triggering site for log correlation.
+ */
+export async function kickQueueDrain(
+  conversation: Conversation,
+  reason: QueueDrainReason = "loop_complete",
+  origin?: string,
+): Promise<void> {
+  try {
+    await drainQueue(conversation, reason);
+    return;
+  } catch (err) {
+    log.error(
+      {
+        err,
+        conversationId: conversation.conversationId,
+        reason,
+        origin,
+        queueDepth: conversation.queue.length,
+      },
+      "drainQueue rejected; retrying once",
+    );
+  }
+  try {
+    await drainQueue(conversation, reason);
+  } catch (err) {
+    log.error(
+      {
+        err,
+        conversationId: conversation.conversationId,
+        reason,
+        origin,
+        queueDepth: conversation.queue.length,
+      },
+      "drainQueue retry rejected; queued messages remain stranded until the next drain trigger",
+    );
+    for (const queued of conversation.queue.snapshot()) {
+      queued.onEvent({
+        type: "error",
+        conversationId: conversation.conversationId,
+        requestId: queued.requestId,
+        message:
+          "The assistant couldn't start your queued message due to an internal error. The message is still queued and will be retried after the next reply; you can also cancel and resend it.",
+        category: "queue_drain_failed",
+      });
+    }
   }
-  return drainBatch(conversation, batch, reason);
 }
 
 async function drainSingleMessage(
@@ -526,7 +638,7 @@ async function drainSingleMessage(
   // requeue below stays as the TOCTOU backstop for a lock taken after
   // this check.
   if (conversation.isProcessing()) {
-    requeueOnLockContention(
+    requeueDrainedMessages(
       conversation,
       [next],
       steered,
@@ -952,7 +1064,7 @@ async function drainSingleMessage(
       // Another turn took the lock between this drain's dequeue and its
       // persist. The message is still valid — requeue it at the front and
       // stop; the lock holder's own finally re-drains the queue.
-      requeueOnLockContention(
+      requeueDrainedMessages(
         conversation,
         [next],
         steered,
@@ -1110,7 +1222,7 @@ async function drainBatch(
   // The head persist-busy requeue below stays as the TOCTOU backstop.
   // Steered drains never batch, so there is no steer promotion to restore.
   if (conversation.isProcessing()) {
-    requeueOnLockContention(
+    requeueDrainedMessages(
       conversation,
       batch,
       false,
@@ -1329,7 +1441,7 @@ async function drainBatch(
         // whole batch is still valid — requeue it at the front in order
         // and stop; the lock holder's finally re-drains the queue.
         conversation.preactivatedSkillIds = undefined;
-        requeueOnLockContention(
+        requeueDrainedMessages(
           conversation,
           batch,
           false,
@@ -1503,7 +1615,7 @@ async function drainBatch(
   const successfulEventSinks = Array.from(
     new Set(successfulBatch.map((qm) => qm.onEvent)),
   );
-  const fanOutOnEvent = (msg: ServerMessage) => {
+  const fanOutOnEvent = (msg: AssistantEvent) => {
     for (const onEvent of successfulEventSinks) {
       onEvent(msg);
     }
@@ -1567,7 +1679,7 @@ async function drainBatch(
 export interface ProcessMessageOptions {
   content: string;
   attachments: UserMessageAttachment[];
-  onEvent?: (msg: ServerMessage) => void;
+  onEvent?: (msg: AssistantEvent) => void;
   requestId?: string;
   activeSurfaceId?: string;
   currentPage?: string;

package/src/daemon/conversation-queue-manager.ts

@@ -5,6 +5,7 @@
  * agent loop is in flight.
  */
 
+import type { AssistantEvent } from "../api/index.js";
 import type {
   TurnChannelContext,
   TurnInterfaceContext,
@@ -12,7 +13,6 @@ import type {
 import type { AuthContext } from "../runtime/auth/types.js";
 import { getLogger } from "../util/logger.js";
 import type {
-  ServerMessage,
   UserMessageAttachment,
 } from "./message-protocol.js";
 import type { ConversationTransportMetadata } from "./message-types/conversations.js";
@@ -23,7 +23,7 @@ export interface QueuedMessage {
   content: string;
   attachments: UserMessageAttachment[];
   requestId: string;
-  onEvent: (msg: ServerMessage) => void;
+  onEvent: (msg: AssistantEvent) => void;
   activeSurfaceId?: string;
   currentPage?: string;
   metadata?: Record<string, unknown>;
@@ -156,7 +156,7 @@ export class MessageQueue {
    */
   shiftN(count: number): QueuedMessage[] {
     const n = Math.min(Math.max(0, count), this.items.length);
-    if (n === 0) return [];
+    if (n === 0) {return [];}
     const removed = this.items.splice(0, n);
     for (const item of removed) {
       this.currentBytes -= estimateItemBytes(item);
@@ -188,8 +188,8 @@ export class MessageQueue {
    */
   promoteToHead(requestId: string): QueuedMessage | undefined {
     const idx = this.items.findIndex((m) => m.requestId === requestId);
-    if (idx === -1) return undefined;
-    if (idx === 0) return this.items[0]; // already at head
+    if (idx === -1) {return undefined;}
+    if (idx === 0) {return this.items[0];} // already at head
     const [promoted] = this.items.splice(idx, 1);
     this.items.unshift(promoted);
     return promoted;
@@ -201,7 +201,7 @@ export class MessageQueue {
    */
   removeByRequestId(requestId: string): QueuedMessage | undefined {
     const idx = this.items.findIndex((m) => m.requestId === requestId);
-    if (idx === -1) return undefined;
+    if (idx === -1) {return undefined;}
     const [removed] = this.items.splice(idx, 1);
     this.currentBytes -= estimateItemBytes(removed);
     return removed;
@@ -220,7 +220,7 @@ function estimateItemBytes(item: QueuedMessage): number {
   let bytes = item.content.length * 2; // JS strings are UTF-16
   for (const a of item.attachments) {
     bytes += a.data.length * 2;
-    if (a.extractedText) bytes += a.extractedText.length * 2;
+    if (a.extractedText) {bytes += a.extractedText.length * 2;}
   }
   // Include transport metadata in the estimate so large transport
   // payloads (e.g. hostHomeDir, hostUsername) count against the budget.

package/src/daemon/conversation-runtime-assembly.ts

@@ -74,6 +74,7 @@ import { resolveCapabilities } from "../runtime/capabilities.js";
 import type { SubagentState } from "../subagent/types.js";
 import { TERMINAL_STATUSES } from "../subagent/types.js";
 import { canonicalizeInboundIdentity } from "../util/canonicalize-identity.js";
+import { channelSupportsInlineOptions } from "./channel-ui-capability.js";
 import { findConversationOrSubagent } from "./conversation-registry.js";
 import type { SurfaceShowPair } from "./conversation-surfaces.js";
 import { canonicalizeTimeZone, formatTurnTimestamp } from "./date-context.js";
@@ -97,6 +98,13 @@ export interface ChannelCapabilities {
   dashboardCapable: boolean;
   /** Whether the channel supports dynamic UI surfaces (ui_show / ui_update). */
   supportsDynamicUi: boolean;
+  /**
+   * Whether the channel's adapter can render inline tappable options — approval
+   * buttons and (next) question option pickers. Distinct from `supportsDynamicUi`:
+   * a text-only channel can render inline buttons without dynamic UI. Optional;
+   * absent is treated as `false`.
+   */
+  supportsInlineOptions?: boolean;
   /** Whether the channel supports voice/microphone input. */
   supportsVoiceInput: boolean;
   /** The client OS/interface identifier (e.g. "macos", "ios", "web"). */
@@ -282,6 +290,7 @@ export function resolveChannelCapabilities(
         channel,
         dashboardCapable: supportsDesktopUi,
         supportsDynamicUi: supportsDesktopUi || iface === "web",
+        supportsInlineOptions: channelSupportsInlineOptions(channel),
         supportsVoiceInput: supportsDesktopUi,
         clientOS: iface ?? undefined,
         chatType: resolvedChatType,
@@ -296,6 +305,7 @@ export function resolveChannelCapabilities(
         channel,
         dashboardCapable: false,
         supportsDynamicUi: false,
+        supportsInlineOptions: channelSupportsInlineOptions(channel),
         supportsVoiceInput: false,
         chatType: resolvedChatType,
       };
@@ -304,6 +314,7 @@ export function resolveChannelCapabilities(
         channel,
         dashboardCapable: false,
         supportsDynamicUi: false,
+        supportsInlineOptions: channelSupportsInlineOptions(channel),
         supportsVoiceInput: false,
         chatType: resolvedChatType,
       };
@@ -974,6 +985,11 @@ function placeholderForBlockType(type: ContentBlock["type"]): string | null {
     case "tool_result":
     case "web_search_tool_result":
       return "[tool result]";
+    // Surfaces normally ride with a `_surfaceFallback` text sibling that
+    // supplies the line, so this label is reached only by legacy rows that
+    // carry a bare card — better than rendering an empty transcript line.
+    case "ui_surface":
+      return "[card]";
     case "thinking":
     case "redacted_thinking":
     case "text":

package/src/daemon/conversation-store.ts

@@ -118,6 +118,9 @@ export async function getOrCreateConversation(
     (conversation.isStale() && !conversation.isProcessing())
   ) {
     if (conversation) {
+      // Stale rebuild: the conversation id lives on, so abort in-flight
+      // children but keep terminal subagent results readable for the
+      // retention window.
       getSubagentManager().abortAllForParent(conversationId);
       conversation.dispose();
     }
@@ -247,12 +250,15 @@ export async function getOrCreateConversation(
  * deleted conversation and trip FK constraints.
  */
 export function destroyActiveConversation(conversationId: string): void {
+  // Subagent teardown is keyed by parent id, not the live instance — an
+  // evicted parent still retains its terminal children, and deleting the
+  // conversation must take their records with it.
+  getSubagentManager().disposeAllForParent(conversationId);
   const conversation = findConversation(conversationId);
   if (!conversation) {
     return;
   }
   removeFromEvictor(conversationId);
-  getSubagentManager().abortAllForParent(conversationId);
   conversation.dispose();
   deleteConversation(conversationId);
   deleteConversationOptions(conversationId);
@@ -277,10 +283,12 @@ export function stopConversations(): void {
  */
 export function clearAllActiveConversations(): number {
   const count = conversationCount();
-  const subagentManager = getSubagentManager();
+  // Dispose subagents across ALL parents, not just the in-memory ones — an
+  // evicted parent still retains its terminal children, and clear-all must
+  // take their records with it.
+  getSubagentManager().disposeAllForAllParents();
   for (const id of conversationIds()) {
     removeFromEvictor(id);
-    subagentManager.abortAllForParent(id);
   }
   for (const conversation of allConversations()) {
     conversation.dispose();

package/src/daemon/conversation-surfaces.ts

@@ -2,6 +2,7 @@ import { v4 as uuid, v7 as uuidv7 } from "uuid";
 import { z } from "zod";
 
 import { SurfaceActionSchema } from "../api/events/ui-surface-show.js";
+import type { AssistantEvent } from "../api/index.js";
 import {
   CardSurfaceDataSchema,
   ChoiceSurfaceDataSchema,
@@ -76,7 +77,6 @@ import type {
   DynamicPagePreview,
   DynamicPageSurfaceData,
   FormSurfaceData,
-  ServerMessage,
   SurfaceAction,
   SurfaceData,
   SurfaceType,
@@ -818,7 +818,7 @@ export interface SurfaceConversationContext {
     channel: string;
     supportsDynamicUi: boolean;
   };
-  sendToClient(msg: ServerMessage): void;
+  sendToClient(msg: AssistantEvent): void;
   pendingSurfaceActions: Map<string, { surfaceType: SurfaceType }>;
   lastSurfaceAction: Map<
     string,
@@ -2001,7 +2001,7 @@ export async function handleSurfaceAction(
     // Pass conversationId so events without an inline conversationId (e.g.
     // text_delta) are published with the correct conversation scope and
     // reach the SSE subscriber filtered to this conversation.
-    const onEvent = (msg: ServerMessage) =>
+    const onEvent = (msg: AssistantEvent) =>
       broadcastMessage(msg, ctx.conversationId);
 
     const result = ctx.enqueueMessage({
@@ -2228,7 +2228,7 @@ export async function handleSurfaceAction(
   // Pass conversationId so events without an inline conversationId (e.g.
   // text_delta) are published with the correct conversation scope and
   // reach the SSE subscriber filtered to this conversation.
-  const onEvent = (msg: ServerMessage) =>
+  const onEvent = (msg: AssistantEvent) =>
     broadcastMessage(msg, ctx.conversationId);
 
   log.info(

package/src/daemon/conversation-tool-setup.ts

@@ -6,12 +6,14 @@
  * keeping the constructor body focused on wiring.
  */
 
+import type { AssistantEvent } from "../api/index.js";
 import {
   type HostProxyCapability,
   supportsHostProxy,
 } from "../channels/types.js";
 import { getIsPlatform } from "../config/env-registry.js";
 import { getConfig } from "../config/loader.js";
+import { isMemoryEnabled } from "../config/memory-v3-gate.js";
 import type { PermissionPrompter } from "../permissions/prompter.js";
 import type { SecretPrompter } from "../permissions/secret-prompter.js";
 import { getBindingByConversation } from "../persistence/external-conversation-store.js";
@@ -62,7 +64,10 @@ import {
   type UsageAttributionSnapshot,
 } from "../usage/attribution.js";
 import { getLogger } from "../util/logger.js";
-import { conversationSupportsDynamicUi } from "./channel-ui-capability.js";
+import {
+  conversationSupportsDynamicUi,
+  conversationSupportsGuardianQuestionCards,
+} from "./channel-ui-capability.js";
 import type { Conversation } from "./conversation.js";
 import { projectSkillTools } from "./conversation-skill-tools.js";
 import {
@@ -73,7 +78,6 @@ import {
   isDoordashCommand,
   markDoordashStepInProgress,
 } from "./doordash-steps.js";
-import type { ServerMessage } from "./message-protocol.js";
 import { runPostExecutionSideEffects } from "./tool-side-effects.js";
 import { FALLBACK_TURN_TRUST, resolveTrustClass } from "./trust-context.js";
 
@@ -176,8 +180,8 @@ export function getEffectiveEnabledPluginSet(conv: {
 // ── read-only pass classification ────────────────────────────────────
 
 /**
- * The ONLY tools allowed in a read-only subagent pass (the live-voice background
- * continuation, `subagentDenySideEffects`). This is a strict fail-safe allowlist
+ * The ONLY tools allowed in a read-only subagent pass
+ * (`subagentDenySideEffects`). This is a strict fail-safe allowlist
  * of tools known to be read-only. Everything else is refused, because:
  * - A side-effect denylist is inherently incomplete — low-risk core mutators
  *   (`remember`, `notify_parent`, `computer_use_*`, `delete_memory_page`, …) are
@@ -391,8 +395,8 @@ export function createToolExecutor(
       enabledPluginSet: effectiveEnabledPluginSet,
       sendToClient: (msg) => {
         // Tool context's sendToClient uses a loose { type: string; [key: string]: unknown }
-        // signature, but at runtime these are always ServerMessage instances.
-        ctx.sendToClient(msg as ServerMessage);
+        // signature, but at runtime these are always AssistantEvent instances.
+        ctx.sendToClient(msg as AssistantEvent);
         if (msg.type === "ui_surface_show") {
           // The tool-context sendToClient signature is loose, so the show
           // message's fields are untyped here; map them through the same
@@ -423,6 +427,8 @@ export function createToolExecutor(
       // channels that can't render dynamic surfaces (Telegram, SMS) instead of
       // emitting one the channel silently drops.
       supportsDynamicUi: conversationSupportsDynamicUi(ctx),
+      supportsGuardianQuestionCards:
+        conversationSupportsGuardianQuestionCards(ctx),
       proxyToolResolver: (
         toolName: string,
         proxyInput: Record<string, unknown>,
@@ -717,7 +723,7 @@ export function isToolActiveForContext(
   }
   if (name === "remember") {
     try {
-      return getConfig().memory?.enabled !== false;
+      return isMemoryEnabled(getConfig());
     } catch {
       return true;
     }

package/src/daemon/conversation-usage.ts

@@ -1,3 +1,4 @@
+import type { AssistantEvent } from "../api/index.js";
 import { getConfig } from "../config/loader.js";
 import { updateConversationUsage } from "../persistence/conversation-crud.js";
 import { recordUsageEvent } from "../persistence/llm-usage-store.js";
@@ -16,7 +17,7 @@ import {
   resolvePricingForUsageWithOverrides,
   usesAnthropicPricingRules,
 } from "../util/pricing.js";
-import type { ServerMessage, UsageStats } from "./message-protocol.js";
+import type { UsageStats } from "./message-protocol.js";
 
 const log = getLogger("conversation-usage");
 
@@ -27,12 +28,12 @@ export interface UsageContext {
 }
 
 function normalizeTokenCount(value: number | null | undefined): number {
-  if (typeof value !== "number" || !Number.isFinite(value)) return 0;
+  if (typeof value !== "number" || !Number.isFinite(value)) {return 0;}
   return Math.max(value, 0);
 }
 
 function asRecord(value: unknown): Record<string, unknown> | null {
-  if (typeof value !== "object" || value == null) return null;
+  if (typeof value !== "object" || value == null) {return null;}
   return value as Record<string, unknown>;
 }
 
@@ -42,7 +43,7 @@ function extractAnthropicCacheCreationFromResponse(
   const rawResponse = asRecord(response);
   const usage = asRecord(rawResponse?.usage);
   const cacheCreation = asRecord(usage?.cache_creation);
-  if (!cacheCreation) return null;
+  if (!cacheCreation) {return null;}
 
   return {
     ephemeral_5m_input_tokens: normalizeTokenCount(
@@ -64,7 +65,7 @@ function extractAnthropicCacheCreation(
 
   for (const response of responses) {
     const details = extractAnthropicCacheCreationFromResponse(response);
-    if (!details) continue;
+    if (!details) {continue;}
     foundDetails = true;
     ephemeral5mInputTokens += normalizeTokenCount(
       details.ephemeral_5m_input_tokens,
@@ -74,7 +75,7 @@ function extractAnthropicCacheCreation(
     );
   }
 
-  if (!foundDetails) return null;
+  if (!foundDetails) {return null;}
 
   return {
     ephemeral_5m_input_tokens: ephemeral5mInputTokens,
@@ -96,8 +97,8 @@ function extractAnthropicSpeed(
   for (const response of responses) {
     const rec = asRecord(response);
     const usage = asRecord(rec?.usage);
-    if (usage?.speed === "fast") return "fast";
-    if (usage?.speed === "standard") foundStandard = true;
+    if (usage?.speed === "fast") {return "fast";}
+    if (usage?.speed === "standard") {foundStandard = true;}
   }
   return foundStandard ? "standard" : null;
 }
@@ -143,7 +144,7 @@ function resolveAttribution(
     | null
     | undefined,
 ): UsageAttributionSnapshot | null {
-  if (attribution == null) return null;
+  if (attribution == null) {return null;}
   return isUsageAttributionSnapshot(attribution)
     ? attribution
     : resolveUsageAttribution(attribution);
@@ -154,7 +155,7 @@ export function recordUsage(
   inputTokens: number,
   outputTokens: number,
   model: string,
-  onEvent: (msg: ServerMessage) => void,
+  onEvent: (msg: AssistantEvent) => void,
   actor: UsageActor,
   requestId: string | null = null,
   cacheCreationInputTokens = 0,
@@ -165,7 +166,7 @@ export function recordUsage(
   attribution?: UsageAttributionInput | UsageAttributionSnapshot | null,
   cronRunId: string | null = null,
 ): void {
-  if (inputTokens <= 0 && outputTokens <= 0) return;
+  if (inputTokens <= 0 && outputTokens <= 0) {return;}
 
   const normalizedCacheCreationInputTokens = normalizeTokenCount(
     cacheCreationInputTokens,