@loadmill/droid-cua 2.22.0 → 2.24.0

package/build/src/core/session.js

@@ -56,6 +56,12 @@ export class Session {
     getTranscriptText() {
         return this.transcript.join("\n");
     }
+    /**
+     * Clear the per-instruction transcript.
+     */
+    clearTranscript() {
+        this.transcript = [];
+    }
     /**
      * Update the previous response ID for chaining
      */

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

@@ -29,6 +29,9 @@ export async function handleLoadmillToolCall({ engine, callId, argumentsText, co
     return {
         kind: "close_turn",
         outputItem: buildTextToolOutputItem(callId, "Loadmill command completed successfully."),
+        nextTurnConfig: {
+            attachFreshScreenshotOnContinuation: true,
+        },
         summaryUpdates: result.runtimeParameterContext?.note
             ? { preserveSessionMessages: true }
             : undefined,

package/build/src/core/tool-handlers/test-design-complete.js

@@ -88,6 +88,7 @@ export async function handleTestDesignCompleteToolCall({ engine, callId, argumen
                 testDesignComplete: false,
             },
             includeComputerToolOverride: false,
+            continuationMode: "fresh",
         },
     };
 }

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

@@ -58,5 +58,6 @@ export async function handleTypeSensitiveTextToolCall({ engine, callId, argument
             imageBase64: screenshotBase64,
         })),
         currentScreenshot,
+        executedActions: [action],
     };
 }

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

@@ -51,8 +51,12 @@ export async function handleModelAction(deviceId, action, scale = 1.0, context =
             case "scroll":
                 const { scrollX, scrollY, startX, startY, endX, endY, hasAnchor } = resolveScrollGesture(action, {
                     scale,
-                    fallbackStartX: 500,
-                    fallbackStartY: 500
+                    fallbackStartX: Number.isFinite(context?.fallbackScrollStartX) ? Math.round(context.fallbackScrollStartX) : 500,
+                    fallbackStartY: Number.isFinite(context?.fallbackScrollStartY) ? Math.round(context.fallbackScrollStartY) : 500,
+                    minX: 0,
+                    maxX: Number.isFinite(context?.deviceWidth) ? Math.round(context.deviceWidth) - 1 : undefined,
+                    minY: 0,
+                    maxY: Number.isFinite(context?.deviceHeight) ? Math.round(context.deviceHeight) - 1 : undefined
                 });
                 addOutput({
                     type: 'action',

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

@@ -21,6 +21,18 @@ async function listConnectedDevices() {
     })
         .filter(entry => entry.id.length > 0);
 }
+export function getAndroidConnectErrorMessage({ state, avdName } = {}) {
+    if (state === "offline" && avdName) {
+        return `Emulator "${avdName}" is running but offline. Restart adb or cold boot the emulator, then retry.`;
+    }
+    if (state === "offline") {
+        return "Device is offline. Reconnect device or restart adb.";
+    }
+    if (state === "unauthorized") {
+        return "Authorize this computer on the device and retry.";
+    }
+    return "Selected device is no longer connected. Refresh and select again.";
+}
 function wait(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -35,6 +47,14 @@ function parseTargetToken(rawTarget) {
     }
     return { kind: "legacy", value: rawTarget };
 }
+function normalizeAvdName(value) {
+    const parts = value
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .filter((line) => line.toUpperCase() !== "OK");
+    return parts[0] || "";
+}
 async function getEmulatorAvdName(serial) {
     const candidates = [
         ["-s", serial, "emu", "avd", "name"],
@@ -45,7 +65,7 @@ async function getEmulatorAvdName(serial) {
     for (const args of candidates) {
         try {
             const { stdout } = await execAdb(args);
-            const value = stdout.trim();
+            const value = normalizeAvdName(stdout);
             if (value)
                 return value;
         }
@@ -74,16 +94,23 @@ function emulatorLaunchTimeoutError() {
     return new Error(`Emulator launch timed out after ${AVD_READY_TIMEOUT_SECONDS}s. Check AVD health and retry.`);
 }
 async function findRunningEmulatorByAvdName(avdName) {
+    const match = await findConnectedEmulatorByAvdName(avdName, { includeOffline: false });
+    return match?.state === "device" ? match.id : null;
+}
+async function findConnectedEmulatorByAvdName(avdName, options = {}) {
     const devices = await listConnectedDevices();
-    const readyEmulators = devices.filter((entry) => entry.state === "device" && entry.id.startsWith("emulator-"));
-    for (const entry of readyEmulators) {
+    const emulatorEntries = devices.filter((entry) => entry.id.startsWith("emulator-") && (options.includeOffline || entry.state === "device"));
+    for (const entry of emulatorEntries) {
         const runningAvdName = await getEmulatorAvdName(entry.id);
         if (runningAvdName === avdName) {
-            return entry.id;
+            return entry;
         }
     }
     return null;
 }
+function offlineEmulatorError(avdName) {
+    return new Error(getAndroidConnectErrorMessage({ state: "offline", avdName }));
+}
 async function launchAndWaitForAvd(avdName, timeoutMs = AVD_READY_TIMEOUT_MS, options = {}) {
     const log = options.log || console.log;
     let avdExists = false;
@@ -99,6 +126,10 @@ async function launchAndWaitForAvd(avdName, timeoutMs = AVD_READY_TIMEOUT_MS, op
     if (!avdExists) {
         throw new Error(`AVD "${avdName}" was not found. Create it in Android Studio and retry.`);
     }
+    const offlineMatch = await findConnectedEmulatorByAvdName(avdName, { includeOffline: true });
+    if (offlineMatch?.state === "offline") {
+        throw offlineEmulatorError(avdName);
+    }
     const baseline = await listConnectedDevices();
     const baselineReadyEmulators = new Set(baseline.filter((entry) => entry.state === "device" && entry.id.startsWith("emulator-")).map((entry) => entry.id));
     log(`Launching Android emulator "${avdName}"...`);
@@ -128,12 +159,16 @@ export async function connectToDevice(deviceTargetId, options = {}) {
     const readyDevices = devices.filter((entry) => entry.state === "device");
     if (parsedTarget.kind === "auto") {
         if (readyDevices.length === 0) {
+            const offlineEmulator = devices.find((entry) => entry.state === "offline" && entry.id.startsWith("emulator-"));
+            const message = offlineEmulator
+                ? "Android emulator is running but offline. Restart adb or cold boot the emulator, then retry."
+                : "No ready Android devices found. Connect a device (or start an emulator), authorize adb, and retry.";
             emitDesktopDebug("device.error", "device", {}, {
                 platform: "android",
                 operation: "connect",
-                message: "No ready Android devices detected."
+                message
             });
-            throw new Error("No ready Android devices found. Connect a device (or start an emulator), authorize adb, and retry.");
+            throw new Error(message);
         }
         const selected = readyDevices[0].id;
         log(`Using connected Android device: ${selected}`);
@@ -142,15 +177,18 @@ export async function connectToDevice(deviceTargetId, options = {}) {
     }
     if (parsedTarget.kind === "avd") {
         const deadline = Date.now() + AVD_READY_TIMEOUT_MS;
-        const alreadyRunning = await findRunningEmulatorByAvdName(parsedTarget.avdName);
-        if (alreadyRunning) {
-            const ready = await waitForWindowServiceReady(alreadyRunning, remainingTimeoutMs(deadline));
+        const existingEmulator = await findConnectedEmulatorByAvdName(parsedTarget.avdName, { includeOffline: true });
+        if (existingEmulator?.state === "offline") {
+            throw offlineEmulatorError(parsedTarget.avdName);
+        }
+        if (existingEmulator?.state === "device") {
+            const ready = await waitForWindowServiceReady(existingEmulator.id, remainingTimeoutMs(deadline));
             if (!ready) {
                 throw emulatorLaunchTimeoutError();
             }
-            log(`Using already-running emulator for AVD "${parsedTarget.avdName}": ${alreadyRunning}`);
-            emitDesktopDebug("device.connect", "device", {}, { platform: "android", stage: "success", deviceId: alreadyRunning, reused: true });
-            return alreadyRunning;
+            log(`Using already-running emulator for AVD "${parsedTarget.avdName}": ${existingEmulator.id}`);
+            emitDesktopDebug("device.connect", "device", {}, { platform: "android", stage: "success", deviceId: existingEmulator.id, reused: true });
+            return existingEmulator.id;
         }
         const launchedId = await launchAndWaitForAvd(parsedTarget.avdName, remainingTimeoutMs(deadline), { log });
         const ready = await waitForWindowServiceReady(launchedId, remainingTimeoutMs(deadline));
@@ -179,19 +217,16 @@ export async function connectToDevice(deviceTargetId, options = {}) {
         return targetId;
     }
     if (parsedTarget.kind === "legacy" && targetId) {
-        const runningLegacyAvd = await findRunningEmulatorByAvdName(targetId);
-        if (runningLegacyAvd) {
-            emitDesktopDebug("device.connect", "device", {}, { platform: "android", stage: "success", deviceId: runningLegacyAvd, reused: true });
-            return runningLegacyAvd;
+        const matchedLegacyAvd = await findConnectedEmulatorByAvdName(targetId, { includeOffline: true });
+        if (matchedLegacyAvd?.state === "offline") {
+            throw offlineEmulatorError(targetId);
+        }
+        if (matchedLegacyAvd?.state === "device") {
+            emitDesktopDebug("device.connect", "device", {}, { platform: "android", stage: "success", deviceId: matchedLegacyAvd.id, reused: true });
+            return matchedLegacyAvd.id;
         }
     }
-    let message = "Selected device is no longer connected. Refresh and select again.";
-    if (state === "offline") {
-        message = "Device is offline. Reconnect device or restart adb.";
-    }
-    else if (state === "unauthorized") {
-        message = "Authorize this computer on the device and retry.";
-    }
+    const message = getAndroidConnectErrorMessage({ state });
     emitDesktopDebug("device.error", "device", {}, { platform: "android", operation: "connect", message, targetId: targetId || deviceTargetId, state: state || "missing" });
     throw new Error(message);
 }

package/build/src/device/assertions.js

@@ -3,21 +3,28 @@
  */
 import { printCliOutput } from "../utils/console-output.js";
 export { buildAssertionSystemPrompt } from "../prompts/execution.js";
+const ASSERTION_PREFIXES = ["assert", "verify", "validate", "ensure"];
+function hasAssertionPrefix(lower) {
+    return ASSERTION_PREFIXES.some((prefix) => lower === prefix || lower.startsWith(`${prefix}:`) || lower.startsWith(`${prefix} `));
+}
 export function isAssertion(userInput) {
     const trimmed = userInput.trim();
     const lower = trimmed.toLowerCase();
-    return lower.startsWith("assert:") || lower.startsWith("assert ");
+    return hasAssertionPrefix(lower);
 }
 export function extractAssertionPrompt(userInput) {
     const trimmed = userInput.trim();
     const lower = trimmed.toLowerCase();
-    // Handle "assert:" or "Assert:"
-    if (lower.startsWith("assert:")) {
-        return trimmed.substring("assert:".length).trim();
-    }
-    // Handle "assert " or "Assert "
-    if (lower.startsWith("assert ")) {
-        return trimmed.substring("assert".length).trim();
+    for (const prefix of ASSERTION_PREFIXES) {
+        if (lower === prefix) {
+            return trimmed;
+        }
+        if (lower.startsWith(`${prefix}:`)) {
+            return trimmed.substring(prefix.length + 1).trim();
+        }
+        if (lower.startsWith(`${prefix} `)) {
+            return trimmed.substring(prefix.length).trim();
+        }
     }
     return trimmed;
 }

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

@@ -14,11 +14,11 @@ const execAsync = promisify(exec);
 // Active session state
 let activeSession = null;
 /**
- * Get simulator UDID by name (prefers already-booted simulator)
- * @param {string} simulatorName
- * @returns {Promise<string|null>}
+ * Resolve simulator by UDID or name (name matches prefer already-booted simulators).
+ * @param {string} simulatorNameOrUdid
+ * @returns {Promise<{name: string, udid: string, state: string}|null>}
  */
-async function getSimulatorUDID(simulatorName) {
+async function resolveSimulator(simulatorNameOrUdid) {
     try {
         const { stdout } = await execAsync("xcrun simctl list devices --json");
         const data = JSON.parse(stdout);
@@ -26,25 +26,31 @@ async function getSimulatorUDID(simulatorName) {
         let bootedMatch = null;
         for (const runtime of Object.values(data.devices)) {
             for (const device of runtime) {
-                if (device.name === simulatorName && device.isAvailable) {
+                if (!device.isAvailable) {
+                    continue;
+                }
+                if (device.udid === simulatorNameOrUdid) {
+                    return { name: device.name, udid: device.udid, state: device.state };
+                }
+                if (device.name === simulatorNameOrUdid) {
+                    const match = { name: device.name, udid: device.udid, state: device.state };
                     if (!firstMatch) {
-                        firstMatch = device.udid;
+                        firstMatch = match;
                     }
-                    // Prefer the already-booted one
                     if (device.state === "Booted") {
-                        bootedMatch = device.udid;
+                        bootedMatch = match;
                     }
                 }
             }
         }
         if (bootedMatch) {
-            logger.debug(`Found booted simulator: ${bootedMatch}`);
+            logger.debug(`Found booted simulator: ${bootedMatch.udid}`);
             return bootedMatch;
         }
         return firstMatch;
     }
     catch (error) {
-        logger.error("Failed to get simulator UDID", { error: error.message });
+        logger.error("Failed to resolve simulator", { error: error.message });
     }
     return null;
 }
@@ -84,33 +90,33 @@ async function findAnySimulator() {
  */
 async function bootSimulator(simulatorName, options = {}) {
     const log = options.log || console.log;
-    const udid = await getSimulatorUDID(simulatorName);
-    if (!udid) {
+    const simulator = await resolveSimulator(simulatorName);
+    if (!simulator) {
         throw new Error(`Simulator "${simulatorName}" not found. Run "xcrun simctl list devices" to see available simulators.`);
     }
-    log(`Found simulator "${simulatorName}" with UDID: ${udid}`);
+    log(`Found simulator "${simulator.name}" with UDID: ${simulator.udid}`);
     // Check if already booted
     const { stdout } = await execAsync("xcrun simctl list devices --json");
     const data = JSON.parse(stdout);
     for (const runtime of Object.values(data.devices)) {
         for (const device of runtime) {
-            if (device.udid === udid) {
+            if (device.udid === simulator.udid) {
                 if (device.state === "Booted") {
-                    log(`Simulator "${simulatorName}" is already booted`);
-                    return udid;
+                    log(`Simulator "${simulator.name}" is already booted`);
+                    return simulator;
                 }
                 break;
             }
         }
     }
-    log(`Booting simulator "${simulatorName}"...`);
-    await execAsync(`xcrun simctl boot ${udid}`);
+    log(`Booting simulator "${simulator.name}"...`);
+    await execAsync(`xcrun simctl boot ${simulator.udid}`);
     // Open Simulator app to show the device
     await execAsync("open -a Simulator");
     // Wait for boot to complete
-    await waitForSimulatorBoot(udid);
-    log(`Simulator "${simulatorName}" is fully booted`);
-    return udid;
+    await waitForSimulatorBoot(simulator.udid);
+    log(`Simulator "${simulator.name}" is fully booted`);
+    return simulator;
 }
 /**
  * Wait for simulator to finish booting
@@ -163,30 +169,30 @@ export async function connectToDevice(simulatorName, options = {}) {
         log(`No simulator specified, using: ${simulatorName}`);
     }
     // Boot simulator
-    const udid = await bootSimulator(simulatorName, { log });
+    const simulator = await bootSimulator(simulatorName, { log });
     // Create Appium session
     log("Creating Appium session...");
     const session = await appium.createSession({
         platformName: "iOS",
         "appium:automationName": "XCUITest",
-        "appium:deviceName": simulatorName,
-        "appium:udid": udid,
+        "appium:deviceName": simulator.name,
+        "appium:udid": simulator.udid,
         "appium:noReset": true,
         "appium:shouldTerminateApp": false,
     });
     activeSession = {
         sessionId: session.sessionId,
-        udid,
-        simulatorName,
+        udid: simulator.udid,
+        simulatorName: simulator.name,
     };
-    log(`Connected to simulator "${simulatorName}" (${udid})`);
+    log(`Connected to simulator "${simulator.name}" (${simulator.udid})`);
     emitDesktopDebug("device.connect", "device", {}, {
         platform: "ios",
         stage: "success",
-        simulatorName,
-        udid
+        simulatorName: simulator.name,
+        udid: simulator.udid
     });
-    return udid;
+    return simulator.udid;
 }
 /**
  * Get device info (screen dimensions and scale)

package/build/src/device/openai.js

@@ -1,10 +1,16 @@
 import { buildTestRevisionSystemPrompt } from "../prompts/editor.js";
 import { createOpenAiClient, LOADMILL_MODEL_ALIASES, resolveEffectiveHelperModel, resolveRuntimeConfig, } from "../core/runtime-config.js";
+import { LOADMILL_CUA_MODELS } from "../core/cua-models.js";
 import { DEFAULT_AIM_ASSIST_MODE } from "../core/aim-assist.js";
 import { DEFAULT_CONTEXT_OPTIMIZATION_THRESHOLD } from "../core/context-optimization.js";
 import { logger } from "../utils/logger.js";
 import { CuaDebugTracer } from "../utils/cua-debug-tracer.js";
 const cuaDebugTracer = new CuaDebugTracer(logger);
+const LOADMILL_DEVICE_METADATA_MODELS = new Set([
+    ...LOADMILL_CUA_MODELS,
+    LOADMILL_MODEL_ALIASES.SMART,
+    LOADMILL_MODEL_ALIASES.BEACON,
+]);
 function resolveOpenAiBaseUrl(client) {
     return client?.baseURL || client?.baseUrl || client?._options?.baseURL || null;
 }
@@ -121,6 +127,8 @@ const typeSensitiveTextTool = {
         additionalProperties: false,
     },
 };
+// Design completion is the handoff into script generation; it is separate from
+// execution step-completion markers used by model adapters.
 const testDesignCompleteTool = {
     type: "function",
     name: "test_design_complete",
@@ -235,7 +243,64 @@ function buildContextManagement(contextOptimizationEnabled, contextOptimizationT
     }
     return [{ type: "compaction", compact_threshold: contextOptimizationThreshold }];
 }
-export function buildCuaRequestParams({ cuaModel, aimAssistMode = DEFAULT_AIM_ASSIST_MODE, previousResponseId, input, includeComputerTool = true, contextOptimizationEnabled = true, contextOptimizationThreshold = DEFAULT_CONTEXT_OPTIMIZATION_THRESHOLD, toolCapabilities = {}, }) {
+function normalizeDevicePlatform(deviceInfo = {}) {
+    return typeof deviceInfo?.platform === "string"
+        ? deviceInfo.platform.trim().toLowerCase()
+        : "";
+}
+function resolveComputerToolDeviceType(deviceInfo = {}) {
+    const platform = normalizeDevicePlatform(deviceInfo);
+    if (platform === "browser") {
+        return "web";
+    }
+    if (platform === "ios") {
+        return "iphone";
+    }
+    if (platform === "android") {
+        return "android";
+    }
+    return null;
+}
+function resolveComputerToolEnvironment(deviceInfo = {}) {
+    const platform = normalizeDevicePlatform(deviceInfo);
+    if (platform === "browser") {
+        return "browser";
+    }
+    if (platform === "ios" || platform === "android") {
+        return "mobile";
+    }
+    return null;
+}
+function resolveDisplayDimension(value) {
+    return Number.isFinite(value) && value > 0 ? Math.round(value) : null;
+}
+function usesLoadmillDeviceMetadata(cuaModel) {
+    return LOADMILL_DEVICE_METADATA_MODELS.has(cuaModel);
+}
+function buildComputerTool({ cuaModel, deviceInfo } = {}) {
+    const tool = { type: "computer" };
+    if (!usesLoadmillDeviceMetadata(cuaModel)) {
+        return tool;
+    }
+    const environment = resolveComputerToolEnvironment(deviceInfo);
+    const deviceType = resolveComputerToolDeviceType(deviceInfo);
+    const displayWidth = resolveDisplayDimension(deviceInfo?.scaled_width);
+    const displayHeight = resolveDisplayDimension(deviceInfo?.scaled_height);
+    if (environment) {
+        tool.environment = environment;
+    }
+    if (deviceType) {
+        tool.device_type = deviceType;
+    }
+    if (displayWidth) {
+        tool.display_width = displayWidth;
+    }
+    if (displayHeight) {
+        tool.display_height = displayHeight;
+    }
+    return tool;
+}
+export function buildCuaRequestParams({ cuaModel, aimAssistMode = DEFAULT_AIM_ASSIST_MODE, previousResponseId, input, deviceInfo = null, includeComputerTool = true, contextOptimizationEnabled = true, contextOptimizationThreshold = DEFAULT_CONTEXT_OPTIMIZATION_THRESHOLD, toolCapabilities = {}, }) {
     const contextManagement = buildContextManagement(contextOptimizationEnabled, contextOptimizationThreshold);
     // Keep Responses API storage enabled on every turn so execution can chain
     // reliably through previous_response_id across the whole run.
@@ -248,7 +313,7 @@ export function buildCuaRequestParams({ cuaModel, aimAssistMode = DEFAULT_AIM_AS
         store: true,
         truncation: "auto",
         tools: [
-            ...(includeComputerTool ? [{ type: "computer" }] : []),
+            ...(includeComputerTool ? [buildComputerTool({ cuaModel, deviceInfo })] : []),
             ...buildFunctionTools({ aimAssistMode, toolCapabilities }),
         ],
     };
@@ -294,6 +359,7 @@ export async function sendCUARequest({ client, cuaModel, aimAssistMode = DEFAULT
         aimAssistMode,
         previousResponseId,
         input,
+        deviceInfo,
         includeComputerTool,
         contextOptimizationEnabled,
         contextOptimizationThreshold,

package/build/src/device/scroll-gesture.js

@@ -1,20 +1,33 @@
 // The model returns scroll actions with `scroll_x` / `scroll_y` plus optional
 // anchor coordinates `x` / `y`. This helper converts those model coordinates
 // into backend gesture coordinates: startX/startY and endX/endY.
-export function resolveScrollGesture(action, { scale = 1.0, dpr = 1.0, fallbackStartX = 0, fallbackStartY = 0 } = {}) {
+export function resolveScrollGesture(action, { scale = 1.0, dpr = 1.0, fallbackStartX = 0, fallbackStartY = 0, minX, maxX, minY, maxY } = {}) {
+    const clamp = (value, min, max) => {
+        if (!Number.isFinite(value)) {
+            return value;
+        }
+        if (!Number.isFinite(min) || !Number.isFinite(max) || min > max) {
+            return value;
+        }
+        return Math.min(Math.max(value, min), max);
+    };
     const divisor = scale * dpr;
-    const scrollX = Math.round((action?.scroll_x ?? 0) / divisor);
-    const scrollY = Math.round((action?.scroll_y ?? 0) / divisor);
+    const requestedScrollX = Math.round((action?.scroll_x ?? 0) / divisor);
+    const requestedScrollY = Math.round((action?.scroll_y ?? 0) / divisor);
     const hasAnchor = Number.isFinite(action?.x) && Number.isFinite(action?.y);
-    const startX = hasAnchor ? Math.round(action.x / divisor) : Math.round(fallbackStartX);
-    const startY = hasAnchor ? Math.round(action.y / divisor) : Math.round(fallbackStartY);
+    const unclampedStartX = hasAnchor ? Math.round(action.x / divisor) : Math.round(fallbackStartX);
+    const unclampedStartY = hasAnchor ? Math.round(action.y / divisor) : Math.round(fallbackStartY);
+    const startX = clamp(unclampedStartX, minX, maxX);
+    const startY = clamp(unclampedStartY, minY, maxY);
+    const endX = clamp(startX + requestedScrollX, minX, maxX);
+    const endY = clamp(startY - requestedScrollY, minY, maxY);
     return {
-        scrollX,
-        scrollY,
+        scrollX: endX - startX,
+        scrollY: startY - endY,
         startX,
         startY,
-        endX: startX + scrollX,
-        endY: startY - scrollY,
+        endX,
+        endY,
         hasAnchor
     };
 }

package/build/src/integrations/loadmill/client.js

@@ -138,10 +138,10 @@ export function createLoadmillApiClient({ token = null, baseUrl = null, onUnauth
             body: JSON.stringify(payload),
         });
     }
-    async function getCurrentUser() {
+    async function validateApiToken() {
         const resolvedToken = getApiToken();
         if (!resolvedToken) {
-            return null;
+            return { valid: false, reason: "missing" };
         }
         const response = await fetch(`${getSiteBaseUrl()}/auth/logged-in-user`, {
             method: "GET",
@@ -150,11 +150,26 @@ export function createLoadmillApiClient({ token = null, baseUrl = null, onUnauth
                 Authorization: `Bearer ${resolvedToken}`,
             },
         });
+        if (response.status === 401 || response.status === 403) {
+            return { valid: false, reason: "invalid", status: response.status };
+        }
         if (!response.ok) {
-            return null;
+            return { valid: false, reason: "unavailable", status: response.status };
+        }
+        try {
+            const user = extractLoadmillSessionUser(await response.json());
+            return user
+                ? { valid: true, user }
+                : { valid: false, reason: "unavailable", status: response.status };
+        }
+        catch {
+            return { valid: false, reason: "unavailable", status: response.status };
         }
+    }
+    async function getCurrentUser() {
         try {
-            return extractLoadmillSessionUser(await response.json());
+            const validation = await validateApiToken();
+            return validation.valid ? validation.user : null;
         }
         catch {
             return null;
@@ -172,6 +187,7 @@ export function createLoadmillApiClient({ token = null, baseUrl = null, onUnauth
         getTestSuiteFlowRun,
         explainFailure,
         reportDroidRun,
+        validateApiToken,
         getCurrentUser,
     };
 }

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

@@ -206,7 +206,7 @@ export class DesignModeInk {
                     toolCapabilities: this.engine.toolCapabilities,
                 });
                 // Run turn with action tracking and interruption checking
-                const { responseId: newResponseId } = await this.engine.runFullTurn(response, (action) => {
+                const { responseId: newResponseId, summary: turnSummary } = await this.engine.runFullTurn(response, (action) => {
                     // Check if user interrupted - stop immediately
                     if (this.inputQueue.length > 0) {
                         return true; // Signal to stop execution
@@ -223,6 +223,15 @@ export class DesignModeInk {
                     }
                     return false; // Continue execution
                 }, this.context, null, { currentScreenshot });
+                if (turnSummary.failed) {
+                    if (this.context.setAgentWorking) {
+                        this.context.setAgentWorking(false);
+                    }
+                    addOutput({ type: 'error', text: turnSummary.error || 'Design mode stopped.' });
+                    this.conversationActive = false;
+                    this.cleanup();
+                    return;
+                }
                 this.session.updateResponseId(newResponseId);
                 this.consecutiveErrorCount = 0;
                 // Clear agent working status

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

@@ -170,7 +170,7 @@ export class DesignMode {
                     toolCapabilities: this.engine.toolCapabilities,
                 });
                 // Run turn with action tracking and interruption checking
-                const { responseId: newResponseId } = await this.engine.runFullTurn(response, (action) => {
+                const { responseId: newResponseId, summary: turnSummary } = await this.engine.runFullTurn(response, (action) => {
                     // Check if user pressed ESC - stop immediately
                     if (this.escPressed) {
                         return true; // Signal to stop execution
@@ -188,6 +188,12 @@ export class DesignMode {
                     }
                     return false; // Continue execution
                 }, null, null, { currentScreenshot });
+                if (turnSummary.failed) {
+                    this.cleanupEscDetection(keypressHandler);
+                    console.log(`\n${turnSummary.error || "Design mode stopped."}`);
+                    this.conversationActive = false;
+                    return;
+                }
                 this.session.updateResponseId(newResponseId);
                 this.consecutiveErrorCount = 0;
                 // Cleanup ESC detection