@vellumai/assistant 0.8.3 → 0.8.4

package/src/providers/inference/resolve-auth.ts

@@ -2,10 +2,11 @@
  * Resolves an `Auth` config into a `ResolvedAuth` that adapters consume.
  *
  * Resolution rules:
- *   - api_key  → fetch credential from vault → inject as bearer header
- *   - platform → build managed proxy URL and fetch the platform API key
- *   - none     → pass through with no auth headers
- *   - oauth_subscription / service_account → reject (v2 not yet shipped)
+ *   - api_key              → fetch credential from vault → inject as bearer header
+ *   - platform             → build managed proxy URL and fetch the platform API key
+ *   - none                 → pass through with no auth headers
+ *   - oauth_subscription   → fetch OAuth token from vault (with auto-refresh) → inject as bearer header
+ *   - service_account      → reject (v2 not yet shipped)
  */
 
 import {
@@ -13,7 +14,11 @@ import {
   resolveManagedProxyContext,
 } from "../../providers/platform-proxy/context.js";
 import { getSecureKeyAsync } from "../../security/secure-keys.js";
+import { getLogger } from "../../util/logger.js";
 import type { Auth, ResolvedAuth } from "./auth.js";
+import { PROVIDERS_REQUIRING_BASE_URL_AND_MODELS } from "./connections.js";
+
+const log = getLogger("resolve-auth");
 
 export type ResolveAuthError =
   | { code: "credential_not_found"; credential: string }
@@ -27,6 +32,19 @@ export async function resolveAuth(
 ): Promise<
   { ok: true; resolved: ResolvedAuth } | { ok: false; error: ResolveAuthError }
 > {
+  // Defense-in-depth: strip baseUrl for providers that should not accept one.
+  // The route layer rejects base_url for non-openai-compatible providers, but
+  // this guard catches any code path that bypasses route validation (e.g.
+  // corrupted DB rows, direct calls from internal code).
+  let safeBaseUrl = opts.baseUrl;
+  if (safeBaseUrl && !PROVIDERS_REQUIRING_BASE_URL_AND_MODELS.has(provider)) {
+    log.warn(
+      { provider, baseUrl: safeBaseUrl },
+      `Stripping baseUrl for provider "${provider}" — base_url is only valid for openai-compatible providers.`,
+    );
+    safeBaseUrl = null;
+  }
+
   switch (auth.type) {
     case "api_key": {
       const value = await getSecureKeyAsync(auth.credential);
@@ -41,7 +59,7 @@ export async function resolveAuth(
         resolved: {
           kind: "header",
           headers: { Authorization: `Bearer ${value}` },
-          ...(opts.baseUrl ? { baseUrl: opts.baseUrl } : {}),
+          ...(safeBaseUrl ? { baseUrl: safeBaseUrl } : {}),
         },
       };
     }
@@ -65,7 +83,32 @@ export async function resolveAuth(
     case "none":
       return { ok: true, resolved: { kind: "none" } };
 
-    case "oauth_subscription":
+    case "oauth_subscription": {
+      // Extract the credential prefix from the credential key.
+      // The credential field stores "credential/openai-codex/access_token";
+      // we need the prefix "credential/openai-codex" for the refresh logic.
+      const credentialPrefix = auth.credential.replace(/\/access_token$/, "");
+
+      const { getValidCodexAccessToken } = await import(
+        "./codex-token-refresh.js"
+      );
+      const token = await getValidCodexAccessToken(credentialPrefix);
+
+      if (!token) {
+        return {
+          ok: false,
+          error: { code: "credential_not_found", credential: auth.credential },
+        };
+      }
+      return {
+        ok: true,
+        resolved: {
+          kind: "header",
+          headers: { Authorization: `Bearer ${token}` },
+        },
+      };
+    }
+
     case "service_account":
       return {
         ok: false,

package/src/providers/model-catalog.ts

@@ -45,6 +45,13 @@ export interface CatalogModel {
   supportsVision?: boolean;
   supportsToolUse?: boolean;
   pricing?: CatalogModelPricing;
+  /**
+   * Upper bound for `reasoning_effort` accepted by this model's upstream API.
+   * Used by providers (e.g. Fireworks) to clamp Vellum's `xhigh`/`max` tiers
+   * down to whatever the model documents. Omit to inherit the provider
+   * default.
+   */
+  maxEffort?: "high" | "xhigh" | "max";
   /** When set, this model is only visible when the named feature flag is enabled. */
   featureFlag?: string;
 }
@@ -393,6 +400,21 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
       linkLabel: "Open Google AI Studio",
     },
     models: [
+      {
+        id: "gemini-3.5-flash",
+        displayName: "Gemini 3.5 Flash",
+        contextWindowTokens: 1048576,
+        maxOutputTokens: 65536,
+        supportsThinking: true,
+        supportsCaching: true,
+        supportsVision: true,
+        supportsToolUse: true,
+        pricing: {
+          inputPer1mTokens: 1.5,
+          outputPer1mTokens: 9.0,
+          cacheReadPer1mTokens: 0.15,
+        },
+      },
       {
         id: "gemini-3.1-pro-preview",
         displayName: "Gemini 3.1 Pro Preview",
@@ -589,6 +611,7 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
         supportsCaching: true,
         supportsVision: true,
         supportsToolUse: true,
+        maxEffort: "high",
         pricing: {
           inputPer1mTokens: 0.95,
           outputPer1mTokens: 4.0,
@@ -636,10 +659,11 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
         displayName: "DeepSeek V4 Pro",
         contextWindowTokens: 1040000,
         maxOutputTokens: 131072,
-        supportsThinking: false,
+        supportsThinking: true,
         supportsCaching: false,
         supportsVision: false,
         supportsToolUse: true,
+        maxEffort: "max",
         pricing: { inputPer1mTokens: 1.74, outputPer1mTokens: 3.48 },
       },
     ],
@@ -775,6 +799,17 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
         supportsToolUse: true,
         pricing: { inputPer1mTokens: 3, outputPer1mTokens: 15 },
       },
+      {
+        id: "x-ai/grok-4.3",
+        displayName: "Grok 4.3",
+        contextWindowTokens: 1000000,
+        maxOutputTokens: 16000,
+        supportsThinking: true,
+        supportsCaching: false,
+        supportsVision: true,
+        supportsToolUse: true,
+        pricing: { inputPer1mTokens: 1.25, outputPer1mTokens: 2.5 },
+      },
       {
         id: "x-ai/grok-4",
         displayName: "Grok 4",
@@ -1057,6 +1092,18 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
         supportsToolUse: true,
         pricing: { inputPer1mTokens: 0.8, outputPer1mTokens: 3.2 },
       },
+      // Owl (OpenRouter first-party)
+      {
+        id: "openrouter/owl-alpha",
+        displayName: "Owl Alpha",
+        contextWindowTokens: 1048576,
+        maxOutputTokens: 262144,
+        supportsThinking: false,
+        supportsCaching: false,
+        supportsVision: false,
+        supportsToolUse: true,
+        pricing: { inputPer1mTokens: 0, outputPer1mTokens: 0 },
+      },
     ],
     defaultModel: "x-ai/grok-4.20-beta",
     apiKeyUrl: "https://openrouter.ai/keys",

package/src/providers/openai/chat-completions-provider.ts

@@ -66,34 +66,56 @@ export interface OpenAIChatCompletionsProviderOptions {
   extraCreateParams?: Record<string, unknown>;
   /** Upper bound for `reasoning_effort` sent on the wire. Defaults to "xhigh"
    *  (OpenAI's current ceiling). Compatibility providers whose APIs only
-   *  document `low|medium|high` (e.g. Fireworks) should set this to "high" so
-   *  Vellum's `xhigh`/`max` tiers don't 4xx upstream. */
-  maxReasoningEffort?: "high" | "xhigh";
+   *  document `low|medium|high` should set this to "high" so Vellum's
+   *  `xhigh`/`max` tiers don't 4xx upstream. Set to "max" for providers like
+   *  Fireworks DeepSeek V4 that accept the full effort range. Subclasses can
+   *  override {@link OpenAIChatCompletionsProvider.resolveMaxReasoningEffort}
+   *  for per-model ceilings. */
+  maxReasoningEffort?: "high" | "xhigh" | "max";
   /** Parse `<think>...</think>` tags from the content stream into thinking
    *  blocks. MiniMax and similar providers embed reasoning inside XML-style
    *  tags in the regular content field rather than using `reasoning_content`. */
   parseThinkTags?: boolean;
 }
 
-/** Map our internal effort values to OpenAI's reasoning_effort parameter.
- *  OpenAI caps at "xhigh", so our "max" tier collapses to "xhigh". `"none"` is
- *  passed through explicitly because OpenAI defaults `reasoning_effort` to
- *  "medium" when the field is omitted — the user's opt-out is only honored
- *  when we send it on the wire. */
-export const EFFORT_TO_REASONING_EFFORT: Record<
-  string,
-  NonNullable<
-    OpenAI.Chat.Completions.ChatCompletionCreateParams["reasoning_effort"]
-  >
-> = {
+/** Wire-level reasoning_effort values. The OpenAI SDK type doesn't include
+ *  `"max"`, but Fireworks accepts it for DeepSeek V4; the assignment to
+ *  `params.reasoning_effort` casts through this union. */
+type ReasoningEffortWire = "none" | "low" | "medium" | "high" | "xhigh" | "max";
+
+const REASONING_EFFORT_RANK: Record<ReasoningEffortWire, number> = {
+  none: 0,
+  low: 1,
+  medium: 2,
+  high: 3,
+  xhigh: 4,
+  max: 5,
+};
+
+/** Map our internal effort values to a reasoning_effort wire value. `"max"`
+ *  is emitted raw — providers cap it down to their own ceiling
+ *  ({@link OpenAIChatCompletionsProviderOptions.maxReasoningEffort}) at send
+ *  time. `"none"` is passed through explicitly because OpenAI-compatible APIs
+ *  default `reasoning_effort` to `"medium"` when the field is omitted, so the
+ *  user's opt-out is only honored when we send it on the wire. */
+export const EFFORT_TO_REASONING_EFFORT: Record<string, ReasoningEffortWire> = {
   none: "none",
   low: "low",
   medium: "medium",
   high: "high",
   xhigh: "xhigh",
-  max: "xhigh",
+  max: "max",
 };
 
+export function clampReasoningEffort(
+  value: ReasoningEffortWire,
+  ceiling: "high" | "xhigh" | "max",
+): ReasoningEffortWire {
+  return REASONING_EFFORT_RANK[value] > REASONING_EFFORT_RANK[ceiling]
+    ? ceiling
+    : value;
+}
+
 const OPENAI_SUPPORTED_IMAGE_TYPES = new Set([
   "image/jpeg",
   "image/png",
@@ -122,7 +144,7 @@ export class OpenAIChatCompletionsProvider implements Provider {
   private model: string;
   private streamTimeoutMs: number;
   private extraCreateParams: Record<string, unknown>;
-  private maxReasoningEffort: "high" | "xhigh";
+  private maxReasoningEffort: "high" | "xhigh" | "max";
   private requestHeaders: Record<string, string>;
   private parseThinkTags: boolean;
 
@@ -187,10 +209,13 @@ export class OpenAIChatCompletionsProvider implements Provider {
         ? EFFORT_TO_REASONING_EFFORT[effort]
         : undefined;
       if (reasoningEffort && typeof nestedReasoningEffort !== "string") {
-        params.reasoning_effort =
-          reasoningEffort === "xhigh" && this.maxReasoningEffort === "high"
-            ? "high"
-            : reasoningEffort;
+        const ceiling = this.resolveMaxReasoningEffort(
+          modelOverride ?? this.model,
+        );
+        params.reasoning_effort = clampReasoningEffort(
+          reasoningEffort,
+          ceiling,
+        ) as OpenAI.Chat.Completions.ChatCompletionCreateParams["reasoning_effort"];
       }
 
       if (tools && tools.length > 0) {
@@ -546,6 +571,18 @@ export class OpenAIChatCompletionsProvider implements Provider {
     return this.extraCreateParams;
   }
 
+  /**
+   * Per-request reasoning_effort ceiling. Defaults to the provider-wide
+   * `maxReasoningEffort` from constructor options. Subclasses (e.g. Fireworks)
+   * override to consult the model catalog so per-model accepted ranges are
+   * respected.
+   */
+  protected resolveMaxReasoningEffort(
+    _model: string,
+  ): "high" | "xhigh" | "max" {
+    return this.maxReasoningEffort;
+  }
+
   /** Convert neutral messages + system prompt to OpenAI message format. */
   private toOpenAIMessages(
     messages: Message[],

package/src/providers/openai/responses-provider.ts

@@ -23,6 +23,9 @@ export interface OpenAIResponsesProviderOptions {
   providerLabel?: string;
   streamTimeoutMs?: number;
   useNativeWebSearch?: boolean;
+  /** When true, target the Codex subscription endpoint and strip fields it
+   *  rejects (`max_output_tokens`, `metadata`). */
+  codexSubscription?: boolean;
 }
 
 /** Map our internal effort values to the Responses API reasoning.effort parameter.
@@ -103,6 +106,7 @@ export class OpenAIResponsesProvider implements Provider {
   private model: string;
   private streamTimeoutMs: number;
   private useNativeWebSearch: boolean;
+  private codexSubscription: boolean;
 
   constructor(
     apiKey: string,
@@ -111,9 +115,12 @@ export class OpenAIResponsesProvider implements Provider {
   ) {
     this.name = options.providerName ?? "openai";
     this.providerLabel = options.providerLabel ?? "OpenAI";
+    this.codexSubscription = options.codexSubscription ?? false;
     this.client = new OpenAI({
       apiKey,
-      baseURL: options.baseURL,
+      baseURL: this.codexSubscription
+        ? "https://chatgpt.com/backend-api/codex"
+        : options.baseURL,
     });
     this.model = model;
     this.streamTimeoutMs = options.streamTimeoutMs ?? 1_800_000;
@@ -142,7 +149,6 @@ export class OpenAIResponsesProvider implements Provider {
       const params: Record<string, unknown> = {
         model: modelOverride ?? this.model,
         input,
-        store: false,
       };
 
       if (systemPrompt) {
@@ -152,7 +158,7 @@ export class OpenAIResponsesProvider implements Provider {
         );
       }
 
-      if (maxTokens) {
+      if (maxTokens && !this.codexSubscription) {
         params.max_output_tokens = maxTokens;
       }
 

package/src/providers/openrouter/client.ts

@@ -1,6 +1,7 @@
 import { ProviderError } from "../../util/errors.js";
 import { AnthropicProvider } from "../anthropic/client.js";
 import {
+  clampReasoningEffort,
   EFFORT_TO_REASONING_EFFORT,
   OpenAIChatCompletionsProvider,
 } from "../openai/chat-completions-provider.js";
@@ -200,7 +201,10 @@ export class OpenRouterProvider extends OpenAIChatCompletionsProvider {
     const summaryOverride = extractReasoningSummaryOverride(config);
     const reasoning: Record<string, unknown> = { enabled: thinkingEnabled };
     if (mappedEffort) {
-      reasoning.effort = mappedEffort;
+      reasoning.effort = clampReasoningEffort(
+        mappedEffort,
+        this.resolveMaxReasoningEffort(this.resolveEffectiveModel(options)),
+      );
     }
     if (thinkingEnabled) {
       reasoning.summary = summaryOverride ?? "detailed";

package/src/providers/types.ts

@@ -27,6 +27,15 @@ export interface FileContent {
     filename: string;
   };
   extracted_text?: string;
+  /**
+   * Internal id linking this block to a row in the attachments table.
+   * Set when the file block originates from a persisted user-message
+   * attachment so downstream consumers (DB joins, inline-chip
+   * positioning) can correlate the block back to its attachment id.
+   * Stripped by `daemon/handlers/shared.ts` before sending to the
+   * model.
+   */
+  _attachmentId?: string;
 }
 
 export interface ToolUseContent {
@@ -137,6 +146,22 @@ export type ProviderEvent =
       toolUseId: string;
       isError: boolean;
       content?: unknown[];
+      /**
+       * Finalized input for the server tool call (e.g. the actual query).
+       * Anthropic streams `server_tool_use` block input via `input_json_delta`
+       * events, so consumers reading the input at `server_tool_start` see `{}`.
+       * The provider accumulates the JSON and surfaces it here once the block
+       * stops, so downstream handlers can build accurate activity metadata.
+       */
+      resolvedInput?: Record<string, unknown>;
+      /**
+       * Provider-specific error code when `isError` is true (e.g. Anthropic's
+       * `max_uses_exceeded`, `query_too_long`). Surfaced so user-facing
+       * messages can be specific instead of a generic "Search failed".
+       */
+      errorCode?: string;
+      /** Optional human-readable error message from the provider. */
+      errorMessage?: string;
     };
 
 export interface SendMessageConfig {

package/src/runtime/__tests__/agent-wake.test.ts

@@ -22,8 +22,29 @@ import type { DiskPressureStatus } from "../../daemon/disk-pressure-guard.js";
 // Stub the DB-backed override-profile read so unit tests don't need a
 // real SQLite database. The wake helper calls this on every invocation
 // to honor the conversation's pinned inference profile.
+// `getConversation` is consumed by `defaultResolveTarget` — most tests
+// pass explicit `deps.resolveTarget` and bypass it, but the
+// trust-context threading test below drives the default resolver and
+// needs the existence/archived check to pass.
 mock.module("../../memory/conversation-crud.js", () => ({
   getConversationOverrideProfile: () => undefined,
+  getConversation: () => ({ archivedAt: null }),
+}));
+
+const mockGetOrCreateConversationCalls: Array<{
+  conversationId: string;
+  options: unknown;
+}> = [];
+mock.module("../../daemon/conversation-store.js", () => ({
+  getOrCreateConversation: (conversationId: string, options?: unknown) => {
+    mockGetOrCreateConversationCalls.push({ conversationId, options });
+    return Promise.resolve({ __mockConversation: true });
+  },
+}));
+
+let mockResolverTarget: unknown = null;
+mock.module("../../daemon/wake-target-adapter.js", () => ({
+  conversationToWakeTarget: () => mockResolverTarget,
 }));
 
 mock.module("../../config/loader.js", () => ({
@@ -248,6 +269,8 @@ function makeTarget(options: {
 beforeEach(() => {
   __resetWakeChainForTests();
   recordRequestLogCalls.length = 0;
+  mockGetOrCreateConversationCalls.length = 0;
+  mockResolverTarget = null;
   mockDiskPressureStatus = {
     enabled: false,
     state: "disabled",
@@ -1587,4 +1610,195 @@ describe("wakeAgentForOpportunity", () => {
     // No log row was inserted because JSON.stringify threw.
     expect(recordRequestLogCalls).toHaveLength(0);
   });
+
+  // Regression guard for fork-based memory retrospectives: PR #31260
+  // forked a conversation and waked it with a guardian trustContext,
+  // but the wake's default resolver called
+  // `getOrCreateConversation(conversationId)` with no options, so the
+  // store hydrated with `trustContext === undefined`. `loadFromDb`
+  // fail-closes to `trustClass: "unknown"` and filters out every
+  // guardian-provenance message — so the LLM saw an empty history and
+  // every fork sent `messages: []`. Threading trustContext through
+  // ensures `setTrustContext` + `ensureActorScopedHistory` run during
+  // hydration.
+  const makeDefaultResolverTarget = (conversationId: string): WakeTarget => {
+    const history: Message[] = [];
+    let processing = false;
+    return {
+      conversationId,
+      agentLoop: { run: async (input) => input },
+      getMessages: () => history,
+      pushMessage: () => {},
+      emitAgentEvent: () => {},
+      isProcessing: () => processing,
+      markProcessing: (on) => {
+        processing = on;
+      },
+      persistTailMessage: async () => {},
+    };
+  };
+
+  test("default resolver threads WakeOptions.trustContext into getOrCreateConversation", async () => {
+    mockResolverTarget = makeDefaultResolverTarget("conv-thread-trust");
+    const trustContext = {
+      sourceChannel: "vellum",
+      trustClass: "guardian",
+    } as const;
+
+    await wakeAgentForOpportunity({
+      conversationId: "conv-thread-trust",
+      hint: "consolidate",
+      source: "memory_v2_consolidation",
+      trustContext,
+    });
+
+    expect(mockGetOrCreateConversationCalls).toEqual([
+      { conversationId: "conv-thread-trust", options: { trustContext } },
+    ]);
+  });
+
+  test("default resolver passes trustContext: undefined when WakeOptions.trustContext is omitted", async () => {
+    // Inbound user-turn wakes get trust via processMessage(); the wake
+    // must not synthesize a trust context out of thin air.
+    mockResolverTarget = makeDefaultResolverTarget("conv-no-trust-default");
+
+    await wakeAgentForOpportunity({
+      conversationId: "conv-no-trust-default",
+      hint: "x",
+      source: "unit-test",
+    });
+
+    expect(mockGetOrCreateConversationCalls).toEqual([
+      {
+        conversationId: "conv-no-trust-default",
+        options: { trustContext: undefined },
+      },
+    ]);
+  });
+
+  describe("suppressWakeSurface option", () => {
+    function makeCheckpointTarget(): {
+      target: WakeTarget;
+      persistedTailCalls: Message[];
+      wakeProducedOutputCalls: string[];
+    } {
+      const firstAssistant: Message = {
+        role: "assistant",
+        content: [
+          { type: "tool_use", id: "tu-1", name: "some_tool", input: {} },
+        ],
+      };
+      const toolResult: Message = {
+        role: "user",
+        content: [{ type: "tool_result", tool_use_id: "tu-1", content: "ok" }],
+      };
+      const persistedTailCalls: Message[] = [];
+      const baseline: Message[] = [
+        { role: "user", content: [{ type: "text", text: "hi" }] },
+      ];
+      const history: Message[] = [...baseline];
+      let processing = false;
+      const wakeProducedOutputCalls: string[] = [];
+
+      const target: WakeTarget = {
+        conversationId: "conv-suppress-surface",
+        agentLoop: {
+          run: async (_input, _onEvent, _signal, _requestId, onCheckpoint) => {
+            const runHistory: Message[] = [..._input];
+            runHistory.push(firstAssistant);
+            runHistory.push(toolResult);
+            await onCheckpoint!({
+              turnIndex: 0,
+              toolCount: 1,
+              hasToolUse: true,
+              history: runHistory,
+            });
+            return runHistory;
+          },
+        },
+        getMessages: () => history,
+        pushMessage: (msg) => {
+          history.push(msg);
+        },
+        emitAgentEvent: () => {},
+        isProcessing: () => processing,
+        markProcessing: (on) => {
+          processing = on;
+        },
+        persistTailMessage: async (msg) => {
+          persistedTailCalls.push(msg);
+        },
+        onWakeProducedOutput: (_source, _hint, surfaceId) => {
+          wakeProducedOutputCalls.push(surfaceId);
+        },
+      };
+      return { target, persistedTailCalls, wakeProducedOutputCalls };
+    }
+
+    test(
+      "default (suppressWakeSurface omitted) still injects the ui_surface " +
+        "card and calls onWakeProducedOutput",
+      async () => {
+        const { target, persistedTailCalls, wakeProducedOutputCalls } =
+          makeCheckpointTarget();
+
+        await wakeAgentForOpportunity(
+          {
+            conversationId: "conv-suppress-surface",
+            hint: "do the thing",
+            source: "memory_v2_consolidation",
+          },
+          { resolveTarget: async () => target },
+        );
+
+        // Existing behavior: card injected, broadcast fired exactly once.
+        expect(wakeProducedOutputCalls).toHaveLength(1);
+        const persistedFirst = persistedTailCalls[0];
+        expect(persistedFirst).toBeDefined();
+        const blocks = Array.isArray(persistedFirst!.content)
+          ? persistedFirst!.content
+          : [];
+        const uiBlock = blocks.find(
+          (b: { type?: string }) => b.type === "ui_surface",
+        );
+        expect(uiBlock).toBeDefined();
+      },
+    );
+
+    test(
+      "suppressWakeSurface: true produces output but skips the ui_surface " +
+        "card injection and the onWakeProducedOutput broadcast",
+      async () => {
+        const { target, persistedTailCalls, wakeProducedOutputCalls } =
+          makeCheckpointTarget();
+
+        await wakeAgentForOpportunity(
+          {
+            conversationId: "conv-suppress-surface",
+            hint: "do the thing",
+            source: "memory_v2_consolidation",
+            suppressWakeSurface: true,
+          },
+          { resolveTarget: async () => target },
+        );
+
+        // Tail still persisted (wake produced real output).
+        const persistedFirst = persistedTailCalls[0];
+        expect(persistedFirst).toBeDefined();
+        // First assistant tail message should NOT have a ui_surface block
+        // prepended at the front.
+        const blocks = Array.isArray(persistedFirst!.content)
+          ? persistedFirst!.content
+          : [];
+        const firstBlock = blocks[0] as { type?: string } | undefined;
+        expect(firstBlock?.type).not.toBe("ui_surface");
+        const uiBlock = blocks.find(
+          (b: { type?: string }) => b.type === "ui_surface",
+        );
+        expect(uiBlock).toBeUndefined();
+        // Live broadcast was suppressed.
+        expect(wakeProducedOutputCalls).toHaveLength(0);
+      },
+    );
+  });
 });