@vellumai/assistant 0.11.2 → 0.11.3-staging.1

package/src/__tests__/visible-app-context.test.ts

@@ -13,7 +13,7 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 
-import { createApp, deleteApp, getAppDirPath } from "../apps/app-store.js";
+import { createApp, deleteApp } from "../apps/app-store.js";
 import {
   clearConversations,
   setConversation,
@@ -56,7 +56,7 @@ afterEach(() => {
 });
 
 describe("buildVisibleAppContext", () => {
-  test("resolves the app's name, readable slug, and source directory", () => {
+  test("resolves the app's name and readable slug, without a host path", () => {
     // A workspace app id is an opaque UUID; the slug is the handle a human
     // (or the model) recognizes, so both have to come back.
     const app = createApp({
@@ -69,10 +69,27 @@ describe("buildVisibleAppContext", () => {
       appId: app.id,
       name: "Grocery List",
       slug: "grocery-list",
-      sourceDir: getAppDirPath(app.id),
     });
   });
 
+  test("carries no resolved directory, only derivable handles", () => {
+    // Only derivable handles ship: a workspace app's directory is the
+    // workspace `Root:` joined with the app-builder skill's
+    // `data/apps/<slug>/` layout, so no value here may be an absolute path.
+    const app = createApp({
+      name: "Grocery List",
+      schemaJson: "{}",
+      htmlDefinition: "<h1>Hello</h1>",
+    });
+
+    const context = buildVisibleAppContext(app.id);
+
+    expect(context).not.toBeNull();
+    for (const value of Object.values(context ?? {})) {
+      expect(value.startsWith("/")).toBe(false);
+    }
+  });
+
   test("returns null when no app is in view", () => {
     expect(buildVisibleAppContext(undefined)).toBeNull();
     expect(buildVisibleAppContext("")).toBeNull();
@@ -109,7 +126,6 @@ describe("buildVisibleAppContext", () => {
       appId: "plugins~acme~acme-dashboard",
       name: "acme-dashboard",
       slug: "acme-dashboard",
-      sourceDir: join(pluginDir, "apps", "acme-dashboard"),
       pluginName: "acme",
     });
   });

package/src/__tests__/web-search-history.test.ts

@@ -328,4 +328,100 @@ describe("stripHistoricalWebSearchResults", () => {
     const afterTypes = messages[0].content.map((b) => b.type);
     expect(afterTypes).toEqual(beforeTypes);
   });
+
+  test("drops the server_tool_use of a cross-message pair from a deferred execution", () => {
+    // Deferred execution places the web_search_tool_result at the head of the
+    // assistant message after the client tool round-trip. Both sides of the
+    // pair must go together, or the leftover server_tool_use reads as an
+    // orphan and gets a synthetic error result downstream.
+    const messages: Message[] = [
+      { role: "user", content: [{ type: "text", text: "Check both" }] },
+      {
+        role: "assistant",
+        content: [
+          { type: "text", text: "On it" },
+          { type: "tool_use", id: "tu_read", name: "file_read", input: {} },
+          {
+            type: "server_tool_use",
+            id: "stu_deferred",
+            name: "web_search",
+            input: { query: "deferred query" },
+          },
+        ],
+      },
+      {
+        role: "user",
+        content: [
+          { type: "tool_result", tool_use_id: "tu_read", content: "file" },
+        ],
+      },
+      {
+        role: "assistant",
+        content: [
+          {
+            type: "web_search_tool_result",
+            tool_use_id: "stu_deferred",
+            content: [
+              {
+                type: "web_search_result",
+                url: "https://example.com",
+                title: "Deferred",
+                encrypted_content: "tok",
+              },
+            ],
+          },
+          { type: "text", text: "Found it." },
+        ],
+      },
+    ];
+
+    const { messages: result, stats } =
+      stripHistoricalWebSearchResults(messages);
+
+    // The use in the earlier assistant message is dropped with its result
+    expect(result[1].content.map((b) => b.type)).toEqual(["text", "tool_use"]);
+    const summarized = result[3].content[0];
+    expect(summarized.type).toBe("text");
+    expect((summarized as { text: string }).text).toContain("deferred query");
+    expect((summarized as { text: string }).text).toContain(
+      "https://example.com",
+    );
+    expect(stats.serverToolUsesDropped).toBe(1);
+    expect(stats.blocksStripped).toBe(1);
+    expect(stats.messagesModified).toBe(2);
+  });
+
+  test("leaves a pending server_tool_use with no result anywhere untouched", () => {
+    // A resultless use at the tail is a deferred search the provider executes
+    // on this request; stripping it would cancel the search.
+    const messages: Message[] = [
+      { role: "user", content: [{ type: "text", text: "Check both" }] },
+      {
+        role: "assistant",
+        content: [
+          { type: "tool_use", id: "tu_read", name: "file_read", input: {} },
+          {
+            type: "server_tool_use",
+            id: "stu_pending",
+            name: "web_search",
+            input: { query: "pending" },
+          },
+        ],
+      },
+      {
+        role: "user",
+        content: [
+          { type: "tool_result", tool_use_id: "tu_read", content: "file" },
+        ],
+      },
+    ];
+
+    const { messages: result, stats } =
+      stripHistoricalWebSearchResults(messages);
+
+    expect(result).toEqual(messages);
+    expect(stats.serverToolUsesDropped).toBe(0);
+    expect(stats.blocksStripped).toBe(0);
+    expect(stats.messagesModified).toBe(0);
+  });
 });

package/src/__tests__/workspace-migration-139-clear-renamed-cost-profile-label.test.ts

@@ -51,15 +51,15 @@ afterEach(() => {
 });
 
 describe("139-clear-renamed-cost-profile-label migration", () => {
-  test("has correct migration id and is registered last", () => {
+  test("has correct migration id and is registered", () => {
     expect(clearRenamedCostProfileLabelMigration.id).toBe(
       "139-clear-renamed-cost-profile-label",
     );
-    // getLastWorkspaceMigrationId() reports the final entry as the registry
-    // ceiling, so the highest id must stay last.
-    expect(WORKSPACE_MIGRATIONS[WORKSPACE_MIGRATIONS.length - 1]?.id).toBe(
-      "139-clear-renamed-cost-profile-label",
-    );
+    expect(
+      WORKSPACE_MIGRATIONS.some(
+        (migration) => migration.id === "139-clear-renamed-cost-profile-label",
+      ),
+    ).toBe(true);
   });
 
   test("clears the seeded label so the code catalog label applies", () => {

package/src/__tests__/workspace-migration-140-repair-seed-pinned-memory-v3-live.test.ts

@@ -0,0 +1,330 @@
+/**
+ * Tests for workspace migration `140-repair-seed-pinned-memory-v3-live`.
+ *
+ * The pre-#39847 first-launch seed persisted `memory.v3.live = false` before
+ * migration 105 could record the real decision, stranding brand-new
+ * assistants on v2 and demoting existing v3 assistants whose config.json was
+ * quarantined and reseeded. The repair flips `live` back to true only for
+ * those two victim classes and never over a deliberate opt-out.
+ */
+
+import {
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { Database } from "bun:sqlite";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import { repairSeedPinnedMemoryV3LiveMigration } from "../workspace/migrations/140-repair-seed-pinned-memory-v3-live.js";
+import { WORKSPACE_MIGRATIONS } from "../workspace/migrations/registry.js";
+import type { MigrationRunContext } from "../workspace/migrations/types.js";
+
+const NEW_WORKSPACE_CTX: MigrationRunContext = { isNewWorkspace: true };
+const UPGRADE_CTX: MigrationRunContext = { isNewWorkspace: false };
+
+let workspaceDir: string;
+let configPath: string;
+
+beforeEach(() => {
+  workspaceDir = mkdtempSync(join(tmpdir(), "vellum-migration-140-test-"));
+  configPath = join(workspaceDir, "config.json");
+  mkdirSync(join(workspaceDir, "data", "db"), { recursive: true });
+});
+
+afterEach(() => {
+  if (existsSync(workspaceDir)) {
+    rmSync(workspaceDir, { recursive: true, force: true });
+  }
+});
+
+function readConfig(): Record<string, unknown> {
+  return JSON.parse(readFileSync(configPath, "utf-8"));
+}
+
+function readLive(): unknown {
+  const memory = (readConfig().memory ?? {}) as Record<string, unknown>;
+  const v3 = (memory.v3 ?? {}) as Record<string, unknown>;
+  return v3.live;
+}
+
+function writeConfig(config: Record<string, unknown>): void {
+  writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+}
+
+/** A checkpoint file whose 105 entry ran `gapMs` after the earliest entry. */
+function writeCheckpoints(gapMs: number): void {
+  const base = Date.parse("2026-06-20T12:00:00.000Z");
+  writeFileSync(
+    join(workspaceDir, "data", ".workspace-migrations.json"),
+    JSON.stringify(
+      {
+        applied: {
+          "001-avatar-rename": {
+            appliedAt: new Date(base).toISOString(),
+            status: "completed",
+          },
+          "105-enable-memory-v3-live-for-new-workspaces": {
+            appliedAt: new Date(base + gapMs).toISOString(),
+            status: "completed",
+          },
+        },
+      },
+      null,
+      2,
+    ) + "\n",
+  );
+}
+
+const FIRST_BOOT_GAP_MS = 5_000;
+const UPGRADE_SWEEP_GAP_MS = 30 * 24 * 60 * 60 * 1000;
+
+function writeSelectionRows(file: string): void {
+  const db = new Database(join(workspaceDir, "data", "db", file));
+  db.exec(`
+    CREATE TABLE memory_v3_selections (
+      conversation_id TEXT NOT NULL,
+      turn INTEGER NOT NULL,
+      slug TEXT NOT NULL,
+      source TEXT NOT NULL,
+      pinned INTEGER NOT NULL DEFAULT 0
+    );
+    INSERT INTO memory_v3_selections (conversation_id, turn, slug, source)
+      VALUES ('conv-1', 1, 'some-page', 'needle');
+  `);
+  db.close();
+}
+
+describe("140-repair-seed-pinned-memory-v3-live migration", () => {
+  test("has correct id and is registered last", () => {
+    expect(repairSeedPinnedMemoryV3LiveMigration.id).toBe(
+      "140-repair-seed-pinned-memory-v3-live",
+    );
+    expect(repairSeedPinnedMemoryV3LiveMigration.description).toContain(
+      "memory.v3.live",
+    );
+    // getLastWorkspaceMigrationId() reports the final entry as the registry
+    // ceiling, so ordering matters: this must be registered, and everything
+    // after it must carry a higher id. Asserting it stays literally last
+    // would break on every migration appended after it.
+    const index = WORKSPACE_MIGRATIONS.findIndex(
+      (migration) => migration.id === "140-repair-seed-pinned-memory-v3-live",
+    );
+    expect(index).toBeGreaterThan(-1);
+    for (const later of WORKSPACE_MIGRATIONS.slice(index + 1)) {
+      expect(later.id > "140").toBe(true);
+    }
+  });
+
+  test("flips a seed-race victim: born in the 105 era, live=false, v3 never ran", () => {
+    writeConfig({
+      memory: { v2: { enabled: true }, v3: { live: false } },
+      llm: { activeProfile: "balanced" },
+    });
+    writeCheckpoints(FIRST_BOOT_GAP_MS);
+
+    repairSeedPinnedMemoryV3LiveMigration.run(workspaceDir, UPGRADE_CTX);
+
+    expect(readLive()).toBe(true);
+    // The rest of the config is untouched.
+    const config = readConfig();
+    expect((config.llm as Record<string, unknown>).activeProfile).toBe(
+      "balanced",
+    );
+    expect(
+      ((config.memory as Record<string, unknown>).v2 as Record<string, unknown>)
+        .enabled,
+    ).toBe(true);
+  });
+
+  test("skips new workspaces so a hatch-time opt-out override wins", () => {
+    writeConfig({ memory: { v3: { live: false } } });
+    writeCheckpoints(FIRST_BOOT_GAP_MS);
+
+    repairSeedPinnedMemoryV3LiveMigration.run(workspaceDir, NEW_WORKSPACE_CTX);
+
+    expect(readLive()).toBe(false);
+  });
+
+  test("leaves an absent leaf alone: pre-105 assistants stay on the manual-upgrade path", () => {
+    writeConfig({ memory: { v2: { enabled: true } } });
+    writeCheckpoints(UPGRADE_SWEEP_GAP_MS);
+
+    repairSeedPinnedMemoryV3LiveMigration.run(workspaceDir, UPGRADE_CTX);
+
+    expect(readLive()).toBeUndefined();
+  });
+
+  test("leaves live=true alone (idempotent after its own repair)", () => {
+    writeConfig({ memory: { v3: { live: false } } });
+    writeCheckpoints(FIRST_BOOT_GAP_MS);
+
+    repairSeedPinnedMemoryV3LiveMigration.run(workspaceDir, UPGRADE_CTX);
+    expect(readLive()).toBe(true);
+    const afterFirstRun = readFileSync(configPath, "utf-8");
+
+    repairSeedPinnedMemoryV3LiveMigration.run(workspaceDir, UPGRADE_CTX);
+    expect(readFileSync(configPath, "utf-8")).toBe(afterFirstRun);
+  });
+
+  test("skips a live=false workspace that was NOT born in the 105 era", () => {
+    writeConfig({ memory: { v3: { live: false } } });
+    writeCheckpoints(UPGRADE_SWEEP_GAP_MS);
+
+    repairSeedPinnedMemoryV3LiveMigration.run(workspaceDir, UPGRADE_CTX);
+
+    expect(readLive()).toBe(false);
+  });
+
+  test("skips when the checkpoint file is missing (no era evidence)", () => {
+    writeConfig({ memory: { v3: { live: false } } });
+
+    repairSeedPinnedMemoryV3LiveMigration.run(workspaceDir, UPGRADE_CTX);
+
+    expect(readLive()).toBe(false);
+  });
+
+  test("respects a hatch-time opt-out recorded in the archived default overlay", () => {
+    writeConfig({ memory: { v3: { live: false } } });
+    writeCheckpoints(FIRST_BOOT_GAP_MS);
+    writeFileSync(
+      join(workspaceDir, "default-config.json"),
+      JSON.stringify({ memory: { v3: { live: false } } }, null, 2),
+    );
+
+    repairSeedPinnedMemoryV3LiveMigration.run(workspaceDir, UPGRADE_CTX);
+
+    expect(readLive()).toBe(false);
+  });
+
+  test("an archived overlay without a memory.v3.live opt-out does not block repair", () => {
+    writeConfig({ memory: { v3: { live: false } } });
+    writeCheckpoints(FIRST_BOOT_GAP_MS);
+    writeFileSync(
+      join(workspaceDir, "default-config.json"),
+      JSON.stringify({ llm: { activeProfile: "balanced" } }, null, 2),
+    );
+
+    repairSeedPinnedMemoryV3LiveMigration.run(workspaceDir, UPGRADE_CTX);
+
+    expect(readLive()).toBe(true);
+  });
+
+  test("respects a deliberate opt-out: v3 selection rows exist", () => {
+    writeConfig({ memory: { v3: { live: false } } });
+    writeCheckpoints(FIRST_BOOT_GAP_MS);
+    writeSelectionRows("assistant-memory.db");
+
+    repairSeedPinnedMemoryV3LiveMigration.run(workspaceDir, UPGRADE_CTX);
+
+    expect(readLive()).toBe(false);
+  });
+
+  test("finds selection rows staged under the __relocating name mid-drain", () => {
+    writeConfig({ memory: { v3: { live: false } } });
+    writeCheckpoints(FIRST_BOOT_GAP_MS);
+    const db = new Database(join(workspaceDir, "data", "db", "assistant.db"));
+    db.exec(`
+      CREATE TABLE memory_v3_selections__relocating (
+        conversation_id TEXT NOT NULL,
+        turn INTEGER NOT NULL,
+        slug TEXT NOT NULL,
+        source TEXT NOT NULL
+      );
+      INSERT INTO memory_v3_selections__relocating
+        (conversation_id, turn, slug, source)
+        VALUES ('conv-1', 1, 'some-page', 'needle');
+    `);
+    db.close();
+
+    repairSeedPinnedMemoryV3LiveMigration.run(workspaceDir, UPGRADE_CTX);
+
+    expect(readLive()).toBe(false);
+  });
+
+  test("finds selection rows in the pre-relocation assistant.db too", () => {
+    writeConfig({ memory: { v3: { live: false } } });
+    writeCheckpoints(FIRST_BOOT_GAP_MS);
+    writeSelectionRows("assistant.db");
+
+    repairSeedPinnedMemoryV3LiveMigration.run(workspaceDir, UPGRADE_CTX);
+
+    expect(readLive()).toBe(false);
+  });
+
+  test("an empty selections table is not usage evidence", () => {
+    writeConfig({ memory: { v3: { live: false } } });
+    writeCheckpoints(FIRST_BOOT_GAP_MS);
+    const db = new Database(
+      join(workspaceDir, "data", "db", "assistant-memory.db"),
+    );
+    db.exec(
+      `CREATE TABLE memory_v3_selections (conversation_id TEXT, turn INTEGER)`,
+    );
+    db.close();
+
+    repairSeedPinnedMemoryV3LiveMigration.run(workspaceDir, UPGRADE_CTX);
+
+    expect(readLive()).toBe(true);
+  });
+
+  test("quarantine carry-forward flips a demoted v3 assistant even with usage rows and an old workspace", () => {
+    writeConfig({ memory: { v3: { live: false } } });
+    writeCheckpoints(UPGRADE_SWEEP_GAP_MS);
+    writeSelectionRows("assistant-memory.db");
+    writeFileSync(
+      join(workspaceDir, "config.json.corrupt-2026-08-01T10-00-00.000Z.json"),
+      JSON.stringify({ memory: { v3: { live: true } } }, null, 2),
+    );
+
+    repairSeedPinnedMemoryV3LiveMigration.run(workspaceDir, UPGRADE_CTX);
+
+    expect(readLive()).toBe(true);
+  });
+
+  test("salvages live=true from a truncated (unparseable) quarantined config", () => {
+    writeConfig({ memory: { v3: { live: false } } });
+    writeCheckpoints(UPGRADE_SWEEP_GAP_MS);
+    writeFileSync(
+      join(workspaceDir, "config.json.corrupt-2026-08-01T10-00-00.000Z.json"),
+      `{\n  "memory": {\n    "v3": {\n      "live": true\n    }\n  },\n  "llm": {\n    "activeProf`,
+    );
+
+    repairSeedPinnedMemoryV3LiveMigration.run(workspaceDir, UPGRADE_CTX);
+
+    expect(readLive()).toBe(true);
+  });
+
+  test("the NEWEST quarantined config wins", () => {
+    writeConfig({ memory: { v3: { live: false } } });
+    writeCheckpoints(UPGRADE_SWEEP_GAP_MS);
+    writeFileSync(
+      join(workspaceDir, "config.json.corrupt-2026-07-01T10-00-00.000Z.json"),
+      JSON.stringify({ memory: { v3: { live: true } } }),
+    );
+    writeFileSync(
+      join(workspaceDir, "config.json.corrupt-2026-08-01T10-00-00.000Z.json"),
+      JSON.stringify({ memory: { v3: { live: false } } }),
+    );
+
+    repairSeedPinnedMemoryV3LiveMigration.run(workspaceDir, UPGRADE_CTX);
+
+    expect(readLive()).toBe(false);
+  });
+
+  test("no-ops when config.json is missing or corrupt", () => {
+    // Missing.
+    repairSeedPinnedMemoryV3LiveMigration.run(workspaceDir, UPGRADE_CTX);
+    expect(existsSync(configPath)).toBe(false);
+
+    // Corrupt.
+    writeFileSync(configPath, "{ not json");
+    repairSeedPinnedMemoryV3LiveMigration.run(workspaceDir, UPGRADE_CTX);
+    expect(readFileSync(configPath, "utf-8")).toBe("{ not json");
+  });
+});

package/src/acp/failure-error.ts

@@ -6,15 +6,13 @@
  * `{"error":{"message":"..."}}`. This picks the most specific signal available:
  * a structured stderr error, else the last stderr line, else the ack message.
  *
- * Pure and dependency-free.
+ * Pure; the only dependency is the shared escape-sequence strip.
  */
 
-// CSI escape sequences (colour codes, cursor moves) that adapters interleave
-// with their log lines: ESC `[`, parameter/intermediate bytes, then final byte.
-const ANSI_ESCAPE = /\u001B\[[0-?]*[ -/]*[@-~]/g;
+import { stripAnsiSequences } from "../util/ansi.js";
 
 export function deriveFailureError(ackMessage: string, stderr: string): string {
-  const clean = stderr.replace(ANSI_ESCAPE, "").trim();
+  const clean = stripAnsiSequences(stderr).trim();
 
   // Most precise: a structured adapter error — prefer it over the ack.
   const jsonMessage = lastJsonErrorMessage(clean);

package/src/agent/attachments.ts

@@ -76,35 +76,37 @@ export function attachmentsToReferenceBlocks(
 
 export function attachmentsToContentBlocks(
   attachments: MessageAttachmentInput[],
-): ContentBlock[] {
-  return attachments.map((attachment) => {
-    if (attachment.mimeType.toLowerCase().startsWith("image/")) {
-      const { data, mediaType } = optimizeImageForTransport(
-        attachment.data,
-        attachment.mimeType,
-      );
+): Promise<ContentBlock[]> {
+  return Promise.all(
+    attachments.map(async (attachment) => {
+      if (attachment.mimeType.toLowerCase().startsWith("image/")) {
+        const { data, mediaType } = await optimizeImageForTransport(
+          attachment.data,
+          attachment.mimeType,
+        );
+        return {
+          type: "image",
+          source: {
+            type: "base64",
+            media_type: mediaType,
+            data,
+          },
+        } as ContentBlock;
+      }
+
       return {
-        type: "image",
+        type: "file",
         source: {
           type: "base64",
-          media_type: mediaType,
-          data,
+          media_type: attachment.mimeType,
+          data: attachment.data,
+          filename: attachment.filename,
         },
+        extracted_text: attachment.extractedText,
+        ...(attachment.id ? { _attachmentId: attachment.id } : {}),
       } as ContentBlock;
-    }
-
-    return {
-      type: "file",
-      source: {
-        type: "base64",
-        media_type: attachment.mimeType,
-        data: attachment.data,
-        filename: attachment.filename,
-      },
-      extracted_text: attachment.extractedText,
-      ...(attachment.id ? { _attachmentId: attachment.id } : {}),
-    } as ContentBlock;
-  });
+    }),
+  );
 }
 
 /**

package/src/agent/history-repair/history-repair.ts

@@ -15,6 +15,7 @@
  * recover — so detection and repair of ordering drift live together as one unit.
  */
 
+import { analyzeServerToolPairing } from "../../providers/server-tool-pairing.js";
 import type {
   ContentBlock,
   Message,
@@ -69,6 +70,10 @@ export function repairHistory(messages: Message[]): RepairResult {
   let pendingToolUseIds = new Set<string>();
   // tool_result blocks stripped from assistant messages, keyed by tool_use_id
   let recoveredResults = new Map<string, ToolResultContent>();
+  // Server-tool pairs can legitimately span messages (deferred execution) or
+  // sit unanswered at the tail (the provider runs the search on the next
+  // request), so orphanhood is judged against the whole list, not per message.
+  const serverToolPairing = analyzeServerToolPairing(messages);
 
   for (const [msgIndex, msg] of messages.entries()) {
     if (msg.role === "assistant") {
@@ -100,36 +105,32 @@ export function repairHistory(messages: Message[]): RepairResult {
         }
       }
 
-      // Pair server-side tool blocks within the same assistant message.
-      // Server tools (e.g. web_search) emit server_tool_use + matching
-      // web_search_tool_result. Either side can go missing — the synthetic
-      // result is inserted IMMEDIATELY AFTER the orphan server_tool_use (not
+      // Repair orphaned server-side tool blocks. Server tools (e.g.
+      // web_search) emit server_tool_use + matching web_search_tool_result;
+      // orphanhood comes from `serverToolPairing`, which resolves pairs
+      // across messages and exempts the deferred tail. The synthetic result
+      // is inserted IMMEDIATELY AFTER the orphan server_tool_use (not
       // appended to the end) so ensureToolPairing's split at tool_use
       // boundaries cannot separate the pair. An orphan
-      // web_search_tool_result (no preceding server_tool_use) is downgraded
-      // to text — Anthropic rejects the request otherwise.
-      const serverToolIds = new Set(
-        cleanedContent
-          .filter(
-            (b): b is ServerToolUseContent => b.type === "server_tool_use",
-          )
-          .map((b) => b.id),
-      );
-      const matchedServerIds = new Set(
-        cleanedContent
-          .filter((b) => b.type === "web_search_tool_result")
-          .map((b) => (b as { tool_use_id: string }).tool_use_id),
-      );
+      // web_search_tool_result with no use anywhere is downgraded to text.
+      // Anthropic rejects the request otherwise.
       const orphanedServerIds = new Set<string>();
-      for (const id of serverToolIds) {
-        if (!matchedServerIds.has(id)) {
-          orphanedServerIds.add(id);
-        }
-      }
       const orphanedWebSearchResultIds = new Set<string>();
-      for (const id of matchedServerIds) {
-        if (!serverToolIds.has(id)) {
-          orphanedWebSearchResultIds.add(id);
+      for (const b of cleanedContent) {
+        if (b.type === "server_tool_use") {
+          const id = (b as ServerToolUseContent).id;
+          if (
+            !serverToolPairing.resolvedPairIds.has(id) &&
+            !serverToolPairing.deferredUseIds.has(id)
+          ) {
+            orphanedServerIds.add(id);
+          }
+        }
+        if (b.type === "web_search_tool_result") {
+          const id = (b as { tool_use_id: string }).tool_use_id;
+          if (!serverToolPairing.resolvedPairIds.has(id)) {
+            orphanedWebSearchResultIds.add(id);
+          }
         }
       }