@loadmill/droid-cua 2.32.0 → 2.34.0

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/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 };
+}

package/build/src/device/cloud/actions.js

@@ -77,12 +77,22 @@ export async function handleModelAction(deviceId, action, scale = 1.0, context =
                 break;
             }
             case "type": {
+                const typingSlowly = platform === "ios" && action.typingMode === "slow";
+                const actionText = buildTypeActionText(action, action.text);
                 addOutput({
                     type: "action",
-                    text: buildTypeActionText(action, action.text),
-                    ...meta(buildTypeActionPayload(action, action.text))
+                    text: typingSlowly ? actionText.replace(":", " slowly:") : actionText,
+                    ...meta({
+                        ...buildTypeActionPayload(action, action.text),
+                        ...(typingSlowly ? { typingMode: "slow" } : {})
+                    })
                 });
-                await session.client.type(session.sessionId, action.text);
+                if (typingSlowly) {
+                    await session.client.typeSlowly(session.sessionId, action.text);
+                }
+                else {
+                    await session.client.type(session.sessionId, action.text);
+                }
                 break;
             }
             case "scroll": {

package/build/src/device/cloud/cloud-appium-client.js

@@ -119,6 +119,12 @@ export class CloudAppiumClient {
             ]
         });
     }
+    async typeSlowly(sessionId, text) {
+        await this.request("POST", `/session/${sessionId}/execute/sync`, {
+            script: "mobile: keys",
+            args: [{ keys: [...text] }]
+        });
+    }
     async isKeyboardShown(sessionId) {
         const response = await this.request("POST", `/session/${sessionId}/execute/sync`, {
             script: "mobile: isKeyboardShown",

package/build/src/device/ios/actions.js

@@ -12,17 +12,19 @@ import { logger } from "../../utils/logger.js";
 import { emitDesktopDebug, truncateForDebug } from "../../utils/desktop-debug.js";
 import { getConfiguredStepDelayMs } from "../../utils/step-delay.js";
 import { resolveScrollGesture } from "../scroll-gesture.js";
-import { closeAppiumKeyboard } from "../keyboard.js";
-export async function closeKeyboard() {
+import { closeAppiumKeyboardWithTap } from "../keyboard.js";
+export async function closeKeyboard(_deviceId, { dismissalPoint = null, scale = 1 } = {}) {
     const session = getActiveSession();
     if (!session) {
         throw new Error("No active iOS session");
     }
-    // The local simulator supports Appium's keyboard command reliably, so it
-    // needs neither a model-selected tap nor a direct Return keypress.
-    return closeAppiumKeyboard({
+    const dpr = getDevicePixelRatio();
+    const tap = dismissalPoint
+        ? () => appium.tap(session.sessionId, Math.round((dismissalPoint.x / scale) / dpr), Math.round((dismissalPoint.y / scale) / dpr))
+        : null;
+    return closeAppiumKeyboardWithTap({
         isKeyboardShown: () => appium.isKeyboardShown(session.sessionId),
-        hideKeyboard: () => appium.hideKeyboard(session.sessionId),
+        tap,
     });
 }
 /**
@@ -74,12 +76,22 @@ export async function handleModelAction(simulatorId, action, scale = 1.0, contex
                 break;
             }
             case "type": {
+                const typingSlowly = action.typingMode === "slow";
+                const actionText = buildTypeActionText(action, action.text);
                 addOutput({
                     type: "action",
-                    text: buildTypeActionText(action, action.text),
-                    ...meta(buildTypeActionPayload(action, action.text))
+                    text: typingSlowly ? actionText.replace(":", " slowly:") : actionText,
+                    ...meta({
+                        ...buildTypeActionPayload(action, action.text),
+                        ...(typingSlowly ? { typingMode: "slow" } : {})
+                    })
                 });
-                await appium.type(session.sessionId, action.text);
+                if (typingSlowly) {
+                    await appium.typeSlowly(session.sessionId, action.text);
+                }
+                else {
+                    await appium.type(session.sessionId, action.text);
+                }
                 break;
             }
             case "scroll": {

package/build/src/device/ios/appium-client.js

@@ -123,6 +123,18 @@ export async function type(sessionId, text) {
         ],
     });
 }
+/**
+ * Type text one key at a time through XCUITest's keyboard input API.
+ * @param {string} sessionId
+ * @param {string} text
+ * @returns {Promise<void>}
+ */
+export async function typeSlowly(sessionId, text) {
+    await appiumRequest("POST", `/session/${sessionId}/execute/sync`, {
+        script: "mobile: keys",
+        args: [{ keys: [...text] }],
+    });
+}
 export async function isKeyboardShown(sessionId) {
     const response = await appiumRequest("POST", `/session/${sessionId}/execute/sync`, {
         script: "mobile: isKeyboardShown",
@@ -131,9 +143,8 @@ export async function isKeyboardShown(sessionId) {
     return response.value === true;
 }
 export async function hideKeyboard(sessionId) {
-    // This XCUITest form is used only by the locally validated simulator path.
-    // Real cloud iOS devices use a guarded tap instead because this command was
-    // unreliable there and sending Return directly can submit the current form.
+    // The CUA close_keyboard path uses a model-selected tap because this command
+    // may send Return. Keep the low-level command available for direct callers.
     await appiumRequest("POST", `/session/${sessionId}/execute/sync`, {
         script: "mobile: hideKeyboard",
         args: [{ keys: ["return"] }],

package/build/src/device/keyboard.js

@@ -6,10 +6,9 @@ import { getConfiguredStepDelayMs } from "../utils/step-delay.js";
  *   navigate away. Android's mInputShown flag stays true when a hardware
  *   keyboard suppresses the software keyboard, so that configuration is
  *   treated as already closed before Back is considered.
- * - Local iOS and cloud Android use Appium's native keyboard commands, which
- *   worked reliably in device testing and do not require choosing a tap target.
- * - Cloud iOS uses a model-selected tap. XCUITest's hideKeyboard command was
- *   unreliable on the tested real devices, while Return/newline could submit a
+ * - Cloud Android uses Appium's native keyboard command.
+ * - Local and cloud iOS use a model-selected tap. XCUITest's hideKeyboard
+ *   command was unreliable in testing, while Return/newline could submit a
  *   form. The caller therefore supplies a trusted dismissal point instead.
  *
  * Every strategy follows the same query -> dismiss -> wait -> verify shape and

package/build/src/device/mobile-keypress.js

@@ -37,6 +37,7 @@ export function normalizeMobileKeypress(platform, keys = []) {
         ESCAPE: { semanticKey: "BACK", logText: "Pressing Back" },
         BACK: { semanticKey: "BACK", logText: "Pressing Back" },
         HOME: { semanticKey: "HOME", logText: "Pressing Home" },
+        APP_SWITCH: { semanticKey: "APP_SWITCH", logText: "Pressing Recent Apps" },
         ENTER: { semanticKey: "ENTER", logText: "Pressing Enter" },
         RETURN: { semanticKey: "ENTER", logText: "Pressing Enter" },
         BACKSPACE: { semanticKey: "BACKSPACE", logText: "Pressing Backspace" },
@@ -58,6 +59,7 @@ export function getAndroidAdbTransport(normalized) {
     const transportMap = {
         BACK: "KEYCODE_BACK",
         HOME: "KEYCODE_HOME",
+        APP_SWITCH: "KEYCODE_APP_SWITCH",
         ENTER: "KEYCODE_ENTER",
         BACKSPACE: "KEYCODE_DEL",
         SPACE: "KEYCODE_SPACE"
@@ -75,6 +77,7 @@ export function getCloudAndroidTransport(normalized) {
     const transportMap = {
         BACK: 4,
         HOME: 3,
+        APP_SWITCH: 187,
         ENTER: 66,
         BACKSPACE: 67,
         SPACE: 62

package/build/src/device/openai.js

@@ -103,7 +103,7 @@ const closeCurrentTabTool = {
 const closeKeyboardTool = {
     type: "function",
     name: "close_keyboard",
-    description: "Close the mobile software keyboard after text entry. Call this when a full software keyboard is visible, or after typing into an iOS secure field even when its keyboard is hidden. Do not call it for a slim hardware-keyboard toolbar or suggestions alone. On cloud iOS, optionally provide x and y for a dismissal control or clearly noninteractive background that you trust; never target Return, Go, Search, Next, Continue, Send, or an app action.",
+    description: "Close the mobile software keyboard after text entry. Call this when a full software keyboard is visible. Do not call it for a slim hardware-keyboard toolbar or suggestions alone.",
     strict: false,
     parameters: {
         type: "object",
@@ -115,6 +115,18 @@ const closeKeyboardTool = {
         additionalProperties: false,
     },
 };
+const iosCloseKeyboardTool = {
+    ...closeKeyboardTool,
+    description: "Close the iOS software keyboard after text entry by tapping a safe dismissal point from the current screenshot. Call this when a full software keyboard is visible, or after typing into a secure field even when its keyboard is hidden. Prefer a dedicated keyboard dismissal control or clearly noninteractive background. Never target Return, Go, Search, Next, Continue, Send, or an app action.",
+    parameters: {
+        ...closeKeyboardTool.parameters,
+        properties: {
+            x: { type: "number", description: "Horizontal coordinate of the dismissal point in the current screenshot." },
+            y: { type: "number", description: "Vertical coordinate of the dismissal point in the current screenshot." },
+        },
+        required: ["x", "y"],
+    },
+};
 const loadmillTool = {
     type: "function",
     name: "loadmill",
@@ -143,6 +155,34 @@ const typeSensitiveTextTool = {
         additionalProperties: false,
     },
 };
+const typeTextSlowlyTool = {
+    type: "function",
+    name: "type_text_slowly",
+    description: "Type literal text into the currently focused iOS field using the slower XCTest compatibility input method. Use this when app context says normal typing may drop characters, or after a screenshot shows incomplete input. This method can still drop characters, so inspect the returned screenshot. It does not clear existing text; clear the field first when retrying.",
+    strict: true,
+    parameters: {
+        type: "object",
+        properties: {
+            text: { type: "string" },
+        },
+        required: ["text"],
+        additionalProperties: false,
+    },
+};
+const typeSecretSlowlyTool = {
+    type: "function",
+    name: "type_secret_slowly",
+    description: "Type a listed secret into the currently focused iOS field using the slower XCTest compatibility input method. Use this when app context says normal typing may drop characters, or when separate evidence shows normal secret entry failed. This method can still drop characters and does not clear existing text; clear the field first when retrying.",
+    strict: true,
+    parameters: {
+        type: "object",
+        properties: {
+            secretKey: { type: "string" },
+        },
+        required: ["secretKey"],
+        additionalProperties: false,
+    },
+};
 // Design completion is the handoff into script generation; it is separate from
 // execution step-completion markers used by model adapters.
 const testDesignCompleteTool = {
@@ -177,7 +217,7 @@ const testDesignCompleteTool = {
         additionalProperties: false,
     },
 };
-export function buildFunctionTools({ aimAssistMode = DEFAULT_AIM_ASSIST_MODE, toolCapabilities = {}, } = {}) {
+export function buildFunctionTools({ aimAssistMode = DEFAULT_AIM_ASSIST_MODE, toolCapabilities = {}, deviceInfo = null, } = {}) {
     const tools = [];
     if (aimAssistMode !== "off" && toolCapabilities.previewClick !== false) {
         tools.push(previewClickTool);
@@ -192,7 +232,7 @@ export function buildFunctionTools({ aimAssistMode = DEFAULT_AIM_ASSIST_MODE, to
         tools.push(closeCurrentTabTool);
     }
     if (toolCapabilities.closeKeyboard) {
-        tools.push(closeKeyboardTool);
+        tools.push(deviceInfo?.platform?.toLowerCase() === "ios" ? iosCloseKeyboardTool : closeKeyboardTool);
     }
     if (toolCapabilities.loadmill) {
         tools.push(loadmillTool);
@@ -200,6 +240,12 @@ export function buildFunctionTools({ aimAssistMode = DEFAULT_AIM_ASSIST_MODE, to
     if (toolCapabilities.typeSensitiveText) {
         tools.push(typeSensitiveTextTool);
     }
+    if (toolCapabilities.typeTextSlowly) {
+        tools.push(typeTextSlowlyTool);
+    }
+    if (toolCapabilities.typeTextSlowly && toolCapabilities.typeSensitiveText) {
+        tools.push(typeSecretSlowlyTool);
+    }
     if (toolCapabilities.testDesignComplete) {
         tools.push(testDesignCompleteTool);
     }
@@ -333,7 +379,7 @@ export function buildCuaRequestParams({ cuaModel, aimAssistMode = DEFAULT_AIM_AS
         truncation: "auto",
         tools: [
             ...(includeComputerTool ? [buildComputerTool({ cuaModel, deviceInfo })] : []),
-            ...buildFunctionTools({ aimAssistMode, toolCapabilities }),
+            ...buildFunctionTools({ aimAssistMode, toolCapabilities, deviceInfo }),
         ],
     };
 }

package/build/src/modes/design-mode-ink.js

@@ -42,6 +42,7 @@ export class DesignModeInk {
             navigate: this.session?.deviceInfo?.platform === "browser",
             closeCurrentTab: this.session?.deviceInfo?.platform === "browser",
             closeKeyboard: this.session?.deviceInfo?.platform !== "browser",
+            typeTextSlowly: this.session?.deviceInfo?.platform === "ios",
             loadmill: false,
             typeSensitiveText: this.engine.hasSecrets(),
             testDesignComplete: true,

package/build/src/modes/design-mode.js

@@ -39,6 +39,7 @@ export class DesignMode {
             navigate: this.session?.deviceInfo?.platform === "browser",
             closeCurrentTab: this.session?.deviceInfo?.platform === "browser",
             closeKeyboard: this.session?.deviceInfo?.platform !== "browser",
+            typeTextSlowly: this.session?.deviceInfo?.platform === "ios",
             loadmill: false,
             typeSensitiveText: this.engine.hasSecrets(),
             testDesignComplete: true,

package/build/src/modes/execution-mode.js

@@ -96,6 +96,7 @@ export class ExecutionMode {
             navigate: this.isBrowserSession,
             closeCurrentTab: this.isBrowserSession,
             closeKeyboard: !this.isBrowserSession,
+            typeTextSlowly: this.session?.deviceInfo?.platform === "ios",
             loadmill: true,
             typeSensitiveText: this.engine.hasSecrets(),
         };

package/build/src/prompts/base.js

@@ -156,11 +156,10 @@ function buildBrowserBaseSystemPrompt(deviceInfo, options = {}) {
 }
 function buildMobileBaseSystemPrompt(deviceInfo, options = {}) {
     const aimAssistMode = typeof options.aimAssistMode === "string" ? options.aimAssistMode : "always";
-    const cloudIosKeyboardGuidance = isCloudIosTarget(deviceInfo) ? `
-  - On this cloud iOS device, \`close_keyboard\` can optionally tap a point you choose from the current screenshot.
-  - If you can identify a dedicated keyboard dismissal control or clearly noninteractive background that you trust, pass its \`x\` and \`y\` coordinates to \`close_keyboard\`.
+    const iosKeyboardGuidance = deviceInfo.platform?.trim().toLowerCase() === "ios" ? `
+  - On iOS, \`close_keyboard\` requires \`x\` and \`y\` coordinates from the current screenshot and taps that point.
+  - Prefer a dedicated keyboard dismissal control. Otherwise choose a clearly noninteractive background that you trust.
   - Never use Return, Go, Search, Next, Continue, Send, or an app action as the dismissal point because it may submit or mutate the app.
-  - If dismissal is required but no safe point is identifiable, call \`close_keyboard\` without coordinates. Do not guess.
   - Choose coordinates directly from the post-type screenshot; do not call \`preview_click\` between \`type\` and \`close_keyboard\`.` : "";
     return `
   You are controlling ${describeControlledTarget(deviceInfo)} in a sandboxed testing environment.
@@ -188,14 +187,14 @@ function buildMobileBaseSystemPrompt(deviceInfo, options = {}) {
   - If a full software keyboard is visibly covering part of the screen, your next action must be \`close_keyboard\`.
   - Do not finish the current instruction while a required \`close_keyboard\` action is still pending.
   - A slim hardware-keyboard toolbar, autocomplete suggestions, or a focused field without a full software keyboard does not require \`close_keyboard\`.
-  - Treat \`type_sensitive_text\` as text entry too and apply the same dismissal decision after it returns.
+  - Treat \`type_sensitive_text\`, \`type_text_slowly\`, and \`type_secret_slowly\` as text entry too and apply the same dismissal decision after any of them returns.
   - Whenever dismissal is required, do not click, scroll, inspect, submit, type again, issue a keypress, or call another tool before \`close_keyboard\`.
   - Consecutive DELETE or BACKSPACE keypresses may be used for correction without closing the keyboard between them. After typing the replacement, call \`close_keyboard\`.
   - Password and other secure fields may appear empty in screenshots even after text was entered successfully.
   - On iOS, a secure field may also hide an open keyboard from Appium screenshots. After typing into an iOS secure field, call \`close_keyboard\` even when the keyboard is not visible.
   - Do not type into a secure field again solely because its characters or bullets are not visible.
   - Retry secure-field input only when there is separate evidence of failure, such as another field changing or the app rejecting the value.
-  ${cloudIosKeyboardGuidance}
+  ${iosKeyboardGuidance}
   - Prefer tapping visible controls over hardware key events.
   - Prefer on-screen navigation controls such as menus, tabs, drawer items, back arrows, close buttons, and explicit logout buttons over keypress actions.
   - Do NOT use Back or ESC for normal app navigation when a reliable on-screen control is visible.
@@ -243,6 +242,7 @@ function buildMobileBaseSystemPrompt(deviceInfo, options = {}) {
 
   Mobile-Specific Notes:
   - HOME key returns to the home screen
+  - On Android, APP_SWITCH opens Recent Apps
   - On Android, ESC key maps to Back
   - On iOS, ESC has no effect; use visible on-screen controls instead
   - Never use CTRL, CMD, ALT, OPTION, or SHIFT in a keypress action

package/build/src/prompts/execution.js

@@ -32,6 +32,7 @@ export function buildSecretKeysContextSection(keys = []) {
     return `SECRET KEYS FOR THIS RUN:
 The following secret keys are available. You can see only the keys, not the values.
 Use the \`type_sensitive_text\` tool when you need to enter passwords, OTPs, tokens, API keys, or other hidden credentials.
+When the iOS \`type_secret_slowly\` tool is available and slow typing is needed, pass it the matching \`secretKey\`.
 Never ask the user to reveal these values and never type placeholder text when a matching secret key is available.
 
 ${normalized.map((key) => `- ${key}`).join("\n")}`;
@@ -80,7 +81,7 @@ ${browserTarget ? "" : `   - Every \`type\` action must end its computer-action
    - Call \`close_keyboard\` next when a full software keyboard is visible, or after typing into an iOS secure field even when its keyboard is hidden
    - Do not complete the current instruction while that required \`close_keyboard\` action is pending
    - Otherwise, including when only a slim hardware-keyboard toolbar or suggestions are visible, continue without \`close_keyboard\`
-   - Apply the same dismissal decision after \`type_sensitive_text\`
+   - Apply the same dismissal decision after \`type_sensitive_text\`, \`type_text_slowly\`, and \`type_secret_slowly\`
 `}
    - Use the \`loadmill\` tool whenever the instruction explicitly references running or using a Loadmill flow. Pass the requested flow name/intent and parameters as the command; the tool will search Loadmill, select the best matching flow, run it, and wait for completion. Do not handle Loadmill by typing in the app UI.
 3. Execute the required actions

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loadmill/droid-cua",
-  "version": "2.32.0",
+  "version": "2.34.0",
   "description": "AI-powered Android testing agent using OpenAI's computer-use model and ADB",
   "main": "build/index.js",
   "type": "module",