@loadmill/droid-cua 2.10.1-rc.9 → 2.12.0

package/build/src/cli/lambdatest-app-upload.js

@@ -0,0 +1,66 @@
+import path from "path";
+import { stat } from "fs/promises";
+import { lambdaTestAdapter } from "../device/cloud/lambdatest/adapter.js";
+function trimNullableString(value) {
+    if (typeof value !== "string") {
+        return null;
+    }
+    const trimmed = value.trim();
+    return trimmed || null;
+}
+export function resolveLambdaTestCredentials(env = process.env) {
+    const username = trimNullableString(env.LAMBDATEST_USERNAME);
+    const accessKey = trimNullableString(env.LAMBDATEST_ACCESS_KEY);
+    if (!username || !accessKey) {
+        throw new Error("LAMBDATEST_USERNAME and LAMBDATEST_ACCESS_KEY are required for --device-source lambdatest.");
+    }
+    return {
+        username,
+        accessKey,
+    };
+}
+export function validateLambdaTestAppPath(appPath, platform) {
+    const normalizedPlatform = trimNullableString(platform)?.toLowerCase();
+    if (normalizedPlatform !== "android" && normalizedPlatform !== "ios") {
+        throw new Error("--platform must be one of: android, ios.");
+    }
+    const normalizedAppPath = trimNullableString(appPath);
+    if (!normalizedAppPath) {
+        throw new Error("--app is required with --device-source lambdatest.");
+    }
+    const resolvedPath = path.resolve(normalizedAppPath);
+    const extension = path.extname(resolvedPath).toLowerCase();
+    if (extension === ".app") {
+        throw new Error("LambdaTest real-device sessions require an .apk for Android or an .ipa for iOS. .app bundles are not supported.");
+    }
+    if (normalizedPlatform === "android" && extension !== ".apk") {
+        throw new Error("LambdaTest Android sessions require an .apk build.");
+    }
+    if (normalizedPlatform === "ios" && extension !== ".ipa") {
+        throw new Error("LambdaTest iOS sessions require an .ipa build.");
+    }
+    return resolvedPath;
+}
+export async function uploadLambdaTestCliApp({ appPath, platform, credentials, adapter = lambdaTestAdapter, } = {}) {
+    const resolvedPath = validateLambdaTestAppPath(appPath, platform);
+    let fileStats;
+    try {
+        fileStats = await stat(resolvedPath);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "App file is unavailable.";
+        throw new Error(`App file is unavailable: ${message}`);
+    }
+    if (!fileStats.isFile()) {
+        throw new Error("Selected app path is not a file.");
+    }
+    const uploadedRef = await adapter.uploadApp(credentials, resolvedPath);
+    if (!uploadedRef?.remotePath || typeof uploadedRef.remotePath !== "string") {
+        throw new Error("LambdaTest did not return a valid app reference.");
+    }
+    return {
+        appRef: uploadedRef.remotePath,
+        appPath: resolvedPath,
+        uploadedRef,
+    };
+}

package/build/src/commands/help.js

@@ -15,11 +15,16 @@ export async function handleHelp(args, session, context) {
     addOutput({ type: 'info', text: 'Usage:' });
     addOutput({ type: 'info', text: '  droid-cua --avd <device-name> [options]' });
     addOutput({ type: 'info', text: '  droid-cua --target web --instructions <file> [options]' });
+    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: '  --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' });
+    addOutput({ type: 'info', text: '  --device-name <name>   LambdaTest real device name' });
+    addOutput({ type: 'info', text: '  --os-version <version> LambdaTest OS version' });
+    addOutput({ type: 'info', text: '  --app <path>           LambdaTest app package path (.apk or .ipa)' });
     addOutput({ type: 'info', text: '  --instructions <file>  Run test file in headless mode' });
     addOutput({ type: 'info', text: '  --session-mode <mode>  Browser session mode for web runs: persistent or fresh' });
     addOutput({ type: 'info', text: '  --config <file>        Headless execution JSON config for prompt parity' });
@@ -53,6 +58,7 @@ export async function handleHelp(args, session, context) {
     addOutput({ type: 'info', text: 'Platform Support:' });
     addOutput({ type: 'info', text: '  Android: Uses ADB to communicate with Android devices (physical or emulator)' });
     addOutput({ type: 'info', text: '  iOS:     Uses Appium + XCUITest for iOS Simulator automation' });
+    addOutput({ type: 'info', text: '  LambdaTest: Uses real cloud devices for headless mobile runs' });
     addOutput({ type: 'info', text: '  Web:     Uses Playwright with installed Google Chrome or Microsoft Edge for browser execution' });
     addOutput({ type: 'info', text: '' });
     addOutput({ type: 'info', text: 'Platform Detection:' });
@@ -74,6 +80,7 @@ export async function handleHelp(args, session, context) {
     addOutput({ type: 'info', text: '  droid-cua --platform ios --avd MySim    (Force iOS platform)' });
     addOutput({ type: 'info', text: '  droid-cua --instructions tests/login.dcua --context app/context.md' });
     addOutput({ type: 'info', text: '  droid-cua --target web --instructions tests/search.dcua' });
+    addOutput({ type: 'info', text: '  droid-cua --device-source lambdatest --platform android --device-name "Galaxy S24" --os-version 14 --app app.apk --instructions tests/login.dcua' });
     addOutput({ type: 'info', text: '  /create login-test                      (design a new test)' });
     addOutput({ type: 'info', text: '  /list                                   (see all tests)' });
     addOutput({ type: 'info', text: '  /view login-test                        (view test contents)' });

package/build/src/core/context-optimization.js

@@ -1,5 +1,5 @@
 export const DEFAULT_CONTEXT_OPTIMIZATION_ENABLED = true;
-export const DEFAULT_CONTEXT_OPTIMIZATION_THRESHOLD = 20000;
+export const DEFAULT_CONTEXT_OPTIMIZATION_THRESHOLD = 30000;
 export const MIN_CONTEXT_OPTIMIZATION_THRESHOLD = 10000;
 export const MAX_CONTEXT_OPTIMIZATION_THRESHOLD = 900000;
 export const CONTEXT_OPTIMIZATION_ENABLED_ENV = "DROID_CUA_CONTEXT_OPTIMIZATION_ENABLED";

package/build/src/core/session.js

@@ -9,6 +9,7 @@ export class Session {
         this.deviceName = targetInfo?.device_name || null;
         this.browserSessionId = targetInfo?.platform === "browser" ? targetSessionId : null;
         this.browserInfo = targetInfo?.platform === "browser" ? targetInfo : null;
+        this.browserFamily = targetInfo?.browserFamily || null;
         this.browserName = targetInfo?.browserName || null;
         this.currentUrl = targetInfo?.currentUrl || null;
         this.sessionMode = targetInfo?.sessionMode || null;

package/build/src/core/tool-handlers/assert.js

@@ -2,19 +2,100 @@ import { randomUUID } from "node:crypto";
 import { buildAssertionSystemPrompt, checkAssertionResult, extractFailureDetails, handleAssertionFailure, handleAssertionSuccess, } from "../../device/assertions.js";
 import { CAPTURE_SOURCES } from "../capture-sources.js";
 import { printCliOutput } from "../../utils/console-output.js";
-import { buildNestedToolDebugContext, buildTextToolOutputItem, isDesignContext, parseStringToolArgument, } from "./utils.js";
+import { emitDesktopDebug } from "../../utils/desktop-debug.js";
+import { buildNestedToolDebugContext, buildTextToolOutputItem, isDesignContext, parseJsonArguments, } from "./utils.js";
+function parseAssertionArguments(argumentsText) {
+    const parsed = parseJsonArguments(argumentsText);
+    if (!parsed.ok || typeof parsed.value !== "object" || !parsed.value) {
+        return {
+            ok: false,
+            message: 'Invalid assert arguments: expected a JSON object with string "condition" and "context" fields.',
+        };
+    }
+    const condition = parsed.value.condition;
+    const assertionContext = parsed.value.context;
+    if (typeof condition !== "string" || !condition.trim()) {
+        return {
+            ok: false,
+            message: 'Invalid assert arguments: "condition" must be a non-empty string.',
+        };
+    }
+    if (typeof assertionContext !== "string" || !assertionContext.trim()) {
+        return {
+            ok: false,
+            message: 'Invalid assert arguments: "context" must be a non-empty string.',
+        };
+    }
+    return {
+        ok: true,
+        condition: condition.trim(),
+        context: assertionContext.trim(),
+    };
+}
+function extractResponseText(response) {
+    if (typeof response?.output_text === "string" && response.output_text.trim()) {
+        return response.output_text.trim();
+    }
+    const parts = [];
+    for (const item of response?.output || []) {
+        if (typeof item?.text === "string" && item.text.trim()) {
+            parts.push(item.text.trim());
+        }
+        for (const contentItem of item?.content || []) {
+            if (typeof contentItem?.text === "string" && contentItem.text.trim()) {
+                parts.push(contentItem.text.trim());
+            }
+        }
+    }
+    return parts.join("\n").trim();
+}
+function extractPassDetails(assertionText) {
+    const parts = assertionText.split("ASSERTION RESULT: PASS");
+    return parts[1]?.trim() || "Assertion passed.";
+}
+function emitAssertionToolCall({ callId, argumentsText, assertionPrompt, assertionContext, context, stepContext }) {
+    const scope = isDesignContext(context) ? "design" : "execution";
+    const ids = {
+        ...(scope === "design" ? { sessionId: context?.sessionId } : { runId: context?.runId }),
+        ...(stepContext?.stepId ? { stepId: stepContext.stepId } : {}),
+        ...(Number.isInteger(stepContext?.instructionIndex) ? { instructionIndex: stepContext.instructionIndex } : {}),
+    };
+    const payload = {
+        toolName: "assert",
+        callId,
+        condition: assertionPrompt,
+        context: assertionContext,
+        arguments: argumentsText,
+    };
+    emitDesktopDebug("tool_call", scope, ids, payload);
+    const addOutput = context?.addOutput || null;
+    if (addOutput) {
+        addOutput({
+            type: "muted",
+            text: `Validating assertion: ${assertionPrompt}`,
+            eventType: "tool_call",
+            runId: context?.runId,
+            stepId: stepContext?.stepId,
+            instructionIndex: stepContext?.instructionIndex,
+            payload,
+        });
+    }
+}
 export async function handleAssertionToolCall({ engine, callId, argumentsText, context = null, stepContext = null }) {
     const session = engine.session;
-    const parsed = parseStringToolArgument(argumentsText, "condition", "assert");
+    const parsed = parseAssertionArguments(argumentsText);
     if (!parsed.ok) {
         return {
             kind: "continue",
             outputItem: buildTextToolOutputItem(callId, parsed.message),
         };
     }
-    const assertionPrompt = parsed.value;
-    const transcriptStartIndex = session.transcript.length;
+    const assertionPrompt = parsed.condition;
+    const assertionContext = parsed.context;
+    emitAssertionToolCall({ callId, argumentsText, assertionPrompt, assertionContext, context, stepContext });
+    const transcriptBeforeAssertion = session.getTranscriptText();
     session.addToTranscript(`[Assertion] ${assertionPrompt}`);
+    session.addToTranscript(`[Assertion Context] ${assertionContext}`);
     const screenshotBase64 = await engine.getScreenshotAsBase64(session.deviceId, session.deviceInfo);
     const assertionEventId = randomUUID();
     const assertionScreenshot = await engine.recordScreenshot(screenshotBase64, {
@@ -35,8 +116,11 @@ export async function handleAssertionToolCall({ engine, callId, argumentsText, c
         ...(assertionScreenshotPath ? { screenshotPath: assertionScreenshotPath } : {}),
         ...(assertionScreenshotDataUrl ? { screenshotDataUrl: assertionScreenshotDataUrl } : {}),
     };
-    const assertionSystemPrompt = buildAssertionSystemPrompt(engine.baseSystemPrompt || session.systemPrompt || "", assertionPrompt);
-    const nestedDebugContext = buildNestedToolDebugContext(context, stepContext, "assert", callId);
+    const assertionSystemPrompt = buildAssertionSystemPrompt(engine.baseSystemPrompt || session.systemPrompt || "", assertionPrompt, {
+        assertionContext,
+        transcript: transcriptBeforeAssertion,
+    });
+    const assertionDebugContext = buildNestedToolDebugContext(context, stepContext, "assert", callId);
     const assertionResponse = await engine.sendCUARequest({
         messages: [
             { role: "system", content: assertionSystemPrompt },
@@ -45,30 +129,30 @@ export async function handleAssertionToolCall({ engine, callId, argumentsText, c
         screenshotBase64,
         previousResponseId: null,
         deviceInfo: session.deviceInfo,
-        debugContext: nestedDebugContext,
+        debugContext: assertionDebugContext,
+        includeComputerTool: false,
         toolCapabilities: {
+            previewClick: false,
             assert: false,
             navigate: false,
             loadmill: false,
         },
     });
-    // Nested assertion turn: we discard the returned summary because the
-    // parent turn (the one that dispatched the assert tool call) is what
-    // the caller will read.
-    const nestedTurn = await engine.runFullTurn(assertionResponse, () => false, context, stepContext, {
-        suppressAssistantOutput: true,
-        debugContextOverride: nestedDebugContext,
-        currentScreenshot: assertionScreenshot,
-    });
-    const currentScreenshot = nestedTurn.currentScreenshot ?? assertionScreenshot;
-    const assertionTranscript = session.transcript.slice(transcriptStartIndex);
+    const assertionText = extractResponseText(assertionResponse);
+    session.addToTranscript(`[Assistant] ${assertionText}`);
+    const assertionTranscript = [assertionText];
     const result = checkAssertionResult(assertionTranscript);
+    const failureDetails = extractFailureDetails(assertionTranscript);
+    const passDetails = extractPassDetails(assertionText);
     if (isDesignContext(context)) {
         const details = result.passed
-            ? "Assertion passed."
-            : `Assertion failed: ${extractFailureDetails(assertionTranscript)}`;
+            ? passDetails
+            : `Assertion failed: ${failureDetails}`;
         if (result.passed) {
-            handleAssertionSuccess(assertionPrompt, context, stepContext, assertionEventPayload);
+            handleAssertionSuccess(assertionPrompt, context, stepContext, {
+                details: passDetails,
+                ...assertionEventPayload,
+            });
         }
         else {
             const addOutput = context?.addOutput || printCliOutput;
@@ -82,7 +166,7 @@ export async function handleAssertionToolCall({ engine, callId, argumentsText, c
                 payload: {
                     assertion: assertionPrompt,
                     passed: false,
-                    details: extractFailureDetails(assertionTranscript),
+                    details: failureDetails,
                     ...assertionEventPayload,
                 },
             });
@@ -92,7 +176,7 @@ export async function handleAssertionToolCall({ engine, callId, argumentsText, c
             outputItem: buildTextToolOutputItem(callId, result.passed
                 ? `ASSERTION RESULT: PASS\n${details}`
                 : `ASSERTION RESULT: FAIL\n${details}`),
-            currentScreenshot,
+            currentScreenshot: assertionScreenshot,
         };
     }
     if (result.failed) {
@@ -134,9 +218,9 @@ export async function handleAssertionToolCall({ engine, callId, argumentsText, c
         if (choice === "skip" || choice === "s") {
             return {
                 kind: "close_turn",
-                outputItem: buildTextToolOutputItem(callId, `ASSERTION RESULT: FAIL\n${extractFailureDetails(assertionTranscript)}`),
+                outputItem: buildTextToolOutputItem(callId, `ASSERTION RESULT: FAIL\n${failureDetails}`),
                 summaryUpdates: { assertionStatus: "failed_skipped" },
-                currentScreenshot,
+                currentScreenshot: assertionScreenshot,
             };
         }
         return {
@@ -145,11 +229,14 @@ export async function handleAssertionToolCall({ engine, callId, argumentsText, c
             summaryUpdates: { assertionStatus: "failed" },
         };
     }
-    handleAssertionSuccess(assertionPrompt, context, stepContext, assertionEventPayload);
+    handleAssertionSuccess(assertionPrompt, context, stepContext, {
+        details: passDetails,
+        ...assertionEventPayload,
+    });
     return {
         kind: "close_turn",
-        outputItem: buildTextToolOutputItem(callId, "ASSERTION RESULT: PASS\nAssertion passed."),
+        outputItem: buildTextToolOutputItem(callId, `ASSERTION RESULT: PASS\n${passDetails}`),
         summaryUpdates: { assertionStatus: "passed" },
-        currentScreenshot,
+        currentScreenshot: assertionScreenshot,
     };
 }

package/build/src/core/tool-handlers/loadmill.js

@@ -10,7 +10,11 @@ export async function handleLoadmillToolCall({ engine, callId, argumentsText, co
     }
     const loadmillCommand = parsed.value;
     session.addToTranscript(`[Loadmill] ${loadmillCommand}`);
-    const result = await engine.executeLoadmillInstruction(loadmillCommand, engine.isHeadlessMode, context, stepContext);
+    const result = await engine.executeLoadmillInstruction(loadmillCommand, engine.isHeadlessMode, {
+        ...context,
+        session,
+        futureInstructions: context?.futureInstructions || [],
+    }, stepContext);
     if (result.retry) {
         return {
             kind: "retry_instruction",
@@ -25,5 +29,8 @@ export async function handleLoadmillToolCall({ engine, callId, argumentsText, co
     return {
         kind: "close_turn",
         outputItem: buildTextToolOutputItem(callId, "Loadmill command completed successfully."),
+        summaryUpdates: result.runtimeParameterContext?.note
+            ? { preserveSessionMessages: true }
+            : undefined,
     };
 }

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

@@ -2,36 +2,12 @@ import { logger } from "../../utils/logger.js";
 import { emitDesktopDebug, truncateForDebug } from "../../utils/desktop-debug.js";
 import { getConfiguredStepDelayMs } from "../../utils/step-delay.js";
 import { buildActionEventMeta } from "../action-event-meta.js";
+import { buildMobileKeypressPayload, getAndroidAdbTransport, normalizeMobileKeypress } from "../mobile-keypress.js";
 import { resolveScrollGesture } from "../scroll-gesture.js";
 import { execAdb } from "./tools.js";
 function adbShell(deviceId, command) {
     return execAdb(["-s", deviceId, "shell", command]);
 }
-function normalizeMobileKeypress(keys = []) {
-    if (!Array.isArray(keys) || keys.length === 0) {
-        throw new Error("Keypress action is missing keys");
-    }
-    if (keys.length > 1) {
-        throw new Error(`Unsupported mobile key chord: ${keys.join(", ")}. Use taps and text entry instead.`);
-    }
-    const key = String(keys[0]).trim().toUpperCase();
-    const mobileKeyMap = {
-        ESC: "KEYCODE_BACK",
-        ESCAPE: "KEYCODE_BACK",
-        HOME: "KEYCODE_HOME",
-        BACK: "KEYCODE_BACK",
-        ENTER: "KEYCODE_ENTER",
-        RETURN: "KEYCODE_ENTER",
-        BACKSPACE: "KEYCODE_DEL",
-        DELETE: "KEYCODE_DEL",
-        SPACE: "KEYCODE_SPACE"
-    };
-    const mappedKey = mobileKeyMap[key];
-    if (!mappedKey) {
-        throw new Error(`Unsupported mobile keypress: ${keys[0]}. Only single mobile-safe keys are allowed.`);
-    }
-    return { originalKey: keys[0], mappedKey };
-}
 export async function handleModelAction(deviceId, action, scale = 1.0, context = null) {
     const addOutput = context?.addOutput || ((item) => console.log(item.text || item));
     const meta = (payload = {}) => buildActionEventMeta({
@@ -109,9 +85,16 @@ export async function handleModelAction(deviceId, action, scale = 1.0, context =
                 break;
             case "keypress":
                 {
-                    const { originalKey, mappedKey } = normalizeMobileKeypress(keys);
-                    addOutput({ type: 'action', text: `Pressing key: ${mappedKey}`, ...meta({ keys: [originalKey], mappedKeys: [mappedKey] }) });
-                    await adbShell(deviceId, `input keyevent ${mappedKey}`);
+                    const normalized = normalizeMobileKeypress("android", keys);
+                    const transport = getAndroidAdbTransport(normalized);
+                    addOutput({
+                        type: 'action',
+                        text: normalized.logText,
+                        ...meta(buildMobileKeypressPayload(normalized, transport, {
+                            mappedKeys: [transport.transportValue]
+                        }))
+                    });
+                    await adbShell(deviceId, `input keyevent ${transport.transportValue}`);
                 }
                 break;
             case "wait":

package/build/src/device/assertions.js

@@ -54,11 +54,7 @@ export function handleAssertionFailure(assertionPrompt, transcript, isHeadlessMo
     addOutput({ type: 'error', text: `Assertion: ${assertionPrompt}`, ...meta });
     addOutput({ type: 'error', text: `Details: ${details}`, ...meta });
     if (isHeadlessMode) {
-        // Headless mode: exit with error code
-        if (context?.exit) {
-            context.exit();
-        }
-        process.exit(1);
+        return;
     }
     // Interactive mode: caller should clear remaining instructions
 }

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

@@ -2,48 +2,9 @@ import { logger } from "../../utils/logger.js";
 import { emitDesktopDebug, truncateForDebug } from "../../utils/desktop-debug.js";
 import { getConfiguredStepDelayMs } from "../../utils/step-delay.js";
 import { buildActionEventMeta } from "../action-event-meta.js";
+import { buildMobileKeypressPayload, getCloudAndroidTransport, getIosTransport, normalizeMobileKeypress } from "../mobile-keypress.js";
 import { getActiveSession, getDevicePixelRatio } from "./connection.js";
 import { resolveScrollGesture } from "../scroll-gesture.js";
-function normalizeMobileKeypress(platform, keys = []) {
-    if (!Array.isArray(keys) || keys.length === 0) {
-        throw new Error("Keypress action is missing keys");
-    }
-    if (keys.length > 1) {
-        throw new Error(`Unsupported mobile key chord: ${keys.join(", ")}. Use taps and text entry instead.`);
-    }
-    const key = String(keys[0]).trim().toUpperCase();
-    if (platform === "ios") {
-        if (key === "ESC" || key === "ESCAPE" || key === "HOME") {
-            return { kind: "ios-button", originalKey: keys[0], mapped: "home" };
-        }
-        if (key === "ENTER" || key === "RETURN") {
-            return { kind: "text", originalKey: keys[0], mapped: "\n", label: "Return key" };
-        }
-        if (key === "BACKSPACE" || key === "DELETE") {
-            return { kind: "text", originalKey: keys[0], mapped: "\b", label: "Delete key" };
-        }
-        if (key === "SPACE") {
-            return { kind: "text", originalKey: keys[0], mapped: " ", label: "Space key" };
-        }
-        throw new Error(`Unsupported mobile keypress: ${keys[0]}. Only single mobile-safe keys are allowed.`);
-    }
-    const androidKeyMap = {
-        ESC: 3,
-        ESCAPE: 3,
-        HOME: 3,
-        BACK: 4,
-        ENTER: 66,
-        RETURN: 66,
-        BACKSPACE: 67,
-        DELETE: 67,
-        SPACE: 62
-    };
-    const keycode = androidKeyMap[key];
-    if (!keycode) {
-        throw new Error(`Unsupported mobile keypress: ${keys[0]}. Only single mobile-safe keys are allowed.`);
-    }
-    return { kind: "android-keycode", originalKey: keys[0], keycode };
-}
 export async function handleModelAction(deviceId, action, scale = 1.0, context = null) {
     const addOutput = context?.addOutput || ((item) => console.log(item.text || item));
     const session = getActiveSession();
@@ -128,17 +89,40 @@ export async function handleModelAction(deviceId, action, scale = 1.0, context =
             }
             case "keypress": {
                 const normalized = normalizeMobileKeypress(platform, action.keys);
-                if (normalized.kind === "ios-button") {
-                    addOutput({ type: "action", text: "Pressing Home button", ...meta({ keys: [normalized.originalKey], mapped: normalized.mapped }) });
-                    await session.client.pressIosButton(session.sessionId, normalized.mapped);
-                }
-                else if (normalized.kind === "android-keycode") {
-                    addOutput({ type: "action", text: `Pressing keycode ${normalized.keycode}`, ...meta({ keys: [normalized.originalKey], keycode: normalized.keycode }) });
-                    await session.client.pressAndroidKeyCode(session.sessionId, normalized.keycode);
+                if (platform === "ios") {
+                    const transport = getIosTransport(normalized);
+                    if (transport.transportType === "noop") {
+                        addOutput({
+                            type: "info",
+                            text: normalized.logText,
+                            ...meta(buildMobileKeypressPayload(normalized, transport, { ignored: true }))
+                        });
+                    }
+                    else if (transport.transportType === "ios-button") {
+                        addOutput({
+                            type: "action",
+                            text: normalized.logText,
+                            ...meta(buildMobileKeypressPayload(normalized, transport))
+                        });
+                        await session.client.pressIosButton(session.sessionId, transport.transportValue);
+                    }
+                    else {
+                        addOutput({
+                            type: "action",
+                            text: normalized.logText,
+                            ...meta(buildMobileKeypressPayload(normalized, transport))
+                        });
+                        await session.client.type(session.sessionId, transport.transportValue);
+                    }
                 }
                 else {
-                    addOutput({ type: "action", text: `Pressing ${normalized.label}`, ...meta({ keys: [normalized.originalKey], mapped: normalized.label }) });
-                    await session.client.type(session.sessionId, normalized.mapped);
+                    const transport = getCloudAndroidTransport(normalized);
+                    addOutput({
+                        type: "action",
+                        text: normalized.logText,
+                        ...meta(buildMobileKeypressPayload(normalized, transport, { keycode: transport.keycode }))
+                    });
+                    await session.client.pressAndroidKeyCode(session.sessionId, transport.keycode);
                 }
                 break;
             }

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

@@ -3,7 +3,7 @@ import { getCloudProviderAdapter } from "./registry.js";
 import { CloudAppiumClient } from "./cloud-appium-client.js";
 let activeSession = null;
 function buildCloudCapabilities(options) {
-    const { providerId, platform, deviceName, osVersion, appRef, credentials } = options;
+    const { providerId, platform, deviceName, osVersion, appRef, credentials, buildName, sessionName } = options;
     const adapter = getCloudProviderAdapter(providerId);
     if (!adapter) {
         throw new Error(`Cloud provider "${providerId}" is not registered.`);
@@ -18,8 +18,8 @@ function buildCloudCapabilities(options) {
             username: credentials?.username,
             accessKey: credentials?.accessKey,
             projectName: "droid-cua",
-            buildName: `desktop-${new Date().toISOString().slice(0, 10)}`,
-            sessionName: `${deviceName} (${platform})`
+            buildName: buildName || `desktop-${new Date().toISOString().slice(0, 10)}`,
+            sessionName: sessionName || `${deviceName} (${platform})`
         }
     };
 }
@@ -27,7 +27,7 @@ export async function connectToDevice(options) {
     if (!options || typeof options !== "object") {
         throw new Error("Cloud device connection requires a provider payload.");
     }
-    const { providerId, platform, deviceName, osVersion, appRef, credentials } = options;
+    const { providerId, platform, deviceName, osVersion, appRef, credentials, buildName, sessionName } = options;
     if (!providerId || !platform || !deviceName || !osVersion || !appRef) {
         throw new Error("Cloud device connection is missing required session details.");
     }
@@ -40,7 +40,9 @@ export async function connectToDevice(options) {
         deviceName,
         osVersion,
         appRef,
-        credentials
+        credentials,
+        buildName,
+        sessionName
     });
     const client = new CloudAppiumClient(platform, adapter, credentials);
     console.log(`Creating ${adapter.displayName} session on ${deviceName} (${osVersion})...`);

package/build/src/device/cloud/lambdatest/adapter.js

@@ -5,6 +5,7 @@ const DEVICE_REGIONS = ["us", "ap", "eu"];
 const DEVICE_LIST_URL = "https://mobile-api.lambdatest.com/mobile-automation/api/v1/list";
 const APP_UPLOAD_URL = "https://manual-api.lambdatest.com/app/upload/realDevice";
 const APP_DATA_URL = "https://manual-api.lambdatest.com/app/data";
+const SESSION_DATA_URL = "https://mobile-api.lambdatest.com/mobile-automation/api/v1/sessions";
 function notImplemented(methodName) {
     throw new Error(`LambdaTest adapter stub: ${methodName} is not implemented yet.`);
 }
@@ -307,6 +308,54 @@ async function lookupUploadedApp(creds, ref) {
     }
     return null;
 }
+function unwrapSessionPayload(payload) {
+    if (typeof payload !== "object" || payload === null || Array.isArray(payload)) {
+        return null;
+    }
+    if (typeof payload.data === "object" && payload.data !== null && !Array.isArray(payload.data)) {
+        return payload.data;
+    }
+    return payload;
+}
+async function fetchSessionArtifacts(creds, sessionId) {
+    const fallbackDashboardUrl = `https://automation.lambdatest.com/logs/?sessionID=${encodeURIComponent(sessionId)}`;
+    const response = await fetch(`${SESSION_DATA_URL}/${encodeURIComponent(sessionId)}`, {
+        method: "GET",
+        headers: {
+            Authorization: lambdaTestAdapter.getAuthHeader(creds)
+        }
+    });
+    if (!response.ok) {
+        return {
+            dashboardUrl: fallbackDashboardUrl
+        };
+    }
+    const session = unwrapSessionPayload(await response.json());
+    const testId = normalizeString(session?.test_id) ?? normalizeString(session?.testID) ?? normalizeString(session?.testId);
+    const buildId = normalizeString(session?.build_id) ??
+        normalizeString(session?.buildID) ??
+        normalizeString(session?.buildId) ??
+        (Number.isFinite(session?.build_id) ? String(session.build_id) : undefined) ??
+        (Number.isFinite(session?.buildId) ? String(session.buildId) : undefined);
+    if (!testId || !buildId) {
+        return {
+            dashboardUrl: fallbackDashboardUrl
+        };
+    }
+    const params = new URLSearchParams({
+        build: buildId,
+        testID: testId,
+    });
+    return {
+        dashboardUrl: `https://appautomation.lambdatest.com/test?${params.toString()}`,
+        consoleLogsUrl: normalizeString(session?.console_logs_url),
+        networkLogsUrl: normalizeString(session?.network_logs_url),
+        commandLogsUrl: normalizeString(session?.command_logs_url),
+        appiumLogsUrl: normalizeString(session?.appium_logs_url),
+        deviceLogsUrl: normalizeString(session?.device_logs_url),
+        crashLogsUrl: normalizeString(session?.crash_logs_url)
+    };
+}
 /** @type {import("../adapter").CloudProviderAdapter} */
 export const lambdaTestAdapter = {
     id: "lambdatest",
@@ -391,10 +440,8 @@ export const lambdaTestAdapter = {
         const accessKey = typeof creds.accessKey === "string" ? creds.accessKey : "";
         return `Basic ${Buffer.from(`${username}:${accessKey}`).toString("base64")}`;
     },
-    async getSessionArtifacts(_creds, sessionId) {
-        return {
-            dashboardUrl: `https://automation.lambdatest.com/logs/?sessionID=${encodeURIComponent(sessionId)}`
-        };
+    async getSessionArtifacts(creds, sessionId) {
+        return fetchSessionArtifacts(creds, sessionId);
     },
     async setSessionStatus(_creds, _sessionId, _status) {
         return notImplemented("setSessionStatus");