@vellumai/assistant 0.11.7 → 0.11.8-staging.1

package/src/providers/model-catalog.ts

@@ -59,6 +59,12 @@ export interface CatalogModel {
    * `adaptiveThinkingOnly`.
    */
   adaptiveThinkingUnsupported?: boolean;
+  /**
+   * Lowest thinking level the model accepts on the Gemini wire. `"low"`
+   * means `"minimal"` is not a valid request. Omit when `"minimal"` is
+   * accepted.
+   */
+  thinkingFloor?: "minimal" | "low";
   supportsCaching?: boolean;
   supportsVision?: boolean;
   /**
@@ -77,6 +83,16 @@ export interface CatalogModel {
    * default.
    */
   maxEffort?: "high" | "xhigh" | "max";
+  /**
+   * Wire `reasoning_effort` values this model's upstream accepts, for models
+   * whose accepted set is sparse rather than a contiguous range under
+   * `maxEffort` (e.g. GLM 5.3 accepts only low/high/max). After the
+   * `maxEffort` ceiling clamp, provider clients snap an unsupported value
+   * down to the nearest listed value ("none" is exempt: it is the explicit
+   * opt-out and keeps its own rejection handling). Daemon-only: not
+   * projected into the client catalog (see scripts/sync-llm-catalog.ts).
+   */
+  supportedEfforts?: readonly ("low" | "medium" | "high" | "xhigh" | "max")[];
   /**
    * Daemon-only: when true, the direct-OpenAI Responses transport sends
    * explicit prompt-cache breakpoints for this model (GPT-5.6+ semantics:
@@ -597,6 +613,22 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
       linkLabel: "Open Google AI Studio",
     },
     models: [
+      {
+        id: "gemini-3.7-flash",
+        displayName: "Gemini 3.7 Flash",
+        contextWindowTokens: 1048576,
+        maxOutputTokens: 65536,
+        supportsThinking: true,
+        thinkingFloor: "low",
+        supportsCaching: true,
+        supportsVision: true,
+        supportsToolUse: true,
+        pricing: {
+          inputPer1mTokens: 1.5,
+          outputPer1mTokens: 7.5,
+          cacheReadPer1mTokens: 0.15,
+        },
+      },
       {
         id: "gemini-3.6-flash",
         displayName: "Gemini 3.6 Flash",
@@ -649,6 +681,7 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
         maxOutputTokens: 65536,
         longContextPricingThresholdTokens: 200000,
         supportsThinking: true,
+        thinkingFloor: "low",
         supportsCaching: true,
         supportsVision: true,
         supportsToolUse: true,
@@ -673,6 +706,7 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
         maxOutputTokens: 65536,
         longContextPricingThresholdTokens: 200000,
         supportsThinking: true,
+        thinkingFloor: "low",
         supportsCaching: true,
         supportsVision: true,
         supportsToolUse: true,
@@ -893,6 +927,45 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
           cacheReadPer1mTokens: 0.26,
         },
       },
+      {
+        id: "accounts/fireworks/models/glm-5p3",
+        displayName: "GLM 5.3",
+        contextWindowTokens: 1040000,
+        maxOutputTokens: 131072,
+        supportsThinking: true,
+        // GLM 5.3 reasoning is always on (reasoning_effort low/high/max);
+        // it cannot be disabled upstream.
+        adaptiveThinkingOnly: true,
+        supportsCaching: true,
+        supportsVision: false,
+        supportsToolUse: true,
+        maxEffort: "max",
+        supportedEfforts: ["low", "high", "max"],
+        pricing: {
+          inputPer1mTokens: 1.4,
+          outputPer1mTokens: 4.4,
+          cacheReadPer1mTokens: 0.26,
+        },
+      },
+      {
+        id: "accounts/fireworks/models/glm-5p3-flash",
+        displayName: "GLM 5.3 Flash",
+        contextWindowTokens: 1040000,
+        maxOutputTokens: 131072,
+        supportsThinking: true,
+        // Same always-on reasoning as GLM 5.3.
+        adaptiveThinkingOnly: true,
+        supportsCaching: true,
+        supportsVision: true,
+        supportsToolUse: true,
+        maxEffort: "max",
+        supportedEfforts: ["low", "high", "max"],
+        pricing: {
+          inputPer1mTokens: 0.15,
+          outputPer1mTokens: 0.5,
+          cacheReadPer1mTokens: 0.029,
+        },
+      },
       // Kimi K2.5 (accounts/fireworks/models/kimi-k2p5) is intentionally
       // absent: Fireworks serves it on-demand/dedicated only, so serverless
       // chat/completions calls 404 ("not found, inaccessible, and/or not
@@ -2366,6 +2439,24 @@ export function modelEffortCeilings(
   );
 }
 
+/**
+ * Per-model sparse `reasoning_effort` support for a provider, keyed by model
+ * ID (same derivation pattern as {@link modelEffortCeilings}). Models without
+ * `supportedEfforts` are absent and accept any value under their ceiling.
+ */
+export function modelSupportedEfforts(
+  providerId: string,
+): ReadonlyMap<
+  string,
+  readonly ("low" | "medium" | "high" | "xhigh" | "max")[]
+> {
+  return new Map(
+    PROVIDER_CATALOG.find((p) => p.id === providerId)?.models.flatMap((m) =>
+      m.supportedEfforts ? ([[m.id, m.supportedEfforts]] as const) : [],
+    ) ?? [],
+  );
+}
+
 /**
  * Return the catalog provider that owns a model ID, if known. When multiple
  * providers list the same ID (e.g. OpenRouter and the Vercel AI Gateway share

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

@@ -225,6 +225,28 @@ export function clampReasoningEffort(
     : value;
 }
 
+/** Snap a wire effort onto a model's sparse accepted set: the nearest
+ *  supported value at or below it, or the smallest supported value when the
+ *  request sits below all of them. Models like GLM 5.3 accept only
+ *  `low|high|max` and 4xx on the in-between tiers instead of rounding, so the
+ *  client rounds for them. `"none"` is never snapped: it is the explicit
+ *  opt-out and has its own rejection retry. */
+export function snapReasoningEffortToSupported(
+  value: ReasoningEffortWire,
+  supported: readonly ReasoningEffortWire[],
+): ReasoningEffortWire {
+  if (value === "none" || supported.includes(value)) {
+    return value;
+  }
+  const ranked = [...supported].sort(
+    (a, b) => REASONING_EFFORT_RANK[a] - REASONING_EFFORT_RANK[b],
+  );
+  const atOrBelow = ranked.filter(
+    (s) => REASONING_EFFORT_RANK[s] < REASONING_EFFORT_RANK[value],
+  );
+  return atOrBelow[atOrBelow.length - 1] ?? ranked[0] ?? value;
+}
+
 /** Human-readable text from an OpenAI-compatible error, including wrapped
  *  upstream detail (OpenRouter `metadata.raw`). Used by the one-shot
  *  compatibility retries so a generic SDK wrapper message cannot hide the
@@ -781,12 +803,16 @@ export class OpenAIChatCompletionsProvider implements Provider {
         ? EFFORT_TO_REASONING_EFFORT[effort]
         : undefined;
       if (reasoningEffort && typeof nestedReasoningEffort !== "string") {
-        const ceiling = this.resolveMaxReasoningEffort(
-          modelOverride ?? this.model,
-        );
-        params.reasoning_effort = clampReasoningEffort(
+        const effortModel = modelOverride ?? this.model;
+        const clamped = clampReasoningEffort(
           reasoningEffort,
-          ceiling,
+          this.resolveMaxReasoningEffort(effortModel),
+        );
+        const supported = this.resolveSupportedReasoningEfforts(effortModel);
+        params.reasoning_effort = (
+          supported
+            ? snapReasoningEffortToSupported(clamped, supported)
+            : clamped
         ) as OpenAI.Chat.Completions.ChatCompletionCreateParams["reasoning_effort"];
       }
 
@@ -1352,6 +1378,19 @@ export class OpenAIChatCompletionsProvider implements Provider {
     return this.maxReasoningEffort;
   }
 
+  /**
+   * Per-model sparse `reasoning_effort` support. Subclasses return the
+   * accepted values for models that 4xx on in-between tiers (e.g. GLM 5.3's
+   * `low|high|max`); the outbound value is snapped onto that set after the
+   * ceiling clamp (see {@link snapReasoningEffortToSupported}). Undefined
+   * means any value under the ceiling is accepted.
+   */
+  protected resolveSupportedReasoningEfforts(
+    _model: string,
+  ): readonly ReasoningEffortWire[] | undefined {
+    return undefined;
+  }
+
   /** Convert neutral messages + system prompt to OpenAI message format. */
   private async toOpenAIMessages(
     messages: Message[],

package/src/providers/retry.ts

@@ -813,17 +813,15 @@ function normalizeSendMessageOptions(
     }
   }
 
-  if (
-    isThinkingConfigDisabled(nextConfig.thinking) &&
-    disabledThinkingForcesEffortNone(providerName, nextConfig.model)
-  ) {
-    nextConfig.effort = "none";
-  }
-
-  // Claude Fable always reasons with adaptive thinking and rejects an explicit
-  // `thinking: { type: "disabled" }` (Anthropic 400s the request). Drop a
-  // disabled thinking config for these models so they fall back to their
-  // always-on adaptive thinking; effort and other params are unaffected.
+  // Adaptive-thinking-only models (Claude Fable, Fireworks Kimi K3 / GLM 5.3)
+  // always reason and reject an explicit opt-out: Anthropic 400s
+  // `thinking: { type: "disabled" }`, and effort-encoding providers 4xx a
+  // generated `reasoning_effort: "none"`. Drop a disabled thinking config for
+  // these models BEFORE the opt-out is encoded as `effort: "none"` below, so
+  // they fall back to their always-on thinking with the user's chosen effort
+  // and other params unaffected. Profiles can retain a stale
+  // `thinking: { enabled: false }` after switching to such a model, so this
+  // state is reachable from the profile editor.
   if (
     typeof nextConfig.model === "string" &&
     isAdaptiveThinkingOnlyModel(nextConfig.model) &&
@@ -832,6 +830,13 @@ function normalizeSendMessageOptions(
     delete nextConfig.thinking;
   }
 
+  if (
+    isThinkingConfigDisabled(nextConfig.thinking) &&
+    disabledThinkingForcesEffortNone(providerName, nextConfig.model)
+  ) {
+    nextConfig.effort = "none";
+  }
+
   // Pre-adaptive Claude models (Haiku 4.5, Opus 4.5, Sonnet 4.5) reject
   // `thinking: { type: "adaptive" }` (Anthropic 400s the request), and Vellum
   // never sends the legacy budget_tokens form. Drop an adaptive thinking

package/src/providers/types.ts

@@ -80,6 +80,19 @@ export type MediaSource = Base64MediaSource | WorkspaceRefMediaSource;
 export interface ImageContent {
   type: "image";
   source: MediaSource;
+  /**
+   * Internal id linking a base64 image block to a row in the attachments table,
+   * the same correlation {@link FileContent._attachmentId} carries. A live turn
+   * sends its uploads inline while persisting them as references, so this is
+   * the only handle on the in-memory copy of an image whose stored form is a
+   * `workspace_ref`; camera-frame retention matches on it. Redundant once the
+   * block is a reference (use `source.attachmentId`).
+   *
+   * Never reaches a provider: every client builds its image payload out of
+   * `source` alone (see the `case "image"` arms of the Anthropic, Gemini, and
+   * both OpenAI clients), so top-level fields are dropped by construction.
+   */
+  _attachmentId?: string;
 }
 
 export interface FileContent {
@@ -97,6 +110,49 @@ export interface FileContent {
   _attachmentId?: string;
 }
 
+/**
+ * The `_attachmentId` property as a spreadable fragment, or nothing when there
+ * is no usable id.
+ *
+ * Every producer of a media block faces the same choice: it either knows the
+ * attachment row the block came from, or it does not, and the field has to be
+ * absent rather than present-and-empty in the second case. This helper is the
+ * one place that decision lives, so every producer answers it the same way.
+ * Callers pass whatever id they hold: the source block's own
+ * ({@link ImageContent._attachmentId}) when carrying it across a rebuild, or an
+ * upload's row id when stamping a fresh block.
+ *
+ * Empty counts as absent, matching the read side, which requires a non-empty
+ * string before it will treat the field as an id (see
+ * `daemon/handlers/shared.ts`).
+ */
+export function attachmentIdFragment(attachmentId: string | undefined): {
+  _attachmentId?: string;
+} {
+  return attachmentId ? { _attachmentId: attachmentId } : {};
+}
+
+/**
+ * The attachment row a media block came from, whichever of the two shapes it
+ * is in, or undefined for a block that came from none (tool-generated and
+ * assistant-authored media).
+ *
+ * A reference names its row on `source.attachmentId`; an inline block has
+ * nowhere to put it but the top-level `_attachmentId`. Both are the same fact,
+ * so anything asking "which attachment is this?" has to read both or it goes
+ * blind on half the histories. Reading only `_attachmentId` in particular is
+ * the sharp edge: it is absent on every reference block, so a rebuild that
+ * flattens a reference to inline bytes drops the link unless it derives the id
+ * through here first.
+ */
+export function mediaBlockAttachmentId(
+  block: ImageContent | FileContent,
+): string | undefined {
+  return block.source.type === "workspace_ref"
+    ? block.source.attachmentId
+    : block._attachmentId;
+}
+
 export interface ToolUseContent {
   type: "tool_use";
   id: string;

package/src/routes/__tests__/control.test.ts

@@ -14,7 +14,7 @@ import * as realLogger from "../../util/logger.js";
 import * as realWorkerProcess from "../../util/worker-process.js";
 
 let enabled = false;
-let spawnArgs: Array<{ options?: { detached?: boolean } }> = [];
+let spawnArgs: Array<{ options?: { terminateOnTimeout?: boolean } }> = [];
 let stopStatus: { status: "running" | "not_running"; pid?: number } = {
   status: "not_running",
 };
@@ -39,7 +39,9 @@ mock.module("../../util/logger.js", () => ({
 
 mock.module("../../util/worker-process.js", () => ({
   ...realWorkerProcess,
-  spawnWorkerProcess: async (args: { options?: { detached?: boolean } }) => {
+  spawnWorkerProcess: async (args: {
+    options?: { terminateOnTimeout?: boolean };
+  }) => {
     spawnArgs.push(args);
     return { pid: 4242, alreadyRunning: false };
   },
@@ -76,7 +78,6 @@ describe("startRouteHost", () => {
     startRouteHost();
     await Promise.resolve();
     expect(spawnArgs).toHaveLength(1);
-    expect(spawnArgs[0].options?.detached).toBe(false);
   });
 });
 

package/src/routes/control.ts

@@ -101,7 +101,7 @@ export function startRouteHost(): void {
   if (!isRouteHostEnabled()) {
     return;
   }
-  void spawnRouteHostWorkerProcess({ detached: false })
+  void spawnRouteHostWorkerProcess()
     .then((r) =>
       log.info(
         { pid: r.pid, alreadyRunning: r.alreadyRunning },

package/src/routes/route-host-client.ts

@@ -153,7 +153,7 @@ export class RouteHostClient {
         workerLabel: "Route host",
         // Owned by the daemon (appears in its process tree, torn down with it);
         // kill it if it hangs during startup so a failed spawn leaves nothing.
-        options: { detached: false, terminateOnTimeout: true },
+        options: { terminateOnTimeout: true },
       }));
     } catch (err) {
       // A failed bring-up (crash-on-startup, PID-file timeout) is a retryable

package/src/runtime/AGENTS.md

@@ -156,7 +156,7 @@ All CDP-backed browser tools (`browser_navigate`, `browser_snapshot`, `browser_s
 
 **Auto-mode fallback logging**: In auto mode, fallback transitions are logged at `warn` level with structured metadata including the full candidate sequence and per-candidate failure reasons. This ensures fallback events are always observable in production logs.
 
-**Test coverage:** Regression tests for `browser_mode` wiring live in `__tests__/headless-browser-mode.test.ts`. E2E regression tests for backend precedence live in `__tests__/host-browser-e2e-cloud.test.ts` (extension path and macOS SSE bridge path) and `__tests__/conversation-routes-disk-view.test.ts` (macOS fallback path). Unit tests for pinned candidate construction and failover live in `tools/browser/cdp-client/__tests__/factory.test.ts`. Browser status tests covering macOS host-browser diagnostics live in `tools/browser/__tests__/browser-status.test.ts`.
+**Test coverage:** Regression tests for `browser_mode` wiring live in `__tests__/headless-browser-mode.test.ts`. Route-wiring coverage for the macOS fallback path lives in `__tests__/conversation-routes-disk-view.test.ts`, which asserts a macOS turn carries its interface context rather than exercising the backends themselves. Unit tests for pinned candidate construction and failover live in `tools/browser/cdp-client/__tests__/factory.test.ts`. Browser status tests covering macOS host-browser diagnostics live in `tools/browser/__tests__/browser-status.test.ts`.
 
 ### Interactive requests on channels (approvals, questions)
 
@@ -190,18 +190,36 @@ the gateway's Channel Identity Vocabulary, which covers the wire side.
 - **`slackMeta`** is the per-row key describing what a row is in its Slack
   conversation: `channelTs` for the row's own id, `threadTs` for its thread,
   `reaction.targetChannelTs` for the message a reaction was attached to, plus
-  Slack's own file markers and timezone labels. Every channel-path reader goes
-  through it today.
+  Slack's own file markers and timezone labels. Most channel-path readers
+  still go through it directly; the lookups in `persistence/delivery-crud.ts`
+  read through `readProviderMetadata` instead, which serves this envelope and
+  the neutral shape below from one call.
 - **`providerMeta`** is the channel-neutral counterpart of that key
-  (`messaging/provider-message-metadata.ts`): `conversationExternalId`,
-  `messageId`, `threadId`, `actorExternalId`, `eventKind` and
-  `reaction.targetMessageId`, deliberately the same vocabulary the inbound
-  wire uses in `InboundEventBase`, so a channel that can describe itself at
-  ingress can describe its stored rows without a translation of its own.
-  Writable by any channel, including one this repo has no code for. `readProviderMetadata` reads it and maps `slackMeta` onto it.
-  **Nothing writes or reads it yet**; it is the home a new channel should use
-  rather than inventing a sixth key, and existing readers move onto it as
-  channels adopt it.
+  (`messaging/provider-message-metadata.ts`): `source`,
+  `conversationExternalId`, `messageId`, `threadId`, `actorExternalId`,
+  `eventKind`, the `reaction` sub-key, and the `editedAt` / `deletedAt`
+  marks. Deliberately the same vocabulary the inbound wire uses in
+  `InboundEventBase`, so a channel that can describe itself at ingress can
+  describe its stored rows without a translation of its own. Writable by any
+  channel, including one this repo has no code for, which is why a new
+  channel belongs here rather than in a sixth key of its own.
+
+  Every channel except Slack writes it: a reaction row carries the whole
+  shape (`inbound-stages/reaction-intercept.ts`), an edit or a delete
+  stamps `editedAt` / `deletedAt` onto whatever the row already said about
+  itself through `mergeProviderMessageMetadata`
+  (`inbound-stages/edit-intercept.ts`, `inbound-message-handler.ts`), and an
+  outbound assistant reply is stamped with a partial envelope at reserve time
+  (`buildAssistantChannelMetadata`) whose `messageId` (and, for a reply
+  split into several posts, `additionalMessageIds`) the post-send
+  reconciliation in `channel-reply-delivery.ts` back-fills from the
+  transport's delivery results, which is what lets a later reaction on the
+  assistant's own post resolve back to its row. Slack
+  keeps writing `slackMeta`, and `readProviderMetadata` maps that envelope
+  onto this shape on read, so the channel-agnostic readers in
+  `persistence/delivery-crud.ts` (thread evidence, and finding the
+  conversation that holds a given provider message id) serve both without a
+  per-channel branch.
 
 ### Channel verification: gateway-owned
 

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

@@ -347,6 +347,7 @@ import {
   deleteConversation,
   setConversation,
 } from "../../daemon/conversation-registry.js";
+import { stripAgedSightFrames } from "../../daemon/conversation-sight-frames.js";
 import { ContextOverflowError, type Message } from "../../providers/types.js";
 import {
   __resetWakeChainForTests,
@@ -521,6 +522,11 @@ function makeWakeConversation(options: {
         return runBody(input, onEvent, options);
       },
     },
+    // The wake trims its own run input, the way the orchestrator's pre-run
+    // pass trims a normal turn's. Empty capture times leave the array
+    // untouched, which is what every case but the camera one wants.
+    trimAgedSightFrames: (msgs: Message[]) =>
+      stripAgedSightFrames(msgs, wakeSightFrameCaptureTimes).messages,
     messages,
     getMessages: () => messages,
     isProcessing: () => processing,
@@ -605,8 +611,12 @@ function makeWakeConversation(options: {
   return conversation as unknown as WakeConversation;
 }
 
+/** Tagged camera frames the fake conversation's trim resolves against. */
+let wakeSightFrameCaptureTimes = new Map<string, number>();
+
 beforeEach(() => {
   __resetWakeChainForTests();
+  wakeSightFrameCaptureTimes = new Map();
   wakeConvRegistry.clear();
   recordRequestLogCalls.length = 0;
   recordUsageCalls.length = 0;
@@ -934,6 +944,62 @@ describe("wakeAgentForOpportunity", () => {
     expect(conversation.personaOverrideSets).toEqual([]);
   });
 
+  test("bounds camera frames in the run input it sends", async () => {
+    // The wake sends its run input itself and keeps the in-loop budget gate
+    // disabled, so neither the orchestrator's pre-run pass nor the loop's
+    // post-compaction transform ever sees this array. Without its own trim a
+    // long camera session would send every frame it captured.
+    wakeSightFrameCaptureTimes = new Map([
+      ["f1", 1000],
+      ["f2", 2000],
+      ["f3", 3000],
+      ["f4", 4000],
+    ]);
+    const frame = (attachmentId: string): Message => ({
+      role: "user",
+      content: [
+        {
+          type: "image",
+          source: { type: "base64", media_type: "image/png", data: "AAAAAAAA" },
+          _attachmentId: attachmentId,
+        },
+      ],
+    });
+    const conversation = makeWakeConversation({
+      baseline: [frame("f1"), frame("f2"), frame("f3"), frame("f4")],
+      scriptedAssistant: {
+        role: "assistant",
+        content: [{ type: "text", text: "" }],
+      },
+    });
+
+    await wakeAgentForOpportunity(
+      {
+        conversationId: conversation.conversationId,
+        hint: "look around",
+        source: "unit-test",
+      },
+      { resolveTarget: async () => conversation },
+    );
+
+    const input = conversation.runCalls[0]!.input;
+    const images = input.flatMap((message) =>
+      message.content.filter((block) => block.type === "image"),
+    );
+    const stubs = input.flatMap((message) =>
+      message.content.filter(
+        (block) =>
+          block.type === "text" &&
+          block.text.startsWith("[Camera frame omitted from context:"),
+      ),
+    );
+    expect(images).toHaveLength(2);
+    expect(stubs).toHaveLength(2);
+    // The trim replaces blocks in place, so the wake's tail accounting still
+    // indexes the same positions.
+    expect(input.filter((m) => m.role === "user").length).toBeGreaterThan(0);
+  });
+
   test("silent no-op when agent produces no tool calls and no text", async () => {
     const conversation = makeWakeConversation({
       baseline: [
@@ -1092,10 +1158,10 @@ describe("wakeAgentForOpportunity", () => {
       },
     });
 
-    // Mirror formatShellOutput on large output: ~20KB body + a recovery marker
-    // pointing at the full-output temp file. The default tool_result budget
-    // would re-truncate the marker off; the caller passes a larger maxChars.
-    const marker = '<output_truncated limit="20K" file="/tmp/bg-xyz.txt" />';
+    // Mirror formatShellOutput on large output: ~20KB body + a truncation
+    // marker. The default tool_result budget would slice the marker off; the
+    // caller passes a larger maxChars.
+    const marker = '<output_truncated limit="20K" />';
     const big = `${"x".repeat(20_000)}\n${marker}`;
 
     await wakeAgentForOpportunity(
@@ -1116,8 +1182,7 @@ describe("wakeAgentForOpportunity", () => {
     const text = (
       conversation.persistedTailCalls[0]!.content as Array<{ text: string }>
     )[0]!.text;
-    // The trailing recovery marker survives (not re-truncated off) and the
-    // fence is still well-formed.
+    // The trailing truncation marker survives and the fence is well-formed.
     expect(text).toContain(marker);
     expect(text).toContain('<external_content source="tool_result">');
     expect(text.endsWith("</background_event>")).toBe(true);