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

package/src/tools/acp/status.ts

@@ -1,13 +1,37 @@
 import { z } from "zod";
 
-import { getAcpSessionManager } from "../../acp/index.js";
-import type { AcpSessionState } from "../../acp/types.js";
+import { resolvedClaudeCredentialDigest } from "../../acp/prepare-agent-env.js";
+import {
+  type AcpSessionSnapshot,
+  getAcpSessionSnapshot,
+  listAcpSessionSnapshots,
+  withCurrentAuthMarkers,
+} from "../../acp/session-snapshot.js";
 import {
   invalidToolInputResult,
   nullAsOmitted,
 } from "../shared/zod-tool-schema.js";
 import type { ToolContext, ToolExecutionResult } from "../types.js";
 
+const STATUS_LIST_LIMIT = 50;
+
+/**
+ * Keep every live session visible, then fill remaining capacity from durable
+ * history. An older active run must not be displaced by newer historical rows.
+ */
+function selectStatusSnapshots(
+  sessions: AcpSessionSnapshot[],
+): AcpSessionSnapshot[] {
+  const live = sessions.filter((session) => session.source === "live");
+  const history = sessions
+    .filter((session) => session.source === "history")
+    .sort((a, b) => b.startedAt - a.startedAt);
+  const remaining = Math.max(0, STATUS_LIST_LIMIT - live.length);
+  return [...live, ...history.slice(0, remaining)].sort(
+    (a, b) => b.startedAt - a.startedAt,
+  );
+}
+
 /**
  * Model-input schema, `safeParse`d at the top of {@link executeAcpStatus}.
  * Same in-tool pattern and TOOLS.json drift guard as the other bundled-skill
@@ -24,33 +48,48 @@ export const acpStatusInputSchema = z.looseObject({
  * `AcpSessionState` for those surfaces should not reach this one by default.
  * `model` stays: which model a session is running on is answerable.
  */
-function projectSession(state: AcpSessionState) {
+function projectSession(snapshot: AcpSessionSnapshot) {
+  const fromHistory = snapshot.source === "history";
+  const idle =
+    fromHistory &&
+    snapshot.status === "completed" &&
+    snapshot.stopReason !== "cancelled" &&
+    snapshot.resumable;
+  const latestUsage =
+    snapshot.usedTokens !== undefined && snapshot.contextSize !== undefined
+      ? {
+          usedTokens: snapshot.usedTokens,
+          contextSize: snapshot.contextSize,
+          costAmount: snapshot.costAmount,
+          costCurrency: snapshot.costCurrency,
+          inputTokens: snapshot.inputTokens,
+          outputTokens: snapshot.outputTokens,
+        }
+      : undefined;
   return {
-    id: state.id,
-    agentId: state.agentId,
-    acpSessionId: state.acpSessionId,
-    parentConversationId: state.parentConversationId,
-    status: state.status,
-    startedAt: state.startedAt,
-    completedAt: state.completedAt,
-    error: state.error,
-    stopReason: state.stopReason,
-    task: state.task,
-    parentToolUseId: state.parentToolUseId,
-    authErrorCode: state.authErrorCode,
-    authErrorCredential: state.authErrorCredential,
-    latestUsage: state.latestUsage,
-    model: state.model,
+    id: snapshot.id,
+    agentId: snapshot.agentId,
+    acpSessionId: snapshot.acpSessionId,
+    parentConversationId: snapshot.parentConversationId,
+    status: idle ? "idle" : snapshot.status,
+    startedAt: snapshot.startedAt,
+    completedAt: snapshot.completedAt ?? undefined,
+    error: snapshot.error ?? undefined,
+    stopReason: snapshot.stopReason ?? undefined,
+    task: snapshot.task,
+    parentToolUseId: snapshot.parentToolUseId,
+    authErrorCode: snapshot.authErrorCode,
+    latestUsage,
+    model: snapshot.model,
+    ...(fromHistory
+      ? {
+          resumable: snapshot.resumable,
+          lastRunStatus: snapshot.status,
+        }
+      : {}),
   };
 }
 
-/** Projects either shape `getStatus` answers with. */
-function projectStatus(status: AcpSessionState | AcpSessionState[]): unknown {
-  return Array.isArray(status)
-    ? status.map(projectSession)
-    : projectSession(status);
-}
-
 export async function executeAcpStatus(
   input: Record<string, unknown>,
   _context: ToolContext,
@@ -60,24 +99,51 @@ export async function executeAcpStatus(
     return invalidToolInputResult("acp_status", parsedInput.error);
   }
   const acpSessionId = parsedInput.data.acp_session_id;
-  const manager = getAcpSessionManager();
-
   try {
     if (acpSessionId) {
+      const snapshot = getAcpSessionSnapshot(acpSessionId, {
+        includeEventLog: false,
+      });
+      if (!snapshot) {
+        return {
+          content: `ACP session "${acpSessionId}" not found`,
+          isError: true,
+        };
+      }
+      const judged = (
+        await withCurrentAuthMarkers(
+          [snapshot],
+          resolvedClaudeCredentialDigest,
+        )
+      )[0];
+      if (!judged) {
+        return {
+          content: `ACP session "${acpSessionId}" not found`,
+          isError: true,
+        };
+      }
       return {
-        content: JSON.stringify(projectStatus(manager.getStatus(acpSessionId))),
+        content: JSON.stringify(projectSession(judged)),
         isError: false,
       };
     }
 
-    // List all sessions.
-    const allStates = manager.getStatus();
-    if (Array.isArray(allStates) && allStates.length === 0) {
+    const snapshots = selectStatusSnapshots(
+      listAcpSessionSnapshots({
+        limit: STATUS_LIST_LIMIT,
+        includeEventLog: false,
+      }).sessions,
+    );
+    if (snapshots.length === 0) {
       return { content: "No ACP sessions found.", isError: false };
     }
 
+    const judged = await withCurrentAuthMarkers(
+      snapshots,
+      resolvedClaudeCredentialDigest,
+    );
     return {
-      content: JSON.stringify(projectStatus(allStates)),
+      content: JSON.stringify(judged.map(projectSession)),
       isError: false,
     };
   } catch (err) {

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

@@ -1,4 +1,5 @@
 import { optimizeImageForTransport } from "../../agent/image-optimize.js";
+import type { BrowserOperationContext as ToolContext } from "../../browser/types.js";
 import { getConfig } from "../../config/loader.js";
 import { HostBrowserProxy } from "../../daemon/host-browser-proxy.js";
 import type { ImageContent } from "../../providers/types.js";
@@ -21,7 +22,7 @@ import {
   sanitizeUrlForOutput,
   sanitizeUrlStringForOutput,
 } from "../network/url-safety.js";
-import type { ToolContext, ToolExecutionResult } from "../types.js";
+import type { ToolExecutionResult } from "../types.js";
 import {
   type AuthChallenge,
   detectAuthChallenge,
@@ -515,6 +516,9 @@ async function acquireCdpClientWithMode(
     }
   | { cdp?: never; browserMode?: never; errorResult: ToolExecutionResult }
 > {
+  if (context.cdpClient) {
+    return { cdp: context.cdpClient, browserMode: "cdp-inspect" };
+  }
   const modeResult = parseBrowserMode(input);
   if (!modeResult.ok) {
     return {
@@ -746,6 +750,17 @@ export type ResolvedElement =
   | { kind: "backend"; backendNodeId: number; eid: string }
   | { kind: "selector"; selector: string };
 
+function snapshotConversationId(context: ToolContext): string {
+  return context.cdpClient?.conversationId ?? context.conversationId;
+}
+
+function clearBrowserSessionState(context: ToolContext): void {
+  browserManager.clearSnapshotBackendNodeMap(snapshotConversationId(context));
+  if (!context.cdpClient) {
+    browserManager.clearPreferredBackendKind(context.conversationId);
+  }
+}
+
 /**
  * Resolve an element reference (either `element_id` from a prior
  * snapshot or a raw `selector`) for CDP-native tools. Returns a
@@ -872,6 +887,9 @@ export async function executeBrowserNavigate(
     typeof input.target_client_id === "string" && input.target_client_id !== ""
       ? input.target_client_id
       : undefined;
+  if (context.cdpClient && forceNewTab) {
+    await cdp.send("Vellum.createTab", {}, context.signal);
+  }
   if (cdp.kind === "extension" && useActiveTab) {
     // Explicit opt-out: target the currently-active tab. Clear any
     // conversation pin and reset the live session so this navigate is
@@ -1188,7 +1206,7 @@ export async function executeBrowserNavigate(
     // Navigation changed the page content, so clear stale snapshot
     // mappings regardless of backend. The backendNodeId map is shared
     // per-conversation state that needs to be invalidated on any nav.
-    browserManager.clearSnapshotBackendNodeMap(context.conversationId);
+    browserManager.clearSnapshotBackendNodeMap(snapshotConversationId(context));
 
     // Auto-dismiss common blocker modals (regulatory notices, cookie
     // banners) that aren't exposed in the accessibility tree. Runs
@@ -1398,7 +1416,7 @@ export async function executeBrowserSnapshot(
     const { elements, selectorMap: backendNodeMap } = transformAxTree(rawTree);
 
     browserManager.storeSnapshotBackendNodeMap(
-      context.conversationId,
+      snapshotConversationId(context),
       backendNodeMap,
     );
 
@@ -1600,8 +1618,7 @@ export async function executeBrowserDetach(
     // Vellum.detach round-trip failed (target gone, transport dropped).
     // browser_detach is the user's recovery path — leaving a stale
     // sticky backend or snapshot map behind would defeat its purpose.
-    browserManager.clearSnapshotBackendNodeMap(context.conversationId);
-    browserManager.clearPreferredBackendKind(context.conversationId);
+    clearBrowserSessionState(context);
     cdp.dispose();
   }
 }
@@ -1653,8 +1670,7 @@ export async function executeBrowserClose(
         // Tolerate detach failures (already detached, tab closed, etc.)
       }
     }
-    browserManager.clearSnapshotBackendNodeMap(context.conversationId);
-    browserManager.clearPreferredBackendKind(context.conversationId);
+    clearBrowserSessionState(context);
     return {
       content:
         "Browser session cleared. (Your Chrome tab was not closed — close it yourself if desired.)",
@@ -1683,7 +1699,10 @@ export async function executeBrowserClick(
   input: Record<string, unknown>,
   context: ToolContext,
 ): Promise<ToolExecutionResult> {
-  const { resolved, error } = resolveElement(context.conversationId, input);
+  const { resolved, error } = resolveElement(
+    snapshotConversationId(context),
+    input,
+  );
   if (error) {
     return { content: error, isError: true };
   }
@@ -1796,7 +1815,10 @@ export async function executeBrowserType(
   input: Record<string, unknown>,
   context: ToolContext,
 ): Promise<ToolExecutionResult> {
-  const { resolved, error } = resolveElement(context.conversationId, input);
+  const { resolved, error } = resolveElement(
+    snapshotConversationId(context),
+    input,
+  );
   if (error) {
     return { content: error, isError: true };
   }
@@ -1887,7 +1909,7 @@ export async function executeBrowserPressKey(
   let targetDescription: string | null = null;
   let resolved: ResolvedElement | null = null;
   if (hasTarget) {
-    const res = resolveElement(context.conversationId, input);
+    const res = resolveElement(snapshotConversationId(context), input);
     if (res.error) {
       return { content: res.error, isError: true };
     }
@@ -2025,7 +2047,10 @@ export async function executeBrowserSelectOption(
   input: Record<string, unknown>,
   context: ToolContext,
 ): Promise<ToolExecutionResult> {
-  const { resolved, error } = resolveElement(context.conversationId, input);
+  const { resolved, error } = resolveElement(
+    snapshotConversationId(context),
+    input,
+  );
   if (error) {
     return { content: error, isError: true };
   }
@@ -2162,7 +2187,10 @@ export async function executeBrowserHover(
   input: Record<string, unknown>,
   context: ToolContext,
 ): Promise<ToolExecutionResult> {
-  const { resolved, error } = resolveElement(context.conversationId, input);
+  const { resolved, error } = resolveElement(
+    snapshotConversationId(context),
+    input,
+  );
   if (error) {
     return { content: error, isError: true };
   }
@@ -2410,7 +2438,10 @@ export async function executeBrowserFillCredential(
     return { content: "Error: field is required.", isError: true };
   }
 
-  const { resolved, error } = resolveElement(context.conversationId, input);
+  const { resolved, error } = resolveElement(
+    snapshotConversationId(context),
+    input,
+  );
   if (error) {
     return { content: error, isError: true };
   }

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

@@ -2804,3 +2804,72 @@ describe("macOS host-browser proxy without extension registry", () => {
     expect(result).toEqual({ ok: true, via: "extension" });
   });
 });
+
+describe("native renderer browser compatibility", () => {
+  beforeEach(() => {
+    setCdpInspectEnabled(false);
+    setDesktopAutoConfig({ enabled: true, cooldownMs: 30_000 });
+    _resetDesktopAutoCooldown();
+    _resetHostBridgeCooldown();
+    mockSingletonProxy = null;
+  });
+  test.each(["macos", "windows"] as const)(
+    "%s web renderer sends CDP to the connected host bridge",
+    async (clientOs) => {
+      mockSingletonProxy = makeMacosBridgeOnlyProxy();
+      const client = getCdpClient(
+        makeContext({
+          conversationId: "conv-native",
+          transportInterface: "web",
+          clientOs,
+        }),
+      );
+      try {
+        expect(await client.send("Page.getFrameTree", {})).toMatchObject({
+          via: "host-bridge",
+        });
+      } finally {
+        client.dispose();
+      }
+    },
+  );
+
+  test.each(["macos", "windows"] as const)(
+    "%s web renderer keeps the existing Playwright fallback without a bridge",
+    async (clientOs) => {
+      const client = getCdpClient(
+        makeContext({
+          conversationId: "conv-native",
+          transportInterface: "web",
+          clientOs,
+        }),
+      );
+      try {
+        expect(await client.send("Page.getFrameTree", {})).toMatchObject({
+          via: "local",
+        });
+      } finally {
+        client.dispose();
+      }
+    },
+  );
+
+  test("explicit Playwright choice overrides the native browser default", async () => {
+    mockSingletonProxy = makeMacosBridgeOnlyProxy();
+    const client = getCdpClient(
+      makeContext({
+        conversationId: "conv-native",
+        transportInterface: "web",
+        clientOs: "windows",
+      }),
+      { mode: "local" },
+    );
+    try {
+      expect(await client.send("Page.getFrameTree", {})).toMatchObject({
+        via: "local",
+      });
+    } finally {
+      client.dispose();
+    }
+  });
+});

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

@@ -417,6 +417,7 @@ describe("connectCdpWsTransport", () => {
         }
         expect(caught).toBeInstanceOf(CdpWsTransportError);
         expect((caught as CdpWsTransportError).code).toBe("closed");
+        expect(transport.closed).toBe(true);
 
         // After close, subsequent sends also reject with closed.
         let caught2: unknown;

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

@@ -99,6 +99,8 @@ export interface CdpTransportEvent {
  * CDP error mapping to the shared `CdpError` taxonomy.
  */
 export interface CdpWsTransport {
+  readonly closed?: boolean;
+
   /**
    * Send a CDP method call over the socket and await its response.
    *
@@ -464,6 +466,9 @@ function createTransport(ws: WsLike): CdpWsTransport {
   ws.addEventListener("error", handleError);
 
   const transport: CdpWsTransport = {
+    get closed() {
+      return disposed || closed;
+    },
     send<T = unknown>(
       method: string,
       params?: Record<string, unknown>,

package/src/tools/computer-use/definitions.ts

@@ -352,7 +352,7 @@ export const computerUseOpenAppTool = {
 export const computerUseRunAppleScriptTool = {
   name: "computer_use_run_applescript",
   description:
-    "Run an AppleScript command. Prefer this over click/type when possible - it doesn't move the cursor or interrupt foreground activity. Never use 'do shell script' inside AppleScript (blocked for security).",
+    "Run an AppleScript on the Mac. Try the target app's own scripting dictionary first, asking it for the state you want rather than for the clicks that would produce it; fall back to System Events menu clicking for apps with no dictionary entry for what you need. Prefer this over click and type when the app supports it; it does not move the cursor. The result is the script's return value, and the accessibility tree may not change even when the script worked. Never use 'do shell script' inside AppleScript (blocked for security).",
   category: "computer-use",
   defaultRiskLevel: RiskLevel.Low,
   executionTarget: "host",
@@ -367,8 +367,7 @@ export const computerUseRunAppleScriptTool = {
       },
       reasoning: {
         type: "string",
-        description:
-          "Explanation of what this script does and why AppleScript is better than UI interaction for this step",
+        description: "What this script does",
       },
       target_client_id: {
         type: "string",

package/src/util/abort-reasons.ts

@@ -21,7 +21,18 @@ export type AbortReasonKind =
   /** A signal-file cancel was written by an out-of-process caller (CLI, hook). */
   | "signal_cancel"
   /** Voice session bridge aborted the conversation (turn supersession, call end). */
-  | "voice_session_aborted";
+  | "voice_session_aborted"
+  /**
+   * One spoken progress update ran out of its generation budget.
+   *
+   * Distinct from {@link "voice_session_aborted"} because nothing was aborted
+   * but the update itself: the call is still up, the turn is still running,
+   * and the only consequence is that this beat goes unspoken. Sharing the
+   * session-abort kind made a narrator that had gone fail-open read in the
+   * logs as a session dying over and over, which is the opposite of what the
+   * line means.
+   */
+  | "voice_progress_narration_timeout";
 
 const ABORT_REASON_TAG = "__vellumAbortReason" as const;
 

package/src/util/plugin-manifest.ts

@@ -0,0 +1,203 @@
+/**
+ * Resolve the manifest that identifies an installed plugin.
+ *
+ * `package.json` is the primary manifest for Vellum plugins. A root
+ * `plugin.json` is selected only when `package.json` is absent, so a legacy
+ * plugin can carry another ecosystem's `plugin.json` without being
+ * reclassified.
+ */
+
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+
+import { z } from "zod";
+
+export const LEGACY_PLUGIN_MANIFEST = "package.json";
+export const STANDARD_PLUGIN_MANIFEST = "plugin.json";
+export const AGENT_PLUGINS_MANIFEST_SCHEMA_URL =
+  "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json";
+
+const PluginNameSchema = z
+  .string()
+  .min(1)
+  .max(64)
+  .regex(/^[a-z0-9](?!.*(?:--|\.\.))[a-z0-9.-]*[a-z0-9]$|^[a-z0-9]$/);
+
+const LegacyPluginManifestSchema = z
+  .object({
+    name: z.string().min(1),
+    version: z.string().optional(),
+    description: z.string().min(1).optional(),
+    homepage: z.string().optional(),
+    license: z.unknown().optional(),
+    peerDependencies: z.record(z.string(), z.string()).optional(),
+    credentialKeyPatterns: z.unknown().optional(),
+    displayName: z.string().min(1).optional(),
+    icon: z.string().min(1).optional(),
+  })
+  .passthrough();
+
+const StandardPluginManifestSchema = z
+  .object({
+    $schema: z.literal(AGENT_PLUGINS_MANIFEST_SCHEMA_URL),
+    name: PluginNameSchema,
+    version: z.string().optional(),
+    description: z.string().optional(),
+    author: z
+      .object({
+        name: z.string().optional(),
+        email: z.string().optional(),
+        url: z.string().optional(),
+      })
+      .strict()
+      .optional(),
+    homepage: z.string().optional(),
+    repository: z.string().optional(),
+    license: z.string().optional(),
+    keywords: z.array(z.string()).optional(),
+    // The core specification says a non-object extensions value is reported
+    // and ignored rather than rejecting the plugin. This host does not consume
+    // a standard extension namespace here, so keep it opaque.
+    extensions: z.unknown().optional(),
+  })
+  // Unknown core fields are reported-and-ignored by the specification. The
+  // loader does not assign them semantics, so passthrough preserves that
+  // non-fatal behavior without copying them into runtime metadata.
+  .passthrough();
+
+export type PluginManifestSource =
+  | typeof LEGACY_PLUGIN_MANIFEST
+  | typeof STANDARD_PLUGIN_MANIFEST;
+
+export interface ResolvedPluginManifest {
+  readonly source: PluginManifestSource;
+  readonly name: string;
+  readonly version?: string;
+  readonly description?: string;
+  readonly homepage?: string;
+  readonly license?: unknown;
+  /** Parsed selected manifest, retained for Vellum-specific legacy fields. */
+  readonly raw: Record<string, unknown>;
+}
+
+export type PluginManifestInstallAction = "keep" | "synthesize-legacy";
+
+export class PluginManifestError extends Error {
+  constructor(
+    readonly pluginDir: string,
+    readonly source: PluginManifestSource | null,
+    message: string,
+    readonly cause?: unknown,
+  ) {
+    super(message);
+    this.name = "PluginManifestError";
+  }
+}
+
+/** True when the directory carries either supported root manifest. */
+export function hasPluginManifest(pluginDir: string): boolean {
+  return (
+    existsSync(join(pluginDir, LEGACY_PLUGIN_MANIFEST)) ||
+    existsSync(join(pluginDir, STANDARD_PLUGIN_MANIFEST))
+  );
+}
+
+/**
+ * Decide whether an installed artifact needs the compatibility `package.json`.
+ *
+ * A `package.json` file is always preserved. A root `plugin.json`
+ * claims the Agent Plugins format only when it names the supported schema. A
+ * claimed standard manifest is validated before install; other `plugin.json`
+ * files remain foreign metadata beside the synthesized compatibility manifest.
+ */
+export function getPluginManifestInstallAction(
+  pluginDir: string,
+): PluginManifestInstallAction {
+  if (existsSync(join(pluginDir, LEGACY_PLUGIN_MANIFEST))) {
+    return "keep";
+  }
+
+  const standardPath = join(pluginDir, STANDARD_PLUGIN_MANIFEST);
+  if (!existsSync(standardPath)) {
+    return "synthesize-legacy";
+  }
+
+  let json: unknown;
+  try {
+    json = JSON.parse(readFileSync(standardPath, "utf8"));
+  } catch {
+    return "synthesize-legacy";
+  }
+
+  if (
+    typeof json !== "object" ||
+    json === null ||
+    Array.isArray(json) ||
+    (json as Record<string, unknown>).$schema !==
+      AGENT_PLUGINS_MANIFEST_SCHEMA_URL
+  ) {
+    return "synthesize-legacy";
+  }
+
+  readPluginManifest(pluginDir);
+  return "keep";
+}
+
+/**
+ * Read and validate the selected root manifest.
+ *
+ * Selection is deterministic: `package.json` wins when present, including
+ * when it is malformed. The loader never falls through
+ * from a selected malformed legacy manifest to `plugin.json`.
+ */
+export function readPluginManifest(pluginDir: string): ResolvedPluginManifest {
+  const source = existsSync(join(pluginDir, LEGACY_PLUGIN_MANIFEST))
+    ? LEGACY_PLUGIN_MANIFEST
+    : existsSync(join(pluginDir, STANDARD_PLUGIN_MANIFEST))
+      ? STANDARD_PLUGIN_MANIFEST
+      : null;
+  if (source === null) {
+    throw new PluginManifestError(
+      pluginDir,
+      null,
+      `plugin at ${pluginDir} is missing package.json and plugin.json`,
+    );
+  }
+
+  const path = join(pluginDir, source);
+  let json: unknown;
+  try {
+    json = JSON.parse(readFileSync(path, "utf8"));
+  } catch (cause) {
+    const reason = cause instanceof Error ? cause.message : String(cause);
+    throw new PluginManifestError(
+      pluginDir,
+      source,
+      `${source} at ${pluginDir} could not be read or parsed: ${reason}`,
+      cause,
+    );
+  }
+
+  const parsed =
+    source === LEGACY_PLUGIN_MANIFEST
+      ? LegacyPluginManifestSchema.safeParse(json)
+      : StandardPluginManifestSchema.safeParse(json);
+  if (!parsed.success) {
+    throw new PluginManifestError(
+      pluginDir,
+      source,
+      `${source} at ${pluginDir} failed schema validation: ${parsed.error.message}`,
+      parsed.error,
+    );
+  }
+
+  return {
+    source,
+    name: parsed.data.name,
+    version: parsed.data.version,
+    description: parsed.data.description,
+    homepage: parsed.data.homepage,
+    license: parsed.data.license,
+    raw: parsed.data,
+  };
+}

package/src/desktop/desktop-feature.test.ts

@@ -1,18 +0,0 @@
-import { describe, expect, test } from "bun:test";
-
-import { setOverridesForTesting } from "../__tests__/feature-flag-test-helpers.js";
-import type { AssistantConfig } from "../config/schema.js";
-import { isAssistantDesktopEnabled } from "./desktop-feature.js";
-
-describe("isAssistantDesktopEnabled", () => {
-  const config = {} as AssistantConfig;
-
-  test("needs both the flag and a containerized runtime", () => {
-    setOverridesForTesting({ "assistant-desktop": true });
-    expect(isAssistantDesktopEnabled(config, true)).toBe(true);
-    expect(isAssistantDesktopEnabled(config, false)).toBe(false);
-
-    setOverridesForTesting({ "assistant-desktop": false });
-    expect(isAssistantDesktopEnabled(config, true)).toBe(false);
-  });
-});