@vellumai/assistant 0.6.6 → 0.7.1

package/src/tools/browser/cdp-client/__tests__/factory.test.ts

@@ -113,6 +113,29 @@ mock.module("../../../../util/logger.js", () => ({
   }),
 }));
 
+/** Mutable singleton proxy. Tests set this to control extension availability. */
+let mockSingletonProxy: HostBrowserProxy | null = null;
+
+/** Default proxy that reports unavailable — used when no test override is set. */
+const unavailableFallback: HostBrowserProxy = {
+  isAvailable: () => false,
+  request: () => Promise.reject(new Error("no extension")),
+  resolve: () => {},
+  hasPendingRequest: () => false,
+  dispose: () => {},
+} as unknown as HostBrowserProxy;
+
+mock.module("../../../../daemon/host-browser-proxy.js", () => ({
+  HostBrowserProxy: {
+    get instance() {
+      return mockSingletonProxy ?? unavailableFallback;
+    },
+    reset() {
+      mockSingletonProxy = null;
+    },
+  },
+}));
+
 // Import under test AFTER mock.module calls so that the factory's
 // top-level imports resolve to our fakes.
 const {
@@ -127,9 +150,9 @@ const {
 } = await import("../factory.js");
 
 /**
- * Minimal ToolContext suitable for factory tests. Only the fields the
- * factory reads (`conversationId` and `hostBrowserProxy`) need to be
- * populated; other required fields are cast away.
+ * Minimal ToolContext suitable for factory tests. Only `conversationId`
+ * needs to be populated; other required fields are cast away.
+ * Extension availability is controlled via `mockSingletonProxy`.
  */
 function makeContext(
   overrides: Partial<ToolContext> & { conversationId: string },
@@ -171,15 +194,16 @@ describe("getCdpClient", () => {
     _resetDesktopAutoCooldown();
     logWarnCalls.length = 0;
     logDebugCalls.length = 0;
+    mockSingletonProxy = null;
   });
 
   // ── Candidate selection (kind reported before first send) ────────────
 
   test("routes to ExtensionCdpClient when hostBrowserProxy is set and available", async () => {
     const fakeProxy = makeAvailableProxy();
+    mockSingletonProxy = fakeProxy;
     const ctx = makeContext({
       conversationId: "test-convo",
-      hostBrowserProxy: fakeProxy,
     });
 
     const client = getCdpClient(ctx);
@@ -205,9 +229,9 @@ describe("getCdpClient", () => {
 
   test("skips extension when hostBrowserProxy is present but unavailable", async () => {
     const fakeProxy = makeUnavailableProxy();
+    mockSingletonProxy = fakeProxy;
     const ctx = makeContext({
       conversationId: "disconnected-proxy",
-      hostBrowserProxy: fakeProxy,
     });
 
     const client = getCdpClient(ctx);
@@ -227,9 +251,9 @@ describe("getCdpClient", () => {
   test("skips extension but uses cdp-inspect when proxy unavailable and cdp-inspect enabled", async () => {
     cdpInspectEnabled = true;
     const fakeProxy = makeUnavailableProxy();
+    mockSingletonProxy = fakeProxy;
     const ctx = makeContext({
       conversationId: "disconnected-inspect",
-      hostBrowserProxy: fakeProxy,
     });
 
     const client = getCdpClient(ctx);
@@ -247,9 +271,9 @@ describe("getCdpClient", () => {
   test("extension wins even when cdpInspect is enabled", async () => {
     cdpInspectEnabled = true;
     const fakeProxy = makeAvailableProxy();
+    mockSingletonProxy = fakeProxy;
     const ctx = makeContext({
       conversationId: "ext-wins",
-      hostBrowserProxy: fakeProxy,
     });
 
     const client = getCdpClient(ctx);
@@ -268,7 +292,6 @@ describe("getCdpClient", () => {
     cdpInspectEnabled = true;
     const ctx = makeContext({
       conversationId: "inspect-convo",
-      hostBrowserProxy: undefined,
     });
 
     const client = getCdpClient(ctx);
@@ -295,7 +318,6 @@ describe("getCdpClient", () => {
     cdpInspectEnabled = false;
     const ctx = makeContext({
       conversationId: "local-convo",
-      hostBrowserProxy: undefined,
     });
 
     const client = getCdpClient(ctx);
@@ -333,9 +355,9 @@ describe("getCdpClient", () => {
 
   test("getCdpClient without options behaves identically to auto mode", async () => {
     const fakeProxy = makeAvailableProxy();
+    mockSingletonProxy = fakeProxy;
     const ctx = makeContext({
       conversationId: "no-opts",
-      hostBrowserProxy: fakeProxy,
     });
 
     const client = getCdpClient(ctx);
@@ -361,9 +383,9 @@ describe("getCdpClient", () => {
 
   test("forwards send() through the manager to the extension-backed client", async () => {
     const fakeProxy = makeAvailableProxy();
+    mockSingletonProxy = fakeProxy;
     const ctx = makeContext({
       conversationId: "send-ext",
-      hostBrowserProxy: fakeProxy,
     });
 
     const client = getCdpClient(ctx);
@@ -507,9 +529,9 @@ describe("getCdpClient", () => {
 
   test("dispose() on an extension-backed client tears down the extension client", async () => {
     const fakeProxy = makeAvailableProxy();
+    mockSingletonProxy = fakeProxy;
     const ctx = makeContext({
       conversationId: "dispose-ext",
-      hostBrowserProxy: fakeProxy,
     });
 
     const client = getCdpClient(ctx);
@@ -576,9 +598,9 @@ describe("getCdpClient", () => {
 
   test("context with transportInterface set routes normally to extension backend", async () => {
     const fakeProxy = makeAvailableProxy();
+    mockSingletonProxy = fakeProxy;
     const ctx = makeContext({
       conversationId: "macos-ext",
-      hostBrowserProxy: fakeProxy,
       transportInterface: "macos",
     });
 
@@ -629,13 +651,14 @@ describe("buildCandidateList", () => {
     cdpInspectEnabled = false;
     desktopAutoConfig = { enabled: true, cooldownMs: 30_000 };
     _resetDesktopAutoCooldown();
+    mockSingletonProxy = null;
   });
 
   test("includes extension candidate when proxy is present and available", () => {
     const fakeProxy = makeAvailableProxy();
+    mockSingletonProxy = fakeProxy;
     const ctx = makeContext({
       conversationId: "candidates-ext",
-      hostBrowserProxy: fakeProxy,
     });
 
     const candidates = buildCandidateList(ctx);
@@ -648,9 +671,9 @@ describe("buildCandidateList", () => {
 
   test("excludes extension candidate when proxy is present but unavailable", () => {
     const fakeProxy = makeUnavailableProxy();
+    mockSingletonProxy = fakeProxy;
     const ctx = makeContext({
       conversationId: "candidates-no-ext",
-      hostBrowserProxy: fakeProxy,
     });
 
     const candidates = buildCandidateList(ctx);
@@ -672,9 +695,9 @@ describe("buildCandidateList", () => {
   test("candidate order: extension > cdp-inspect > local when all present", () => {
     cdpInspectEnabled = true;
     const fakeProxy = makeAvailableProxy();
+    mockSingletonProxy = fakeProxy;
     const ctx = makeContext({
       conversationId: "candidates-all",
-      hostBrowserProxy: fakeProxy,
     });
 
     const candidates = buildCandidateList(ctx);
@@ -710,10 +733,12 @@ describe("buildChainedClient failover", () => {
     _resetDesktopAutoCooldown();
     logWarnCalls.length = 0;
     logDebugCalls.length = 0;
+    mockSingletonProxy = null;
   });
 
   test("fails over from extension to local on transport_error", async () => {
     const fakeProxy = makeAvailableProxy();
+    mockSingletonProxy = fakeProxy;
 
     // Make extension client fail with transport_error
     createExtensionCdpClientMock.mockImplementationOnce(
@@ -735,7 +760,6 @@ describe("buildChainedClient failover", () => {
 
     const ctx = makeContext({
       conversationId: "failover-ext-to-local",
-      hostBrowserProxy: fakeProxy,
     });
 
     const client = getCdpClient(ctx);
@@ -754,6 +778,7 @@ describe("buildChainedClient failover", () => {
   test("fails over from extension to cdp-inspect to local on transport errors", async () => {
     cdpInspectEnabled = true;
     const fakeProxy = makeAvailableProxy();
+    mockSingletonProxy = fakeProxy;
 
     // Make extension fail with transport_error
     createExtensionCdpClientMock.mockImplementationOnce(
@@ -785,7 +810,6 @@ describe("buildChainedClient failover", () => {
 
     const ctx = makeContext({
       conversationId: "failover-chain",
-      hostBrowserProxy: fakeProxy,
     });
 
     const client = getCdpClient(ctx);
@@ -803,6 +827,7 @@ describe("buildChainedClient failover", () => {
   test("does NOT fail over on cdp_error -- propagates immediately", async () => {
     cdpInspectEnabled = true;
     const fakeProxy = makeAvailableProxy();
+    mockSingletonProxy = fakeProxy;
 
     // Make extension fail with cdp_error (not transport_error)
     createExtensionCdpClientMock.mockImplementationOnce(
@@ -820,7 +845,6 @@ describe("buildChainedClient failover", () => {
 
     const ctx = makeContext({
       conversationId: "no-failover-cdp-error",
-      hostBrowserProxy: fakeProxy,
     });
 
     const client = getCdpClient(ctx);
@@ -868,6 +892,7 @@ describe("buildChainedClient failover", () => {
   test("backend becomes sticky after first successful command", async () => {
     cdpInspectEnabled = true;
     const fakeProxy = makeAvailableProxy();
+    mockSingletonProxy = fakeProxy;
 
     // Make extension fail on first call with transport_error
     createExtensionCdpClientMock.mockImplementationOnce(
@@ -885,7 +910,6 @@ describe("buildChainedClient failover", () => {
 
     const ctx = makeContext({
       conversationId: "sticky-test",
-      hostBrowserProxy: fakeProxy,
     });
 
     const client = getCdpClient(ctx);
@@ -946,6 +970,7 @@ describe("buildChainedClient failover", () => {
 
   test("kind reflects the active backend after failover", async () => {
     const fakeProxy = makeAvailableProxy();
+    mockSingletonProxy = fakeProxy;
 
     // Make extension fail
     createExtensionCdpClientMock.mockImplementationOnce(
@@ -961,7 +986,6 @@ describe("buildChainedClient failover", () => {
 
     const ctx = makeContext({
       conversationId: "kind-after-failover",
-      hostBrowserProxy: fakeProxy,
     });
 
     const client = getCdpClient(ctx);
@@ -976,6 +1000,7 @@ describe("buildChainedClient failover", () => {
 
   test("dispose cleans up failed backends from failover chain", async () => {
     const fakeProxy = makeAvailableProxy();
+    mockSingletonProxy = fakeProxy;
 
     // Make extension fail
     createExtensionCdpClientMock.mockImplementationOnce(
@@ -991,7 +1016,6 @@ describe("buildChainedClient failover", () => {
 
     const ctx = makeContext({
       conversationId: "dispose-failover",
-      hostBrowserProxy: fakeProxy,
     });
 
     const client = getCdpClient(ctx);
@@ -1023,6 +1047,7 @@ describe("desktop-auto cdp-inspect (macOS)", () => {
     _resetDesktopAutoCooldown();
     logWarnCalls.length = 0;
     logDebugCalls.length = 0;
+    mockSingletonProxy = null;
   });
 
   // ── buildCandidateList with desktopAuto ─────────────────────────────
@@ -1043,9 +1068,9 @@ describe("desktop-auto cdp-inspect (macOS)", () => {
 
   test("macOS turn with extension available: extension > cdp-inspect > local", () => {
     const fakeProxy = makeAvailableProxy();
+    mockSingletonProxy = fakeProxy;
     const ctx = makeContext({
       conversationId: "macos-all",
-      hostBrowserProxy: fakeProxy,
       transportInterface: "macos",
     });
 
@@ -1060,38 +1085,33 @@ describe("desktop-auto cdp-inspect (macOS)", () => {
 
   test("macOS turn with registry-routed proxy unavailable skips desktop-auto cdp-inspect (extension intent)", () => {
     const fakeProxy = makeUnavailableProxy();
+    mockSingletonProxy = fakeProxy;
     const ctx = makeContext({
       conversationId: "macos-proxy-unavailable-no-inspect",
-      hostBrowserProxy: fakeProxy,
       transportInterface: "macos",
-      hostBrowserRegistryRouted: true,
     });
 
     const candidates = buildCandidateList(ctx);
 
-    // Should only include local -- cdp-inspect is suppressed because extension
-    // transport is expected (registry-routed proxy) but temporarily unavailable.
-    expect(candidates.length).toBe(1);
-    expect(candidates[0].kind).toBe("local");
+    // Extension unavailable => cdp-inspect (desktop-auto) + local
+    expect(candidates.length).toBe(2);
+    expect(candidates[0].kind).toBe("cdp-inspect");
+    expect(candidates[1].kind).toBe("local");
   });
 
-  test("macOS turn with SSE-backed proxy unavailable still includes desktop-auto cdp-inspect", () => {
+  test("macOS turn with singleton proxy unavailable still includes desktop-auto cdp-inspect", () => {
     const fakeProxy = makeUnavailableProxy();
+    mockSingletonProxy = fakeProxy;
     const ctx = makeContext({
-      conversationId: "macos-sse-proxy-unavailable-inspect-allowed",
-      hostBrowserProxy: fakeProxy,
+      conversationId: "macos-proxy-unavailable-inspect-allowed",
       transportInterface: "macos",
-      // hostBrowserRegistryRouted is NOT set -- SSE-backed proxy
     });
 
     const candidates = buildCandidateList(ctx);
 
-    // SSE-backed proxy that is unavailable (non-interactive turn) should NOT
-    // suppress cdp-inspect -- the SSE proxy was never expected to service
-    // browser requests, so cdp-inspect remains available as a fallback.
+    // Extension unavailable => cdp-inspect (desktop-auto) + local
     expect(candidates.length).toBe(2);
     expect(candidates[0].kind).toBe("cdp-inspect");
-    expect(candidates[0].reason).toContain("desktopAuto");
     expect(candidates[1].kind).toBe("local");
   });
 
@@ -1112,9 +1132,9 @@ describe("desktop-auto cdp-inspect (macOS)", () => {
 
   test("macOS turn with extension available still includes cdp-inspect as fallback", () => {
     const fakeProxy = makeAvailableProxy();
+    mockSingletonProxy = fakeProxy;
     const ctx = makeContext({
       conversationId: "macos-ext-available-inspect-fallback",
-      hostBrowserProxy: fakeProxy,
       transportInterface: "macos",
     });
 
@@ -1263,43 +1283,41 @@ describe("desktop-auto cdp-inspect (macOS)", () => {
     expect(candidates[0].kind).toBe("local");
   });
 
-  test("macOS turn with registry-routed proxy unavailable routes to local without trying cdp-inspect", async () => {
+  test("macOS turn with registry-routed proxy unavailable still tries cdp-inspect (desktop-auto)", async () => {
     const fakeProxy = makeUnavailableProxy();
+    mockSingletonProxy = fakeProxy;
     const ctx = makeContext({
       conversationId: "macos-proxy-unavail-route",
-      hostBrowserProxy: fakeProxy,
       transportInterface: "macos",
-      hostBrowserRegistryRouted: true,
     });
 
     const client = getCdpClient(ctx);
 
-    // Should go straight to local -- no cdp-inspect candidate inserted
-    // because the registry-routed extension was expected but is unavailable.
-    expect(client.kind).toBe("local");
+    // Extension unavailable no longer suppresses cdp-inspect — desktop-auto
+    // inserts it as a candidate and it succeeds.
+    expect(client.kind).toBe("cdp-inspect");
     const result = await client.send<{ ok: boolean; via: string }>(
       "Page.navigate",
     );
-    expect(result).toEqual({ ok: true, via: "local" });
-    expect(createCdpInspectClientMock).not.toHaveBeenCalled();
+    expect(result).toEqual({ ok: true, via: "cdp-inspect" });
+    expect(createCdpInspectClientMock).toHaveBeenCalledTimes(1);
     expect(createExtensionCdpClientMock).not.toHaveBeenCalled();
-    expect(createLocalCdpClientMock).toHaveBeenCalledTimes(1);
+    expect(createLocalCdpClientMock).not.toHaveBeenCalled();
     client.dispose();
   });
 
-  test("macOS turn with SSE-backed proxy unavailable falls through to cdp-inspect", async () => {
+  test("macOS turn with singleton proxy unavailable still tries cdp-inspect (desktop-auto)", async () => {
     const fakeProxy = makeUnavailableProxy();
+    mockSingletonProxy = fakeProxy;
     const ctx = makeContext({
-      conversationId: "macos-sse-proxy-unavail-inspect",
-      hostBrowserProxy: fakeProxy,
+      conversationId: "macos-proxy-unavail-local",
       transportInterface: "macos",
-      // hostBrowserRegistryRouted is NOT set -- SSE-backed proxy
     });
 
     const client = getCdpClient(ctx);
 
-    // SSE-backed proxy unavailable (non-interactive turn) should NOT
-    // suppress cdp-inspect -- it falls through to desktop-auto cdp-inspect.
+    // Extension unavailable no longer suppresses cdp-inspect — desktop-auto
+    // inserts it as a candidate and it succeeds.
     expect(client.kind).toBe("cdp-inspect");
     const result = await client.send<{ ok: boolean; via: string }>(
       "Page.navigate",
@@ -1307,6 +1325,7 @@ describe("desktop-auto cdp-inspect (macOS)", () => {
     expect(result).toEqual({ ok: true, via: "cdp-inspect" });
     expect(createExtensionCdpClientMock).not.toHaveBeenCalled();
     expect(createCdpInspectClientMock).toHaveBeenCalledTimes(1);
+    expect(createLocalCdpClientMock).not.toHaveBeenCalled();
     client.dispose();
   });
 
@@ -1380,15 +1399,16 @@ describe("pinned-mode selection", () => {
     _resetDesktopAutoCooldown();
     logWarnCalls.length = 0;
     logDebugCalls.length = 0;
+    mockSingletonProxy = null;
   });
 
   // ── Pinned extension ────────────────────────────────────────────────
 
   test("pinned extension mode routes to extension when proxy is available", async () => {
     const fakeProxy = makeAvailableProxy();
+    mockSingletonProxy = fakeProxy;
     const ctx = makeContext({
       conversationId: "pinned-ext",
-      hostBrowserProxy: fakeProxy,
     });
 
     const client = getCdpClient(ctx, { mode: "extension" });
@@ -1415,7 +1435,7 @@ describe("pinned-mode selection", () => {
       const cdpErr = err as CdpError;
       expect(cdpErr.code).toBe("transport_error");
       expect(cdpErr.message).toContain('Pinned mode "extension" unavailable');
-      expect(cdpErr.message).toContain("no host browser proxy provisioned");
+      expect(cdpErr.message).toContain("no active extension connection");
       expect(cdpErr.attemptDiagnostics).toBeDefined();
       expect(cdpErr.attemptDiagnostics).toHaveLength(1);
       expect(cdpErr.attemptDiagnostics![0].candidateKind).toBe("extension");
@@ -1425,9 +1445,9 @@ describe("pinned-mode selection", () => {
 
   test("pinned extension mode throws when proxy is present but unavailable", () => {
     const fakeProxy = makeUnavailableProxy();
+    mockSingletonProxy = fakeProxy;
     const ctx = makeContext({
       conversationId: "pinned-ext-unavail",
-      hostBrowserProxy: fakeProxy,
     });
 
     expect(() => getCdpClient(ctx, { mode: "extension" })).toThrow(CdpError);
@@ -1437,13 +1457,14 @@ describe("pinned-mode selection", () => {
     } catch (err) {
       const cdpErr = err as CdpError;
       expect(cdpErr.code).toBe("transport_error");
-      expect(cdpErr.message).toContain("not connected");
+      expect(cdpErr.message).toContain("no active extension connection");
       expect(cdpErr.attemptDiagnostics![0].stage).toBe("candidate_selection");
     }
   });
 
   test("pinned extension mode does NOT fall back to local on transport error", async () => {
     const fakeProxy = makeAvailableProxy();
+    mockSingletonProxy = fakeProxy;
 
     // Make extension fail with transport_error
     createExtensionCdpClientMock.mockImplementationOnce(
@@ -1459,7 +1480,6 @@ describe("pinned-mode selection", () => {
 
     const ctx = makeContext({
       conversationId: "pinned-ext-no-fallback",
-      hostBrowserProxy: fakeProxy,
     });
 
     const client = getCdpClient(ctx, { mode: "extension" });
@@ -1535,9 +1555,9 @@ describe("pinned-mode selection", () => {
 
   test("pinned local mode routes to local", async () => {
     const fakeProxy = makeAvailableProxy();
+    mockSingletonProxy = fakeProxy;
     const ctx = makeContext({
       conversationId: "pinned-local",
-      hostBrowserProxy: fakeProxy,
     });
 
     // Even with proxy available, pinned local should skip extension
@@ -1591,13 +1611,14 @@ describe("buildPinnedCandidateList", () => {
     cdpInspectEnabled = false;
     desktopAutoConfig = { enabled: true, cooldownMs: 30_000 };
     _resetDesktopAutoCooldown();
+    mockSingletonProxy = null;
   });
 
   test("extension mode produces single extension candidate", () => {
     const fakeProxy = makeAvailableProxy();
+    mockSingletonProxy = fakeProxy;
     const ctx = makeContext({
       conversationId: "bpl-ext",
-      hostBrowserProxy: fakeProxy,
     });
 
     const candidates = buildPinnedCandidateList(ctx, "extension");
@@ -1663,11 +1684,13 @@ describe("attempt diagnostics", () => {
     _resetDesktopAutoCooldown();
     logWarnCalls.length = 0;
     logDebugCalls.length = 0;
+    mockSingletonProxy = null;
   });
 
   test("exhausted candidates error includes full attempt diagnostics", async () => {
     cdpInspectEnabled = true;
     const fakeProxy = makeAvailableProxy();
+    mockSingletonProxy = fakeProxy;
 
     // Make extension fail
     createExtensionCdpClientMock.mockImplementationOnce(
@@ -1707,7 +1730,6 @@ describe("attempt diagnostics", () => {
 
     const ctx = makeContext({
       conversationId: "diag-all-fail",
-      hostBrowserProxy: fakeProxy,
     });
 
     const client = getCdpClient(ctx);
@@ -1750,6 +1772,7 @@ describe("attempt diagnostics", () => {
 
   test("successful fallback still records diagnostics for failed candidates", async () => {
     const fakeProxy = makeAvailableProxy();
+    mockSingletonProxy = fakeProxy;
 
     // Make extension fail
     createExtensionCdpClientMock.mockImplementationOnce(
@@ -1765,7 +1788,6 @@ describe("attempt diagnostics", () => {
 
     const ctx = makeContext({
       conversationId: "diag-partial",
-      hostBrowserProxy: fakeProxy,
     });
 
     const client = getCdpClient(ctx);
@@ -1786,6 +1808,7 @@ describe("attempt diagnostics", () => {
   test("auto-mode fallback log includes candidate sequence and failure reasons", async () => {
     cdpInspectEnabled = true;
     const fakeProxy = makeAvailableProxy();
+    mockSingletonProxy = fakeProxy;
 
     // Make extension fail
     createExtensionCdpClientMock.mockImplementationOnce(
@@ -1813,7 +1836,6 @@ describe("attempt diagnostics", () => {
 
     const ctx = makeContext({
       conversationId: "diag-log-shape",
-      hostBrowserProxy: fakeProxy,
     });
 
     const client = getCdpClient(ctx);
@@ -1937,10 +1959,12 @@ describe("no-fallback guarantees", () => {
     desktopAutoConfig = { enabled: true, cooldownMs: 30_000 };
     _resetDesktopAutoCooldown();
     logWarnCalls.length = 0;
+    mockSingletonProxy = null;
   });
 
   test("pinned extension: only one candidate is ever constructed", async () => {
     const fakeProxy = makeAvailableProxy();
+    mockSingletonProxy = fakeProxy;
 
     // Make extension fail
     createExtensionCdpClientMock.mockImplementationOnce(
@@ -1956,7 +1980,6 @@ describe("no-fallback guarantees", () => {
 
     const ctx = makeContext({
       conversationId: "nofb-ext",
-      hostBrowserProxy: fakeProxy,
     });
     const client = getCdpClient(ctx, { mode: "extension" });
 
@@ -2043,7 +2066,7 @@ describe("no-fallback guarantees", () => {
 // Verify that macOS turns can use the host browser proxy without requiring
 // extension registry connectivity. When a HostBrowserProxy is provisioned
 // via the SSE sender path (no extension), the factory should select
-// extension as the top candidate (because hostBrowserProxy is available).
+// extension as the top candidate (because the singleton proxy is available).
 // When both proxy and fallback backends exist, selection is deterministic:
 // extension > cdp-inspect > local.
 
@@ -2060,15 +2083,16 @@ describe("macOS host-browser proxy without extension registry", () => {
     _resetDesktopAutoCooldown();
     logWarnCalls.length = 0;
     logDebugCalls.length = 0;
+    mockSingletonProxy = null;
   });
 
   test("macOS turn with SSE-provisioned hostBrowserProxy selects extension backend", async () => {
     // Simulates macOS provisioning a HostBrowserProxy via SSE (no extension
     // registry connection). The proxy is available so extension is selected.
     const fakeProxy = makeAvailableProxy();
+    mockSingletonProxy = fakeProxy;
     const ctx = makeContext({
       conversationId: "macos-sse-proxy",
-      hostBrowserProxy: fakeProxy,
       transportInterface: "macos",
     });
 
@@ -2085,9 +2109,9 @@ describe("macOS host-browser proxy without extension registry", () => {
 
   test("macOS turn with both proxy and cdp-inspect produces deterministic 3-candidate chain", () => {
     const fakeProxy = makeAvailableProxy();
+    mockSingletonProxy = fakeProxy;
     const ctx = makeContext({
       conversationId: "macos-deterministic",
-      hostBrowserProxy: fakeProxy,
       transportInterface: "macos",
     });
 
@@ -2119,9 +2143,9 @@ describe("macOS host-browser proxy without extension registry", () => {
     // enablement — proxy presence drives extension selection regardless of
     // interface.
     const fakeProxy = makeAvailableProxy();
+    mockSingletonProxy = fakeProxy;
     const ctx = makeContext({
       conversationId: "non-macos-proxy",
-      hostBrowserProxy: fakeProxy,
       transportInterface: "cli",
     });
 

package/src/tools/browser/cdp-client/accessibility-snapshot.ts

@@ -47,7 +47,7 @@ export interface AxSnapshotResult {
 // ── Constants ─────────────────────────────────────────────────────────
 
 /** Default maximum number of interactive elements returned in a snapshot. */
-export const DEFAULT_MAX_ELEMENTS = 150;
+const DEFAULT_MAX_ELEMENTS = 150;
 
 /**
  * AX roles we consider "interactive" and surface to the LLM. Includes

package/src/tools/browser/cdp-client/cdp-inspect/discovery.ts

@@ -25,6 +25,8 @@
  * value.
  */
 
+import type { CdpWsTransport } from "./ws-transport.js";
+
 /**
  * Stable error codes surfaced by discovery helpers.
  *
@@ -704,7 +706,7 @@ interface CdpTargetInfo {
  * @param signal - Optional abort signal for the CDP call.
  */
 export async function discoverTargetsViaWs(opts: {
-  transport: import("./ws-transport.js").CdpWsTransport;
+  transport: CdpWsTransport;
   host: string;
   port: number;
   signal?: AbortSignal;