@vellumai/assistant 0.7.3 → 0.8.1

package/src/skills/include-graph.ts

@@ -61,14 +61,10 @@ type IncludeValidationResult =
   | IncludeValidationError
   | IncludeValidationCycleError;
 
-/**
- * Validate the include graph starting from the given root skill ID.
- * Uses three-state DFS (unseen/visiting/done) to detect both missing children
- * and cycles. Returns the first error encountered in DFS order.
- */
-export function validateIncludes(
+function validateIncludeGraph(
   rootId: string,
   catalogIndex: Map<string, SkillSummary>,
+  options: { failOnMissing: boolean },
 ): IncludeValidationResult {
   const visited: string[] = [];
   type State = "unseen" | "visiting" | "done";
@@ -97,13 +93,16 @@ export function validateIncludes(
     if (skill?.includes) {
       for (const childId of skill.includes) {
         if (!catalogIndex.has(childId)) {
-          return {
-            ok: false,
-            error: "missing",
-            missingChildId: childId,
-            parentId: id,
-            path: [...ancestry],
-          };
+          if (options.failOnMissing) {
+            return {
+              ok: false,
+              error: "missing",
+              missingChildId: childId,
+              parentId: id,
+              path: [...ancestry],
+            };
+          }
+          continue;
         }
         const childError = dfs(childId);
         if (childError) return childError;
@@ -120,6 +119,29 @@ export function validateIncludes(
   return { ok: true, visited };
 }
 
+/**
+ * Validate the include graph starting from the given root skill ID.
+ * Uses three-state DFS (unseen/visiting/done) to detect both missing children
+ * and cycles. Returns the first error encountered in DFS order.
+ */
+export function validateIncludes(
+  rootId: string,
+  catalogIndex: Map<string, SkillSummary>,
+): IncludeValidationResult {
+  return validateIncludeGraph(rootId, catalogIndex, { failOnMissing: true });
+}
+
+/**
+ * Validate only cycle safety for a graph that may intentionally have missing
+ * advisory includes. Missing child IDs are skipped during traversal.
+ */
+export function validateIncludeCycles(
+  rootId: string,
+  catalogIndex: Map<string, SkillSummary>,
+): IncludeValidationResult {
+  return validateIncludeGraph(rootId, catalogIndex, { failOnMissing: false });
+}
+
 /**
  * Recursively traverse the include graph starting from the given root skill ID.
  * Returns all visited skill IDs in DFS pre-order.

package/src/subagent/manager.ts

@@ -10,14 +10,15 @@
 
 import { v4 as uuid } from "uuid";
 
+import { resolveCallSiteConfig } from "../config/llm-resolver.js";
 import { getConfig } from "../config/loader.js";
 import { Conversation } from "../daemon/conversation.js";
 import { findConversation } from "../daemon/conversation-store.js";
 import type { ServerMessage } from "../daemon/message-protocol.js";
 import { bootstrapConversation } from "../memory/conversation-bootstrap.js";
-import { CallSiteRoutingProvider } from "../providers/call-site-routing.js";
+import { wrapWithCallSiteRouting } from "../providers/call-site-routing.js";
+import { resolveDefaultProvider } from "../providers/connection-resolution.js";
 import { RateLimitProvider } from "../providers/ratelimit.js";
-import { getProvider } from "../providers/registry.js";
 import { createAbortReason } from "../util/abort-reasons.js";
 import { getLogger } from "../util/logger.js";
 import { getSandboxWorkingDir } from "../util/platform.js";
@@ -181,19 +182,23 @@ export class SubagentManager {
 
     // ── Build conversation dependencies ─────────────────────────────
     const appConfig = getConfig();
-    let provider = getProvider(appConfig.llm.default.provider);
+    // Connection-aware default-provider resolution. Throws
+    // `ConnectionResolutionError` if `llm.default.provider_connection` is
+    // unset or the connection row is missing/mismatched (config bugs).
+    // Returns null on soft credential failures (vault miss, transient
+    // auth) — handled below as "no provider available". Per-call
+    // `callSite` routing is layered next.
+    const baseProvider = await resolveDefaultProvider(appConfig);
+    if (!baseProvider) {
+      throw new Error(
+        `Subagent: default provider '${resolveCallSiteConfig("mainAgent", appConfig.llm).provider}' is not registered`,
+      );
+    }
     // Per-call `options.config.callSite` (e.g. `subagentSpawn`) can resolve
-    // to a provider name that differs from `llm.default.provider`. Wrap the
-    // default provider so the actual transport routes correctly per call,
-    // rather than only forwarding metadata to the default's HTTP client.
-    // See `providers/call-site-routing.ts`.
-    provider = new CallSiteRoutingProvider(provider, (name) => {
-      try {
-        return getProvider(name);
-      } catch {
-        return undefined;
-      }
-    });
+    // to a profile that differs from `llm.default`. The shared wrapper
+    // threads `appConfig` through so per-call alternate-profile routing is
+    // also connection-aware (matches the canonical dispatch path).
+    let provider = wrapWithCallSiteRouting(baseProvider, appConfig);
     const { rateLimit } = appConfig;
     if (rateLimit.maxRequestsPerMinute > 0) {
       provider = new RateLimitProvider(
@@ -225,7 +230,7 @@ export class SubagentManager {
         config.systemPromptOverride ??
         buildSubagentSystemPrompt({ ...config, id: subagentId }, role);
     }
-    const maxTokens = appConfig.llm.default.maxTokens;
+    const maxTokens = resolveCallSiteConfig("subagentSpawn", appConfig.llm).maxTokens;
     const workingDir = getSandboxWorkingDir();
 
     // ── Initialise state ────────────────────────────────────────────

package/src/tools/browser/__tests__/browser-execution-acquire.test.ts

@@ -0,0 +1,206 @@
+/**
+ * Tests for the target_client_id sticky-mode override in
+ * acquireCdpClientWithMode (browser-execution.ts).
+ *
+ * Fix 1: when target_client_id is provided, the sticky backend kind
+ * remembered from prior turns in the conversation must NOT be applied.
+ * The factory must receive mode:"extension" so the request reaches the
+ * host-browser proxy regardless of any prior local/cdp-inspect preference.
+ */
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+import type { ToolContext } from "../../types.js";
+import type { BrowserMode, CdpClientKind } from "../cdp-client/types.js";
+
+// ---------------------------------------------------------------------------
+// Captured call state
+// ---------------------------------------------------------------------------
+
+interface CdpClientCallOpts {
+  mode?: BrowserMode;
+  targetClientId?: string;
+}
+
+const getCdpClientCalls: CdpClientCallOpts[] = [];
+
+function makeFakeScopedClient(kind: CdpClientKind, conversationId: string) {
+  return {
+    kind,
+    conversationId,
+    send: mock(async () => ({})),
+    dispose: mock(() => {}),
+  };
+}
+
+const getCdpClientMock = mock(
+  (ctx: ToolContext, opts?: CdpClientCallOpts) => {
+    getCdpClientCalls.push({
+      mode: opts?.mode,
+      targetClientId: opts?.targetClientId,
+    });
+    return makeFakeScopedClient("extension", ctx.conversationId);
+  },
+);
+
+// ---------------------------------------------------------------------------
+// Mutable sticky-kind control
+// ---------------------------------------------------------------------------
+
+let stickyKind: CdpClientKind | null = null;
+
+const setPreferredBackendKindMock = mock(
+  (_conversationId: string, _kind: CdpClientKind) => {},
+);
+const clearPreferredBackendKindMock = mock((_conversationId: string) => {});
+
+// ---------------------------------------------------------------------------
+// Module mocks (must be declared before dynamic import)
+// ---------------------------------------------------------------------------
+
+mock.module("../cdp-client/factory.js", () => ({
+  getCdpClient: getCdpClientMock,
+  buildCandidateList: mock(() => []),
+  isDesktopAutoCooldownActive: () => false,
+}));
+
+mock.module("../browser-manager.js", () => ({
+  browserManager: {
+    getPreferredBackendKind: (_conversationId: string) => stickyKind,
+    setPreferredBackendKind: setPreferredBackendKindMock,
+    clearPreferredBackendKind: clearPreferredBackendKindMock,
+    storeSnapshotBackendNodeMap: () => {},
+    clearSnapshotBackendNodeMap: () => {},
+    resolveSnapshotBackendNodeId: () => undefined,
+    isInteractive: () => false,
+    supportsRouteInterception: false,
+  },
+}));
+
+mock.module("../../../config/loader.js", () => ({
+  getConfig: () => ({
+    hostBrowser: {
+      cdpInspect: {
+        enabled: false,
+        host: "localhost",
+        port: 9222,
+        probeTimeoutMs: 500,
+        desktopAuto: { enabled: false, cooldownMs: 30_000 },
+      },
+    },
+  }),
+}));
+
+mock.module("../../../daemon/host-browser-proxy.js", () => ({
+  HostBrowserProxy: {
+    get instance() {
+      return {
+        isAvailable: () => false,
+        hasExtensionClient: () => false,
+        request: () => Promise.reject(new Error("no extension")),
+      };
+    },
+  },
+}));
+
+mock.module("../runtime-check.js", () => ({
+  checkBrowserRuntime: async () => ({
+    playwrightAvailable: true,
+    chromiumInstalled: true,
+    chromiumPath: "/tmp/chromium",
+    error: null,
+  }),
+}));
+
+mock.module("../../../util/logger.js", () => ({
+  getLogger: () => ({
+    debug: () => {},
+    warn: () => {},
+    info: () => {},
+    error: () => {},
+  }),
+}));
+
+// Import under test after all mock.module calls.
+const { executeBrowserAttach } = await import("../browser-execution.js");
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function makeContext(conversationId: string): ToolContext {
+  return {
+    conversationId,
+    workingDir: "/tmp",
+    trustClass: "guardian",
+    signal: new AbortController().signal,
+  } as unknown as ToolContext;
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("acquireCdpClientWithMode: target_client_id overrides sticky backend mode", () => {
+  beforeEach(() => {
+    getCdpClientCalls.length = 0;
+    getCdpClientMock.mockClear();
+    setPreferredBackendKindMock.mockClear();
+    clearPreferredBackendKindMock.mockClear();
+    stickyKind = null;
+  });
+
+  test("sticky local + target_client_id → getCdpClient receives mode:extension, not local", async () => {
+    // Simulate a prior turn that pinned the conversation to the local backend.
+    stickyKind = "local";
+
+    await executeBrowserAttach(
+      { target_client_id: "host-client-abc" },
+      makeContext("sticky-local-override"),
+    );
+
+    expect(getCdpClientMock).toHaveBeenCalledTimes(1);
+    // Fix 1: sticky "local" must be bypassed when target_client_id is present.
+    expect(getCdpClientCalls[0].mode).toBe("extension");
+    expect(getCdpClientCalls[0].targetClientId).toBe("host-client-abc");
+  });
+
+  test("sticky cdp-inspect + target_client_id → getCdpClient receives mode:extension, not cdp-inspect", async () => {
+    stickyKind = "cdp-inspect";
+
+    await executeBrowserAttach(
+      { target_client_id: "host-client-xyz" },
+      makeContext("sticky-inspect-override"),
+    );
+
+    expect(getCdpClientMock).toHaveBeenCalledTimes(1);
+    expect(getCdpClientCalls[0].mode).toBe("extension");
+    expect(getCdpClientCalls[0].targetClientId).toBe("host-client-xyz");
+  });
+
+  test("sticky local + no target_client_id → getCdpClient receives mode:local (sticky honored)", async () => {
+    // Without target_client_id, the sticky preference must still apply.
+    stickyKind = "local";
+
+    await executeBrowserAttach(
+      {}, // no target_client_id
+      makeContext("sticky-honored"),
+    );
+
+    expect(getCdpClientMock).toHaveBeenCalledTimes(1);
+    expect(getCdpClientCalls[0].mode).toBe("local");
+    expect(getCdpClientCalls[0].targetClientId).toBeUndefined();
+  });
+
+  test("no sticky + target_client_id → getCdpClient receives mode:extension", async () => {
+    stickyKind = null; // No prior sticky preference
+
+    await executeBrowserAttach(
+      { target_client_id: "host-client-fresh" },
+      makeContext("no-sticky-targeted"),
+    );
+
+    expect(getCdpClientMock).toHaveBeenCalledTimes(1);
+    expect(getCdpClientCalls[0].mode).toBe("extension");
+    expect(getCdpClientCalls[0].targetClientId).toBe("host-client-fresh");
+  });
+});

package/src/tools/browser/browser-execution.ts

@@ -378,16 +378,25 @@ function acquireCdpClientWithMode(
   }
   const browserMode = modeResult.mode;
 
+  const targetClientId =
+    typeof input.target_client_id === "string" && input.target_client_id !== ""
+      ? input.target_client_id
+      : undefined;
+
   const rememberedKind = browserManager.getPreferredBackendKind(
     context.conversationId,
   );
+  // target_client_id requires the extension proxy path — bypass any sticky
+  // backend remembered from prior turns so the explicit target always wins.
   const effectiveMode: BrowserMode =
-    browserMode === "auto" && rememberedKind !== null
+    targetClientId != null
+      ? "extension"
+      : browserMode === "auto" && rememberedKind !== null
       ? rememberedKind
       : browserMode;
 
   try {
-    const raw = getCdpClient(context, { mode: effectiveMode });
+    const raw = getCdpClient(context, { mode: effectiveMode, targetClientId });
     const cdp = wrapWithKindMemo(raw, context.conversationId);
     return { cdp, browserMode };
   } catch (err) {
@@ -395,10 +404,12 @@ function acquireCdpClientWithMode(
     // a remembered backend kind that has since become unavailable. Drop
     // the stale memo and retry with fresh auto selection so a dead
     // sticky preference doesn't surface as a hard failure.
-    if (browserMode === "auto" && effectiveMode !== "auto") {
+    // Do not apply this fallback when target_client_id is set — a targeting
+    // failure must surface as an error, not silently route elsewhere.
+    if (browserMode === "auto" && effectiveMode !== "auto" && targetClientId == null) {
       browserManager.clearPreferredBackendKind(context.conversationId);
       try {
-        const raw = getCdpClient(context, { mode: "auto" });
+        const raw = getCdpClient(context, { mode: "auto", targetClientId });
         const cdp = wrapWithKindMemo(raw, context.conversationId);
         return { cdp, browserMode };
       } catch (retryErr) {

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

@@ -78,13 +78,26 @@ let desktopAutoConfig = { enabled: true, cooldownMs: 30_000 };
 const logWarnCalls: Array<{ args: unknown[] }> = [];
 const logDebugCalls: Array<{ args: unknown[] }> = [];
 
+// Spread-real-module pattern: bun's `mock.module` is process-global, so a
+// factory that returns ONLY `{ createExtensionCdpClient }` would clobber
+// the `ExtensionCdpClient` class export for every later test file that
+// imports from this module path (e.g. extension-cdp-client.test.ts). We
+// snapshot the real exports first and override only the symbols this
+// suite stubs out.
+import * as realCdpInspectClient from "../cdp-inspect-client.js";
+import * as realExtensionCdpClient from "../extension-cdp-client.js";
+import * as realLocalCdpClient from "../local-cdp-client.js";
+
 mock.module("../extension-cdp-client.js", () => ({
+  ...realExtensionCdpClient,
   createExtensionCdpClient: createExtensionCdpClientMock,
 }));
 mock.module("../local-cdp-client.js", () => ({
+  ...realLocalCdpClient,
   createLocalCdpClient: createLocalCdpClientMock,
 }));
 mock.module("../cdp-inspect-client.js", () => ({
+  ...realCdpInspectClient,
   createCdpInspectClient: createCdpInspectClientMock,
 }));
 mock.module("../../../../config/loader.js", () => ({
@@ -235,9 +248,15 @@ describe("getCdpClient", () => {
     );
     expect(result).toEqual({ ok: true, via: "extension" });
     expect(createExtensionCdpClientMock).toHaveBeenCalledTimes(1);
+    // Call signature includes optional cdpSessionId, sourceActorPrincipalId,
+    // and targetClientId (all undefined here — no pinned session id, no actor
+    // binding, no explicit client target in this legacy ctx).
     expect(createExtensionCdpClientMock).toHaveBeenCalledWith(
       fakeProxy,
       "test-convo",
+      undefined,
+      undefined,
+      undefined,
     );
     expect(createLocalCdpClientMock).not.toHaveBeenCalled();
     expect(createCdpInspectClientMock).not.toHaveBeenCalled();
@@ -658,6 +677,105 @@ describe("getCdpClient", () => {
     await client.send("Page.navigate");
     expect(createCdpInspectClientMock).toHaveBeenCalledTimes(1);
   });
+
+  test("threads sourceActorPrincipalId from ToolContext into createExtensionCdpClient", async () => {
+    // The proxy uses sourceActorPrincipalId to refuse cross-user dispatch
+    // when host_browser is exposed cross-client (web/iOS turn → connected
+    // extension/macOS bridge). The factory must thread the value from the
+    // ToolContext through to ExtensionCdpClient on every candidate-list path
+    // so the actor identity reaches the proxy at request time.
+    const fakeProxy = makeAvailableProxy();
+    mockSingletonProxy = fakeProxy;
+    const ctx = makeContext({
+      conversationId: "actor-bound",
+      sourceActorPrincipalId: "user-actor-1",
+    });
+
+    const client = getCdpClient(ctx);
+    await client.send("Page.navigate");
+
+    expect(createExtensionCdpClientMock).toHaveBeenCalledTimes(1);
+    expect(createExtensionCdpClientMock).toHaveBeenCalledWith(
+      fakeProxy,
+      "actor-bound",
+      undefined,
+      "user-actor-1",
+      undefined,
+    );
+  });
+
+  test("threads targetClientId from options into createExtensionCdpClient", async () => {
+    const fakeProxy = makeAvailableProxy();
+    mockSingletonProxy = fakeProxy;
+    const ctx = makeContext({
+      conversationId: "targeted-client",
+      sourceActorPrincipalId: "user-actor-1",
+    });
+
+    const client = getCdpClient(ctx, { targetClientId: "specific-ext-client" });
+    await client.send("Page.navigate");
+
+    expect(createExtensionCdpClientMock).toHaveBeenCalledTimes(1);
+    expect(createExtensionCdpClientMock).toHaveBeenCalledWith(
+      fakeProxy,
+      "targeted-client",
+      undefined,
+      "user-actor-1",
+      "specific-ext-client",
+    );
+  });
+
+  // ── auto mode + targetClientId: no fallback (Fix 2) ─────────────────
+
+  test("auto mode + targetClientId + no extension → throws targeting error, does not fall through to local", () => {
+    // No extension connected — without targetClientId, local would be the
+    // fallback. With targetClientId, the factory must fail immediately.
+    const ctx = makeContext({ conversationId: "auto-targeted-no-ext" });
+
+    expect(() =>
+      getCdpClient(ctx, { mode: "auto", targetClientId: "specific-host-client" }),
+    ).toThrow(
+      expect.objectContaining({
+        code: "transport_error",
+        message: expect.stringContaining("specific-host-client"),
+      }),
+    );
+    expect(createLocalCdpClientMock).not.toHaveBeenCalled();
+    expect(createCdpInspectClientMock).not.toHaveBeenCalled();
+  });
+
+  test("auto mode + targetClientId + extension available → routes only to extension, no other backends tried", async () => {
+    cdpInspectEnabled = true; // cdp-inspect would normally be in the candidate list
+    const fakeProxy = makeAvailableProxy();
+    mockSingletonProxy = fakeProxy;
+    const ctx = makeContext({
+      conversationId: "auto-targeted-ext-available",
+      sourceActorPrincipalId: "actor-42",
+    });
+
+    const client = getCdpClient(ctx, {
+      mode: "auto",
+      targetClientId: "specific-host-client",
+    });
+    expect(client.kind).toBe("extension");
+
+    const result = await client.send<{ ok: boolean; via: string }>(
+      "Page.navigate",
+    );
+    expect(result).toEqual({ ok: true, via: "extension" });
+
+    expect(createExtensionCdpClientMock).toHaveBeenCalledTimes(1);
+    expect(createExtensionCdpClientMock).toHaveBeenCalledWith(
+      fakeProxy,
+      "auto-targeted-ext-available",
+      undefined,
+      "actor-42",
+      "specific-host-client",
+    );
+    // cdp-inspect and local must NOT have been tried — no fallback.
+    expect(createCdpInspectClientMock).not.toHaveBeenCalled();
+    expect(createLocalCdpClientMock).not.toHaveBeenCalled();
+  });
 });
 
 // ── buildCandidateList tests ─────────────────────────────────────────────
@@ -748,6 +866,62 @@ describe("buildCandidateList", () => {
     expect(candidates.length).toBe(1);
     expect(candidates[0].kind).toBe("local");
   });
+
+  // ── targetClientId: no-fallback single-extension list (Fix 2) ────────
+
+  test("targetClientId: returns a single extension candidate when extension is available", () => {
+    const fakeProxy = makeAvailableProxy();
+    mockSingletonProxy = fakeProxy;
+    const ctx = makeContext({ conversationId: "target-with-ext" });
+
+    const candidates = buildCandidateList(ctx, "host-client-42");
+
+    // Must be exactly one candidate — no cdp-inspect or local fallbacks.
+    expect(candidates.length).toBe(1);
+    expect(candidates[0].kind).toBe("extension");
+    expect(candidates[0].reason).toContain("host-client-42");
+  });
+
+  test("targetClientId: throws transport_error immediately when no Chrome Extension is connected", () => {
+    // No extension — local would normally be the fallback, but targeting
+    // requires the proxy path and must fail loudly instead of routing elsewhere.
+    const ctx = makeContext({ conversationId: "target-no-ext" });
+
+    expect(() => buildCandidateList(ctx, "host-client-42")).toThrow(
+      expect.objectContaining({
+        code: "transport_error",
+        message: expect.stringContaining("host-client-42"),
+      }),
+    );
+    // Verify we did NOT silently fall through to a local candidate.
+    expect(createLocalCdpClientMock).not.toHaveBeenCalled();
+  });
+
+  test("targetClientId: threads targetClientId into the extension candidate's create() call", async () => {
+    const fakeProxy = makeAvailableProxy();
+    mockSingletonProxy = fakeProxy;
+    const ctx = makeContext({
+      conversationId: "target-threads-id",
+      sourceActorPrincipalId: "actor-1",
+    });
+
+    const candidates = buildCandidateList(ctx, "host-client-99");
+    expect(candidates.length).toBe(1);
+
+    // Clear accumulated calls from prior tests in this describe block before
+    // materialising the candidate so the call count is unambiguous.
+    createExtensionCdpClientMock.mockClear();
+    candidates[0].create();
+
+    expect(createExtensionCdpClientMock).toHaveBeenCalledTimes(1);
+    expect(createExtensionCdpClientMock).toHaveBeenCalledWith(
+      fakeProxy,
+      "target-threads-id",
+      undefined,
+      "actor-1",
+      "host-client-99",
+    );
+  });
 });
 
 // ── buildChainedClient failover tests ────────────────────────────────────

package/src/tools/browser/cdp-client/cdp-inspect/__tests__/ws-transport.test.ts

@@ -249,18 +249,22 @@ describe("connectCdpWsTransport", () => {
   });
 
   test("fans out events (frames with no id) to listeners", async () => {
+    // The server pushes the unsolicited event in direct response to
+    // a client trigger, sending the event frame BEFORE the response
+    // ack. WebSocket message ordering then guarantees the event
+    // arrives at the client (and is fanned out) before the trigger
+    // resolves — no setTimeout race between the server's open
+    // callback and the test attaching its listener.
     const server = startFakeWsServer({
-      onOpen(ws) {
-        // Push an unsolicited event shortly after open.
-        setTimeout(() => {
-          ws.send(
-            JSON.stringify({
-              method: "Target.targetCreated",
-              params: { targetId: "abc" },
-              sessionId: "S1",
-            }),
-          );
-        }, 5);
+      onMessage(ws, frame) {
+        ws.send(
+          JSON.stringify({
+            method: "Target.targetCreated",
+            params: { targetId: "abc" },
+            sessionId: "S1",
+          }),
+        );
+        ws.send(JSON.stringify({ id: frame.id, result: {} }));
       },
     });
     try {
@@ -273,8 +277,7 @@ describe("connectCdpWsTransport", () => {
         transport.addEventListener((ev) => {
           received.push(ev);
         });
-        // Wait for the event to arrive.
-        await new Promise((r) => setTimeout(r, 50));
+        await transport.send("Test.trigger");
         expect(received).toEqual([
           {
             method: "Target.targetCreated",

package/src/tools/browser/cdp-client/extension-cdp-client.ts

@@ -44,6 +44,19 @@ export class ExtensionCdpClient implements ScopedCdpClient {
     private readonly proxy: HostBrowserProxy,
     public readonly conversationId: string,
     private readonly cdpSessionId?: string,
+    /**
+     * Caller's actor principal id. When provided, the proxy will refuse to
+     * dispatch this CDP command to a host_browser-capable client owned by a
+     * different actor — closing the cross-client exposure path's same-user
+     * boundary.
+     */
+    private readonly sourceActorPrincipalId?: string,
+    /**
+     * Explicit target client id. When provided, the proxy routes directly
+     * to that client instead of auto-resolving to the most-recently-active
+     * same-actor host_browser client.
+     */
+    private readonly targetClientId?: string,
   ) {}
 
   async send<T = unknown>(
@@ -74,6 +87,8 @@ export class ExtensionCdpClient implements ScopedCdpClient {
         },
         this.conversationId,
         signal,
+        this.sourceActorPrincipalId,
+        this.targetClientId,
       );
     } catch (err) {
       throw new CdpError(
@@ -194,6 +209,14 @@ export function createExtensionCdpClient(
   proxy: HostBrowserProxy,
   conversationId: string,
   cdpSessionId?: string,
+  sourceActorPrincipalId?: string,
+  targetClientId?: string,
 ): ExtensionCdpClient {
-  return new ExtensionCdpClient(proxy, conversationId, cdpSessionId);
+  return new ExtensionCdpClient(
+    proxy,
+    conversationId,
+    cdpSessionId,
+    sourceActorPrincipalId,
+    targetClientId,
+  );
 }