@vellumai/assistant 0.4.48 → 0.4.50

package/src/tools/skills/load.ts

@@ -9,6 +9,11 @@ import { loadSkillBySelector, loadSkillCatalog } from "../../config/skills.js";
 import { RiskLevel } from "../../permissions/types.js";
 import type { ToolDefinition } from "../../providers/types.js";
 import {
+  autoInstallFromCatalog,
+  resolveCatalog,
+} from "../../skills/catalog-install.js";
+import {
+  collectAllMissing,
   indexCatalogById,
   validateIncludes,
 } from "../../skills/include-graph.js";
@@ -137,7 +142,32 @@ export class SkillLoadTool implements Tool {
       };
     }
 
-    const loaded = loadSkillBySelector(selector);
+    let loaded = loadSkillBySelector(selector);
+
+    // Auto-install from catalog if the skill isn't found locally
+    if (
+      !loaded.skill &&
+      (loaded.errorCode === "not_found" || loaded.errorCode === "empty_catalog")
+    ) {
+      try {
+        const installed = await autoInstallFromCatalog(selector);
+        if (installed) {
+          log.info({ skillId: selector }, "Auto-installed skill from catalog");
+          loaded = loadSkillBySelector(selector);
+        }
+      } catch (err) {
+        const installError = err instanceof Error ? err.message : String(err);
+        log.warn(
+          { err, skillId: selector },
+          "Auto-install from catalog failed",
+        );
+        return {
+          content: `Error: skill "${selector}" was found in the catalog but installation failed: ${installError}`,
+          isError: true,
+        };
+      }
+    }
+
     if (!loaded.skill) {
       return {
         content: `Error: ${loaded.error ?? "Failed to load skill"}`,
@@ -160,10 +190,62 @@ export class SkillLoadTool implements Tool {
     // Load catalog for include validation and child metadata output
     let catalogIndex: Map<string, SkillSummary> | undefined;
     if (skill.includes && skill.includes.length > 0) {
-      const catalog = loadSkillCatalog();
+      let catalog = loadSkillCatalog();
       catalogIndex = indexCatalogById(catalog);
 
-      // Validate recursive includes (fail-closed)
+      // Auto-install missing includes before validation (max 5 rounds for transitive deps)
+      // Defer catalog resolution until we confirm there are missing includes,
+      // then cache the result to avoid redundant network requests per dependency.
+      let remoteCatalog: Awaited<ReturnType<typeof resolveCatalog>> | undefined;
+
+      const MAX_INSTALL_ROUNDS = 5;
+      for (let round = 0; round < MAX_INSTALL_ROUNDS; round++) {
+        const missing = collectAllMissing(skill.id, catalogIndex);
+        if (missing.size === 0) break;
+
+        // Lazily resolve catalog on first round with missing includes
+        if (!remoteCatalog) {
+          try {
+            remoteCatalog = await resolveCatalog([...missing][0]);
+          } catch (err) {
+            log.warn(
+              { err, skillId: skill.id },
+              "Failed to resolve catalog for include auto-install",
+            );
+            break;
+          }
+        }
+
+        let installedAny = false;
+        for (const missingId of missing) {
+          try {
+            const installed = await autoInstallFromCatalog(
+              missingId,
+              remoteCatalog,
+            );
+            if (installed) {
+              log.info(
+                { skillId: missingId, parentSkillId: skill.id },
+                "Auto-installed missing include",
+              );
+              installedAny = true;
+            }
+          } catch (err) {
+            log.warn(
+              { err, skillId: missingId },
+              "Failed to auto-install missing include",
+            );
+          }
+        }
+
+        if (!installedAny) break; // Nothing could be installed, stop trying
+
+        // Reload catalog to pick up newly installed skills
+        catalog = loadSkillCatalog();
+        catalogIndex = indexCatalogById(catalog);
+      }
+
+      // Validate (fail-closed — catches genuinely missing deps + cycles)
       const validation = validateIncludes(skill.id, catalogIndex);
       if (!validation.ok) {
         if (validation.error === "missing") {

package/src/tools/watch/watch-state.ts

@@ -24,18 +24,6 @@ export interface WatchSession {
   timeoutHandle?: ReturnType<typeof setTimeout>;
   /** Guards against concurrent generateSummary calls */
   summaryInFlight?: boolean;
-  /** Whether this session was started via ride shotgun (no live commentary) */
-  isRideShotgun?: boolean;
-  /** Learn mode records network traffic alongside screen observations */
-  isLearnMode?: boolean;
-  /** Domain filter for network recording in learn mode */
-  targetDomain?: string;
-  /** Recording ID for learn mode sessions */
-  recordingId?: string;
-  /** Path where the learn recording was successfully saved (undefined if save failed) */
-  savedRecordingPath?: string;
-  /** Reason the learn-mode bootstrap failed (CDP launch vs recorder attach) */
-  bootstrapFailureReason?: string;
 }
 
 /** Module-level map of watch sessions keyed by watchId. */

package/src/util/logger.ts

@@ -12,11 +12,7 @@ import pino from "pino";
 import type { PrettyOptions } from "pino-pretty";
 import pinoPretty from "pino-pretty";
 
-import {
-  getDebugMode,
-  getDebugStdoutLogs,
-  getLogStderr,
-} from "../config/env-registry.js";
+import { getDebugStdoutLogs } from "../config/env-registry.js";
 import { logSerializers } from "./log-redact.js";
 import { getLogPath } from "./platform.js";
 
@@ -110,31 +106,18 @@ function buildRotatingLogger(config: LogFileConfig): pino.Logger {
   activeLogDate = today;
   activeLogFileConfig = config;
 
-  const level = getDebugMode() ? "debug" : "info";
-
-  if (getDebugMode()) {
-    const prettyStream = pinoPretty(prettyOpts({ destination: 2 }));
-    return pino(
-      { name: "assistant", level, serializers: logSerializers },
-      pino.multistream([
-        { stream: fileStream, level: "info" as const },
-        { stream: prettyStream, level: "debug" as const },
-      ]),
-    );
-  }
-
   // When stdout is not a TTY (e.g. desktop app redirects to a hatch log file),
   // write to the rotating file only — the hatch log already captured early
   // startup output and echoing pino output there is unnecessary duplication.
   if (!process.stdout.isTTY) {
     return pino(
-      { name: "assistant", level, serializers: logSerializers },
+      { name: "assistant", level: "info", serializers: logSerializers },
       fileStream,
     );
   }
 
   return pino(
-    { name: "assistant", level, serializers: logSerializers },
+    { name: "assistant", level: "info", serializers: logSerializers },
     pino.multistream([
       { stream: fileStream, level: "info" as const },
       {
@@ -173,13 +156,11 @@ function getRootLogger(): pino.Logger {
   }
   if (!rootLogger) {
     const forceStderr =
-      process.env.BUN_TEST === "1" ||
-      process.env.NODE_ENV === "test" ||
-      getLogStderr();
+      process.env.BUN_TEST === "1" || process.env.NODE_ENV === "test";
     if (forceStderr) {
       rootLogger = pino(
         {
-          level: getDebugMode() ? "debug" : "info",
+          level: "info",
           serializers: logSerializers,
         },
         pino.destination(2),
@@ -208,17 +189,7 @@ function getRootLogger(): pino.Logger {
         prettyOpts({ destination: fileDest, colorize: false }),
       );
 
-      if (getDebugMode()) {
-        const prettyStream = pinoPretty(prettyOpts({ destination: 2 }));
-        const multi = pino.multistream([
-          { stream: fileStream, level: "info" as const },
-          { stream: prettyStream, level: "debug" as const },
-        ]);
-        rootLogger = pino(
-          { level: "debug", serializers: logSerializers },
-          multi,
-        );
-      } else if (getDebugStdoutLogs()) {
+      if (getDebugStdoutLogs()) {
         rootLogger = pino(
           { level: "info", serializers: logSerializers },
           pino.multistream([
@@ -238,7 +209,7 @@ function getRootLogger(): pino.Logger {
     } catch {
       rootLogger = pino(
         {
-          level: getDebugMode() ? "debug" : "info",
+          level: "info",
           serializers: logSerializers,
         },
         pinoPretty(prettyOpts({ destination: 2 })),
@@ -248,11 +219,6 @@ function getRootLogger(): pino.Logger {
   return rootLogger;
 }
 
-/** Returns true when VELLUM_DEBUG=1 is set. */
-export function isDebug(): boolean {
-  return getDebugMode();
-}
-
 /**
  * Truncate a string for debug logging. Returns the original if under maxLen,
  * otherwise returns the first maxLen chars with a suffix indicating how much was cut.

package/src/util/platform.ts

@@ -8,13 +8,7 @@ import {
 import { homedir } from "node:os";
 import { join } from "node:path";
 
-import {
-  getBaseDataDir,
-  getDaemonIosPairing,
-  getDaemonTcpEnabled,
-  getDaemonTcpHost,
-  getDaemonTcpPort,
-} from "../config/env-registry.js";
+import { getBaseDataDir } from "../config/env-registry.js";
 
 export function isMacOS(): boolean {
   return process.platform === "darwin";
@@ -245,39 +239,30 @@ export function getInterfacesDir(): string {
 
 /**
  * Returns the TCP port the daemon should listen on for iOS clients.
- * Reads VELLUM_DAEMON_TCP_PORT env var; defaults to 8765.
+ * Hardcoded default: 8765.
  */
 export function getTCPPort(): number {
-  return getDaemonTcpPort();
+  return 8765;
 }
 
 /**
  * Returns whether the daemon TCP listener should be enabled.
- * Resolution order (first match wins):
- *   1. VELLUM_DAEMON_TCP_ENABLED env var ('true'/'1' → on, 'false'/'0' → off)
- *   2. Presence of the flag file ~/.vellum/tcp-enabled (exists → on)
- *   3. Default: false
+ * Checks for the presence of the flag file ~/.vellum/tcp-enabled.
+ * Default: false.
  *
  * The flag-file check makes it easy to enable TCP in dev without restarting
  * the shell: `touch ~/.vellum/tcp-enabled && kill -USR1 <daemon-pid>`.
- * The macOS CLI (AssistantCli) also sets the env var for bundled-binary deployments.
  */
 export function isTCPEnabled(): boolean {
-  const envValue = getDaemonTcpEnabled();
-  if (envValue !== undefined) return envValue;
   return existsSync(join(getRootDir(), "tcp-enabled"));
 }
 
 /**
  * Returns the hostname/address for the TCP listener.
- * Resolution order (first match wins):
- *   1. VELLUM_DAEMON_TCP_HOST env var (explicit override)
- *   2. If iOS pairing is enabled: '0.0.0.0' (LAN-accessible)
- *   3. Default: '127.0.0.1' (localhost only)
+ * If iOS pairing is enabled (flag file): '0.0.0.0' (LAN-accessible).
+ * Default: '127.0.0.1' (localhost only).
  */
 export function getTCPHost(): string {
-  const override = getDaemonTcpHost();
-  if (override) return override;
   if (isIOSPairingEnabled()) return "0.0.0.0";
   return "127.0.0.1";
 }
@@ -288,17 +273,13 @@ export function getTCPHost(): string {
  * instead of 127.0.0.1 (localhost only), making the daemon reachable
  * from iOS devices on the same local network.
  *
- * Resolution order (first match wins):
- *   1. VELLUM_DAEMON_IOS_PAIRING env var ('true'/'1' → on, 'false'/'0' → off)
- *   2. Presence of the flag file ~/.vellum/ios-pairing-enabled (exists → on)
- *   3. Default: false
+ * Checks for the presence of the flag file ~/.vellum/ios-pairing-enabled.
+ * Default: false.
  *
  * This is separate from isTCPEnabled() — TCP can be enabled for localhost-only
  * access without exposing the daemon to the LAN.
  */
 export function isIOSPairingEnabled(): boolean {
-  const envValue = getDaemonIosPairing();
-  if (envValue !== undefined) return envValue;
   return existsSync(join(getRootDir(), "ios-pairing-enabled"));
 }
 

package/src/watcher/providers/google-calendar.ts

@@ -13,7 +13,8 @@ import {
 import type { CalendarEvent } from "../../config/bundled-skills/google-calendar/types.js";
 import type { OAuthConnection } from "../../oauth/connection.js";
 import { resolveOAuthConnection } from "../../oauth/connection-resolver.js";
-import { GOOGLE_CALENDAR_BASE_URL } from "../../oauth/provider-base-urls.js";
+
+const GOOGLE_CALENDAR_BASE_URL = "https://www.googleapis.com/calendar/v3";
 import { getLogger } from "../../util/logger.js";
 import type {
   FetchResult,

package/src/__tests__/clarification-resolver.test.ts

@@ -1,193 +0,0 @@
-import { beforeEach, describe, expect, mock, test } from "bun:test";
-
-let llmCallCount = 0;
-let llmDelayMs = 0;
-let llmResolution:
-  | "keep_existing"
-  | "keep_candidate"
-  | "merge"
-  | "still_unclear" = "still_unclear";
-let llmResolvedStatement = "";
-let llmExplanation = "Unclear response from user.";
-
-mock.module("../providers/provider-send-message.js", () => ({
-  getConfiguredProvider: () => ({
-    sendMessage: async (
-      _messages: unknown,
-      _tools: unknown,
-      _system: unknown,
-      opts?: { signal?: AbortSignal },
-    ) => {
-      llmCallCount += 1;
-      if (llmDelayMs > 0) {
-        await new Promise((resolve, reject) => {
-          const timer = setTimeout(resolve, llmDelayMs);
-          opts?.signal?.addEventListener("abort", () => {
-            clearTimeout(timer);
-            reject(new Error("Request was aborted."));
-          });
-        });
-      }
-      return {
-        content: [
-          {
-            type: "tool_use" as const,
-            id: "test-tool-use-id",
-            name: "resolve_conflict",
-            input: {
-              resolution: llmResolution,
-              resolved_statement: llmResolvedStatement,
-              explanation: llmExplanation,
-            },
-          },
-        ],
-        model: "claude-haiku-4-5-20251001",
-        stopReason: "tool_use",
-        usage: { inputTokens: 0, outputTokens: 0 },
-      };
-    },
-  }),
-  createTimeout: (ms: number) => {
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), ms);
-    return {
-      signal: controller.signal,
-      cleanup: () => clearTimeout(timer),
-    };
-  },
-  extractToolUse: (response: { content: Array<{ type: string }> }) => {
-    return response.content.find(
-      (b: { type: string }) => b.type === "tool_use",
-    );
-  },
-  userMessage: (text: string) => ({
-    role: "user",
-    content: [{ type: "text", text }],
-  }),
-}));
-
-mock.module("../config/loader.js", () => ({
-  getConfig: () => ({
-    ui: {},
-
-    apiKeys: {
-      anthropic: "test-key",
-    },
-  }),
-}));
-
-import { resolveConflictClarification } from "../memory/clarification-resolver.js";
-
-beforeEach(() => {
-  llmCallCount = 0;
-  llmDelayMs = 0;
-  llmResolution = "still_unclear";
-  llmResolvedStatement = "";
-  llmExplanation = "Unclear response from user.";
-});
-
-describe("resolveConflictClarification", () => {
-  test("returns keep_existing from deterministic heuristic", async () => {
-    const result = await resolveConflictClarification({
-      existingStatement: "Use React for frontend work.",
-      candidateStatement: "Use Vue for frontend work.",
-      userMessage: "Keep the old React preference.",
-    });
-
-    expect(result.resolution).toBe("keep_existing");
-    expect(result.strategy).toBe("heuristic");
-    expect(llmCallCount).toBe(0);
-  });
-
-  test("returns keep_candidate from deterministic heuristic", async () => {
-    const result = await resolveConflictClarification({
-      existingStatement: "Use React for frontend work.",
-      candidateStatement: "Use Vue for frontend work.",
-      userMessage: "Use the new Vue note going forward.",
-    });
-
-    expect(result.resolution).toBe("keep_candidate");
-    expect(result.strategy).toBe("heuristic");
-    expect(llmCallCount).toBe(0);
-  });
-
-  test("returns merge from deterministic heuristic", async () => {
-    const result = await resolveConflictClarification({
-      existingStatement: "React is preferred for dashboards.",
-      candidateStatement: "Vue is preferred for marketing pages.",
-      userMessage:
-        "Both are true: React for dashboards and Vue for marketing pages.",
-    });
-
-    expect(result.resolution).toBe("merge");
-    expect(result.strategy).toBe("heuristic");
-    expect(result.resolvedStatement).toContain("Both are true");
-    expect(llmCallCount).toBe(0);
-  });
-
-  test("uses LLM fallback when heuristics are inconclusive", async () => {
-    llmResolution = "still_unclear";
-    llmExplanation = "The user message does not pick a side.";
-
-    const result = await resolveConflictClarification({
-      existingStatement: "Use React for frontend work.",
-      candidateStatement: "Use Vue for frontend work.",
-      userMessage: "Not sure yet.",
-    });
-
-    expect(result.resolution).toBe("still_unclear");
-    expect(result.strategy).toBe("llm");
-    expect(llmCallCount).toBe(1);
-  });
-
-  test("does not match cue substrings inside unrelated words", async () => {
-    llmResolution = "keep_candidate";
-    llmExplanation = "User wants Vue.";
-
-    // "told" contains "old" as a substring but not as a whole word
-    const result = await resolveConflictClarification({
-      existingStatement: "Use React for frontend work.",
-      candidateStatement: "Use Vue for frontend work.",
-      userMessage: "I told you, use Vue.",
-    });
-
-    expect(result.resolution).toBe("keep_candidate");
-    expect(result.strategy).toBe("llm");
-    expect(llmCallCount).toBe(1);
-  });
-
-  test("delegates to LLM when multiple cue categories match", async () => {
-    llmResolution = "keep_existing";
-    llmExplanation = "User wants the old one.";
-
-    // "either" is a merge cue, "old" is an existing cue — ambiguous
-    const result = await resolveConflictClarification({
-      existingStatement: "Use React for frontend work.",
-      candidateStatement: "Use Vue for frontend work.",
-      userMessage: "I don't want either, keep the old one.",
-    });
-
-    expect(result.resolution).toBe("keep_existing");
-    expect(result.strategy).toBe("llm");
-    expect(llmCallCount).toBe(1);
-  });
-
-  test("enforces timeout bound on LLM fallback", async () => {
-    llmResolution = "keep_candidate";
-    llmExplanation = "Prefer the newer statement.";
-    llmDelayMs = 50;
-
-    const result = await resolveConflictClarification(
-      {
-        existingStatement: "Use React for frontend work.",
-        candidateStatement: "Use Vue for frontend work.",
-        userMessage: "I cannot decide right now.",
-      },
-      { timeoutMs: 5 },
-    );
-
-    expect(result.resolution).toBe("still_unclear");
-    expect(result.strategy).toBe("llm_timeout");
-    expect(llmCallCount).toBe(1);
-  });
-});

package/src/__tests__/computer-use-session-compaction.test.ts

@@ -1,143 +0,0 @@
-import { describe, expect, test } from "bun:test";
-
-import { ComputerUseSession } from "../daemon/computer-use-session.js";
-import type { Message } from "../providers/types.js";
-
-/**
- * Helper to create a user message with a tool_result block containing
- * an AX tree wrapped in markers.
- */
-function toolResultMsg(content: string): Message {
-  return {
-    role: "user",
-    content: [
-      {
-        type: "tool_result",
-        tool_use_id: "test-id",
-        content,
-      },
-    ],
-  };
-}
-
-describe("ComputerUseSession.escapeAxTreeContent", () => {
-  test("escapes a literal closing tag in the content", () => {
-    const input = "some text </ax-tree> more text";
-    const escaped = ComputerUseSession.escapeAxTreeContent(input);
-    expect(escaped).toBe("some text &lt;/ax-tree&gt; more text");
-  });
-
-  test("escapes multiple occurrences", () => {
-    const input = "</ax-tree> hello </ax-tree>";
-    const escaped = ComputerUseSession.escapeAxTreeContent(input);
-    expect(escaped).toBe("&lt;/ax-tree&gt; hello &lt;/ax-tree&gt;");
-  });
-
-  test("is case-insensitive", () => {
-    const input = "</AX-TREE> and </Ax-Tree>";
-    const escaped = ComputerUseSession.escapeAxTreeContent(input);
-    expect(escaped).toBe("&lt;/ax-tree&gt; and &lt;/ax-tree&gt;");
-  });
-
-  test("leaves content without closing tags unchanged", () => {
-    const input = 'Window "My App" [1]\n  Button "OK" [2]';
-    expect(ComputerUseSession.escapeAxTreeContent(input)).toBe(input);
-  });
-});
-
-describe("ComputerUseSession.compactHistory", () => {
-  test("[experimental] strips old AX trees and keeps the most recent ones", () => {
-    const messages: Message[] = [
-      { role: "assistant", content: [{ type: "text", text: "thinking..." }] },
-      toolResultMsg(
-        '<ax-tree>CURRENT SCREEN STATE:\nWindow "App" [1]</ax-tree>',
-      ),
-      { role: "assistant", content: [{ type: "text", text: "action 1" }] },
-      toolResultMsg(
-        '<ax-tree>CURRENT SCREEN STATE:\nWindow "App" [2]</ax-tree>',
-      ),
-      { role: "assistant", content: [{ type: "text", text: "action 2" }] },
-      toolResultMsg(
-        '<ax-tree>CURRENT SCREEN STATE:\nWindow "App" [3]</ax-tree>',
-      ),
-    ];
-
-    const compacted = ComputerUseSession.compactHistory(messages);
-
-    // First AX tree (index 1) should be stripped
-    const firstToolResult = compacted[1].content[0];
-    expect(firstToolResult.type).toBe("tool_result");
-    if (firstToolResult.type === "tool_result") {
-      expect(firstToolResult.content).toContain("<ax_tree_omitted />");
-      expect(firstToolResult.content).not.toContain("<ax-tree>");
-    }
-
-    // Last two AX trees should be preserved
-    const secondToolResult = compacted[3].content[0];
-    if (secondToolResult.type === "tool_result") {
-      expect(secondToolResult.content).toContain("<ax-tree>");
-    }
-    const thirdToolResult = compacted[5].content[0];
-    if (thirdToolResult.type === "tool_result") {
-      expect(thirdToolResult.content).toContain("<ax-tree>");
-    }
-  });
-
-  test("[experimental] handles AX tree content containing literal </ax-tree> (escaped)", () => {
-    // Simulate content where the AX tree text includes an escaped closing tag,
-    // e.g. user is viewing XML source code with "</ax-tree>" in it.
-    const escapedContent =
-      '<ax-tree>CURRENT SCREEN STATE:\nTextArea "editor" [1]\n  ' +
-      "Line: &lt;/ax-tree&gt; some xml\n</ax-tree>";
-
-    const messages: Message[] = [
-      { role: "assistant", content: [{ type: "text", text: "action 0" }] },
-      toolResultMsg(escapedContent),
-      { role: "assistant", content: [{ type: "text", text: "action 1" }] },
-      toolResultMsg(escapedContent),
-      { role: "assistant", content: [{ type: "text", text: "action 2" }] },
-      toolResultMsg(
-        '<ax-tree>CURRENT SCREEN STATE:\nWindow "App" [3]</ax-tree>',
-      ),
-    ];
-
-    const compacted = ComputerUseSession.compactHistory(messages);
-
-    // The first message with escaped content should be fully stripped
-    const firstToolResult = compacted[1].content[0];
-    if (firstToolResult.type === "tool_result") {
-      expect(firstToolResult.content).not.toContain("<ax-tree>");
-      expect(firstToolResult.content).toContain("<ax_tree_omitted />");
-    }
-  });
-
-  test("regex fails on unescaped </ax-tree> inside content (demonstrating the bug)", () => {
-    // This test demonstrates what happens WITHOUT escaping: the regex
-    // only partially removes the AX tree block.
-    const unescapedContent =
-      '<ax-tree>CURRENT SCREEN STATE:\nTextArea "editor" [1]\n  ' +
-      "Line: </ax-tree> some xml leftover\n</ax-tree>";
-
-    const messages: Message[] = [
-      { role: "assistant", content: [{ type: "text", text: "action 0" }] },
-      toolResultMsg(unescapedContent),
-      { role: "assistant", content: [{ type: "text", text: "action 1" }] },
-      toolResultMsg(unescapedContent),
-      { role: "assistant", content: [{ type: "text", text: "action 2" }] },
-      toolResultMsg(
-        '<ax-tree>CURRENT SCREEN STATE:\nWindow "App" [3]</ax-tree>',
-      ),
-    ];
-
-    const compacted = ComputerUseSession.compactHistory(messages);
-
-    // Without escaping, the first tool result has leftover content after
-    // the regex only matched up to the FIRST </ax-tree>.
-    const firstToolResult = compacted[1].content[0];
-    if (firstToolResult.type === "tool_result") {
-      // The non-greedy regex stops at the first </ax-tree>, leaving
-      // " some xml leftover\n</ax-tree>" behind.
-      expect(firstToolResult.content).toContain("some xml leftover");
-    }
-  });
-});