@vellumai/assistant 0.12.2-staging.2 → 0.12.2-staging.3

package/src/providers/opencode/client.test.ts

@@ -9,18 +9,72 @@ import {
   EMPTY_ASSISTANT_TURN_PLACEHOLDER,
   OpenAIChatCompletionsProvider,
 } from "../openai/chat-completions-provider.js";
+import { OpenAIResponsesProvider } from "../openai/responses-provider.js";
+import type { Message } from "../types.js";
 import {
   buildOpenCodeRequestHeaders,
   OPENCODE_GO_BASE_URL,
   OPENCODE_REQUEST_HEADER,
+  OPENCODE_RESPONSES_ONLY_MODELS,
   OPENCODE_SESSION_HEADER,
   OPENCODE_ZEN_BASE_URL,
   OpenCodeProvider,
+  OpenCodeResponsesProvider,
   resetOpenCodeFallbackSessionForTests,
   resolveOpenCodeBaseURL,
   resolveOpenCodeRequestHeaders,
 } from "./client.js";
 
+const USER_TURN: Message[] = [
+  { role: "user", content: [{ type: "text", text: "question" }] },
+];
+
+/** Stub both wires on an OpenCodeProvider and record which one was called. */
+function stubTransports(provider: OpenCodeProvider) {
+  const chat: unknown[] = [];
+  const responses: Array<{ params: unknown; options: unknown }> = [];
+  (provider as unknown as { client: unknown }).client = {
+    chat: {
+      completions: {
+        create: async (params: unknown) => {
+          chat.push(params);
+          return {
+            async *[Symbol.asyncIterator]() {
+              yield {
+                choices: [{ delta: { content: "ok" }, finish_reason: "stop" }],
+                usage: { prompt_tokens: 2, completion_tokens: 1 },
+              };
+            },
+          };
+        },
+      },
+    },
+  };
+  const inner = (
+    provider as unknown as { getResponsesInner(): OpenCodeResponsesProvider }
+  ).getResponsesInner();
+  (inner as unknown as { client: unknown }).client = {
+    responses: {
+      create: async (params: unknown, options: unknown) => {
+        responses.push({ params, options });
+        return {
+          async *[Symbol.asyncIterator]() {
+            yield { type: "response.output_text.delta", delta: "ok" };
+            yield {
+              type: "response.completed",
+              response: {
+                status: "completed",
+                usage: { input_tokens: 2, output_tokens: 1 },
+              },
+            };
+          },
+        };
+      },
+    },
+  };
+  return { chat, responses };
+}
+
 describe("resolveOpenCodeBaseURL", () => {
   test("defaults to OpenCode Zen", () => {
     expect(resolveOpenCodeBaseURL()).toBe(OPENCODE_ZEN_BASE_URL);
@@ -241,3 +295,116 @@ describe("OpenCodeProvider", () => {
     expect(assistantMsg.content).toBe(EMPTY_ASSISTANT_TURN_PLACEHOLDER);
   });
 });
+
+describe("OPENCODE_RESPONSES_ONLY_MODELS", () => {
+  test("lists the verified responses-only models and nothing else", () => {
+    expect([...OPENCODE_RESPONSES_ONLY_MODELS].sort()).toEqual([
+      "muse-spark-1.2-contributor-free",
+      "muse-spark-1.3-contributor-free",
+    ]);
+  });
+});
+
+describe("OpenCodeResponsesProvider", () => {
+  test("is the Responses transport under the opencode name on OpenCode Zen", () => {
+    const provider = new OpenCodeResponsesProvider(
+      "sk-test",
+      "muse-spark-1.2-contributor-free",
+    );
+    expect(provider).toBeInstanceOf(OpenAIResponsesProvider);
+    expect(provider.name).toBe("opencode");
+    expect(
+      (provider as unknown as { client: { baseURL?: string } }).client.baseURL,
+    ).toBe(OPENCODE_ZEN_BASE_URL);
+  });
+
+  test("keeps a configured OpenCode Go origin", () => {
+    const provider = new OpenCodeResponsesProvider(
+      "sk-test",
+      "muse-spark-1.2-contributor-free",
+      { baseURL: OPENCODE_GO_BASE_URL },
+    );
+    expect(
+      (provider as unknown as { client: { baseURL?: string } }).client.baseURL,
+    ).toBe(OPENCODE_GO_BASE_URL);
+  });
+});
+
+describe("OpenCodeProvider transport selection", () => {
+  beforeEach(() => {
+    mockDeviceId = null;
+    resetOpenCodeFallbackSessionForTests();
+  });
+
+  test("sends a responses-only model through the Responses API with the caller's OpenCode headers", async () => {
+    const provider = new OpenCodeProvider(
+      "sk-test",
+      "muse-spark-1.2-contributor-free",
+    );
+    const { chat, responses } = stubTransports(provider);
+
+    const result = await provider.sendMessage(USER_TURN, {
+      config: {
+        requestHeaders: {
+          [OPENCODE_SESSION_HEADER]: "conv-xyz",
+          [OPENCODE_REQUEST_HEADER]: "req-123",
+        },
+      },
+    });
+
+    expect(chat).toHaveLength(0);
+    expect(responses).toHaveLength(1);
+    expect((responses[0]!.params as { model: string }).model).toBe(
+      "muse-spark-1.2-contributor-free",
+    );
+    const options = responses[0]!.options as {
+      headers?: Record<string, string>;
+    };
+    expect(options.headers?.[OPENCODE_SESSION_HEADER]).toBe("conv-xyz");
+    expect(options.headers?.[OPENCODE_REQUEST_HEADER]).toBe("req-123");
+    expect(options.headers).not.toHaveProperty("session_id");
+    expect(result.content).toEqual([{ type: "text", text: "ok" }]);
+  });
+
+  test("stamps the session backstop on a configless Responses call", async () => {
+    mockDeviceId = "device-abc";
+    const provider = new OpenCodeProvider(
+      "sk-test",
+      "muse-spark-1.2-contributor-free",
+    );
+    const { responses } = stubTransports(provider);
+
+    await provider.sendMessage(USER_TURN);
+
+    const options = responses[0]!.options as {
+      headers?: Record<string, string>;
+    };
+    expect(options.headers?.[OPENCODE_SESSION_HEADER]).toBe("device-abc");
+    expect(options.headers?.[OPENCODE_REQUEST_HEADER]).toBeTruthy();
+  });
+
+  test("keeps a chat-completions model on the chat wire", async () => {
+    const provider = new OpenCodeProvider("sk-test", "mimo-v2.5-free");
+    const { chat, responses } = stubTransports(provider);
+
+    await provider.sendMessage(USER_TURN);
+
+    expect(chat).toHaveLength(1);
+    expect(responses).toHaveLength(0);
+  });
+
+  test("a per-call model override picks the transport that model needs", async () => {
+    const provider = new OpenCodeProvider("sk-test", "mimo-v2.5-free");
+    const { chat, responses } = stubTransports(provider);
+
+    await provider.sendMessage(USER_TURN, {
+      config: { model: "muse-spark-1.2-contributor-free" },
+    });
+
+    expect(chat).toHaveLength(0);
+    expect(responses).toHaveLength(1);
+    expect((responses[0]!.params as { model: string }).model).toBe(
+      "muse-spark-1.2-contributor-free",
+    );
+  });
+});

package/src/providers/opencode/client.ts

@@ -2,6 +2,7 @@ import { randomUUID } from "node:crypto";
 
 import { getExistingDeviceId } from "../../util/device-id.js";
 import { OpenAIChatCompletionsProvider } from "../openai/chat-completions-provider.js";
+import { OpenAIResponsesProvider } from "../openai/responses-provider.js";
 import type {
   Message,
   ProviderResponse,
@@ -18,6 +19,18 @@ export interface OpenCodeProviderOptions {
   streamTimeoutMs?: number;
 }
 
+/**
+ * OpenCode Zen models served only by the Responses API: Zen answers
+ * `/chat/completions` for them with HTTP 500 and completes the same request
+ * on `/responses`. OpenCode's own client picks the transport per model from
+ * its catalog's `api.endpoint`; the assistant has no such feed, so the
+ * verified ids live here. Everything else stays on chat completions.
+ */
+export const OPENCODE_RESPONSES_ONLY_MODELS: ReadonlySet<string> = new Set([
+  "muse-spark-1.2-contributor-free",
+  "muse-spark-1.3-contributor-free",
+]);
+
 /**
  * Resolve the OpenCode chat-completions origin. A stored connection URL
  * wins; otherwise the request goes to OpenCode Zen.
@@ -82,7 +95,38 @@ export function resolveOpenCodeRequestHeaders(
   });
 }
 
+/**
+ * Responses-API transport for OpenCode. Shares the chat client's origin
+ * resolution and provider name, so the same `x-opencode-session` /
+ * `x-opencode-request` headers reach its requests.
+ */
+export class OpenCodeResponsesProvider extends OpenAIResponsesProvider {
+  constructor(
+    apiKey: string,
+    model: string,
+    options: OpenCodeProviderOptions = {},
+  ) {
+    super(apiKey, model, {
+      baseURL: resolveOpenCodeBaseURL(options.baseURL),
+      providerName: "opencode",
+      providerLabel: "OpenCode",
+      streamTimeoutMs: options.streamTimeoutMs,
+    });
+  }
+}
+
+/**
+ * OpenCode adapter. Chat completions is the default wire; models in
+ * {@link OPENCODE_RESPONSES_ONLY_MODELS} are delegated to an
+ * {@link OpenCodeResponsesProvider} on the same origin. The choice is made
+ * per send from the effective model, so a per-call model override lands on
+ * the transport that model needs.
+ */
 export class OpenCodeProvider extends OpenAIChatCompletionsProvider {
+  private readonly openCodeApiKey: string;
+  private readonly openCodeOptions: OpenCodeProviderOptions;
+  private responsesInner: OpenCodeResponsesProvider | undefined;
+
   constructor(
     apiKey: string,
     model: string,
@@ -96,20 +140,22 @@ export class OpenCodeProvider extends OpenAIChatCompletionsProvider {
       assistantReasoningField: "reasoning_content",
       omitToolChoiceWhenReasoning: true,
     });
+    this.openCodeApiKey = apiKey;
+    this.openCodeOptions = options;
   }
 
   /**
    * Transport-level backstop so a call that reaches this provider without
    * going through `RetryProvider` (or with no config at all) still carries
-   * the session and request headers zen/go requires. Headers the caller
-   * already resolved (conversation-derived) win.
+   * the session and request headers zen/go requires on either wire. Headers
+   * the caller already resolved (conversation-derived) win.
    */
   override async sendMessage(
     messages: Message[],
     options?: SendMessageOptions,
   ): Promise<ProviderResponse> {
     const config = options?.config ?? {};
-    return super.sendMessage(messages, {
+    const stamped: SendMessageOptions = {
       ...options,
       config: {
         ...config,
@@ -118,6 +164,29 @@ export class OpenCodeProvider extends OpenAIChatCompletionsProvider {
           ...config.requestHeaders,
         },
       },
-    });
+    };
+    if (
+      OPENCODE_RESPONSES_ONLY_MODELS.has(this.resolveEffectiveModel(config))
+    ) {
+      return this.getResponsesInner().sendMessage(messages, stamped);
+    }
+    return super.sendMessage(messages, stamped);
+  }
+
+  private resolveEffectiveModel(config: Record<string, unknown>): string {
+    const override =
+      typeof config.model === "string" && config.model.trim().length > 0
+        ? config.model.trim()
+        : undefined;
+    return override ?? this.defaultModel;
+  }
+
+  private getResponsesInner(): OpenCodeResponsesProvider {
+    this.responsesInner ??= new OpenCodeResponsesProvider(
+      this.openCodeApiKey,
+      this.defaultModel,
+      this.openCodeOptions,
+    );
+    return this.responsesInner;
   }
 }

package/src/runtime/AGENTS.md

@@ -161,6 +161,10 @@ In the CDP factory the bridge is the internal `"host-bridge"` candidate kind (`I
 
 **After the first successful CDP command**, the selected backend becomes **sticky** for the remainder of the tool invocation. Subsequent commands always route through the same backend so multi-command tool flows do not hop transports mid-step.
 
+### Browser CLI surface defaults
+
+The browser execute and tab routes share `browser/virtual-desktop-target.ts`. Platform-hosted web guardian conversations use installed, enabled virtual desktop Chrome by default. The shared `isVirtualDesktopEnabled` gate requires both `IS_PLATFORM` and `IS_CONTAINERIZED` alongside the `assistant-desktop` flag. Native renderer turns also use the `web` transport, so the frozen turn `clientOs` excludes native apps from automatic streamed-browser selection. Native apps retain their existing backend selection and fallback behavior. Explicit desktop/backend/client targets and existing personal-browser sessions override the surface default. Disabled or uninstalled desktop support retains the existing browser path; selection never triggers installation.
+
 ### Per-tool `browser_mode` override
 
 All CDP-backed browser tools (`browser_navigate`, `browser_snapshot`, `browser_screenshot`, `browser_click`, `browser_type`, `browser_hover`, `browser_scroll`, `browser_press_key`, `browser_select_option`, `browser_wait_for`, `browser_extract`, `browser_fill_credential`, `browser_attach`, `browser_detach`, `browser_close`, `browser_status`) accept an optional `browser_mode` input parameter that overrides the automatic backend selection for that invocation.

package/src/runtime/__tests__/desktop-stream-upgrade.test.ts

@@ -15,6 +15,7 @@ describe("RuntimeHttpServer /v1/desktop/stream upgrade", () => {
   let baseUrl: string;
   let restoreAuthEnv: () => void;
   const originalContainerized = process.env.IS_CONTAINERIZED;
+  const originalPlatform = process.env.IS_PLATFORM;
 
   beforeEach(async () => {
     restoreAuthEnv = requireHttpAuth();
@@ -22,6 +23,7 @@ describe("RuntimeHttpServer /v1/desktop/stream upgrade", () => {
     server = new RuntimeHttpServer({ port, hostname: "127.0.0.1" });
     await server.start();
     baseUrl = `127.0.0.1:${server.actualPort}`;
+    process.env.IS_PLATFORM = "true";
   });
 
   afterEach(async () => {
@@ -32,6 +34,11 @@ describe("RuntimeHttpServer /v1/desktop/stream upgrade", () => {
     } else {
       process.env.IS_CONTAINERIZED = originalContainerized;
     }
+    if (originalPlatform === undefined) {
+      delete process.env.IS_PLATFORM;
+    } else {
+      process.env.IS_PLATFORM = originalPlatform;
+    }
     setOverridesForTesting({});
   });
 
@@ -70,7 +77,9 @@ describe("RuntimeHttpServer /v1/desktop/stream upgrade", () => {
     );
     const closed = await waitForClose(ws);
     expect(closed.code).toBe(4008);
-    expect(closed.reason).toBe("Desktop is not available on this assistant");
+    expect(closed.reason).toBe(
+      "Virtual desktop is available only on enabled platform-hosted assistants",
+    );
   });
   for (const flag of [false, undefined]) {
     test(`refuses a containerized stream with a disabled or missing flag (${flag})`, async () => {
@@ -83,7 +92,41 @@ describe("RuntimeHttpServer /v1/desktop/stream upgrade", () => {
       );
       const closed = await waitForClose(ws);
       expect(closed.code).toBe(4008);
-      expect(closed.reason).toBe("Desktop is not available on this assistant");
+      expect(closed.reason).toBe(
+        "Virtual desktop is available only on enabled platform-hosted assistants",
+      );
     });
   }
 });
+
+test("self-hosted containers cannot stream with the feature flag enabled", async () => {
+  const originalPlatform = process.env.IS_PLATFORM;
+  const originalContainerized = process.env.IS_CONTAINERIZED;
+  const restoreAuth = requireHttpAuth();
+  const server = new RuntimeHttpServer({ port: 0, hostname: "127.0.0.1" });
+  try {
+    await server.start();
+    process.env.IS_PLATFORM = "false";
+    process.env.IS_CONTAINERIZED = "true";
+    setOverridesForTesting({ "assistant-desktop": true });
+    const baseUrl = `127.0.0.1:${server.actualPort}`;
+    const ws = new WebSocket(
+      `ws://${baseUrl}/v1/desktop/stream?token=${encodeURIComponent(mintGatewayToken())}`,
+    );
+    expect((await waitForClose(ws)).code).toBe(4008);
+  } finally {
+    await server.stop();
+    restoreAuth();
+    if (originalPlatform === undefined) {
+      delete process.env.IS_PLATFORM;
+    } else {
+      process.env.IS_PLATFORM = originalPlatform;
+    }
+    if (originalContainerized === undefined) {
+      delete process.env.IS_CONTAINERIZED;
+    } else {
+      process.env.IS_CONTAINERIZED = originalContainerized;
+    }
+    setOverridesForTesting({});
+  }
+});

package/src/runtime/http-server.ts

@@ -32,12 +32,12 @@ import {
 } from "../daemon/daemon-readiness.js";
 import { processMessage } from "../daemon/process-message.js";
 import { makeAddrInUseError } from "../daemon/startup-error.js";
-import { isAssistantDesktopEnabled } from "../desktop/desktop-feature.js";
 import {
   DESKTOP_CLOSE,
   destroyDesktopSessionManager,
 } from "../desktop/desktop-session-manager.js";
 import { DesktopStreamBridge } from "../desktop/desktop-stream-bridge.js";
+import { isVirtualDesktopEnabled } from "../desktop/virtual-desktop-feature.js";
 import {
   createLiveVoiceConnection,
   type LiveVoiceConnection,
@@ -252,9 +252,9 @@ type AllWebSocketData =
   | WatchStreamWebSocketData
   | DesktopStreamWebSocketData;
 
-function assistantDesktopEnabled(): boolean {
+function virtualDesktopEnabled(): boolean {
   try {
-    return isAssistantDesktopEnabled(getConfig());
+    return isVirtualDesktopEnabled(getConfig());
   } catch (err) {
     log.warn({ err }, "Failed to read config for desktop stream gate");
     return false;
@@ -453,15 +453,15 @@ export class RuntimeHttpServer {
           }
           if (data.wsType === "desktop-stream") {
             log.info("Desktop stream WebSocket opened");
-            if (!assistantDesktopEnabled()) {
+            if (!virtualDesktopEnabled()) {
               ws.close(
                 DESKTOP_CLOSE.unavailable,
-                "Desktop is not available on this assistant",
+                "Virtual desktop is available only on enabled platform-hosted assistants",
               );
               return;
             }
             const bridge = new DesktopStreamBridge(ws, {
-              isEnabled: assistantDesktopEnabled,
+              isEnabled: virtualDesktopEnabled,
             });
             data.bridge = bridge;
             void bridge.start();

package/src/runtime/routes/__tests__/plugins-routes.test.ts

@@ -1239,8 +1239,12 @@ describe("GET /v1/plugins/search", () => {
 
 async function invokeUninstall(
   args: RouteHandlerArgs = {},
-): Promise<{ name: string; target: string }> {
-  return (await uninstallHandler(args)) as { name: string; target: string };
+): Promise<{ name: string; target: string; warnings?: string[] }> {
+  return (await uninstallHandler(args)) as {
+    name: string;
+    target: string;
+    warnings?: string[];
+  };
 }
 
 describe("DELETE /v1/plugins/:name", () => {
@@ -1278,6 +1282,22 @@ describe("DELETE /v1/plugins/:name", () => {
     expectPluginsListBroadcast();
   });
 
+  test("returns non-fatal cleanup warnings from the shared uninstall", async () => {
+    uninstallSpy.mockImplementation(async (opts) => ({
+      name: opts.name,
+      target: `/workspace/.vellum/plugins/${opts.name}`,
+      warnings: ["plugin.uninstall.mcp_oauth_credentials_unchecked"],
+    }));
+
+    const result = await invokeUninstall({
+      pathParams: { name: "simple-memory" },
+    });
+
+    expect(result.warnings).toEqual([
+      "plugin.uninstall.mcp_oauth_credentials_unchecked",
+    ]);
+  });
+
   test("threads x-vellum-client-id into the published event's originClientId", async () => {
     uninstallSpy.mockImplementation(async (opts) => ({
       name: opts.name,
@@ -2759,7 +2779,9 @@ describe("POST /v1/plugins/:name/disable", () => {
       toggleResult(name, "disable"),
     );
 
-    const result = await invokeDisable({ pathParams: { name: "simple-memory" } });
+    const result = await invokeDisable({
+      pathParams: { name: "simple-memory" },
+    });
 
     expect(result).toEqual({ ok: true });
     expect(disablePluginSpy.mock.calls[0]?.[0]).toBe("simple-memory");

package/src/runtime/routes/browser-context.ts

@@ -0,0 +1,39 @@
+import { resolveTurnClientOs } from "../../daemon/conversation-client-surface.js";
+import { findConversation } from "../../daemon/conversation-registry.js";
+import type { ToolContext } from "../../tools/types.js";
+import { resolveActorPrincipalIdForLocalGuardian } from "../local-actor-identity.js";
+
+export function browserCliConversationKey(sessionId: string): string {
+  return `browser-cli:${sessionId}`;
+}
+
+export async function resolveBrowserContext(
+  conversationId: string | undefined,
+  sessionId: string,
+  headers: Record<string, string>,
+  abortSignal?: AbortSignal,
+): Promise<ToolContext> {
+  const conversation = conversationId
+    ? findConversation(conversationId)
+    : undefined;
+  const actor = await resolveActorPrincipalIdForLocalGuardian(
+    conversation?.getTurnActorPrincipalId() ??
+      headers["x-vellum-actor-principal-id"]?.trim(),
+  );
+  const signals = [abortSignal, conversation?.abortController?.signal].filter(
+    (signal): signal is AbortSignal => signal !== undefined,
+  );
+  return {
+    workingDir: process.cwd(),
+    conversationId: conversation
+      ? conversationId!
+      : browserCliConversationKey(sessionId),
+    trustClass: conversation?.trustContext?.trustClass ?? "unknown",
+    transportInterface: conversation?.transportInterface,
+    clientOs: conversation
+      ? resolveTurnClientOs(conversation).clientOs
+      : undefined,
+    sourceActorPrincipalId: actor,
+    signal: signals.length ? AbortSignal.any(signals) : undefined,
+  };
+}

package/src/runtime/routes/browser-routes.ts

@@ -16,10 +16,12 @@ import {
   BROWSER_OPERATIONS,
   type BrowserOperation,
 } from "../../browser/types.js";
-import { findConversation } from "../../daemon/conversation-registry.js";
+import { shouldUseVirtualDesktopBrowser } from "../../browser/virtual-desktop-target.js";
+import { executeDesktopBrowserOperation } from "../../desktop/desktop-browser-operations.js";
 import type { ContentBlock } from "../../providers/types.js";
 import { LOCAL_PRINCIPALS } from "../auth/route-policy.js";
-import { resolveActorPrincipalIdForLocalGuardian } from "../local-actor-identity.js";
+import { resolveBrowserContext } from "./browser-context.js";
+export { browserCliConversationKey } from "./browser-context.js";
 import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
 
 // ── Param validation ─────────────────────────────────────────────────
@@ -29,18 +31,9 @@ const BrowserExecuteParams = z.object({
   input: z.record(z.string(), z.unknown()).default({}),
   sessionId: z.string().min(1).default("default"),
   conversationId: z.string().min(1).optional(),
+  desktop: z.boolean().optional(),
 });
 
-// ── Conversation key ─────────────────────────────────────────────────
-
-/**
- * Build a deterministic conversation key from a session ID.
- * All CLI browser calls with the same session share browser state.
- */
-export function browserCliConversationKey(sessionId: string): string {
-  return `browser-cli:${sessionId}`;
-}
-
 // ── Screenshot extraction ────────────────────────────────────────────
 
 /**
@@ -70,45 +63,21 @@ function extractScreenshots(
 async function handleBrowserExecute({
   body = {},
   headers = {},
+  abortSignal,
 }: RouteHandlerArgs) {
-  const { operation, input, sessionId, conversationId } =
+  const { operation, input, sessionId, conversationId, desktop } =
     BrowserExecuteParams.parse(body);
 
-  // When the caller passes a live conversation ID (e.g. from
-  // __CONVERSATION_ID in a nested bash invocation), reuse that
-  // conversation's trust context and transport interface.
-  const conversation = conversationId
-    ? findConversation(conversationId)
-    : undefined;
-
-  const resolvedConversationId = conversation
-    ? conversationId!
-    : browserCliConversationKey(sessionId);
-
-  // Actor principal lets host-browser routing enforce same-actor ownership.
-  // A live conversation's turn actor owns the request (e.g. a nested-bash
-  // browser call inherits the conversation's actor), so it wins over the
-  // request header — which over IPC may carry a synthetic local-guardian id
-  // injected for header-less local callers. Resolve through the local-guardian
-  // translation so the value matches the actorPrincipalId host_browser clients
-  // register with (dev-bypass otherwise mismatches).
-  const headerActor =
-    headers["x-vellum-actor-principal-id"]?.trim() || undefined;
-  const sourceActorPrincipalId = await resolveActorPrincipalIdForLocalGuardian(
-    conversation?.getTurnActorPrincipalId() ?? headerActor,
-  );
-
-  const result = await executeBrowserOperation(
-    operation as BrowserOperation,
-    input,
-    {
-      workingDir: process.cwd(),
-      conversationId: resolvedConversationId,
-      trustClass: conversation?.trustContext?.trustClass ?? "unknown",
-      transportInterface: conversation?.transportInterface,
-      sourceActorPrincipalId,
-    },
+  const context = await resolveBrowserContext(
+    conversationId,
+    sessionId,
+    headers,
+    abortSignal,
   );
+  const execute = shouldUseVirtualDesktopBrowser(desktop, input, context)
+    ? executeDesktopBrowserOperation
+    : executeBrowserOperation;
+  const result = await execute(operation as BrowserOperation, input, context);
 
   const screenshots = extractScreenshots(result.contentBlocks);