@vellumai/assistant 0.8.5 → 0.8.7

package/src/__tests__/compaction-events.test.ts

@@ -10,12 +10,8 @@
  */
 import { describe, expect, mock, test } from "bun:test";
 
-import type {
-  AgentEvent,
-  AgentLoopConfig,
-  CheckpointDecision,
-  CheckpointInfo,
-} from "../agent/loop.js";
+import { CompactionCircuit } from "../agent/compaction-circuit.js";
+import type { AgentEvent } from "../agent/loop.js";
 import type { ContextWindowResult } from "../context/window-manager.js";
 import type { ServerMessage } from "../daemon/message-protocol.js";
 import type { Message, ProviderResponse } from "../providers/types.js";
@@ -150,6 +146,7 @@ mock.module("../memory/conversation-crud.js", () => ({
   addMessage: () => ({ id: `msg-${Date.now()}` }),
   updateConversationUsage: () => {},
   updateConversationTitle: () => {},
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 
 mock.module("../memory/conversation-queries.js", () => ({
@@ -220,11 +217,8 @@ mock.module("../memory/auto-analysis-enqueue.js", () => ({
 
 mock.module("../agent/loop.js", () => ({
   AgentLoop: class {
-    constructor(
-      _provider: unknown,
-      _systemPrompt: string,
-      _config?: Partial<AgentLoopConfig>,
-    ) {}
+    compactionCircuit = new CompactionCircuit("test-conv");
+    constructor() {}
     getToolTokenBudget() {
       return 0;
     }
@@ -237,11 +231,6 @@ mock.module("../agent/loop.js", () => ({
     async run(
       _messages: Message[],
       _onEvent: (event: AgentEvent) => void,
-      _signal?: AbortSignal,
-      _requestId?: string,
-      _onCheckpoint?: (
-        checkpoint: CheckpointInfo,
-      ) => CheckpointDecision | Promise<CheckpointDecision>,
     ): Promise<Message[]> {
       return [];
     }
@@ -300,11 +289,11 @@ function makeConversation(
     id,
     makeProvider(),
     "system prompt",
-    4096,
     (msg) => {
       collected.push(msg);
     },
     "/tmp",
+    { maxTokens: 4096 },
   );
 }
 

package/src/__tests__/compaction-pipeline.test.ts

@@ -20,7 +20,7 @@ import type { TrustContext } from "../daemon/trust-context.js";
 import {
   DEFAULT_COMPACTION_PLUGIN_NAME,
   defaultCompactionTerminal,
-} from "../plugins/defaults/compaction.js";
+} from "../plugins/defaults/compaction/terminal.js";
 import { runPipeline } from "../plugins/pipeline.js";
 import {
   type CompactionArgs,

package/src/__tests__/compaction-timeout-recovery.test.ts

@@ -5,8 +5,9 @@
  * `DEFAULT_TIMEOUTS.compaction`), the pipeline runner throws
  * `PluginTimeoutError`. The three compaction call sites in
  * `conversation-agent-loop.ts` (start-of-turn, mid-loop, emergency) catch
- * that error, invoke `trackCompactionOutcome(..., true, onEvent)` so the
- * circuit breaker records the failure, and degrade gracefully.
+ * that error, record the failure on the loop-held `CompactionCircuit`
+ * (`recordOutcome(turn, true, ...)`) so the circuit breaker counts it, and degrade
+ * gracefully.
  *
  * This file asserts the tight coupling between:
  *  (1) a `PluginTimeoutError`-driven failure and
@@ -21,13 +22,14 @@
 
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 
-import { trackCompactionOutcome } from "../daemon/conversation-agent-loop.js";
+import {
+  type CircuitTurnInfo,
+  CompactionCircuit,
+} from "../agent/compaction-circuit.js";
 import type { ServerMessage } from "../daemon/message-protocol.js";
 import type { TrustContext } from "../daemon/trust-context.js";
-import {
-  COMPACTION_CIRCUIT_FAILURE_THRESHOLD,
-  defaultCircuitBreakerPlugin,
-} from "../plugins/defaults/circuit-breaker.js";
+import { COMPACTION_CIRCUIT_FAILURE_THRESHOLD } from "../plugins/defaults/circuit-breaker/middlewares/circuitBreaker.js";
+import { defaultCircuitBreakerPlugin } from "../plugins/defaults/circuit-breaker/register.js";
 import { DEFAULT_TIMEOUTS, runPipeline } from "../plugins/pipeline.js";
 import {
   getMiddlewaresFor,
@@ -44,27 +46,14 @@ import {
 
 // ─── Fixtures ───────────────────────────────────────────────────────────────
 
-interface FakeConversationCtx {
-  readonly conversationId: string;
-  consecutiveCompactionFailures: number;
-  compactionCircuitOpenUntil: number | null;
-  currentRequestId?: string;
-  currentTurnTrustContext?: TrustContext;
-  trustContext?: TrustContext;
-  turnCount: number;
+function makeCircuit(conversationId = "conv-timeout-test"): CompactionCircuit {
+  return new CompactionCircuit(conversationId);
 }
 
-function makeConversationCtx(
-  conversationId = "conv-timeout-test",
-): FakeConversationCtx {
-  return {
-    conversationId,
-    consecutiveCompactionFailures: 0,
-    compactionCircuitOpenUntil: null,
-    turnCount: 0,
-    trustContext: { sourceChannel: "vellum", trustClass: "guardian" },
-  };
-}
+const turn: CircuitTurnInfo = {
+  turnCount: 0,
+  trustContext: { sourceChannel: "vellum", trustClass: "guardian" },
+};
 
 const trust: TrustContext = {
   sourceChannel: "vellum",
@@ -130,34 +119,34 @@ describe("compaction timeout recovery (JARVIS-587)", () => {
     expect((caught as PluginTimeoutError).pipeline).toBe("compaction");
   });
 
-  test("trackCompactionOutcome(failed=true) driven by PluginTimeoutError trips the breaker at the 3rd strike", async () => {
+  test("recordOutcome(failed=true) driven by PluginTimeoutError trips the breaker at the 3rd strike", async () => {
     // Simulates the production sequence: each mid-loop compaction hits the
-    // pipeline's 30s ceiling, the orchestrator's catch block calls
-    // `trackCompactionOutcome(ctx, true, onEvent)`. After three such catches
+    // pipeline's 30s ceiling, the catch path calls
+    // `circuit.recordOutcome(turn, true, onEvent)`. After three such catches
     // the circuit breaker must be open — matching the same invariant the
     // existing breaker test file exercises for normal summary-LLM throws.
-    const ctx = makeConversationCtx();
+    const circuit = makeCircuit();
     const { onEvent, events } = collectEvents();
 
     // First two timeouts — circuit still closed.
-    await trackCompactionOutcome(ctx, true, onEvent);
-    await trackCompactionOutcome(ctx, true, onEvent);
-    expect(ctx.consecutiveCompactionFailures).toBe(2);
-    expect(ctx.compactionCircuitOpenUntil).toBeNull();
+    await circuit.recordOutcome(turn, true, onEvent);
+    await circuit.recordOutcome(turn, true, onEvent);
+    expect(circuit.consecutiveCompactionFailures).toBe(2);
+    expect(circuit.compactionCircuitOpenUntil).toBeNull();
     expect(events).toHaveLength(0);
 
     // Third timeout — breaker trips and emits the canonical transition event.
-    await trackCompactionOutcome(ctx, true, onEvent);
-    expect(ctx.consecutiveCompactionFailures).toBe(
+    await circuit.recordOutcome(turn, true, onEvent);
+    expect(circuit.consecutiveCompactionFailures).toBe(
       COMPACTION_CIRCUIT_FAILURE_THRESHOLD,
     );
-    expect(ctx.compactionCircuitOpenUntil).not.toBeNull();
+    expect(circuit.compactionCircuitOpenUntil).not.toBeNull();
     expect(events).toHaveLength(1);
     expect(events[0]).toEqual({
       type: "compaction_circuit_open",
-      conversationId: ctx.conversationId,
+      conversationId: circuit.conversationId,
       reason: "3_consecutive_failures",
-      openUntil: ctx.compactionCircuitOpenUntil as number,
+      openUntil: circuit.compactionCircuitOpenUntil as number,
     });
   });
 
@@ -165,19 +154,19 @@ describe("compaction timeout recovery (JARVIS-587)", () => {
     // The recovery path doesn't interfere with the breaker's normal reset —
     // once a compaction call eventually succeeds, the streak is broken and
     // the next failure starts counting from 1.
-    const ctx = makeConversationCtx();
+    const circuit = makeCircuit();
     const { onEvent } = collectEvents();
 
-    await trackCompactionOutcome(ctx, true, onEvent);
-    await trackCompactionOutcome(ctx, true, onEvent);
-    expect(ctx.consecutiveCompactionFailures).toBe(2);
+    await circuit.recordOutcome(turn, true, onEvent);
+    await circuit.recordOutcome(turn, true, onEvent);
+    expect(circuit.consecutiveCompactionFailures).toBe(2);
 
-    await trackCompactionOutcome(ctx, false, onEvent);
-    expect(ctx.consecutiveCompactionFailures).toBe(0);
-    expect(ctx.compactionCircuitOpenUntil).toBeNull();
+    await circuit.recordOutcome(turn, false, onEvent);
+    expect(circuit.consecutiveCompactionFailures).toBe(0);
+    expect(circuit.compactionCircuitOpenUntil).toBeNull();
 
-    await trackCompactionOutcome(ctx, true, onEvent);
-    expect(ctx.consecutiveCompactionFailures).toBe(1);
+    await circuit.recordOutcome(turn, true, onEvent);
+    expect(circuit.consecutiveCompactionFailures).toBe(1);
   });
 
   test("compaction call-site recovery remains defense-in-depth even when DEFAULT_TIMEOUTS.compaction is null", () => {

package/src/__tests__/compaction-trail-store.test.ts

@@ -0,0 +1,186 @@
+/**
+ * Tests for the compaction-trail store helper `getCompactionLogsBetween`.
+ *
+ * Exercises the SQL directly against a real in-memory DB — same pattern
+ * as `llm-request-log-turn-query.test.ts`. Each test sets up a small
+ * conversation, inserts a mix of `mainAgent` / `compactionAgent` /
+ * NULL-call-site rows with controlled `createdAt` timestamps, and
+ * asserts the right subset comes back.
+ */
+
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+mock.module("../config/loader.js", () => ({
+  getConfig: () => ({
+    ui: {},
+    model: "test",
+    provider: "test",
+    memory: { enabled: false },
+    rateLimit: { maxRequestsPerMinute: 0 },
+    secretDetection: { enabled: false },
+  }),
+}));
+
+import { eq } from "drizzle-orm";
+
+import { createConversation } from "../memory/conversation-crud.js";
+import { getDb } from "../memory/db-connection.js";
+import { initializeDb } from "../memory/db-init.js";
+import {
+  getCompactionLogsBetween,
+  recordRequestLog,
+} from "../memory/llm-request-log-store.js";
+import { llmRequestLogs } from "../memory/schema.js";
+
+initializeDb();
+
+function resetTables(): void {
+  const db = getDb();
+  db.delete(llmRequestLogs).run();
+  db.run("DELETE FROM messages");
+  db.run("DELETE FROM conversations");
+}
+
+/**
+ * Insert a log row and overwrite its `createdAt` so tests can assert
+ * order/cutoff without relying on `Date.now()` timing.
+ */
+function insertLogAt(
+  conversationId: string,
+  createdAt: number,
+  callSite: "mainAgent" | "compactionAgent" | null,
+): string {
+  const id = recordRequestLog(
+    conversationId,
+    "{}",
+    "{}",
+    undefined,
+    "anthropic",
+    callSite ?? undefined,
+  );
+  // Use the Drizzle update builder rather than `db.run("UPDATE … ?")` —
+  // the drizzle wrapper doesn't accept positional parameters the same
+  // way `bun:sqlite` does, and a silent no-op there manifests as zero
+  // rows in the query under test (the inserted `created_at` keeps its
+  // `Date.now()` value and ends up far in the future of the cutoff).
+  const db = getDb();
+  db.update(llmRequestLogs)
+    .set({ createdAt })
+    .where(eq(llmRequestLogs.id, id))
+    .run();
+  return id;
+}
+
+describe("getCompactionLogsBetween", () => {
+  beforeEach(() => {
+    resetTables();
+  });
+
+  test("returns only compactionAgent rows in the conversation, in the (after, before) window", () => {
+    const conv = createConversation("test-conv");
+
+    // Timeline (createdAt in ms):
+    //   100 → compactionAgent  ← excluded (before the floor — would belong to an earlier turn)
+    //   150 ← floor (the prior real call's createdAt)
+    //   200 → mainAgent        ← excluded (wrong call site)
+    //   300 → compactionAgent  ← included
+    //   400 → null call site   ← excluded (pre-migration row, not a compaction)
+    //   500 ← ceiling (the selected call's createdAt)
+    //   600 → compactionAgent  ← excluded (after ceiling)
+    insertLogAt(conv.id, 100, "compactionAgent");
+    insertLogAt(conv.id, 200, "mainAgent");
+    insertLogAt(conv.id, 300, "compactionAgent");
+    insertLogAt(conv.id, 400, null);
+    insertLogAt(conv.id, 600, "compactionAgent");
+
+    const result = getCompactionLogsBetween(conv.id, 150, 500);
+    expect(result).toHaveLength(1);
+    expect(result[0]!.createdAt).toBe(300);
+    expect(result[0]!.callSite).toBe("compactionAgent");
+    expect(result[0]!.conversationId).toBe(conv.id);
+  });
+
+  test("null floor matches all compactions before the ceiling (first-real-call case)", () => {
+    const conv = createConversation("null-floor");
+
+    insertLogAt(conv.id, 100, "compactionAgent");
+    insertLogAt(conv.id, 200, "compactionAgent");
+    insertLogAt(conv.id, 300, "compactionAgent");
+    insertLogAt(conv.id, 600, "compactionAgent");
+
+    const result = getCompactionLogsBetween(conv.id, null, 500);
+    expect(result.map((r) => r.createdAt)).toEqual([100, 200, 300]);
+  });
+
+  test("uses strict < at the ceiling (a row exactly at the cutoff is excluded)", () => {
+    const conv = createConversation("strict-ceiling");
+
+    insertLogAt(conv.id, 100, "compactionAgent");
+    insertLogAt(conv.id, 500, "compactionAgent"); // exactly at the ceiling
+
+    const result = getCompactionLogsBetween(conv.id, null, 500);
+    expect(result).toHaveLength(1);
+    expect(result[0]!.createdAt).toBe(100);
+  });
+
+  test("uses strict > at the floor (a row exactly at the floor is excluded)", () => {
+    const conv = createConversation("strict-floor");
+
+    insertLogAt(conv.id, 150, "compactionAgent"); // exactly at the floor
+    insertLogAt(conv.id, 200, "compactionAgent");
+
+    const result = getCompactionLogsBetween(conv.id, 150, 500);
+    expect(result).toHaveLength(1);
+    expect(result[0]!.createdAt).toBe(200);
+  });
+
+  test("scopes by conversation_id (other conversations are invisible)", () => {
+    const a = createConversation("conv-a");
+    const b = createConversation("conv-b");
+
+    insertLogAt(a.id, 100, "compactionAgent");
+    insertLogAt(b.id, 150, "compactionAgent");
+    insertLogAt(a.id, 200, "compactionAgent");
+
+    const result = getCompactionLogsBetween(a.id, null, 500);
+    expect(result).toHaveLength(2);
+    for (const row of result) {
+      expect(row.conversationId).toBe(a.id);
+    }
+  });
+
+  test("returns rows in chronological order by createdAt then id", () => {
+    const conv = createConversation("ordered");
+
+    // Insert out of order to verify the ORDER BY clause does the work.
+    insertLogAt(conv.id, 300, "compactionAgent");
+    insertLogAt(conv.id, 100, "compactionAgent");
+    insertLogAt(conv.id, 200, "compactionAgent");
+
+    const result = getCompactionLogsBetween(conv.id, null, 500);
+    expect(result.map((r) => r.createdAt)).toEqual([100, 200, 300]);
+  });
+
+  test("returns an empty array when no compaction rows fall in the window", () => {
+    const conv = createConversation("empty");
+
+    // mainAgent (wrong site) + compactionAgent after the ceiling.
+    insertLogAt(conv.id, 100, "mainAgent");
+    insertLogAt(conv.id, 600, "compactionAgent");
+
+    const result = getCompactionLogsBetween(conv.id, null, 500);
+    expect(result).toEqual([]);
+  });
+
+  test("returns an empty array for an unknown conversation_id", () => {
+    const result = getCompactionLogsBetween("nonexistent-conv", null, 500);
+    expect(result).toEqual([]);
+  });
+});

package/src/__tests__/compactor-call-site-logging.test.ts

@@ -31,6 +31,7 @@ mock.module("../util/logger.js", () => ({
 
 mock.module("../memory/conversation-crud.js", () => ({
   getMessages: () => [],
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 
 mock.module("../memory/attachments-store.js", () => ({

package/src/__tests__/compactor-image-manifest-trust.test.ts

@@ -0,0 +1,112 @@
+/**
+ * Compaction must not surface guardian-only images to untrusted actors.
+ *
+ * `loadFromDb` hides guardian-provenance messages (and their images) from
+ * untrusted actors. The compaction image manifest reads the DB directly, so
+ * without the same provenance filter an untrusted actor's compaction turn
+ * could list a guardian image, retain it, and re-attach its bytes — leaking
+ * content the actor was never allowed to see. `collectImageManifest` applies
+ * the identical trust filter so this cannot happen.
+ */
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+mock.module("../config/loader.js", () => ({
+  getConfig: () => ({
+    ui: {},
+    model: "test",
+    provider: "test",
+    memory: { enabled: false },
+  }),
+}));
+
+import { collectImageManifest } from "../context/compactor.js";
+import { attachInlineAttachmentToMessage } from "../memory/attachments-store.js";
+import { addMessage, createConversation } from "../memory/conversation-crud.js";
+import { getDb } from "../memory/db-connection.js";
+import { initializeDb } from "../memory/db-init.js";
+
+initializeDb();
+
+// 1x1 transparent PNG.
+const PNG_1X1_BASE64 =
+  "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==";
+
+function resetTables(): void {
+  const db = getDb();
+  db.run("DELETE FROM message_attachments");
+  db.run("DELETE FROM attachments");
+  db.run("DELETE FROM messages");
+  db.run("DELETE FROM conversations");
+}
+
+async function addImageMessage(
+  conversationId: string,
+  provenanceTrustClass: "guardian" | "trusted_contact" | "unknown",
+  filename: string,
+): Promise<void> {
+  const inserted = await addMessage(
+    conversationId,
+    "user",
+    JSON.stringify([{ type: "text", text: filename }]),
+    {
+      metadata: { provenanceTrustClass },
+      skipIndexing: true,
+    },
+  );
+  attachInlineAttachmentToMessage(
+    inserted.id,
+    0,
+    filename,
+    "image/png",
+    PNG_1X1_BASE64,
+  );
+}
+
+describe("collectImageManifest trust filtering", () => {
+  beforeEach(resetTables);
+
+  test("untrusted actor manifest excludes guardian images", async () => {
+    // GIVEN a conversation with a guardian image and an unknown-actor image
+    const conv = createConversation();
+    await addImageMessage(conv.id, "guardian", "guardian-secret.png");
+    await addImageMessage(conv.id, "unknown", "visitor.png");
+
+    // WHEN the manifest is built for an untrusted ("unknown") actor
+    const manifest = collectImageManifest(conv.id, "unknown");
+
+    // THEN only the untrusted actor's own image is listed
+    const filenames = manifest.map((e) => e.filename);
+    expect(filenames).toContain("visitor.png");
+    expect(filenames).not.toContain("guardian-secret.png");
+  });
+
+  test("guardian actor manifest includes all images", async () => {
+    // GIVEN a conversation with a guardian image and an unknown-actor image
+    const conv = createConversation();
+    await addImageMessage(conv.id, "guardian", "guardian-secret.png");
+    await addImageMessage(conv.id, "unknown", "visitor.png");
+
+    // WHEN the manifest is built for the guardian
+    const manifest = collectImageManifest(conv.id, "guardian");
+
+    // THEN every image is listed
+    const filenames = manifest.map((e) => e.filename);
+    expect(filenames).toContain("guardian-secret.png");
+    expect(filenames).toContain("visitor.png");
+  });
+
+  test("omitted trust class defaults to the untrusted filter", async () => {
+    // GIVEN a conversation containing a guardian image
+    const conv = createConversation();
+    await addImageMessage(conv.id, "guardian", "guardian-secret.png");
+    await addImageMessage(conv.id, "trusted_contact", "contact.png");
+
+    // WHEN the manifest is built without an explicit trust class
+    const manifest = collectImageManifest(conv.id);
+
+    // THEN the guardian image is excluded (fail-closed, mirroring loadFromDb)
+    const filenames = manifest.map((e) => e.filename);
+    expect(filenames).toContain("contact.png");
+    expect(filenames).not.toContain("guardian-secret.png");
+  });
+});

package/src/__tests__/compactor-preserved-tail-count.test.ts

@@ -23,6 +23,7 @@ mock.module("../util/logger.js", () => ({
 
 mock.module("../memory/conversation-crud.js", () => ({
   getMessages: () => [],
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 
 mock.module("../memory/attachments-store.js", () => ({

package/src/__tests__/computer-use-skill-manifest-regression.test.ts

@@ -113,8 +113,9 @@ describe("computer-use skill manifest regression", () => {
     await initializeTools();
 
     // Simulate what projectSkillTools() does when the computer-use skill is
-    // activated: create skill-origin Tool objects matching the manifest names
-    // and register them. This must not throw.
+    // activated: create Tool objects matching the manifest names and register
+    // them through `registerSkillTools(skillId, tools)`, which records
+    // ownership in the registry's `ownersByName` map. This must not throw.
     const skillTools: Tool[] = manifest.tools.map(
       (entry: { name: string; description: string }) => ({
         name: entry.name,
@@ -122,13 +123,14 @@ describe("computer-use skill manifest regression", () => {
         input_schema: { type: "object" as const, properties: {} },
         category: "computer-use",
         defaultRiskLevel: RiskLevel.Low,
-        origin: "skill" as const,
-        ownerSkillId: "computer-use",
         execute: async () => ({ content: "stub", isError: false }),
       }),
     );
 
-    expect(() => registerSkillTools(skillTools)).not.toThrow();
+    // Owner flows in through `registerSkillTools(skillId, tools)` and lands
+    // in the registry's `ownersByName` map — the tools themselves carry no
+    // per-tool owner field.
+    expect(() => registerSkillTools("computer-use", skillTools)).not.toThrow();
 
     // Clean up
     unregisterSkillTools("computer-use");

package/src/__tests__/computer-use-tools.test.ts

@@ -23,7 +23,7 @@ interface JsonSchema {
 }
 
 /** Cast a tool definition's input_schema to a usable JSON Schema shape. */
-function schema(tool: { input_schema: object }): JsonSchema {
+function schema(tool: { input_schema?: object }): JsonSchema {
   return tool.input_schema as JsonSchema;
 }
 
@@ -40,12 +40,6 @@ describe("computer-use tool definitions", () => {
     expect(allComputerUseTools.length).toBe(11);
   });
 
-  test("all tools have proxy execution mode", () => {
-    for (const tool of allComputerUseTools) {
-      expect(tool.executionMode).toBe("proxy");
-    }
-  });
-
   test("all tools belong to computer-use category", () => {
     for (const tool of allComputerUseTools) {
       expect(tool.category).toBe("computer-use");
@@ -59,7 +53,7 @@ describe("computer-use tool definitions", () => {
 
   test("all tools have descriptions", () => {
     for (const tool of allComputerUseTools) {
-      expect(tool.description.length).toBeGreaterThan(0);
+      expect(tool.description!.length).toBeGreaterThan(0);
     }
   });
 });
@@ -94,8 +88,10 @@ describe("computer_use_click (unified)", () => {
     expect(props.y.type).toBe("integer");
   });
 
-  test("execute throws proxy error", () => {
-    expect(() => computerUseClickTool.execute({}, ctx)).toThrow("Proxy tool");
+  test("execute returns isError when no proxy resolver is configured", async () => {
+    const result = await computerUseClickTool.execute({}, ctx);
+    expect(result.isError).toBe(true);
+    expect(result.content).toMatch(/No proxy resolver/);
   });
 });
 
@@ -107,10 +103,10 @@ describe("computer_use_type_text", () => {
     expect(schema(computerUseTypeTextTool).required).toContain("reasoning");
   });
 
-  test("execute throws proxy error", () => {
-    expect(() => computerUseTypeTextTool.execute({}, ctx)).toThrow(
-      "Proxy tool",
-    );
+  test("execute returns isError when no proxy resolver is configured", async () => {
+    const result = await computerUseTypeTextTool.execute({}, ctx);
+    expect(result.isError).toBe(true);
+    expect(result.content).toMatch(/No proxy resolver/);
   });
 });
 
@@ -122,8 +118,10 @@ describe("computer_use_key", () => {
     expect(schema(computerUseKeyTool).required).toContain("reasoning");
   });
 
-  test("execute throws proxy error", () => {
-    expect(() => computerUseKeyTool.execute({}, ctx)).toThrow("Proxy tool");
+  test("execute returns isError when no proxy resolver is configured", async () => {
+    const result = await computerUseKeyTool.execute({}, ctx);
+    expect(result.isError).toBe(true);
+    expect(result.content).toMatch(/No proxy resolver/);
   });
 });