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

package/src/providers/inference/__tests__/endpoint-probe.test.ts

@@ -107,6 +107,51 @@ describe("testInferenceConnection", () => {
     expect(calls[0].body).not.toHaveProperty(OPENCODE_SESSION_HEADER);
   });
 
+  test("probes /responses for an OpenCode responses-only model", async () => {
+    const calls: ProbeCall[] = [];
+    const result = await testInferenceConnection(
+      {
+        provider: "opencode",
+        auth: { type: "none" },
+        baseUrl: "https://opencode.ai/zen/v1",
+        models: [{ id: "muse-spark-1.2-contributor-free" }],
+      },
+      stubFetch(200, calls),
+    );
+
+    expect(result).toMatchObject({
+      ok: true,
+      resolved_url: "https://opencode.ai/zen/v1/responses",
+    });
+    expect(calls[0].body).toMatchObject({
+      model: "muse-spark-1.2-contributor-free",
+      input: "ping",
+      max_output_tokens: 16,
+    });
+    expect(calls[0].headers[OPENCODE_SESSION_HEADER]).toBeTruthy();
+  });
+
+  test("keeps other OpenCode models on /chat/completions", async () => {
+    const calls: ProbeCall[] = [];
+    const result = await testInferenceConnection(
+      {
+        provider: "opencode",
+        auth: { type: "none" },
+        baseUrl: "https://opencode.ai/zen/v1",
+        models: [{ id: "mimo-v2.5-free" }],
+      },
+      stubFetch(200, calls),
+    );
+
+    expect(result?.resolved_url).toBe(
+      "https://opencode.ai/zen/v1/chat/completions",
+    );
+    expect(calls[0].body).toMatchObject({
+      model: "mimo-v2.5-free",
+      max_tokens: 1,
+    });
+  });
+
   test("does not send OpenCode headers to other providers", async () => {
     const calls: ProbeCall[] = [];
     await testInferenceConnection(CONNECTION, stubFetch(200, calls));

package/src/providers/inference/endpoint-probe.ts

@@ -10,7 +10,10 @@
 import { z } from "zod";
 
 import { getLogger } from "../../util/logger.js";
-import { resolveOpenCodeRequestHeaders } from "../opencode/client.js";
+import {
+  OPENCODE_RESPONSES_ONLY_MODELS,
+  resolveOpenCodeRequestHeaders,
+} from "../opencode/client.js";
 import type { Auth, ConnectionModel } from "./auth.js";
 import { resolveAuth } from "./resolve-auth.js";
 
@@ -46,10 +49,12 @@ function hintForStatus(status: number): string {
 }
 
 /**
- * Probe a connection's custom endpoint with a minimal chat-completions
- * request (`max_tokens: 1`). Returns `null` when there is nothing to probe:
- * no custom base URL, no model id to send, or auth that cannot be resolved
- * (a missing credential surfaces through its own error path).
+ * Probe a connection's custom endpoint with a minimal request on the wire
+ * its first model is served over: chat completions (`max_tokens: 1`), or
+ * the Responses API for OpenCode's responses-only models, which answer
+ * `/chat/completions` with HTTP 500. Returns `null` when there is nothing
+ * to probe: no custom base URL, no model id to send, or auth that cannot be
+ * resolved (a missing credential surfaces through its own error path).
  */
 export async function testInferenceConnection(
   connection: {
@@ -78,7 +83,12 @@ export async function testInferenceConnection(
   const providerHeaders =
     connection.provider === "opencode" ? resolveOpenCodeRequestHeaders() : {};
 
-  const url = `${connection.baseUrl.replace(/\/+$/, "")}/chat/completions`;
+  const useResponses =
+    connection.provider === "opencode" &&
+    OPENCODE_RESPONSES_ONLY_MODELS.has(model);
+  const url = `${connection.baseUrl.replace(/\/+$/, "")}${
+    useResponses ? "/responses" : "/chat/completions"
+  }`;
   try {
     const res = await fetchImpl(url, {
       method: "POST",
@@ -87,12 +97,17 @@ export async function testInferenceConnection(
         ...providerHeaders,
         "Content-Type": "application/json",
       },
-      body: JSON.stringify({
-        model,
-        messages: [{ role: "user", content: "ping" }],
-        max_tokens: 1,
-        stream: false,
-      }),
+      body: JSON.stringify(
+        useResponses
+          ? // The Responses API rejects output budgets below 16 tokens.
+            { model, input: "ping", max_output_tokens: 16, stream: false }
+          : {
+              model,
+              messages: [{ role: "user", content: "ping" }],
+              max_tokens: 1,
+              stream: false,
+            },
+      ),
       signal: AbortSignal.timeout(PROBE_TIMEOUT_MS),
     });
     void res.body?.cancel();

package/src/providers/openai/responses-provider.ts

@@ -109,7 +109,9 @@ function mapResponsesReasoningEffort(
     return "none";
   }
   const clamped = clampReasoningEffort(raw, effortCeilingForModel(model));
-  return supported ? snapReasoningEffortToSupported(clamped, supported) : clamped;
+  return supported
+    ? snapReasoningEffortToSupported(clamped, supported)
+    : clamped;
 }
 
 /** Values accepted by the Responses API `text.verbosity` parameter. */
@@ -280,7 +282,11 @@ export class OpenAIResponsesProvider implements Provider {
     const effort = configObj?.effort as string | undefined;
     const verbosity = configObj?.verbosity as string | undefined;
     const usageAttributionHeaders = configObj?.usageAttributionHeaders as
-      Record<string, string> | undefined;
+      | Record<string, string>
+      | undefined;
+    const perRequestHeaders = configObj?.requestHeaders as
+      | Record<string, string>
+      | undefined;
     const disableCache = configObj?.disableCache === true;
     const disableTurnStartCache = configObj?.disableTurnStartCache === true;
     const promptCacheKey =
@@ -463,6 +469,7 @@ export class OpenAIResponsesProvider implements Provider {
         const requestHeaders = {
           ...this.requestHeaders,
           ...(usageAttributionHeaders ?? {}),
+          ...(perRequestHeaders ?? {}),
         };
         const stream = await responsesApi.create(
           { ...params, stream: true },

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__/acp-claude-auth-routes.test.ts

@@ -48,7 +48,7 @@ mock.module("../../../security/oauth2.js", () => ({
 
 const actualClaudeOauth = await import("../../../acp/acp-claude-oauth.js");
 const { CLAUDE_MANUAL_REDIRECT_URI, CLAUDE_OAUTH_CONFIG } = actualClaudeOauth;
-const storeAcpClaudeTokenMock = mock(async (_token: string) => {});
+const storeAcpClaudeTokenMock = mock(async (_tokens: unknown) => {});
 // The connect-status route reads token presence; mock it so the route test
 // doesn't reach real secure storage.
 const hasAcpClaudeTokenMock = mock(async () => false);
@@ -228,9 +228,12 @@ describe("loopback capture", () => {
     const status = await waitForStatus(state, "connected");
     expect(status).toEqual({ status: "connected" });
 
-    // Access token persisted via storeAcpClaudeToken.
     expect(storeAcpClaudeTokenMock).toHaveBeenCalledTimes(1);
-    expect(storeAcpClaudeTokenMock).toHaveBeenCalledWith("sk-ant-oat-access");
+    expect(storeAcpClaudeTokenMock).toHaveBeenCalledWith({
+      accessToken: "sk-ant-oat-access",
+      refreshToken: "refresh-xyz",
+      expiresIn: 3600,
+    });
   });
 
   test("flips status to error when the exchange fails", async () => {
@@ -339,7 +342,11 @@ describe("acp_claude_auth_exchange", () => {
     expect(call[1]).toBe("auth-code-123");
     expect(call[2]).toBe(CLAUDE_MANUAL_REDIRECT_URI);
     expect(call[3]).toBeTruthy(); // PKCE verifier from the start call
-    expect(storeAcpClaudeTokenMock).toHaveBeenCalledWith("sk-ant-oat-manual");
+    expect(storeAcpClaudeTokenMock).toHaveBeenCalledWith({
+      accessToken: "sk-ant-oat-manual",
+      refreshToken: "refresh-manual",
+      expiresIn: 3600,
+    });
 
     // The pending entry is consumed — a second exchange fails.
     await expect(
@@ -360,7 +367,11 @@ describe("acp_claude_auth_exchange", () => {
       string,
     ];
     expect(call[1]).toBe("raw-code-xyz");
-    expect(storeAcpClaudeTokenMock).toHaveBeenCalledWith("sk-ant-oat-manual");
+    expect(storeAcpClaudeTokenMock).toHaveBeenCalledWith({
+      accessToken: "sk-ant-oat-manual",
+      refreshToken: "refresh-manual",
+      expiresIn: 3600,
+    });
   });
 
   test("malformed paste (no `#`, no state) is rejected", async () => {