@gleanwork/mcp-server-tester 2.0.0-beta.2 → 2.0.0-beta.3

package/dist/cli/index.js

@@ -13,6 +13,7 @@ import { createRequire } from 'module';
 import os, { homedir, tmpdir, userInfo } from 'os';
 import { promisify } from 'util';
 import crypto, { randomUUID, createHash } from 'crypto';
+import { setTimeout as setTimeout$1 } from 'timers/promises';
 import { Command } from 'commander';
 import { render, useApp, useInput, Box, Text } from 'ink';
 import React, { useState, useEffect, useCallback, useRef } from 'react';
@@ -942,11 +943,11 @@ function isNodeDefaultFetch(fetch2) {
   return source.includes("internal/deps/undici") || source.includes("lazy loading of undici");
 }
 async function createSafeNodeFetch() {
-  const [{ createRequire: createRequire3 }, { lookup }] = await Promise.all([
+  const [{ createRequire: createRequire4 }, { lookup }] = await Promise.all([
     loadNodeModule("node:module"),
     loadNodeModule("node:dns")
   ]);
-  const { Agent, fetch: fetch2 } = createRequire3(getCurrentModulePath())(
+  const { Agent, fetch: fetch2 } = createRequire4(getCurrentModulePath())(
     "undici"
   );
   const dispatcher = new Agent({
@@ -2454,7 +2455,7 @@ function createProviderToolFactory({
   inputSchema
 }) {
   return ({
-    execute,
+    execute: execute2,
     outputSchema,
     needsApproval,
     toModelOutput,
@@ -2468,7 +2469,7 @@ function createProviderToolFactory({
     args,
     inputSchema,
     outputSchema,
-    execute,
+    execute: execute2,
     needsApproval,
     toModelOutput,
     onInputStart,
@@ -2483,7 +2484,7 @@ function createProviderToolFactoryWithOutputSchema({
   supportsDeferredResults
 }) {
   return ({
-    execute,
+    execute: execute2,
     needsApproval,
     toModelOutput,
     onInputStart,
@@ -2496,7 +2497,7 @@ function createProviderToolFactoryWithOutputSchema({
     args,
     inputSchema,
     outputSchema,
-    execute,
+    execute: execute2,
     needsApproval,
     toModelOutput,
     onInputStart,
@@ -2654,11 +2655,11 @@ function isAsyncIterable(obj) {
   return obj != null && typeof obj[Symbol.asyncIterator] === "function";
 }
 async function* executeTool({
-  execute,
+  execute: execute2,
   input,
   options
 }) {
-  const result = execute(input, options);
+  const result = execute2(input, options);
   if (isAsyncIterable(result)) {
     let lastOutput;
     for await (const output of result) {
@@ -3563,6 +3564,30 @@ var init_pythonRuntime = __esm({
     exec = promisify(execFile);
   }
 });
+
+// src/evals/cowork/driver.ts
+var COMPUTER_USE_TOKEN_FIELDS, CoworkDriverError, CoworkHitlBudgetError;
+var init_driver = __esm({
+  "src/evals/cowork/driver.ts"() {
+    init_esm_shims();
+    COMPUTER_USE_TOKEN_FIELDS = [
+      "input_tokens",
+      "output_tokens",
+      "cache_creation_input_tokens",
+      "cache_read_input_tokens"
+    ];
+    CoworkDriverError = class extends Error {
+      constructor(message, telemetry2) {
+        super(message);
+        this.telemetry = telemetry2;
+      }
+      kind = "failed";
+    };
+    CoworkHitlBudgetError = class extends CoworkDriverError {
+      kind = "hitl-budget-exhausted";
+    };
+  }
+});
 function resolveDriverPath(env) {
   const configuredRoot = env.MST_COWORK_DRIVER_ROOT;
   if (configuredRoot) {
@@ -3616,7 +3641,7 @@ async function runComputerUseDriver(query2, options, mode, label) {
     const childError = error;
     stdout = String(childError.stdout ?? "");
     const reported = parseLastJsonLine(stdout);
-    const telemetry2 = parseTelemetry(reported?.telemetry, env, "partial");
+    const telemetry3 = parseTelemetry(reported?.telemetry, env, "partial");
     const details = error.killed === true ? "driver terminated before completion; not retrying" : "driver exited unsuccessfully; not retrying";
     if (mode === "hitl" && reported?.status === "failed" && typeof reported.error === "string" && /^Computer Use HITL check exceeded \d+ actions after attempting a visible prompt$/.test(
       reported.error
@@ -3626,13 +3651,13 @@ async function runComputerUseDriver(query2, options, mode, label) {
       );
       throw new ComputerUseHitlBudgetError(
         `HITL inspection reached its ${maxActions}-action budget.`,
-        telemetry2
+        telemetry3
       );
     }
     diagnostic(`Computer Use ${label} failed: ${details}`);
     throw new ComputerUseDriverError(
       `Computer Use ${label} failed: ${details}`,
-      telemetry2
+      telemetry3
     );
   }
   diagnostic(
@@ -3652,11 +3677,11 @@ async function runComputerUseDriver(query2, options, mode, label) {
       parseTelemetry(record.telemetry, env, "partial")
     );
   }
-  const telemetry = parseTelemetry(record.telemetry, env, "complete");
+  const telemetry2 = parseTelemetry(record.telemetry, env, "complete");
   const common = {
     action_count: record.action_count,
     model: record.model,
-    ...telemetry ? { telemetry } : {}
+    ...telemetry2 ? { telemetry: telemetry2 } : {}
   };
   diagnostic(
     `Computer Use ${label} completed (actions=${common.action_count})`
@@ -3666,7 +3691,7 @@ async function runComputerUseDriver(query2, options, mode, label) {
   if (submission?.action !== "key" || submission.text !== "enter") {
     throw new ComputerUseDriverError(
       "Computer Use submission returned an invalid submission boundary.",
-      telemetry ? { ...telemetry, accounting: "partial" } : void 0
+      telemetry2 ? { ...telemetry2, accounting: "partial" } : void 0
     );
   }
   return {
@@ -3726,7 +3751,7 @@ function parseTelemetry(value, env, accounting) {
   if (!usage || !coverage) return void 0;
   const safeUsage = {};
   const safeCoverage = {};
-  for (const field of TOKEN_FIELDS) {
+  for (const field of COMPUTER_USE_TOKEN_FIELDS) {
     const count = coverage[field];
     if (!isCount(count) || count > record.planner_response_count)
       return void 0;
@@ -3756,26 +3781,22 @@ function parseTelemetry(value, env, accounting) {
     cost: { status: "unavailable" }
   };
 }
-var execFileAsync, TOKEN_FIELDS, ComputerUseDriverError, ComputerUseHitlBudgetError;
+var execFileAsync, ComputerUseDriverError, ComputerUseHitlBudgetError;
 var init_anthropicComputerUse = __esm({
   "src/evals/cowork/anthropicComputerUse.ts"() {
     init_esm_shims();
     init_pythonRuntime();
+    init_driver();
     execFileAsync = promisify(execFile);
-    TOKEN_FIELDS = [
-      "input_tokens",
-      "output_tokens",
-      "cache_creation_input_tokens",
-      "cache_read_input_tokens"
-    ];
-    ComputerUseDriverError = class extends Error {
-      constructor(message, telemetry) {
-        super(message);
-        this.telemetry = telemetry;
+    ComputerUseDriverError = class extends CoworkDriverError {
+      constructor(message, telemetry2) {
+        super(message, telemetry2);
+        this.telemetry = telemetry2;
       }
     };
     ComputerUseHitlBudgetError = class extends ComputerUseDriverError {
       name = "ComputerUseHitlBudgetError";
+      kind = "hitl-budget-exhausted";
     };
   }
 });
@@ -5011,7 +5032,7 @@ async function prepareMacCoworkSession(options) {
     const { running: wasRunning } = await controller.state();
     await mkdir(lease, { mode: 448 });
     const receiptPath = join(lease, "session.json");
-    const receipt = Buffer.from(
+    const receipt2 = Buffer.from(
       JSON.stringify({
         version: 1,
         nonce: randomUUID(),
@@ -5024,7 +5045,7 @@ async function prepareMacCoworkSession(options) {
     let leaseInfo;
     try {
       leaseInfo = await lstat(lease);
-      await writeFile(receiptPath, receipt, { mode: 384, flag: "wx" });
+      await writeFile(receiptPath, receipt2, { mode: 384, flag: "wx" });
     } catch {
       try {
         await rmdir(lease);
@@ -5036,7 +5057,7 @@ async function prepareMacCoworkSession(options) {
     let installAttempted = false;
     const ownsLease = async () => {
       const current = await lstat(lease);
-      if (!current.isDirectory() || current.isSymbolicLink() || current.dev !== leaseInfo.dev || current.ino !== leaseInfo.ino || current.uid !== process.getuid?.() || (current.mode & 63) !== 0 || !(await privateBytes(receiptPath)).equals(receipt))
+      if (!current.isDirectory() || current.isSymbolicLink() || current.dev !== leaseInfo.dev || current.ino !== leaseInfo.ino || current.uid !== process.getuid?.() || (current.mode & 63) !== 0 || !(await privateBytes(receiptPath)).equals(receipt2))
         throw new Error(ERROR3);
       const names = await readdir(lease);
       if (names.length !== 1 || names[0] !== "session.json")
@@ -5088,7 +5109,7 @@ async function prepareMacCoworkSession(options) {
         } catch {
           const after = await lstat(lease);
           if (after.isDirectory() && after.dev === leaseInfo.dev && after.ino === leaseInfo.ino)
-            await writeFile(receiptPath, receipt, { mode: 384, flag: "wx" });
+            await writeFile(receiptPath, receipt2, { mode: 384, flag: "wx" });
           throw new Error(ERROR3);
         }
       } catch {
@@ -5193,16 +5214,16 @@ async function recoverMacCoworkSession() {
   if (!leaseInfo.isDirectory() || leaseInfo.isSymbolicLink() || leaseInfo.uid !== process.getuid?.() || leaseInfo.mode & 63)
     throw new Error("Recovery lease is not a private owned directory.");
   const bytes = await privateFile(receiptPath);
-  const receipt = Receipt.parse(JSON.parse(bytes.toString("utf8")));
-  if (receipt.profileDirectory !== profile)
+  const receipt2 = Receipt.parse(JSON.parse(bytes.toString("utf8")));
+  if (receipt2.profileDirectory !== profile)
     throw new Error("Recovery profile mismatch.");
-  assertStoppedOwner(receipt.pid);
+  assertStoppedOwner(receipt2.pid);
   await mkdir(gate, { mode: 448 });
   const verifyLease = async () => {
     const current = await lstat(lease);
     if (current.dev !== leaseInfo.dev || current.ino !== leaseInfo.ino || !(await privateFile(receiptPath)).equals(bytes) || (await readdir(lease)).join() !== "session.json")
       throw new Error("Recovery lease changed; refusing cleanup.");
-    assertStoppedOwner(receipt.pid);
+    assertStoppedOwner(receipt2.pid);
   };
   try {
     await verifyLease();
@@ -5211,9 +5232,9 @@ async function recoverMacCoworkSession() {
       const journal = JSON.parse(
         (await privateFile(join(transaction, "journal.json"))).toString("utf8")
       );
-      if (journal.directory !== receipt.stagingDirectory)
+      if (journal.directory !== receipt2.stagingDirectory)
         throw new Error("Recovery staging mismatch.");
-    } else if (await exists3(receipt.stagingDirectory))
+    } else if (await exists3(receipt2.stagingDirectory))
       throw new Error(
         "Staging exists without its transaction; recovery refused."
       );
@@ -5223,10 +5244,10 @@ async function recoverMacCoworkSession() {
       throw new Error("Claude did not stop; recovery refused.");
     await verifyLease();
     if (hasTransaction) await restoreMacCoworkSettings(profile);
-    if (await exists3(transaction) || await exists3(receipt.stagingDirectory))
+    if (await exists3(transaction) || await exists3(receipt2.stagingDirectory))
       throw new Error("Recovery state remains; lease retained.");
-    if (receipt.wasRunning) await controller.start();
-    if ((await controller.state()).running !== receipt.wasRunning)
+    if (receipt2.wasRunning) await controller.start();
+    if ((await controller.state()).running !== receipt2.wasRunning)
       throw new Error(
         "Could not restore prior Claude running state; lease retained."
       );
@@ -5294,6 +5315,240 @@ var init_macos = __esm({
   }
 });
 
+// src/evals/cowork/linux.ts
+var linux_exports = {};
+__export(linux_exports, {
+  linuxCoworkPlatform: () => linuxCoworkPlatform
+});
+async function readSettings(file) {
+  const handle = await open$1(
+    file,
+    constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK
+  );
+  try {
+    const metadata2 = await handle.stat();
+    if (!metadata2.isFile() || metadata2.size > 1024 * 1024)
+      throw new Error("Invalid prepared settings file.");
+    return JSON.parse(await handle.readFile("utf8"));
+  } finally {
+    await handle.close();
+  }
+}
+function telemetry(started, actions, accounting) {
+  return {
+    driver: "linux-desktop",
+    accounting,
+    duration_ms: Math.max(0, Date.now() - started),
+    action_count: actions,
+    planner: { status: "not-applicable" },
+    cost: { status: "not-applicable" }
+  };
+}
+function receipt(stdout) {
+  try {
+    const parsed = JSON.parse(stdout);
+    if (!parsed || typeof parsed !== "object") return void 0;
+    const r = parsed;
+    if (!["ready", "submitted", "hitl_checked", "failed"].includes(
+      String(r.status)
+    ) || typeof r.action_count !== "number" || !Number.isSafeInteger(r.action_count) || r.action_count < 0 || typeof r.duration_ms !== "number" || !Number.isFinite(r.duration_ms) || r.duration_ms < 0)
+      return void 0;
+    return {
+      status: r.status,
+      action_count: r.action_count,
+      duration_ms: r.duration_ms,
+      errorCode: typeof r.error === "string" && /^[a-z_]{1,64}$/.test(r.error) ? r.error : void 0
+    };
+  } catch {
+    return void 0;
+  }
+}
+async function execute(mode, payload, options) {
+  const started = Date.now();
+  const remaining = options.deadlineAt - started;
+  if (remaining <= 0)
+    throw new CoworkDriverError(
+      "Linux desktop deadline exceeded; no action attempted."
+    );
+  const env = { ...process.env, ...options.env };
+  if (!env.DISPLAY || !env.DBUS_SESSION_BUS_ADDRESS)
+    throw new CoworkDriverError(
+      "Linux Cowork requires a prepared DISPLAY and D-Bus desktop session."
+    );
+  if (env.MST_COWORK_URL_OPENER !== void 0 && !isAbsolute(env.MST_COWORK_URL_OPENER))
+    throw new CoworkDriverError(
+      "MST_COWORK_URL_OPENER must be an absolute executable path."
+    );
+  const script = createRequire(
+    typeof __filename$1 === "string" ? __filename$1 : import.meta.url
+  ).resolve("@gleanwork/mcp-server-tester/cowork-linux-runtime");
+  const timeout = Math.min(remaining, mode === "submit" ? 6e4 : 1e4);
+  const driverTimeout = Math.max(
+    1,
+    Math.floor(timeout - Math.min(1e3, timeout / 10))
+  );
+  const result = await new Promise(
+    (resolve10) => {
+      const child = execFile(
+        env.MST_COWORK_PYTHON ?? "python3",
+        [
+          script,
+          "--mode",
+          mode,
+          "--timeout-ms",
+          String(driverTimeout),
+          "--max-actions",
+          String(options.maxActions ?? 24)
+        ],
+        {
+          timeout,
+          killSignal: "SIGKILL",
+          maxBuffer: 64 * 1024,
+          env: {
+            ...Object.fromEntries(
+              SESSION_ENV.flatMap((k) => env[k] ? [[k, env[k]]] : [])
+            ),
+            NO_AT_BRIDGE: "0"
+          }
+        },
+        (error, stdout) => resolve10({ failed: error !== null, stdout: String(stdout) })
+      );
+      child.stdin?.on("error", () => {
+      });
+      child.stdin?.end(JSON.stringify(payload));
+    }
+  );
+  const record = receipt(result.stdout);
+  const expected = mode === "probe" ? "ready" : mode === "submit" ? "submitted" : "hitl_checked";
+  if (result.failed || record?.status !== expected || record.action_count > (options.maxActions ?? 24))
+    throw new CoworkDriverError(
+      `Linux desktop ${mode} failed or its receipt was uncertain (${record?.errorCode ?? "missing_or_invalid_receipt"}); no retry attempted.`,
+      record ? telemetry(started, record.action_count, "partial") : void 0
+    );
+  return record;
+}
+var SESSION_ENV, linuxCoworkPlatform;
+var init_linux = __esm({
+  "src/evals/cowork/linux.ts"() {
+    init_esm_shims();
+    init_driver();
+    SESSION_ENV = [
+      "PATH",
+      "HOME",
+      "DISPLAY",
+      "XAUTHORITY",
+      "DBUS_SESSION_BUS_ADDRESS",
+      "AT_SPI_BUS_ADDRESS",
+      "XDG_RUNTIME_DIR",
+      "XDG_CONFIG_HOME",
+      "MST_COWORK_URL_OPENER",
+      "LANG",
+      "LC_ALL"
+    ];
+    linuxCoworkPlatform = {
+      dataDirectory: (options) => options.dataDir ?? join(
+        process.env.XDG_CONFIG_HOME ?? join(homedir(), ".config"),
+        "Claude-3p",
+        "local-agent-mode-sessions"
+      ),
+      async prepare({ manifest, env, model }) {
+        const settingsFile = env.MST_COWORK_SETTINGS_FILE ?? "/etc/claude-desktop/managed-settings.json";
+        if (!isAbsolute(settingsFile))
+          throw new Error("Linux Cowork settings path must be absolute.");
+        try {
+          const settings = await readSettings(settingsFile);
+          const models = settings.inferenceModels;
+          if (model && !models?.some((m) => m.name === model))
+            throw new Error("model");
+          const expected = manifest.servers ?? [];
+          const actual = settings.managedMcpServers;
+          if (!Array.isArray(actual) || actual.length !== expected.length || settings.allowManagedMcpServersOnly !== true)
+            throw new Error("servers");
+          for (const [index, server] of expected.entries()) {
+            if (server.transport !== "http") throw new Error("transport");
+            const observed = actual.find(
+              (s) => s.name === (server.label ?? `server-${index + 1}`)
+            );
+            if (!observed || observed.transport !== "http" || observed.url !== server.serverUrl)
+              throw new Error("server");
+            if (observed.toolPolicy?.["*"] === "allow" && manifest.coworkSetup?.approveWriteTools !== true)
+              throw new Error("policy");
+          }
+        } catch {
+          throw new Error(
+            "Prepared Linux desktop settings do not match the eval model, MCP servers, or approval policy."
+          );
+        }
+        await execute(
+          "probe",
+          {},
+          { deadlineAt: Date.now() + 15e3, maxActions: 1, env }
+        );
+        return {
+          async dispose() {
+          }
+        };
+      },
+      async recover() {
+        throw new Error(
+          "Linux desktop recovery belongs to the runtime owner, not the MST driver."
+        );
+      },
+      async submit(query2, options) {
+        const started = Date.now();
+        const result = await execute("submit", { prompt: query2 }, options);
+        return {
+          status: "submitted",
+          action_count: result.action_count,
+          telemetry: telemetry(started, result.action_count, "complete")
+        };
+      },
+      async handleHitl(options) {
+        if (!options.isComplete)
+          throw new Error("Linux HITL requires a bound native completion check.");
+        const started = Date.now();
+        let actions = 0;
+        const budget = options.maxActions ?? 12;
+        try {
+          while (Date.now() < options.deadlineAt) {
+            if (await options.isComplete())
+              return {
+                status: "hitl_checked",
+                action_count: actions,
+                telemetry: telemetry(started, actions, "complete")
+              };
+            if (actions >= budget)
+              throw new CoworkHitlBudgetError(
+                "Linux HITL action budget exhausted.",
+                telemetry(started, actions, "partial")
+              );
+            const result = await execute(
+              "hitl",
+              { approveWriteTools: options.approveWriteTools === true },
+              { ...options, maxActions: budget - actions }
+            );
+            actions += result.action_count;
+            await setTimeout$1(
+              Math.min(500, Math.max(0, options.deadlineAt - Date.now()))
+            );
+          }
+        } catch (error) {
+          if (error instanceof CoworkHitlBudgetError) throw error;
+          const partialActions = error instanceof CoworkDriverError ? error.telemetry?.action_count ?? 0 : 0;
+          throw new CoworkDriverError(
+            "Linux HITL failed for the bound native session.",
+            telemetry(started, actions + partialActions, "partial")
+          );
+        }
+        throw new CoworkDriverError(
+          "Linux HITL deadline exceeded.",
+          telemetry(started, actions, "partial")
+        );
+      }
+    };
+  }
+});
+
 // src/cli/index.ts
 init_esm_shims();
 
@@ -5375,7 +5630,7 @@ init_esm_shims();
 
 // package.json
 var package_default = {
-  version: "2.0.0-beta.2"};
+  version: "2.0.0-beta.3"};
 
 // src/cli/templates/index.ts
 function getPlaywrightConfigTemplate(answers) {
@@ -7116,8 +7371,8 @@ ${errorText}`
       return;
     }
     try {
-      const open5 = await import('open');
-      await open5.default(url.toString());
+      const open6 = await import('open');
+      await open6.default(url.toString());
       debug2("Opened browser for authentication");
     } catch (error) {
       debug2("Failed to open browser:", error);
@@ -10565,11 +10820,13 @@ init_esm_shims();
 
 // src/evals/cowork/platform.ts
 init_esm_shims();
-async function getCoworkPlatform() {
-  if (process.platform === "darwin")
+async function getCoworkPlatform(provider) {
+  if (process.platform === "darwin" && provider === "anthropic-computer-use")
     return (await Promise.resolve().then(() => (init_macos(), macos_exports))).macCoworkPlatform;
+  if (process.platform === "linux" && provider === "linux-desktop")
+    return (await Promise.resolve().then(() => (init_linux(), linux_exports))).linuxCoworkPlatform;
   throw new Error(
-    `Cowork has no qualified ${process.platform} desktop adapter. The shared runner is portable; native execution is currently macOS-only.`
+    `Cowork driver ${provider} is not supported on ${process.platform}.`
   );
 }
 
@@ -11155,7 +11412,7 @@ async function waitForClaudeMatch(options, requireCompletion) {
       }
       lastPending = trace;
     }
-    await delay2(POLL_INTERVAL_MS);
+    await delay3(POLL_INTERVAL_MS);
   }
   if (lastPending) {
     throw new Error(
@@ -11318,7 +11575,7 @@ async function waitForAccessibilityTrace(options) {
     if (fallback) {
       return fallback;
     }
-    await delay2(POLL_INTERVAL_MS);
+    await delay3(POLL_INTERVAL_MS);
   }
   throw new Error(
     `Timed out waiting for Claude Chat Desktop visible response for marker ${options.context.marker}`
@@ -11407,6 +11664,7 @@ async function parseClaudeTrace(candidate, marker16) {
     auditParsed,
     transcriptParsed,
     usageAvailable: usage !== void 0,
+    knownUsageFields: knownUsageFields(resultEvents),
     costAvailable: resultEvents.some(
       (event) => typeof event.total_cost_usd === "number"
     ),
@@ -11918,6 +12176,35 @@ function extractAggregatedUsage(events) {
     cacheCreationInputTokens: (total.cacheCreationInputTokens ?? 0) + (value.cacheCreationInputTokens ?? 0)
   }));
 }
+function knownUsageFields(events) {
+  const fields = [
+    [
+      "inputTokens",
+      (event) => event.usage?.input_tokens ?? event.usage?.inputTokens
+    ],
+    [
+      "outputTokens",
+      (event) => event.usage?.output_tokens ?? event.usage?.outputTokens
+    ],
+    [
+      "cacheReadInputTokens",
+      (event) => event.usage?.cache_read_input_tokens ?? event.usage?.cacheReadInputTokens
+    ],
+    [
+      "cacheCreationInputTokens",
+      (event) => event.usage?.cache_creation_input_tokens ?? event.usage?.cacheCreationInputTokens
+    ],
+    ["totalCostUsd", (event) => event.total_cost_usd],
+    ["durationMs", (event) => event.duration_ms],
+    ["durationApiMs", (event) => event.duration_api_ms]
+  ];
+  return fields.filter(
+    ([key, value]) => events.length > 0 && events.every((event) => {
+      const number = value(event);
+      return typeof number === "number" && Number.isFinite(number) && number >= 0 && (key === "totalCostUsd" || Number.isSafeInteger(number));
+    })
+  ).map(([key]) => key);
+}
 function extractUsage(event) {
   const usage = event.usage;
   const inputTokens = getNumber(usage, "input_tokens") ?? getNumber(usage, "inputTokens");
@@ -12014,19 +12301,28 @@ function classifyTraceFailure(message) {
 function formatError2(err) {
   return err instanceof Error ? err.message : String(err);
 }
-function delay2(ms) {
+function delay3(ms) {
   return new Promise((resolve10) => setTimeout(resolve10, ms));
 }
 
 // src/evals/coworkHost.ts
-init_anthropicComputerUse();
+init_driver();
 var OptionsSchema = z.object({
-  computerUseProvider: z.literal("anthropic-computer-use").default("anthropic-computer-use"),
+  computerUseProvider: z.enum(["anthropic-computer-use", "linux-desktop"]).default(
+    () => process.platform === "linux" ? "linux-desktop" : "anthropic-computer-use"
+  ),
   computerUseMaxActions: z.number().int().min(1).max(64).default(24),
   hitlMaxActions: z.number().int().min(1).max(24).default(12),
   computerUseModel: z.string().regex(/^[A-Za-z0-9._:-]+$/).optional(),
   dataDir: z.string().min(1).optional()
-}).strict();
+}).strict().superRefine((options, context) => {
+  if (options.computerUseProvider === "linux-desktop" && options.computerUseModel !== void 0)
+    context.addIssue({
+      code: "custom",
+      path: ["computerUseModel"],
+      message: "linux-desktop does not use a planner model."
+    });
+});
 var CoworkSchema = z.object({
   type: z.string(),
   options: OptionsSchema.default(() => OptionsSchema.parse({})),
@@ -12052,9 +12348,9 @@ async function runBatch(requests, context, selectedPlatform) {
     );
   const config = configs[0];
   const env = { ...process.env, ...context.env, ...config.env };
-  if (!env.ANTHROPIC_API_KEY)
+  if (config.options.computerUseProvider === "anthropic-computer-use" && !env.ANTHROPIC_API_KEY)
     throw new Error("ANTHROPIC_API_KEY is required for Cowork Computer Use.");
-  const platform = await getCoworkPlatform();
+  const platform = await getCoworkPlatform(config.options.computerUseProvider);
   const dataDir = platform.dataDirectory(config.options);
   const servers = requests[0].input.servers;
   const { arms: _arms, ...manifest } = context.manifest;
@@ -12085,7 +12381,7 @@ async function runBatch(requests, context, selectedPlatform) {
   active = true;
   try {
     if (env.MST_COWORK_RECOVER === "1") await platform.recover();
-    if (servers.length || config.model)
+    if (config.options.computerUseProvider === "linux-desktop" || servers.length || config.model)
       session = await platform.prepare({
         manifest: managedManifest,
         env,
@@ -12145,7 +12441,7 @@ async function runBatch(requests, context, selectedPlatform) {
         if (computerUse.submission.status !== "completed") {
           computerUse.submission = {
             status: "failed",
-            ...error instanceof ComputerUseDriverError && error.telemetry ? { telemetry: error.telemetry } : {}
+            ...error instanceof CoworkDriverError && error.telemetry ? { telemetry: error.telemetry } : {}
           };
         }
         results[index] = failure(safeError(error));
@@ -12184,6 +12480,18 @@ async function runBatch(requests, context, selectedPlatform) {
             maxActions: config.options.hitlMaxActions,
             model: config.options.computerUseModel,
             env,
+            approveWriteTools: context.manifest.coworkSetup?.approveWriteTools === true,
+            isComplete: async () => {
+              const current = await findMatchingClaudeSessions({
+                ...match,
+                sessionPath
+              });
+              if (current.length !== 1)
+                throw new Error(
+                  "Bound native session is missing or ambiguous."
+                );
+              return current[0].isComplete;
+            },
             task: `Handle only the currently open Cowork task just submitted with this exact query: ${request.input.scenario}. Do not switch tasks. Never create, type, or resubmit a task. If the current task cannot be identified uniquely, stop without an action.`
           });
           computerUse.hitl = {
@@ -12193,11 +12501,11 @@ async function runBatch(requests, context, selectedPlatform) {
         }
       } catch (error) {
         computerUse.hitl = {
-          status: error instanceof ComputerUseHitlBudgetError ? "budget-exhausted" : "failed",
-          ...error instanceof ComputerUseDriverError && error.telemetry ? { telemetry: error.telemetry } : {}
+          status: error instanceof CoworkDriverError && error.kind === "hitl-budget-exhausted" ? "budget-exhausted" : "failed",
+          ...error instanceof CoworkDriverError && error.telemetry ? { telemetry: error.telemetry } : {}
         };
         const message = safeError(error);
-        if (error instanceof ComputerUseHitlBudgetError) {
+        if (error instanceof CoworkDriverError && error.kind === "hitl-budget-exhausted") {
           hitlWarning = message;
         } else {
           hitlError = message;
@@ -12350,7 +12658,7 @@ async function runBuiltinHost(input, host, context, factory) {
     }
     controller.signal.throwIfAborted();
   }
-  async function execute() {
+  async function execute2() {
     try {
       checkDeadline();
       if (config.hostType !== "cli") {
@@ -12428,9 +12736,9 @@ async function runBuiltinHost(input, host, context, factory) {
     if (config.hostType === "cli" && config.cli?.claudeMcpServers !== void 0) {
       void expired.catch(() => {
       });
-      return await execute();
+      return await execute2();
     }
-    const result = await Promise.race([execute(), expired]);
+    const result = await Promise.race([execute2(), expired]);
     checkDeadline();
     return result;
   } catch (error) {
@@ -16325,7 +16633,7 @@ async function runEvalSuite(options) {
   for (const arm of armResults) {
     totalHostUsage = sumUsage(totalHostUsage, arm.result?.totalHostUsage);
   }
-  const telemetry = {
+  const telemetry2 = {
     cases: allResults.length,
     toolCalls: countToolCalls(allResults),
     failedCases: allResults.filter((result) => !result.pass).length,
@@ -16345,7 +16653,7 @@ async function runEvalSuite(options) {
       passRate: allResults.length > 0 ? allResults.filter((result) => result.pass).length / allResults.length : 0,
       ...computedMetrics
     },
-    telemetry,
+    telemetry: telemetry2,
     armDeltas: buildArmDeltas(armResults),
     results: allResults
   };