@loadmill/droid-cua 2.33.0 → 2.35.0

package/README.md

@@ -79,6 +79,7 @@ Desktop app support:
 
 **All platforms:**
 - Loadmill sign-in for the Loadmill models, or an OpenAI API key for the OpenAI models
+- Node.js 20 or newer for CLI use
 
 **Android:**
 - Android Debug Bridge (ADB)
@@ -180,6 +181,15 @@ droid-cua --avd adb:emulator-5554 --instructions tests
 # Headless iOS simulator run
 droid-cua --platform ios --avd "iPhone 16" --instructions tests/login.dcua
 
+# List running desktop applications and their window IDs (macOS or Windows)
+droid-cua --target desktop --list-desktop-apps
+
+# Control one already-running desktop application window
+droid-cua --target desktop --desktop-app com.apple.TextEdit --desktop-window 123 --instructions tests/editor.dcua
+
+# Explicitly use cursor-free accessibility input instead of the default physical input
+droid-cua --target desktop --desktop-app com.apple.TextEdit --desktop-input accessibility --instructions tests/editor.dcua
+
 # Headless run with prompt-parity config
 droid-cua --avd adb:emulator-5554 --instructions tests/login.dcua --config ci/droid-cua.json
 
@@ -246,6 +256,11 @@ Supported CLI options include:
 - `--app`
 - `--list-devices`
 - `--browser`
+- `--target` (`mobile`, `web`, or `desktop`)
+- `--desktop-app` (desktop application ID or exact name)
+- `--desktop-window` (required when the application has multiple visible windows)
+- `--desktop-input` (`physical` by default; use `accessibility` for cursor-free input)
+- `--list-desktop-apps`
 - `--instructions`
 - `--config`
 - `--cua-model`
@@ -268,6 +283,8 @@ Supported CLI options include:
 `gpt-5.6-terra`, `gpt-5.6-luna`, and `gpt-5.4`. OpenAI models use direct OpenAI
 mode and require `OPENAI_API_KEY`.
 
+Desktop control supports macOS and Windows. In the desktop app, enable **Experimental desktop control** at the bottom of Settings to show Desktop in the platform picker. Desktop runs use visual input by default: they capture the selected window and send physical pointer and keyboard input at the model's coordinates. Use `--desktop-input accessibility` for cursor-free CLI input instead. macOS requires Screen & System Audio Recording and Accessibility permissions for Droid or the terminal running the CLI. Windows targets must run at the same integrity level as Droid; a non-elevated Droid process cannot inject input into an elevated application.
+
 Config and precedence rules:
 - Use `--config <file>` to supply prompt-affecting settings for headless runs.
 - CLI flags override config file values.
@@ -293,7 +310,7 @@ HTML report (`--report`):
 - Writes a self-contained HTML report of the run — the same Run Details view the desktop app shows, with screenshots inlined — that you can share and open in any browser.
 - With no value it saves `<test>--<date>--<time>.html` (e.g. `login--2026-06-03--16-09-20.html`) in the current directory; pass `--report <file>` to pick a filename or `--report <dir>` to pick a folder.
 - In the desktop app the same report is available from a run's **Share → Download HTML report** button.
-- Runs with captured screenshots also expose **Share → Generate video**. The desktop app renders a square mobile replay or 16:9 browser replay locally, then prompts for a save location using `<test>--<date>--<time>--test-replay.mp4` as the suggested filename. While rendering, a compact **Background tasks** card shows progress for **Generating test replay**; it can be minimized to a task-count card or canceled without opening the save dialog.
+- Runs with captured screenshots also expose **Share → Generate video**. The desktop app renders a square mobile replay or 16:9 web and desktop replay locally, then prompts for a save location using `<test>--<date>--<time>--test-replay.mp4` as the suggested filename. While rendering, a compact **Background tasks** card shows progress for **Generating test replay**; it can be minimized to a task-count card or canceled without opening the save dialog.
 - Authenticated headless runs upload their HTML report and screenshots to Loadmill by default. The Loadmill run record also includes the resolved Droid version, model, provider, Agent Pace, Aim Assist, Context Optimization, and target environment. Use `--no-cloud-report` to disable artifact upload; the Droid run record is still reported.
 
 ```sh

package/THIRD_PARTY_NOTICES.md

@@ -0,0 +1,5 @@
+# Third-Party Notices
+
+Desktop control uses `@zavora-ai/computer-use-mcp` version 7.1.0.
+
+Copyright (c) Zavora AI contributors. Licensed under the MIT License. The dependency's complete license text is distributed with its npm package.

package/build/index.js

@@ -43,6 +43,7 @@ import { resolveRunPool } from "./src/device/cloud/loadmill-cloud/run-pool.js";
 import { ARTIFACT_READY_STATUSES } from "./src/device/cloud/loadmill-cloud/run-status.js";
 import { formatDuration } from "./src/core/report/run-log-model.js";
 import { createBrowserSessionTeardown, withLoadmillCloudSession } from "./src/cli/loadmill-cloud-session.js";
+import { createDesktopController, listDesktopApplications } from "./src/desktop/computer-use.js";
 dotenv.config();
 process.once("SIGTERM", async () => {
     process.exitCode = 143;
@@ -310,8 +311,20 @@ async function main() {
         console.log(`Run with: --device-name "<name>" --os-version "<osVersion>"`);
         process.exit(0);
     }
+    if (targetConfig.listDesktopApps) {
+        const applications = await listDesktopApplications({ excludePids: [process.pid] });
+        for (const application of applications) {
+            console.log(`${application.displayName} — ${application.bundleId} (pid ${application.pid})`);
+            for (const window of application.windows) {
+                console.log(`  ${window.windowId}: ${window.title || "Untitled"}`);
+            }
+        }
+        console.log(`\n${applications.length} desktop applications with visible windows.`);
+        process.exit(0);
+    }
     const isHeadlessInstructionsRun = Boolean(instructionsFile);
     const isBrowserTarget = targetConfig.target === "web";
+    const isDesktopTarget = targetConfig.target === "desktop";
     const isLambdaTestTarget = targetConfig.deviceSource === "lambdatest";
     const isAwsDeviceFarmTarget = targetConfig.deviceSource === "aws-device-farm";
     const isLoadmillCloudTarget = targetConfig.deviceSource === "loadmill-cloud";
@@ -326,6 +339,7 @@ async function main() {
     let loadmillCloudBrowserSessionConnected = false;
     let loadmillCloudBrowserTeardown = null;
     let loadmillCloudStatusLine = null;
+    let desktopController = null;
     const headlessDebug = createHeadlessDebugArtifacts({
         cwd: process.cwd(),
         enabled: isHeadlessInstructionsRun && debugMode
@@ -338,6 +352,9 @@ async function main() {
     if (isBrowserTarget && !isHeadlessInstructionsRun) {
         throw new Error("--target web is only supported with --instructions headless execution.");
     }
+    if (isDesktopTarget && !isHeadlessInstructionsRun) {
+        throw new Error("--target desktop is only supported with --instructions headless execution.");
+    }
     if (isCloudTarget && !isHeadlessInstructionsRun) {
         throw new Error(`--device-source ${targetConfig.deviceSource} is only supported with --instructions headless execution.`);
     }
@@ -398,7 +415,7 @@ async function main() {
         }
     }
     // If no device specified, show interactive selection menu
-    if (!isBrowserTarget && !isCloudTarget && !avdName && !platform) {
+    if (!isBrowserTarget && !isDesktopTarget && !isCloudTarget && !avdName && !platform) {
         const selection = await selectDevice();
         platform = selection.platform;
         avdName = selection.deviceName;
@@ -506,6 +523,24 @@ async function main() {
             console.log(`Starting URL: ${deviceInfo.currentUrl}`);
         }
     }
+    else if (isDesktopTarget) {
+        desktopController = await createDesktopController({
+            app: targetConfig.desktopApp,
+            windowId: targetConfig.desktopWindow,
+            inputMode: targetConfig.desktopInput,
+            excludePids: [process.pid],
+        });
+        targetId = desktopController.deviceId;
+        deviceInfo = desktopController.deviceInfo;
+        console.log(`Attached to desktop window: ${deviceInfo.device_name}`);
+        console.log(`Model sees window: ${deviceInfo.scaled_width}x${deviceInfo.scaled_height}`);
+        console.log(`Desktop input: ${deviceInfo.desktopInputMode === "physical" ? "physical OS pointer" : "cursor-free accessibility"}`);
+        process.once("SIGINT", async () => {
+            console.log("\nStopping desktop run...");
+            await desktopController?.close().catch(() => { });
+            process.exit(130);
+        });
+    }
     else if (isLambdaTestTarget) {
         lambdaTestCredentials = resolveLambdaTestCredentials(process.env);
         const lambdaTestBuildName = createLambdaTestCliBuildName();
@@ -787,8 +822,10 @@ async function main() {
                 recordScreenshots,
                 screenshotDir,
                 isBrowserTarget,
+                isDesktopTarget,
+                desktopController,
                 isCloudTarget,
-                runTarget: { isBrowserTarget, isCloudTarget },
+                runTarget: { isBrowserTarget, isDesktopTarget, isCloudTarget },
                 report: reportConfig
             });
             exitCode = result.exitCode;
@@ -845,6 +882,10 @@ async function main() {
                     console.log(`Done in ${formatDuration(Date.now() - processStartTime)}.`);
                 }
             }
+            if (desktopController) {
+                await desktopController.close();
+                desktopController = null;
+            }
         }
         if (exitCode !== null) {
             process.exit(exitCode);

package/build/src/cli/headless-runner.js

@@ -83,9 +83,10 @@ function emitCliAppContextDebug(runId, appContext, appContextText) {
         });
     }
 }
-export function buildHeadlessEngineOptions({ runtimeContext, headlessConfig, executionPrompt, screenshotRecorder, recordScreenshots, screenshotDir, isBrowserTarget, isCloudTarget, runTarget = null, onCuaResponse = null, secrets = null }) {
-    const resolvedRunTarget = runTarget ?? { isBrowserTarget, isCloudTarget };
+export function buildHeadlessEngineOptions({ runtimeContext, headlessConfig, executionPrompt, screenshotRecorder, recordScreenshots, screenshotDir, isBrowserTarget, isDesktopTarget, desktopController, isCloudTarget, runTarget = null, onCuaResponse = null, secrets = null }) {
+    const resolvedRunTarget = runTarget ?? { isBrowserTarget, isDesktopTarget, isCloudTarget };
     const isBrowserRunTarget = Boolean(resolvedRunTarget.isBrowserTarget);
+    const isDesktopRunTarget = Boolean(resolvedRunTarget.isDesktopTarget);
     const isCloudRunTarget = Boolean(resolvedRunTarget.isCloudTarget);
     const sendCUARequest = async (requestArgs) => {
         const response = await runtimeContext.openAi.sendCUARequest({
@@ -101,7 +102,7 @@ export function buildHeadlessEngineOptions({ runtimeContext, headlessConfig, exe
         toolCapabilities: {
             assert: true,
             navigate: isBrowserRunTarget,
-            closeKeyboard: !isBrowserRunTarget,
+            closeKeyboard: !isBrowserRunTarget && !isDesktopRunTarget,
             loadmill: true,
         },
         secretsByKey: secrets?.secretsByKey || {},
@@ -130,6 +131,11 @@ export function buildHeadlessEngineOptions({ runtimeContext, headlessConfig, exe
         engineOptions.handleModelAction = (browserSessionId, action, scale, actionContext) => handleBrowserModelAction(browserSessionId, action, scale, actionContext);
         engineOptions.getCurrentPlatform = getBrowserCurrentPlatform;
     }
+    else if (isDesktopRunTarget) {
+        engineOptions.getScreenshotAsBase64 = desktopController.getScreenshotAsBase64;
+        engineOptions.handleModelAction = desktopController.handleModelAction;
+        engineOptions.getCurrentPlatform = () => "desktop";
+    }
     if (isCloudRunTarget) {
         if (isBrowserRunTarget) {
             engineOptions.connectToBrowser = createRefuseReconnectConnectToBrowser();
@@ -142,7 +148,7 @@ export function buildHeadlessEngineOptions({ runtimeContext, headlessConfig, exe
     }
     return engineOptions;
 }
-async function runHeadlessTest({ runId, testPath, testName, instructions, session, deviceInfo, headlessConfig, appContext, testDataContext = "", runtimeContext, headlessDebug, recordScreenshots, screenshotDir, isBrowserTarget, isCloudTarget, runTarget = null, secrets = null, report = null, isBatchRun = false, reportToLoadmill = true, runConfiguration = {}, cloudUploadSession = null, uploadManager = droidReportUploadManager, }) {
+async function runHeadlessTest({ runId, testPath, testName, instructions, session, deviceInfo, headlessConfig, appContext, testDataContext = "", runtimeContext, headlessDebug, recordScreenshots, screenshotDir, isBrowserTarget, isDesktopTarget, desktopController, isCloudTarget, runTarget = null, secrets = null, report = null, isBatchRun = false, reportToLoadmill = true, runConfiguration = {}, cloudUploadSession = null, uploadManager = droidReportUploadManager, }) {
     let executionMode = null;
     let loadmillSessionUser = null;
     let runUsageTotals = setDroidCuaRunUsageModel(createDroidCuaRunUsageTotals(), runtimeContext.config.cuaModel);
@@ -218,6 +224,8 @@ async function runHeadlessTest({ runId, testPath, testName, instructions, sessio
             recordScreenshots,
             screenshotDir,
             isBrowserTarget,
+            isDesktopTarget,
+            desktopController,
             isCloudTarget,
             runTarget,
             onCuaResponse: (response) => {
@@ -428,8 +436,8 @@ async function runHeadlessTest({ runId, testPath, testName, instructions, sessio
         throw error;
     }
 }
-export async function runHeadlessInstructionRuns({ runs, instructionsTarget, session, deviceInfo, headlessConfig, appContext, runtimeContext, headlessDebug, secrets = null, recordScreenshots, screenshotDir, isBrowserTarget, isCloudTarget, runTarget = null, report = null, droidVersion = getDroidVersion(), runHeadlessTestImpl = runHeadlessTest, uploadManager = droidReportUploadManager, }) {
-    const resolvedRunTarget = runTarget ?? { isBrowserTarget, isCloudTarget };
+export async function runHeadlessInstructionRuns({ runs, instructionsTarget, session, deviceInfo, headlessConfig, appContext, runtimeContext, headlessDebug, secrets = null, recordScreenshots, screenshotDir, isBrowserTarget, isDesktopTarget = false, desktopController = null, isCloudTarget, runTarget = null, report = null, droidVersion = getDroidVersion(), runHeadlessTestImpl = runHeadlessTest, uploadManager = droidReportUploadManager, }) {
+    const resolvedRunTarget = runTarget ?? { isBrowserTarget, isDesktopTarget, isCloudTarget };
     const runConfiguration = buildDroidRunConfiguration({
         droidVersion,
         runtimeConfig: runtimeContext.config,
@@ -489,6 +497,8 @@ export async function runHeadlessInstructionRuns({ runs, instructionsTarget, ses
                 recordScreenshots,
                 screenshotDir: testScreenshotDir,
                 isBrowserTarget: resolvedRunTarget.isBrowserTarget,
+                isDesktopTarget: resolvedRunTarget.isDesktopTarget,
+                desktopController,
                 isCloudTarget: resolvedRunTarget.isCloudTarget,
                 runTarget: resolvedRunTarget,
                 report,

package/build/src/cli/headless-target.js

@@ -4,13 +4,13 @@ function normalizeTarget(value) {
         return "mobile";
     }
     if (typeof value !== "string") {
-        throw new Error("--target must be one of: mobile, web.");
+        throw new Error("--target must be one of: mobile, web, desktop.");
     }
     const normalized = value.trim().toLowerCase();
-    if (normalized === "mobile" || normalized === "web") {
+    if (normalized === "mobile" || normalized === "web" || normalized === "desktop") {
         return normalized;
     }
-    throw new Error("--target must be one of: mobile, web.");
+    throw new Error("--target must be one of: mobile, web, desktop.");
 }
 function normalizeSessionMode(value) {
     if (value == null || value === "") {
@@ -251,6 +251,53 @@ export function resolveHeadlessTarget(args = {}) {
             listDevices: false,
         };
     }
+    if (target === "desktop") {
+        if (avdName || platform || args.browser != null || args["session-mode"] != null) {
+            throw new Error("--avd, --platform, --browser, and --session-mode cannot be used with --target desktop.");
+        }
+        if (deviceSource !== "local") {
+            throw new Error("--device-source can only be used with --target mobile.");
+        }
+        assertNoCloudFlags(args);
+        if (args["list-devices"] != null) {
+            throw new Error("--list-devices can only be used with --target mobile.");
+        }
+        const listDesktopApps = args["list-desktop-apps"] != null;
+        const desktopApp = hasNonEmptyString(args["desktop-app"]) ? args["desktop-app"].trim() : null;
+        const rawWindow = readNonEmptyCliValue(args["desktop-window"]);
+        const desktopWindow = rawWindow == null ? null : Number(rawWindow);
+        const desktopInput = hasNonEmptyString(args["desktop-input"]) ? args["desktop-input"].trim().toLowerCase() : "physical";
+        if (!listDesktopApps && !desktopApp) {
+            throw new Error("--desktop-app is required with --target desktop.");
+        }
+        if (rawWindow != null && (!Number.isInteger(desktopWindow) || desktopWindow < 0)) {
+            throw new Error("--desktop-window must be a non-negative integer window ID.");
+        }
+        if (desktopInput !== "accessibility" && desktopInput !== "physical") {
+            throw new Error('--desktop-input must be "accessibility" or "physical".');
+        }
+        return {
+            target,
+            sessionMode: null,
+            browserFamily: null,
+            deviceSource: "local",
+            avdName: null,
+            platform: null,
+            deviceName: null,
+            osVersion: null,
+            appPath: null,
+            cloudSessionId: null,
+            artifacts: null,
+            listDevices: false,
+            listDesktopApps,
+            desktopApp,
+            desktopWindow,
+            desktopInput,
+        };
+    }
+    if (args["desktop-app"] != null || args["desktop-window"] != null || args["desktop-input"] != null || args["list-desktop-apps"] != null) {
+        throw new Error("--desktop-app, --desktop-window, --desktop-input, and --list-desktop-apps can only be used with --target desktop.");
+    }
     if (args["session-mode"] != null) {
         throw new Error("--session-mode can only be used with --target web.");
     }

package/build/src/commands/help.js

@@ -19,7 +19,11 @@ export async function handleHelp(args, session, context) {
     addOutput({ type: 'info', text: '  droid-cua --device-source lambdatest --instructions <file> [options]' });
     addOutput({ type: 'info', text: '' });
     addOutput({ type: 'info', text: 'Options:' });
-    addOutput({ type: 'info', text: '  --target <kind>        Target kind: mobile (default) or web' });
+    addOutput({ type: 'info', text: '  --target <kind>        Target kind: mobile (default), web, or desktop' });
+    addOutput({ type: 'info', text: '  --desktop-app <id>     Running desktop app ID or exact name' });
+    addOutput({ type: 'info', text: '  --desktop-window <id>  Window ID when the app has multiple windows' });
+    addOutput({ type: 'info', text: '  --desktop-input <mode> Physical pointer (default) or cursor-free accessibility' });
+    addOutput({ type: 'info', text: '  --list-desktop-apps    List running desktop apps and windows' });
     addOutput({ type: 'info', text: '  --avd <name>           Device name (Android device ID/serial or iOS Simulator)' });
     addOutput({ type: 'info', text: '  --platform <platform>  Force platform: android or ios' });
     addOutput({ type: 'info', text: '  --device-source <src>  Mobile source: local (default) or lambdatest' });

package/build/src/core/execution-engine.js

@@ -19,6 +19,7 @@ import { handleAssertionToolCall } from "./tool-handlers/assert.js";
 import { handleLoadmillToolCall } from "./tool-handlers/loadmill.js";
 import { handleTestDesignCompleteToolCall } from "./tool-handlers/test-design-complete.js";
 import { handleTypeSensitiveTextToolCall } from "./tool-handlers/type-sensitive-text.js";
+import { handleTypeSecretSlowlyToolCall, handleTypeTextSlowlyToolCall, } from "./tool-handlers/type-text-slowly.js";
 import { buildDebugContext, buildTextToolOutputItem, } from "./tool-handlers/utils.js";
 const HOLO_RESPONSE_ID_PREFIX = "resp_holo_";
 function isHoloResponseId(responseId) {
@@ -334,6 +335,10 @@ export class ExecutionEngine {
                 return await handleLoadmillToolCall(handlerArgs);
             case "type_sensitive_text":
                 return await handleTypeSensitiveTextToolCall(handlerArgs);
+            case "type_text_slowly":
+                return await handleTypeTextSlowlyToolCall(handlerArgs);
+            case "type_secret_slowly":
+                return await handleTypeSecretSlowlyToolCall(handlerArgs);
             case "test_design_complete":
                 return await handleTestDesignCompleteToolCall(handlerArgs);
             default:

package/build/src/core/session.js

@@ -13,7 +13,11 @@ export class Session {
         this.browserName = targetInfo?.browserName || null;
         this.currentUrl = targetInfo?.currentUrl || null;
         this.sessionMode = targetInfo?.sessionMode || null;
-        this.targetKind = targetInfo?.platform === "browser" ? "browser" : "mobile";
+        this.targetKind = targetInfo?.platform === "browser"
+            ? "browser"
+            : targetInfo?.platform === "desktop"
+                ? "desktop"
+                : "mobile";
         this.messages = [];
         this.previousResponseId = null;
         this.transcript = [];

package/build/src/core/test-data-import.js

@@ -1,13 +1,13 @@
 import path from "path";
 import { resolveEffectiveHelperModel } from "./runtime-config.js";
 import { buildTestDataImportMessages } from "../prompts/test-data-import.js";
-export const TEST_DATA_IMPORT_EXTENSIONS = [".csv", ".txt"];
+export const TEST_DATA_IMPORT_EXTENSIONS = [".csv", ".txt", ".json", ".xml", ".md"];
 export function isSupportedTestDataImportPath(filePath) {
     return TEST_DATA_IMPORT_EXTENSIONS.includes(path.extname(String(filePath ?? "")).toLowerCase());
 }
 export function assertSupportedTestDataImportPath(filePath) {
     if (!isSupportedTestDataImportPath(filePath)) {
-        throw new Error("Test data import supports CSV and TXT files only.");
+        throw new Error("Choose a CSV, TXT, JSON, XML, or Markdown file.");
     }
 }
 function parseTestDataImportContent(content) {

package/build/src/core/tool-handlers/close-keyboard.js

@@ -11,6 +11,9 @@ function parseDismissalPoint(argumentsText, deviceInfo = {}) {
     const hasX = Object.prototype.hasOwnProperty.call(parsed.value, "x");
     const hasY = Object.prototype.hasOwnProperty.call(parsed.value, "y");
     if (!hasX && !hasY) {
+        if (deviceInfo.platform?.trim().toLowerCase() === "ios") {
+            return { ok: false, message: "Invalid close_keyboard arguments: x and y are required on iOS." };
+        }
         return { ok: true, value: null };
     }
     if (!hasX || !hasY || !Number.isFinite(parsed.value.x) || !Number.isFinite(parsed.value.y)) {

package/build/src/core/tool-handlers/type-text-slowly.js

@@ -0,0 +1,155 @@
+import { randomUUID } from "node:crypto";
+import { CAPTURE_SOURCES } from "../capture-sources.js";
+import { emitDesktopDebug } from "../../utils/desktop-debug.js";
+import { buildFunctionCallOutputItem, buildToolOutputContent, buildTextToolOutputItem, parseJsonArguments, parseStringToolArgument, } from "./utils.js";
+const SUPPORTED_TEXT_PATTERN = /^[\x20-\x7e]+$/;
+export async function handleTypeTextSlowlyToolCall({ engine, callId, argumentsText, context = null, stepContext = null, }) {
+    if (engine.session?.deviceInfo?.platform !== "ios") {
+        return continueWithMessage(callId, "type_text_slowly is only supported for iOS runs.");
+    }
+    const parsed = parseLiteralText(argumentsText);
+    if (!parsed.ok) {
+        return continueWithMessage(callId, parsed.message);
+    }
+    return runSlowTyping({
+        engine,
+        callId,
+        context,
+        stepContext,
+        action: { type: "type", text: parsed.text, typingMode: "slow" },
+        resultText: "Typed text slowly.",
+    });
+}
+export async function handleTypeSecretSlowlyToolCall({ engine, callId, argumentsText, context = null, stepContext = null, }) {
+    if (engine.session?.deviceInfo?.platform !== "ios") {
+        return continueWithMessage(callId, "type_secret_slowly is only supported for iOS runs.");
+    }
+    const parsed = parseStringToolArgument(argumentsText, "secretKey", "type_secret_slowly");
+    if (!parsed.ok) {
+        return continueWithMessage(callId, parsed.message);
+    }
+    const resolved = resolveSecretAction(engine, parsed.value);
+    if (!resolved.ok) {
+        return continueWithMessage(callId, resolved.message);
+    }
+    return runSlowTyping({
+        engine,
+        callId,
+        context,
+        stepContext,
+        action: resolved.action,
+        resultText: `Typed secret slowly: ${parsed.value}.`,
+    });
+}
+async function runSlowTyping({ engine, callId, context, stepContext, action, resultText }) {
+    const typed = await executeSlowTyping(engine, action, context, stepContext);
+    if (!typed) {
+        return { kind: "fail", error: "Slow iOS typing failed." };
+    }
+    const { screenshotBase64, currentScreenshot } = await capturePostTypingScreenshot(engine, callId, context, stepContext);
+    return {
+        kind: "continue",
+        outputItem: buildFunctionCallOutputItem(callId, buildToolOutputContent({
+            text: resultText,
+            imageBase64: screenshotBase64,
+        })),
+        currentScreenshot,
+        executedActions: [action],
+    };
+}
+function continueWithMessage(callId, message) {
+    return {
+        kind: "continue",
+        outputItem: buildTextToolOutputItem(callId, message),
+    };
+}
+function parseLiteralText(argumentsText) {
+    const parsed = parseJsonArguments(argumentsText);
+    const text = parsed.ok ? parsed.value?.text : null;
+    if (typeof text !== "string" || text.length === 0) {
+        return {
+            ok: false,
+            message: 'Invalid type_text_slowly arguments: "text" must be a non-empty string.',
+        };
+    }
+    if (!SUPPORTED_TEXT_PATTERN.test(text)) {
+        return { ok: false, message: "type_text_slowly currently supports printable ASCII text only." };
+    }
+    return { ok: true, text };
+}
+function resolveSecretAction(engine, secretKey) {
+    const secretsByKey = engine.secretsByKey && typeof engine.secretsByKey === "object" ? engine.secretsByKey : {};
+    if (!Object.prototype.hasOwnProperty.call(secretsByKey, secretKey)) {
+        return { ok: false, message: `Secret key not found: ${secretKey}` };
+    }
+    const text = String(secretsByKey[secretKey] ?? "");
+    if (!SUPPORTED_TEXT_PATTERN.test(text)) {
+        return {
+            ok: false,
+            message: `Secret ${secretKey} cannot be typed slowly because its value is empty or contains unsupported characters.`,
+        };
+    }
+    return {
+        ok: true,
+        action: {
+            type: "type",
+            text,
+            sensitive: true,
+            sensitiveKey: secretKey,
+            typingMode: "slow",
+        },
+    };
+}
+async function executeSlowTyping(engine, action, context, stepContext) {
+    try {
+        const result = await engine.handleModelAction(engine.session.deviceId, action, engine.session.deviceInfo.scale, {
+            ...context,
+            stepId: stepContext?.stepId,
+            instructionIndex: stepContext?.instructionIndex,
+            eventId: randomUUID(),
+        });
+        return result?.success !== false;
+    }
+    catch {
+        return false;
+    }
+}
+async function capturePostTypingScreenshot(engine, callId, context, stepContext) {
+    const screenshotBase64 = await engine.getScreenshotAsBase64(engine.session.deviceId, engine.session.deviceInfo);
+    const screenshotEventId = randomUUID();
+    emitDesktopDebug("device.screenshot", "device", {
+        runId: context?.runId,
+        stepId: stepContext?.stepId,
+        instructionIndex: stepContext?.instructionIndex,
+    }, {
+        source: "post_action",
+        callId,
+        width: engine.session.deviceInfo?.scaled_width,
+        height: engine.session.deviceInfo?.scaled_height,
+        base64Length: screenshotBase64.length,
+    });
+    const currentScreenshot = await engine.recordScreenshot(screenshotBase64, {
+        runId: context?.runId,
+        sessionId: context?.sessionId,
+        stepId: stepContext?.stepId,
+        instructionIndex: stepContext?.instructionIndex,
+        eventId: screenshotEventId,
+        captureSource: CAPTURE_SOURCES.CALL_OUTPUT_POST_ACTION,
+    });
+    context?.addOutput?.({
+        type: "info",
+        text: "Capturing screen",
+        eventType: "screenshot_captured",
+        actionType: "screenshot",
+        runId: context?.runId,
+        stepId: stepContext?.stepId,
+        instructionIndex: stepContext?.instructionIndex,
+        payload: {
+            eventId: screenshotEventId,
+            captureSource: CAPTURE_SOURCES.CALL_OUTPUT_POST_ACTION,
+            source: "post_action",
+            ...(currentScreenshot?.screenshotPath ? { screenshotPath: currentScreenshot.screenshotPath } : {}),
+        },
+    });
+    return { screenshotBase64, currentScreenshot };
+}