@loadmill/droid-cua 2.21.0 → 2.23.0

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

@@ -19,6 +19,51 @@ 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 { buildDebugContext, buildTextToolOutputItem, } from "./tool-handlers/utils.js";
+const HOLO_RESPONSE_ID_PREFIX = "resp_holo_";
+function isHoloResponseId(responseId) {
+    return typeof responseId === "string" && responseId.startsWith(HOLO_RESPONSE_ID_PREFIX);
+}
+function isImageOutputChunk(chunk) {
+    if (!chunk || typeof chunk !== "object") {
+        return false;
+    }
+    if (chunk.type !== "input_image" && chunk.type !== "image_url") {
+        return false;
+    }
+    if (typeof chunk.image_url === "string") {
+        return chunk.image_url.trim().length > 0;
+    }
+    return typeof chunk.image_url?.url === "string" && chunk.image_url.url.trim().length > 0;
+}
+function functionCallOutputHasImage(outputItem) {
+    if (outputItem?.type !== "function_call_output") {
+        return false;
+    }
+    const chunks = [];
+    if (Array.isArray(outputItem.output)) {
+        chunks.push(...outputItem.output);
+    }
+    if (Array.isArray(outputItem.content)) {
+        chunks.push(...outputItem.content);
+    }
+    return chunks.some((chunk) => isImageOutputChunk(chunk));
+}
+function appendImageToFunctionCallOutput(outputItem, screenshotBase64) {
+    if (outputItem?.type !== "function_call_output" || typeof screenshotBase64 !== "string" || !screenshotBase64) {
+        return outputItem;
+    }
+    return {
+        ...outputItem,
+        output: [
+            ...(Array.isArray(outputItem.output) ? outputItem.output : []),
+            {
+                type: "input_image",
+                image_url: `data:image/png;base64,${screenshotBase64}`,
+                detail: "high",
+            },
+        ],
+    };
+}
 function extractActionableOutputItems(items) {
     const entries = [];
     for (const item of items) {
@@ -58,6 +103,129 @@ function collectPendingSafetyChecks(items = []) {
         .filter((item) => item.type === "pending_safety_check")
         .map((item) => ({ id: item.id }));
 }
+const MAX_OBSERVATION_ONLY_TURNS_WITHOUT_ACTION = 10;
+const OBSERVATION_ONLY_RECOVERY_TURN = 5;
+const MAX_RECOVERY_ACTION_SUMMARIES = 8;
+const OBSERVATION_ONLY_RECOVERY_PROMPT = [
+    "You have repeatedly requested screenshots/previews without taking a device action.",
+    "Perform the next real action, choose a meaningfully different action, or stop if this instruction is complete.",
+    "Do not request another screenshot or preview unless you need it after changing the UI.",
+].join(" ");
+function isObservationOnlyActionableItem(actionableItem) {
+    if (actionableItem?.type === "function_call") {
+        return actionableItem.name === "preview_click";
+    }
+    if (actionableItem?.type !== "computer_call") {
+        return false;
+    }
+    return actionableItem.actions.length > 0 &&
+        actionableItem.actions.every((action) => action?.type === "screenshot");
+}
+function parseObservationToolArguments(argumentsText) {
+    if (typeof argumentsText !== "string" || !argumentsText.trim()) {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(argumentsText);
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function buildObservationOnlyPayload(actionableItem) {
+    if (actionableItem?.type === "function_call") {
+        const parsedArguments = parseObservationToolArguments(actionableItem.arguments);
+        return {
+            observationKind: "preview_click",
+            callId: actionableItem.call_id,
+            toolName: actionableItem.name,
+            ...(parsedArguments ? { toolArguments: parsedArguments } : {}),
+        };
+    }
+    return {
+        observationKind: "screenshot_only",
+        callId: actionableItem?.call_id,
+        actionTypes: actionableItem?.actions?.map((action) => action?.type).filter(Boolean) ?? [],
+    };
+}
+function truncateRecoveryText(text, maxLength = 80) {
+    if (typeof text !== "string")
+        return "";
+    return text.length > maxLength ? `${text.slice(0, maxLength - 1)}...` : text;
+}
+function formatActionForRecovery(action) {
+    if (!action || action.type === "screenshot" || action.type === "wait") {
+        return null;
+    }
+    switch (action.type) {
+        case "click":
+            return "Clicked";
+        case "double_click":
+            return "Double-clicked";
+        case "type": {
+            if (action.sensitive) {
+                return `Typed secret${action.sensitiveKey ? `: ${action.sensitiveKey}` : ""}`;
+            }
+            const text = truncateRecoveryText(action.text);
+            return text ? `Typed ${JSON.stringify(text)}` : "Typed text";
+        }
+        case "keypress": {
+            const keys = Array.isArray(action.keys) ? action.keys.join("+") : action.key || action.keys;
+            return keys ? `Pressed ${keys}` : "Pressed a key";
+        }
+        case "scroll":
+            return "Scrolled";
+        default:
+            return null;
+    }
+}
+function buildObservationOnlyRecoveryMessage({ instruction = null, recentRealActions = [] } = {}) {
+    const content = [OBSERVATION_ONLY_RECOVERY_PROMPT];
+    if (typeof instruction === "string" && instruction.trim()) {
+        content.push(`Current instruction: ${instruction.trim()}`);
+    }
+    if (recentRealActions.length > 0) {
+        content.push([
+            "Recent real interactions:",
+            ...recentRealActions.map((actionSummary) => `- ${actionSummary}`),
+        ].join("\n"));
+    }
+    return {
+        role: "user",
+        content: content.join("\n\n"),
+    };
+}
+function getInstructionScrollDirection(instruction) {
+    if (typeof instruction !== "string") {
+        return null;
+    }
+    const normalizedInstruction = instruction.toLowerCase();
+    if (normalizedInstruction.includes("scroll down")) {
+        return 1;
+    }
+    if (normalizedInstruction.includes("scroll up")) {
+        return -1;
+    }
+    return null;
+}
+function normalizeScrollActionForInstruction(action, instruction) {
+    if (action?.type !== "scroll") {
+        return action;
+    }
+    const expectedDirection = getInstructionScrollDirection(instruction);
+    const scrollY = Number(action.scroll_y);
+    if (!expectedDirection || !Number.isFinite(scrollY) || scrollY === 0) {
+        return action;
+    }
+    if (Math.sign(scrollY) === expectedDirection) {
+        return action;
+    }
+    return {
+        ...action,
+        scroll_y: Math.abs(scrollY) * expectedDirection,
+    };
+}
 export class ExecutionEngine {
     constructor(session, options = {}) {
         this.session = session;
@@ -169,9 +337,10 @@ export class ExecutionEngine {
         }
     }
     async requestNextTurn(messages, previousResponseId, context = null, stepContext = null, options = {}) {
+        const continuationMode = options.continuationModeOverride === "fresh" ? "fresh" : "auto";
         return await this.sendCUARequest({
             messages,
-            previousResponseId,
+            previousResponseId: continuationMode === "fresh" ? null : previousResponseId,
             deviceInfo: this.session.deviceInfo,
             debugContext: options.debugContextOverride ?? buildDebugContext(context, stepContext),
             toolCapabilities: options.toolCapabilitiesOverride ?? this.toolCapabilities,
@@ -180,8 +349,21 @@ export class ExecutionEngine {
     }
     async executeActionBatch(actions, currentScreenshot, shouldStop, context = null, stepContext = null, trackAction = null) {
         let sawExplicitScreenshotAction = false;
-        for (const action of actions) {
+        for (const rawAction of actions) {
+            const action = normalizeScrollActionForInstruction(rawAction, context?.currentInstruction);
             const actionEventId = randomUUID();
+            if (action !== rawAction) {
+                emitDesktopDebug("runner.action.normalized", "execution", {
+                    runId: context?.runId,
+                    stepId: stepContext?.stepId,
+                    instructionIndex: stepContext?.instructionIndex
+                }, {
+                    reason: "instruction_scroll_direction",
+                    instruction: context?.currentInstruction,
+                    originalAction: rawAction,
+                    normalizedAction: action
+                });
+            }
             if (shouldStop()) {
                 return { stopped: true, sawExplicitScreenshotAction };
             }
@@ -219,6 +401,18 @@ export class ExecutionEngine {
                 shouldStop,
                 stepId: stepContext?.stepId,
                 instructionIndex: stepContext?.instructionIndex,
+                deviceWidth: Number.isFinite(this.session.deviceInfo?.device_width)
+                    ? Math.round(this.session.deviceInfo.device_width)
+                    : undefined,
+                deviceHeight: Number.isFinite(this.session.deviceInfo?.device_height)
+                    ? Math.round(this.session.deviceInfo.device_height)
+                    : undefined,
+                fallbackScrollStartX: Number.isFinite(this.session.deviceInfo?.device_width)
+                    ? Math.round(this.session.deviceInfo.device_width / 2)
+                    : undefined,
+                fallbackScrollStartY: Number.isFinite(this.session.deviceInfo?.device_height)
+                    ? Math.round(this.session.deviceInfo.device_height / 2)
+                    : undefined,
                 eventId: actionEventId,
                 captureSource: CAPTURE_SOURCES.ACTION_CLICK_ANNOTATION,
                 ...(annotatedScreenshot?.screenshotPath ? { screenshotPath: annotatedScreenshot.screenshotPath } : {}),
@@ -366,7 +560,8 @@ export class ExecutionEngine {
         const addOutput = context?.addOutput || printCliOutput;
         let newResponseId = response.id;
         let currentScreenshot = options.currentScreenshot ?? null;
-        const shouldStop = () => Boolean(trackAction?.());
+        const originalTrackAction = trackAction;
+        const shouldStop = () => Boolean(originalTrackAction?.());
         const summary = {
             responseId: newResponseId,
             invokedFunctionTools: [],
@@ -383,6 +578,93 @@ export class ExecutionEngine {
             ...extra
         });
         let refreshBeforeNextComputerAction = false;
+        let observationOnlyTurnsSinceLastAction = 0;
+        let observationOnlyRecoverySent = false;
+        let pendingObservationOnlyRecoveryMessage = null;
+        const recentRealActions = [];
+        const recordRecentRealAction = (action) => {
+            const summaryText = formatActionForRecovery(action);
+            if (!summaryText)
+                return;
+            recentRealActions.push(summaryText);
+            if (recentRealActions.length > MAX_RECOVERY_ACTION_SUMMARIES) {
+                recentRealActions.shift();
+            }
+        };
+        const recordRecentRealActions = (actions = []) => {
+            for (const action of actions)
+                recordRecentRealAction(action);
+        };
+        const wrappedTrackAction = (action = null) => {
+            if (action)
+                recordRecentRealAction(action);
+            return originalTrackAction?.(action);
+        };
+        const resetObservationOnlyStreak = () => {
+            observationOnlyTurnsSinceLastAction = 0;
+            observationOnlyRecoverySent = false;
+            pendingObservationOnlyRecoveryMessage = null;
+        };
+        const buildObservationLoopPayload = (actionableItem) => ({
+            reason: "observation_only_loop",
+            responseId: newResponseId,
+            observationOnlyTurnsSinceLastAction,
+            maxObservationOnlyTurnsWithoutAction: MAX_OBSERVATION_ONLY_TURNS_WITHOUT_ACTION,
+            recoveryTurn: OBSERVATION_ONLY_RECOVERY_TURN,
+            recoverySent: observationOnlyRecoverySent,
+            ...buildObservationOnlyPayload(actionableItem),
+        });
+        const queueObservationOnlyRecovery = (actionableItem) => {
+            if (observationOnlyRecoverySent ||
+                observationOnlyTurnsSinceLastAction < OBSERVATION_ONLY_RECOVERY_TURN) {
+                return false;
+            }
+            observationOnlyRecoverySent = true;
+            pendingObservationOnlyRecoveryMessage = buildObservationOnlyRecoveryMessage({
+                instruction: stepContext?.instruction,
+                recentRealActions,
+            });
+            addOutput({
+                type: "warning",
+                text: "The agent seems confused. Trying to get it back on track.",
+                eventType: "system_message",
+                ...eventMeta({
+                    payload: {
+                        ...buildObservationLoopPayload(actionableItem),
+                        recoveryPrompt: pendingObservationOnlyRecoveryMessage.content,
+                        ...(typeof stepContext?.instruction === "string" && stepContext.instruction.trim()
+                            ? { instruction: stepContext.instruction.trim() }
+                            : {}),
+                        ...(recentRealActions.length > 0 ? { recentRealActions: [...recentRealActions] } : {}),
+                    },
+                }),
+            });
+            return true;
+        };
+        const failObservationOnlyLoop = (actionableItem) => {
+            const error = "The agent got too confused. Stopping the test.";
+            summary.failed = true;
+            summary.error = error;
+            summary.observationLoopDetected = true;
+            addOutput({
+                type: "error",
+                text: error,
+                eventType: "error",
+                ...eventMeta({
+                    payload: buildObservationLoopPayload(actionableItem),
+                }),
+            });
+            newResponseId = null;
+        };
+        const updateObservationOnlyStreak = (actionableItem) => {
+            observationOnlyTurnsSinceLastAction += 1;
+            if (observationOnlyTurnsSinceLastAction >= MAX_OBSERVATION_ONLY_TURNS_WITHOUT_ACTION) {
+                failObservationOnlyLoop(actionableItem);
+                return true;
+            }
+            queueObservationOnlyRecovery(actionableItem);
+            return false;
+        };
         while (true) {
             // Check for interruption before processing next batch of actions
             if (shouldStop()) {
@@ -409,6 +691,10 @@ export class ExecutionEngine {
             if (!actionableItem?.call_id) {
                 break;
             }
+            const observationOnlyTurn = isObservationOnlyActionableItem(actionableItem);
+            if (!observationOnlyTurn) {
+                resetObservationOnlyStreak();
+            }
             if (actionableItem.type === "function_call") {
                 const toolResult = await this.handleFunctionToolCall(actionableItem.name, actionableItem.call_id, actionableItem.arguments, context, stepContext);
                 summary.invokedFunctionTools.push(actionableItem.name);
@@ -445,15 +731,51 @@ export class ExecutionEngine {
                     newResponseId = null;
                     break;
                 }
-                const nextTurnMessages = [toolResult.outputItem];
+                if (Array.isArray(toolResult.executedActions)) {
+                    recordRecentRealActions(toolResult.executedActions);
+                }
+                if (observationOnlyTurn && updateObservationOnlyStreak(actionableItem)) {
+                    break;
+                }
                 const nextTurnConfig = toolResult.nextTurnConfig ?? {};
+                let nextTurnOutputItem = toolResult.outputItem;
+                if (nextTurnConfig.attachFreshScreenshotOnContinuation === true
+                    && isHoloResponseId(newResponseId)
+                    && nextTurnOutputItem?.type === "function_call_output"
+                    && !functionCallOutputHasImage(nextTurnOutputItem)) {
+                    let continuationScreenshot = toolResult.currentScreenshot ?? null;
+                    let screenshotBase64 = typeof continuationScreenshot?.base64 === "string" && continuationScreenshot.base64
+                        ? continuationScreenshot.base64
+                        : null;
+                    if (!screenshotBase64) {
+                        screenshotBase64 = await this.getScreenshotAsBase64(this.session.deviceId, this.session.deviceInfo);
+                        continuationScreenshot = await this.recordScreenshot(screenshotBase64, {
+                            runId: context?.runId,
+                            sessionId: context?.sessionId,
+                            stepId: stepContext?.stepId,
+                            instructionIndex: stepContext?.instructionIndex,
+                            captureSource: CAPTURE_SOURCES.CALL_OUTPUT_POST_ACTION,
+                        });
+                    }
+                    nextTurnOutputItem = appendImageToFunctionCallOutput(nextTurnOutputItem, screenshotBase64);
+                    currentScreenshot = continuationScreenshot ?? currentScreenshot;
+                }
+                const startsFreshResponseChain = nextTurnConfig.continuationMode === "fresh";
+                // Fresh follow-ups start a new provider response chain. Tool outputs from
+                // the previous chain cannot be acknowledged without the matching tool call.
+                const nextTurnMessages = startsFreshResponseChain ? [] : [nextTurnOutputItem];
                 if (Array.isArray(nextTurnConfig.followUpMessages) && nextTurnConfig.followUpMessages.length > 0) {
                     nextTurnMessages.push(...nextTurnConfig.followUpMessages);
                 }
+                if (pendingObservationOnlyRecoveryMessage) {
+                    nextTurnMessages.push(pendingObservationOnlyRecoveryMessage);
+                    pendingObservationOnlyRecoveryMessage = null;
+                }
                 response = await this.requestNextTurn(nextTurnMessages, newResponseId, context, stepContext, {
                     debugContextOverride: options.debugContextOverride,
                     toolCapabilitiesOverride: nextTurnConfig.toolCapabilitiesOverride,
                     includeComputerToolOverride: nextTurnConfig.includeComputerToolOverride,
+                    continuationModeOverride: nextTurnConfig.continuationMode,
                 });
                 newResponseId = response.id;
                 if (toolResult.kind === "close_turn") {
@@ -470,7 +792,7 @@ export class ExecutionEngine {
                 refreshBeforeNextComputerAction = false;
                 continue;
             }
-            const actionBatchResult = await this.executeActionBatch(actions, currentScreenshot, shouldStop, context, stepContext, trackAction);
+            const actionBatchResult = await this.executeActionBatch(actions, currentScreenshot, shouldStop, context, stepContext, wrappedTrackAction);
             if (actionBatchResult.stopped) {
                 summary.stopped = true;
                 return finalize();
@@ -496,6 +818,13 @@ export class ExecutionEngine {
                 refreshBeforeNextComputerAction = true;
             }
             currentScreenshot = followUp.currentScreenshot ?? currentScreenshot;
+            if (observationOnlyTurn && updateObservationOnlyStreak(actionableItem)) {
+                break;
+            }
+            if (pendingObservationOnlyRecoveryMessage) {
+                followUp.input.push(pendingObservationOnlyRecoveryMessage);
+                pendingObservationOnlyRecoveryMessage = null;
+            }
             response = await this.requestNextTurn(followUp.input, newResponseId, context, stepContext);
             newResponseId = response.id;
         }

package/build/src/core/prompts.js

@@ -1,3 +1,3 @@
 export { buildBaseSystemPrompt } from "../prompts/base.js";
-export { buildDesignModePrompt, buildDesignRecoveryPrompt, buildDesignScriptGenerationPrompt, } from "../prompts/design.js";
+export { buildDesignModePrompt, buildDesignRecoveryPrompt, buildDesignScriptFormatRetryPrompt, buildDesignScriptGenerationPrompt, } from "../prompts/design.js";
 export { buildAppContextSection, buildAssertionSystemPrompt, buildExecutionModePrompt, buildExecutionNavigationRecoveryPrompt, buildExecutionRecoveryPrompt, buildSecretKeysContextSection, buildTestDataContextSection, } from "../prompts/execution.js";

package/build/src/core/report/render-html-report.js

@@ -2,7 +2,7 @@
 // HTML document that reproduces the Desktop App's run-details view. Pure: no I/O and
 // no external references — screenshots must already be inlined as data URLs in
 // `event.payload.screenshotDataUrl`. Use generate-html-report.js to inline them.
-import { assertionData, formatDuration, hasNearbyAssertionCard, isAssistantAssertionSummary, isDuplicateAssertionLine, isHiddenExecutionLogEvent, runSummaryData, } from "./run-log-model.js";
+import { assertionData, formatDuration, hasNearbyAssertionCard, isAssistantAssertionSummary, isDuplicateAssertionLine, isHiddenExecutionLogEvent, runSummaryData, stepCompletionData, stepCompletionReasonTooltip, } from "./run-log-model.js";
 // ---------- text / value formatting (mirrors the Desktop App) ----------
 function escapeHtml(value) {
     return String(value ?? "")
@@ -18,7 +18,7 @@ function formatRunTimestamp(iso) {
     const parsed = Date.parse(iso);
     if (!Number.isFinite(parsed))
         return "—";
-    return new Date(parsed).toLocaleString();
+    return new Date(parsed).toLocaleString("en-US");
 }
 function formatRunDuration(durationSeconds) {
     if (durationSeconds === null || durationSeconds === undefined || !Number.isFinite(durationSeconds)) {
@@ -121,6 +121,11 @@ function renderEvent(event, shots) {
     }
     const isAssistant = event.eventType === "assistant_message" || event.kind === "assistant";
     if (isAssistant) {
+        const stepCompletion = stepCompletionData(event);
+        if (stepCompletion) {
+            const tooltip = stepCompletionReasonTooltip(stepCompletion);
+            return `<div class="dc-line"${tooltip ? ` title="${escapeHtml(tooltip)}"` : ""}><span aria-hidden="true">&#9873;</span><span>Step complete</span></div>`;
+        }
         return `<div class="dc-assistant">${escapeHtml(event.text)}</div>`;
     }
     const assertion = assertionData(event);
@@ -239,7 +244,7 @@ body { margin: 0; background: #f1f5f9; color: #0f172a; font-family: -apple-syste
 .dc-row-right { justify-content: flex-end; }
 .dc-bubble { display: inline-block; max-width: 70%; background: #f1f5f9; border: 1px solid #e2e8f0; border-radius: 16px; border-bottom-right-radius: 6px; padding: 8px 14px; color: #0f172a; }
 .dc-assistant { max-width: 82%; color: #334155; }
-.dc-line { display: flex; align-items: center; gap: 8px; color: #475569; font-size: 13px; }
+.dc-line { display: flex; align-items: center; gap: 8px; color: #475569; }
 .dc-retry { color: #b45309; }
 .dc-error { color: #b91c1c; }
 .dc-warning { color: #b45309; }

package/build/src/core/report/run-log-model.js

@@ -98,6 +98,48 @@ export function runSummaryData(event) {
         error,
     };
 }
+export function stepCompletionData(eventOrText) {
+    const text = typeof eventOrText === "string"
+        ? eventOrText
+        : typeof eventOrText?.text === "string"
+            ? eventOrText.text
+            : null;
+    if (!text)
+        return null;
+    const normalized = text.replace(/\r/g, "").trim();
+    const prefix = "Step complete:";
+    if (!normalized.startsWith(prefix))
+        return null;
+    const rest = normalized.slice(prefix.length);
+    const reasonLabel = /\sReason:\s*/.exec(rest);
+    if (!reasonLabel)
+        return null;
+    const instruction = rest.slice(0, reasonLabel.index).trim();
+    const reasonStart = reasonLabel.index + reasonLabel[0].length;
+    const afterReason = rest.slice(reasonStart);
+    const visibleStateLabel = /\sVisible state:\s*/.exec(afterReason);
+    if (!visibleStateLabel)
+        return null;
+    const reason = afterReason.slice(0, visibleStateLabel.index).trim();
+    const visibleState = afterReason.slice(visibleStateLabel.index + visibleStateLabel[0].length).trim();
+    if (!instruction || !reason || !visibleState)
+        return null;
+    return { instruction, reason, visibleState };
+}
+export function stepCompletionReasonTooltip(stepCompletion, maxLength = 140) {
+    if (!stepCompletion?.reason)
+        return null;
+    const firstSentence = stepCompletion.reason.match(/^.*?[.!?](?:\s|$)/)?.[0]?.trim();
+    const text = (firstSentence || stepCompletion.reason).replace(/\s+/g, " ").trim();
+    if (!text)
+        return null;
+    if (text.length <= maxLength)
+        return `Reason: ${text}`;
+    const truncated = text.slice(0, Math.max(0, maxLength - 1)).trimEnd();
+    const wordBoundary = truncated.lastIndexOf(" ");
+    const cleanTruncated = wordBoundary > maxLength * 0.6 ? truncated.slice(0, wordBoundary).trimEnd() : truncated;
+    return `Reason: ${cleanTruncated}…`;
+}
 export function formatDuration(ms) {
     if (ms === null || ms === undefined)
         return "n/a";

package/build/src/core/runtime-config.js

@@ -2,13 +2,12 @@ import OpenAI from "openai";
 import { normalizeOptionalAutomationUrl } from "../browser/playwright/url.js";
 import { readContextOptimizationEnv, normalizeContextOptimizationEnabled, normalizeContextOptimizationThreshold, } from "./context-optimization.js";
 import { DEFAULT_OPENAI_CUA_MODEL, isLoadmillCuaModel, resolveCuaModel, resolveCuaModelProviderMode, } from "./cua-models.js";
-import { DEFAULT_FARA_BASE_URL, DEFAULT_FARA_MODEL, resolveCuaBackend, } from "./cua-backends.js";
 import { normalizeStepDelayMs } from "../utils/step-delay.js";
 export const LOADMILL_MODEL_ALIASES = Object.freeze({
     DEFAULT_AGENT_MODEL: "default-agent-model",
     FAST: "fast",
     SMART: "smart",
-    COMPUTER_USE: "computer-use",
+    BEACON: "beacon",
 });
 const LOADMILL_MODEL_ALIAS_SET = new Set(Object.values(LOADMILL_MODEL_ALIASES));
 export const LLM_PROVIDER_MODES = Object.freeze(["loadmill", "openai"]);
@@ -89,19 +88,19 @@ export function inferLlmProviderModeFromCredentials(credentials = {}) {
     }
     return DEFAULT_LLM_PROVIDER_MODE;
 }
-export function resolveGatewayCuaModelAlias({ cuaBackend, cuaModel } = {}) {
-    if (resolveCuaBackend(cuaBackend) === "fara") {
-        return LOADMILL_MODEL_ALIASES.COMPUTER_USE;
-    }
+export function resolveGatewayCuaModelAlias({ cuaModel } = {}) {
     const normalizedCuaModel = resolveCuaModel(cuaModel);
+    if (normalizedCuaModel === "loadmill-beacon") {
+        return LOADMILL_MODEL_ALIASES.BEACON;
+    }
     return normalizedCuaModel === "gpt-5.4-mini"
         ? LOADMILL_MODEL_ALIASES.FAST
         : LOADMILL_MODEL_ALIASES.SMART;
 }
-export function resolveEffectiveCuaModel({ llmProviderMode = null, cuaBackend = null, cuaModel = null, } = {}) {
+export function resolveEffectiveCuaModel({ llmProviderMode = null, cuaModel = null, } = {}) {
     const providerMode = resolveLlmProviderMode(llmProviderMode);
     if (providerMode === "loadmill") {
-        return resolveGatewayCuaModelAlias({ cuaBackend, cuaModel });
+        return resolveGatewayCuaModelAlias({ cuaModel });
     }
     return resolveCuaModelProviderMode(cuaModel) === "openai"
         ? resolveCuaModel(cuaModel)
@@ -115,17 +114,14 @@ export function resolveEffectiveHelperModel({ llmProviderMode = null, cuaModel =
         ? resolveCuaModel(cuaModel)
         : DEFAULT_OPENAI_CUA_MODEL;
 }
-export function resolveRuntimeCredentials({ openAiApiKey = null, faraApiKey = null, faraBaseUrl = null, faraModel = null, loadmillApiToken = null, loadmillBaseUrl = null, } = {}) {
+export function resolveRuntimeCredentials({ openAiApiKey = null, loadmillApiToken = null, loadmillBaseUrl = null, } = {}) {
     return {
         openAiApiKey: trimNullableString(openAiApiKey),
-        faraApiKey: trimNullableString(faraApiKey),
-        faraBaseUrl: trimNullableString(faraBaseUrl) || DEFAULT_FARA_BASE_URL,
-        faraModel: trimNullableString(faraModel) || DEFAULT_FARA_MODEL,
         loadmillApiToken: trimNullableString(loadmillApiToken),
         loadmillBaseUrl: normalizeLoadmillSiteBaseUrl(loadmillBaseUrl),
     };
 }
-export function resolveRuntimeConfig({ llmProviderMode = null, cuaBackend = null, cuaModel = null, stepDelayMs = undefined, contextOptimizationEnabled = undefined, contextOptimizationThreshold = undefined, promptCustomizations = null, appContext = null, } = {}) {
+export function resolveRuntimeConfig({ llmProviderMode = null, cuaModel = null, stepDelayMs = undefined, contextOptimizationEnabled = undefined, contextOptimizationThreshold = undefined, promptCustomizations = null, appContext = null, } = {}) {
     const normalizedCuaModel = typeof cuaModel === "string" && LOADMILL_MODEL_ALIAS_SET.has(cuaModel)
         ? cuaModel
         : resolveCuaModel(cuaModel);
@@ -134,7 +130,6 @@ export function resolveRuntimeConfig({ llmProviderMode = null, cuaBackend = null
         llmProviderMode: llmProviderMode == null && isLoadmillCuaModel(normalizedCuaModel)
             ? "loadmill"
             : normalizedProviderMode,
-        cuaBackend: resolveCuaBackend(cuaBackend),
         cuaModel: normalizedCuaModel,
         stepDelayMs: normalizeStepDelayMs(Number(stepDelayMs)),
         contextOptimizationEnabled: normalizeContextOptimizationEnabled(contextOptimizationEnabled),
@@ -161,11 +156,6 @@ export function resolveRuntimeConfigFromEnv(env = process.env, overrides = {}) {
     const contextOptimization = readContextOptimizationEnv(env);
     return resolveRuntimeConfig({
         llmProviderMode: env.DROID_CUA_LLM_PROVIDER,
-        // Only the explicit backend flag should influence CUA model routing.
-        // Legacy screenshot-provider env vars must not silently remap Loadmill
-        // model aliases like "smart" to backend-specific aliases like
-        // "computer-use".
-        cuaBackend: env.DROID_CUA_BACKEND,
         cuaModel: env.OPENAI_CUA_MODEL,
         stepDelayMs: env.DROID_CUA_STEP_DELAY_MS,
         contextOptimizationEnabled: contextOptimization.enabled,
@@ -176,9 +166,6 @@ export function resolveRuntimeConfigFromEnv(env = process.env, overrides = {}) {
 export function resolveRuntimeCredentialsFromEnv(env = process.env, overrides = {}) {
     return resolveRuntimeCredentials({
         openAiApiKey: env.OPENAI_API_KEY,
-        faraApiKey: env.DROID_CUA_FARA_API_KEY,
-        faraBaseUrl: env.DROID_CUA_FARA_BASE_URL,
-        faraModel: env.DROID_CUA_FARA_MODEL,
         loadmillApiToken: env.LOADMILL_API_TOKEN,
         loadmillBaseUrl: env.LOADMILL_BASE_URL,
         ...overrides,
@@ -278,19 +265,27 @@ export function createLlmClient({ loadmillApiToken, loadmillBaseUrl, clientName
         },
     });
 }
-export function createFaraClient({ apiKey, baseUrl }) {
-    return new OpenAI({
-        apiKey: trimNullableString(apiKey) || "",
-        baseURL: trimNullableString(baseUrl) || DEFAULT_FARA_BASE_URL,
-    });
-}
-export function createResolvedLlmClient({ llmProviderMode = null, credentials = null, clientName = "desktop", maxRetries = 1, } = {}) {
+export function assertRuntimeCredentialsForProvider({ llmProviderMode = null, credentials = null, } = {}) {
     const resolvedCredentials = resolveRuntimeCredentials(credentials);
     const resolvedProviderMode = resolveLlmProviderMode(llmProviderMode);
     if (resolvedProviderMode === "loadmill") {
         if (!hasLoadmillLlmAccess(resolvedCredentials)) {
             throw new Error(missingCredentialErrorMessage(resolvedProviderMode));
         }
+        return;
+    }
+    if (!hasOpenAiLlmAccess(resolvedCredentials)) {
+        throw new Error(missingCredentialErrorMessage(resolvedProviderMode));
+    }
+}
+export function createResolvedLlmClient({ llmProviderMode = null, credentials = null, clientName = "desktop", maxRetries = 1, } = {}) {
+    const resolvedCredentials = resolveRuntimeCredentials(credentials);
+    const resolvedProviderMode = resolveLlmProviderMode(llmProviderMode);
+    assertRuntimeCredentialsForProvider({
+        llmProviderMode: resolvedProviderMode,
+        credentials: resolvedCredentials,
+    });
+    if (resolvedProviderMode === "loadmill") {
         return createLlmClient({
             loadmillApiToken: resolvedCredentials.loadmillApiToken,
             loadmillBaseUrl: resolvedCredentials.loadmillBaseUrl,
@@ -298,9 +293,6 @@ export function createResolvedLlmClient({ llmProviderMode = null, credentials =
             maxRetries,
         });
     }
-    if (!hasOpenAiLlmAccess(resolvedCredentials)) {
-        throw new Error(missingCredentialErrorMessage(resolvedProviderMode));
-    }
     return createOpenAiClient(resolvedCredentials.openAiApiKey);
 }
 export function createRunContext({ config, credentials }) {
@@ -312,7 +304,6 @@ export function createRunContext({ config, credentials }) {
         llmProviderMode: resolvedProviderMode,
         cuaModel: resolveEffectiveCuaModel({
             llmProviderMode: resolvedProviderMode,
-            cuaBackend: resolvedConfig.cuaBackend,
             cuaModel: resolvedConfig.cuaModel,
         }),
     };
@@ -328,12 +319,6 @@ export function createRunContext({ config, credentials }) {
                 credentials: resolvedCredentials,
                 clientName: "desktop",
             }),
-            fara: resolvedConfig.cuaBackend === "fara"
-                ? createFaraClient({
-                    apiKey: resolvedCredentials.faraApiKey,
-                    baseUrl: resolvedCredentials.faraBaseUrl,
-                })
-                : null,
         },
     };
 }