@loadmill/droid-cua 2.14.0 → 2.16.0

package/build/src/cli/ink-shell.js

@@ -35,6 +35,7 @@ export async function startInkShell(session, executionEngine, options = {}) {
                 engine: executionEngine,
                 appContextPath: options.appContextPath ?? null,
                 runtimeContext: options.runtimeContext ?? null,
+                runtimeConfig: options.runtimeContext?.config ?? null,
                 openAiClient: options.runtimeContext?.openAiClient ?? null,
                 loadmillClient: options.runtimeContext?.loadmillClient ?? null,
                 runtimeCredentials: options.runtimeContext?.credentials ?? null

package/build/src/commands/help.js

@@ -28,7 +28,8 @@ export async function handleHelp(args, session, context) {
     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' });
-    addOutput({ type: 'info', text: '  --cua-model <model>    Headless CUA model override: gpt-5.4 or gpt-5.4-mini' });
+    addOutput({ type: 'info', text: '  --llm-provider <mode>  Headless AI provider: loadmill or openai' });
+    addOutput({ type: 'info', text: '  --cua-model <model>    Headless CUA model override: gpt-5.4, loadmill-smart, or gpt-5.4-mini' });
     addOutput({ type: 'info', text: '  --aim-assist <mode>    Headless Aim Assist mode: off, smart, or always' });
     addOutput({ type: 'info', text: '  --context <file>       Optional app context file injected into execution runs' });
     addOutput({ type: 'info', text: '  --no-context           Disable app context for headless execution' });

package/build/src/commands/loadmill.js

@@ -2,7 +2,7 @@
  * Loadmill command handler
  */
 import { createLoadmillApiClient, executeLoadmillCommand, getApiToken } from "../integrations/loadmill/index.js";
-import { createOpenAiClient, resolveRuntimeCredentialsFromEnv } from "../core/runtime-config.js";
+import { createResolvedLlmClient, resolveRuntimeConfigFromEnv, resolveRuntimeCredentialsFromEnv, } from "../core/runtime-config.js";
 /**
  * Handle /loadmill command
  * @param {string} args - Command arguments (natural language command)
@@ -21,12 +21,12 @@ export async function handleLoadmill(args, session, context) {
         addOutput({ type: 'info', text: '  /loadmill <command>          Execute a Loadmill flow' });
         addOutput({ type: 'info', text: '' });
         addOutput({ type: 'info', text: 'Examples:' });
-        addOutput({ type: 'info', text: '  /loadmill search for login flow' });
+        addOutput({ type: 'info', text: '  /loadmill login flow' });
         addOutput({ type: 'info', text: '  /loadmill run checkout flow with user=test123' });
         addOutput({ type: 'info', text: '  /loadmill run payment test with amount=100' });
         addOutput({ type: 'info', text: '' });
         addOutput({ type: 'info', text: 'In test scripts (.dcua files):' });
-        addOutput({ type: 'info', text: '  loadmill: run user authentication flow' });
+        addOutput({ type: 'info', text: '  run loadmill user authentication flow' });
         addOutput({ type: 'info', text: '' });
         addOutput({ type: 'info', text: 'Configuration:' });
         addOutput({ type: 'info', text: '  Set LOADMILL_API_TOKEN in your .env file' });
@@ -48,49 +48,60 @@ export async function handleLoadmill(args, session, context) {
     if (context.setAgentWorking) {
         context.setAgentWorking(true, 'Running Loadmill flow...');
     }
-    const runtimeCredentials = context.runtimeCredentials || resolveRuntimeCredentialsFromEnv();
-    const loadmillClient = context.loadmillClient || createLoadmillApiClient({
-        token: runtimeCredentials.loadmillApiToken,
-        baseUrl: runtimeCredentials.loadmillBaseUrl,
-    });
-    const openAiClient = context.openAiClient || createOpenAiClient(runtimeCredentials.openAiApiKey);
-    // Execute the command
-    const result = await executeLoadmillCommand(command, {
-        loadmillClient,
-        openAiClient,
-        onProgress: ({ message }) => {
-            addOutput({ type: 'info', text: `[Loadmill] ${message}` });
-        }
-    });
-    // Clear agent working status
-    if (context.setAgentWorking) {
-        context.setAgentWorking(false);
-    }
-    // Display results
-    if (result.success) {
-        if (result.action === "search") {
-            addOutput({ type: 'success', text: `Found ${result.result.flows.length} flow(s):` });
-            result.result.flows.forEach((flow, i) => {
-                const name = flow.description || flow.name || "Unknown";
-                const suite = flow.testSuiteDescription ? ` (Suite: ${flow.testSuiteDescription})` : '';
-                addOutput({ type: 'info', text: `  ${i + 1}. ${name}${suite}` });
-                addOutput({ type: 'info', text: `     ID: ${flow.id}` });
-            });
-            if (result.result.selectedFlow) {
-                const selectedName = result.result.selectedFlow.description || result.result.selectedFlow.name || "Unknown";
-                addOutput({ type: 'info', text: '' });
-                addOutput({ type: 'info', text: `Best match: "${selectedName}" (confidence: ${(result.result.confidence * 100).toFixed(0)}%)` });
+    try {
+        const runtimeCredentials = context.runtimeCredentials || resolveRuntimeCredentialsFromEnv();
+        const runtimeConfig = context.runtimeConfig || resolveRuntimeConfigFromEnv();
+        const loadmillClient = context.loadmillClient || createLoadmillApiClient({
+            token: runtimeCredentials.loadmillApiToken,
+            baseUrl: runtimeCredentials.loadmillBaseUrl,
+        });
+        const openAiClient = context.openAiClient || createResolvedLlmClient({
+            llmProviderMode: runtimeConfig.llmProviderMode,
+            credentials: runtimeCredentials,
+            clientName: "cli",
+        });
+        // Execute the command
+        const result = await executeLoadmillCommand(command, {
+            loadmillClient,
+            openAiClient,
+            onProgress: ({ message }) => {
+                addOutput({ type: 'info', text: `[Loadmill] ${message}` });
+            }
+        });
+        // Display results
+        if (result.success) {
+            if (result.action === "search") {
+                addOutput({ type: 'success', text: `Found ${result.result.flows.length} flow(s):` });
+                result.result.flows.forEach((flow, i) => {
+                    const name = flow.description || flow.name || "Unknown";
+                    const suite = flow.testSuiteDescription ? ` (Suite: ${flow.testSuiteDescription})` : '';
+                    addOutput({ type: 'info', text: `  ${i + 1}. ${name}${suite}` });
+                    addOutput({ type: 'info', text: `     ID: ${flow.id}` });
+                });
+                if (result.result.selectedFlow) {
+                    const selectedName = result.result.selectedFlow.description || result.result.selectedFlow.name || "Unknown";
+                    addOutput({ type: 'info', text: '' });
+                    addOutput({ type: 'info', text: `Best match: "${selectedName}" (confidence: ${(result.result.confidence * 100).toFixed(0)}%)` });
+                }
+            }
+            else {
+                addOutput({ type: 'success', text: `Flow "${result.flowName}" passed` });
+                if (result.runId) {
+                    addOutput({ type: 'info', text: `Run ID: ${result.runId}` });
+                }
             }
         }
         else {
-            addOutput({ type: 'success', text: `Flow "${result.flowName}" passed` });
-            if (result.runId) {
-                addOutput({ type: 'info', text: `Run ID: ${result.runId}` });
-            }
+            addOutput({ type: 'error', text: `Loadmill failed: ${result.error}` });
         }
     }
-    else {
-        addOutput({ type: 'error', text: `Loadmill failed: ${result.error}` });
+    catch (error) {
+        addOutput({ type: 'error', text: error instanceof Error ? error.message : 'Loadmill command failed.' });
+    }
+    finally {
+        if (context.setAgentWorking) {
+            context.setAgentWorking(false);
+        }
     }
     return true; // Continue loop
 }

package/build/src/core/cua-backends.js

@@ -0,0 +1,11 @@
+export const CUA_BACKENDS = ["openai", "fara"];
+export const DEFAULT_CUA_BACKEND = "openai";
+export const DEFAULT_FARA_BASE_URL = "http://localhost:5000/v1";
+export const DEFAULT_FARA_MODEL = "Fara-7B";
+const VALID_CUA_BACKENDS = new Set(CUA_BACKENDS);
+export function isValidCuaBackend(value) {
+    return VALID_CUA_BACKENDS.has(value);
+}
+export function resolveCuaBackend(value) {
+    return isValidCuaBackend(value) ? value : DEFAULT_CUA_BACKEND;
+}

package/build/src/core/cua-models.js

@@ -1,9 +1,54 @@
-export const CUA_MODELS = ["gpt-5.4", "gpt-5.4-mini"];
-export const DEFAULT_CUA_MODEL = "gpt-5.4";
+export const DEFAULT_OPENAI_CUA_MODEL = "gpt-5.4";
+export const DEFAULT_LOADMILL_CUA_MODEL = "loadmill-smart";
+export const DEFAULT_CUA_MODEL = DEFAULT_LOADMILL_CUA_MODEL;
+export const OPENAI_CUA_MODELS = ["gpt-5.4", "gpt-5.4-mini"];
+export const LOADMILL_CUA_MODELS = [DEFAULT_LOADMILL_CUA_MODEL];
+export const CUA_MODELS = ["gpt-5.4", "loadmill-smart", "gpt-5.4-mini"];
+export const CUA_MODEL_OPTIONS = Object.freeze([
+    Object.freeze({
+        id: "loadmill-smart",
+        providerMode: "loadmill",
+        providerLabel: "Loadmill",
+        name: "Loadmill Smart",
+        label: "Loadmill Smart (recommended)",
+    }),
+    Object.freeze({
+        id: "gpt-5.4",
+        providerMode: "openai",
+        providerLabel: "OpenAI",
+        name: "GPT-5.4",
+        label: "OpenAI GPT-5.4",
+    }),
+    Object.freeze({
+        id: "gpt-5.4-mini",
+        providerMode: "openai",
+        providerLabel: "OpenAI",
+        name: "GPT-5.4 mini",
+        label: "OpenAI GPT-5.4 mini (faster)",
+    }),
+]);
 const VALID_CUA_MODELS = new Set(CUA_MODELS);
+const OPENAI_CUA_MODEL_SET = new Set(OPENAI_CUA_MODELS);
+const LOADMILL_CUA_MODEL_SET = new Set(LOADMILL_CUA_MODELS);
+const CUA_MODEL_PROVIDER_MODE_MAP = new Map(CUA_MODEL_OPTIONS.map((option) => [option.id, option.providerMode]));
 export function isValidCuaModel(value) {
     return VALID_CUA_MODELS.has(value);
 }
+export function isOpenAiCuaModel(value) {
+    return OPENAI_CUA_MODEL_SET.has(value);
+}
+export function isLoadmillCuaModel(value) {
+    return LOADMILL_CUA_MODEL_SET.has(value);
+}
 export function resolveCuaModel(value) {
     return isValidCuaModel(value) ? value : DEFAULT_CUA_MODEL;
 }
+export function resolveCuaModelProviderMode(value) {
+    const normalized = resolveCuaModel(value);
+    return CUA_MODEL_PROVIDER_MODE_MAP.get(normalized) || "openai";
+}
+export function resolveDefaultCuaModelForProvider(providerMode) {
+    return providerMode === "loadmill"
+        ? DEFAULT_LOADMILL_CUA_MODEL
+        : DEFAULT_OPENAI_CUA_MODEL;
+}

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

@@ -1,7 +1,26 @@
 import OpenAI from "openai";
+import { normalizeOptionalAutomationUrl } from "../browser/playwright/url.js";
 import { readContextOptimizationEnv, normalizeContextOptimizationEnabled, normalizeContextOptimizationThreshold, } from "./context-optimization.js";
-import { resolveCuaModel } from "./cua-models.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",
+});
+const LOADMILL_MODEL_ALIAS_SET = new Set(Object.values(LOADMILL_MODEL_ALIASES));
+export const LLM_PROVIDER_MODES = Object.freeze(["loadmill", "openai"]);
+export const DEFAULT_LLM_PROVIDER_MODE = "loadmill";
+export const DEFAULT_LOADMILL_BASE_URL = "https://app.loadmill.com";
+const VALID_LLM_PROVIDER_MODES = new Set(LLM_PROVIDER_MODES);
+export function isValidLlmProviderMode(value) {
+    return VALID_LLM_PROVIDER_MODES.has(value);
+}
+export function resolveLlmProviderMode(value) {
+    return isValidLlmProviderMode(value) ? value : DEFAULT_LLM_PROVIDER_MODE;
+}
 export function createEmptyPromptCustomizations() {
     return {
         basePromptInstructions: "",
@@ -28,16 +47,95 @@ function trimNullableString(value) {
     const trimmed = value.trim();
     return trimmed || null;
 }
-export function resolveRuntimeCredentials({ openAiApiKey = null, loadmillApiToken = null, loadmillBaseUrl = null, } = {}) {
+function normalizeLoadmillSiteBaseUrl(value) {
+    const trimmed = trimNullableString(value) || DEFAULT_LOADMILL_BASE_URL;
+    const normalizedCandidate = normalizeOptionalAutomationUrl(trimmed) || trimmed;
+    try {
+        const parsed = new URL(normalizedCandidate);
+        const pathname = parsed.pathname.replace(/\/+$/, "");
+        parsed.pathname = pathname
+            .replace(/\/api$/, "")
+            .replace(/\/llm\/v1$/, "")
+            .replace(/\/llm$/, "");
+        parsed.search = "";
+        parsed.hash = "";
+        return parsed.toString().replace(/\/$/, "");
+    }
+    catch {
+        return normalizedCandidate
+            .replace(/\/api\/?$/, "")
+            .replace(/\/llm\/v1\/?$/, "")
+            .replace(/\/llm\/?$/, "")
+            .replace(/\/$/, "") || null;
+    }
+}
+export function buildLoadmillLlmBaseUrl(value) {
+    const siteBaseUrl = normalizeLoadmillSiteBaseUrl(value);
+    return siteBaseUrl ? `${siteBaseUrl}/llm/v1` : null;
+}
+export function hasLoadmillLlmAccess(credentials = {}) {
+    return Boolean(trimNullableString(credentials.loadmillApiToken) &&
+        buildLoadmillLlmBaseUrl(credentials.loadmillBaseUrl));
+}
+export function hasOpenAiLlmAccess(credentials = {}) {
+    return Boolean(trimNullableString(credentials.openAiApiKey));
+}
+export function inferLlmProviderModeFromCredentials(credentials = {}) {
+    if (hasLoadmillLlmAccess(credentials)) {
+        return "loadmill";
+    }
+    if (hasOpenAiLlmAccess(credentials)) {
+        return "openai";
+    }
+    return DEFAULT_LLM_PROVIDER_MODE;
+}
+export function resolveGatewayCuaModelAlias({ cuaBackend, cuaModel } = {}) {
+    if (resolveCuaBackend(cuaBackend) === "fara") {
+        return LOADMILL_MODEL_ALIASES.COMPUTER_USE;
+    }
+    const normalizedCuaModel = resolveCuaModel(cuaModel);
+    return normalizedCuaModel === "gpt-5.4-mini"
+        ? LOADMILL_MODEL_ALIASES.FAST
+        : LOADMILL_MODEL_ALIASES.SMART;
+}
+export function resolveEffectiveCuaModel({ llmProviderMode = null, cuaBackend = null, cuaModel = null, } = {}) {
+    const providerMode = resolveLlmProviderMode(llmProviderMode);
+    if (providerMode === "loadmill") {
+        return resolveGatewayCuaModelAlias({ cuaBackend, cuaModel });
+    }
+    return resolveCuaModelProviderMode(cuaModel) === "openai"
+        ? resolveCuaModel(cuaModel)
+        : DEFAULT_OPENAI_CUA_MODEL;
+}
+export function resolveEffectiveHelperModel({ llmProviderMode = null, cuaModel = null, } = {}) {
+    if (resolveLlmProviderMode(llmProviderMode) === "loadmill") {
+        return LOADMILL_MODEL_ALIASES.DEFAULT_AGENT_MODEL;
+    }
+    return resolveCuaModelProviderMode(cuaModel) === "openai"
+        ? resolveCuaModel(cuaModel)
+        : DEFAULT_OPENAI_CUA_MODEL;
+}
+export function resolveRuntimeCredentials({ openAiApiKey = null, faraApiKey = null, faraBaseUrl = null, faraModel = 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: trimNullableString(loadmillBaseUrl),
+        loadmillBaseUrl: normalizeLoadmillSiteBaseUrl(loadmillBaseUrl),
     };
 }
-export function resolveRuntimeConfig({ cuaModel = null, stepDelayMs = undefined, contextOptimizationEnabled = undefined, contextOptimizationThreshold = undefined, promptCustomizations = null, appContext = null, } = {}) {
+export function resolveRuntimeConfig({ llmProviderMode = null, cuaBackend = 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);
+    const normalizedProviderMode = resolveLlmProviderMode(llmProviderMode);
     return {
-        cuaModel: resolveCuaModel(cuaModel),
+        llmProviderMode: llmProviderMode == null && isLoadmillCuaModel(normalizedCuaModel)
+            ? "loadmill"
+            : normalizedProviderMode,
+        cuaBackend: resolveCuaBackend(cuaBackend),
+        cuaModel: normalizedCuaModel,
         stepDelayMs: normalizeStepDelayMs(Number(stepDelayMs)),
         contextOptimizationEnabled: normalizeContextOptimizationEnabled(contextOptimizationEnabled),
         contextOptimizationThreshold: normalizeContextOptimizationThreshold(contextOptimizationThreshold),
@@ -62,6 +160,12 @@ export function resolveRuntimeConfig({ cuaModel = null, stepDelayMs = undefined,
 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,
@@ -72,6 +176,9 @@ 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,
@@ -82,14 +189,151 @@ export function createOpenAiClient(apiKey) {
         apiKey: trimNullableString(apiKey) || undefined,
     });
 }
+function missingCredentialErrorMessage(llmProviderMode) {
+    return resolveLlmProviderMode(llmProviderMode) === "loadmill"
+        ? "Loadmill authentication is required to use the Loadmill model."
+        : "An OpenAI API key is required to use OpenAI models.";
+}
+function isLoadmillGatewayErrorPayload(payload) {
+    return Boolean(payload &&
+        typeof payload === "object" &&
+        typeof payload.message === "string" &&
+        typeof payload.type === "string" &&
+        typeof payload.code === "string");
+}
+function normalizeLoadmillGatewayErrorBody(body) {
+    const payload = body?.payload;
+    if (!isLoadmillGatewayErrorPayload(payload)) {
+        return null;
+    }
+    return {
+        error: {
+            message: payload.message,
+            type: payload.type,
+            code: payload.code,
+            param: payload.param ?? null,
+            provider: typeof payload.provider === "string" ? payload.provider : null,
+        },
+    };
+}
+async function normalizeLoadmillGatewayErrorResponse(response) {
+    const contentType = response.headers.get("content-type") || "";
+    if (!contentType.includes("application/json")) {
+        return response;
+    }
+    const responseClone = response.clone();
+    const bodyText = await responseClone.text();
+    if (!bodyText) {
+        return response;
+    }
+    let parsedBody;
+    try {
+        parsedBody = JSON.parse(bodyText);
+    }
+    catch {
+        return response;
+    }
+    const normalizedBody = normalizeLoadmillGatewayErrorBody(parsedBody);
+    if (!normalizedBody) {
+        return response;
+    }
+    const headers = new Headers(response.headers);
+    headers.set("content-type", "application/json");
+    return new Response(JSON.stringify(normalizedBody), {
+        status: response.status,
+        statusText: response.statusText,
+        headers,
+    });
+}
+function createLoadmillGatewayFetch(baseFetch = fetch) {
+    return async (input, init) => {
+        const response = await baseFetch(input, init);
+        if (response.ok) {
+            return response;
+        }
+        return await normalizeLoadmillGatewayErrorResponse(response);
+    };
+}
+/**
+ * @param {{
+ *   loadmillApiToken?: string | null,
+ *   loadmillBaseUrl?: string | null,
+ *   clientName?: string,
+ *   maxRetries?: number,
+ * }} [options]
+ */
+export function createLlmClient({ loadmillApiToken, loadmillBaseUrl, clientName = "desktop", maxRetries = 1, } = {}) {
+    const apiKey = trimNullableString(loadmillApiToken);
+    const baseURL = buildLoadmillLlmBaseUrl(loadmillBaseUrl);
+    if (!apiKey || !baseURL) {
+        throw new Error("Loadmill authentication is required for LLM access.");
+    }
+    return new OpenAI({
+        apiKey,
+        baseURL,
+        maxRetries,
+        fetch: createLoadmillGatewayFetch(),
+        defaultHeaders: {
+            "X-Loadmill-Client": 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, } = {}) {
+    const resolvedCredentials = resolveRuntimeCredentials(credentials);
+    const resolvedProviderMode = resolveLlmProviderMode(llmProviderMode);
+    if (resolvedProviderMode === "loadmill") {
+        if (!hasLoadmillLlmAccess(resolvedCredentials)) {
+            throw new Error(missingCredentialErrorMessage(resolvedProviderMode));
+        }
+        return createLlmClient({
+            loadmillApiToken: resolvedCredentials.loadmillApiToken,
+            loadmillBaseUrl: resolvedCredentials.loadmillBaseUrl,
+            clientName,
+            maxRetries,
+        });
+    }
+    if (!hasOpenAiLlmAccess(resolvedCredentials)) {
+        throw new Error(missingCredentialErrorMessage(resolvedProviderMode));
+    }
+    return createOpenAiClient(resolvedCredentials.openAiApiKey);
+}
 export function createRunContext({ config, credentials }) {
     const resolvedConfig = resolveRuntimeConfig(config);
     const resolvedCredentials = resolveRuntimeCredentials(credentials);
+    const resolvedProviderMode = resolveLlmProviderMode(resolvedConfig.llmProviderMode);
+    const effectiveConfig = {
+        ...resolvedConfig,
+        llmProviderMode: resolvedProviderMode,
+        cuaModel: resolveEffectiveCuaModel({
+            llmProviderMode: resolvedProviderMode,
+            cuaBackend: resolvedConfig.cuaBackend,
+            cuaModel: resolvedConfig.cuaModel,
+        }),
+    };
+    const effectiveCredentials = {
+        ...resolvedCredentials,
+    };
     return {
-        config: resolvedConfig,
-        credentials: resolvedCredentials,
+        config: effectiveConfig,
+        credentials: effectiveCredentials,
         clients: {
-            openai: createOpenAiClient(resolvedCredentials.openAiApiKey),
+            openai: createResolvedLlmClient({
+                llmProviderMode: resolvedProviderMode,
+                credentials: resolvedCredentials,
+                clientName: "desktop",
+            }),
+            fara: resolvedConfig.cuaBackend === "fara"
+                ? createFaraClient({
+                    apiKey: resolvedCredentials.faraApiKey,
+                    baseUrl: resolvedCredentials.faraBaseUrl,
+                })
+                : null,
         },
     };
 }

package/build/src/device/loadmill.js

@@ -8,34 +8,6 @@ function getLoadmillSiteBaseUrl(loadmillClient = null) {
     const rawBaseUrl = loadmillClient?.getBaseUrl?.() || "https://app.loadmill.com/api";
     return rawBaseUrl.replace(/\/api\/?$/, "");
 }
-/**
- * Check if an instruction is a Loadmill command
- * @param {string} userInput - The instruction text
- * @returns {boolean}
- */
-export function isLoadmillInstruction(userInput) {
-    const trimmed = userInput.trim();
-    const lower = trimmed.toLowerCase();
-    return lower.startsWith("loadmill:") || lower.startsWith("loadmill ");
-}
-/**
- * Extract the Loadmill command from an instruction
- * @param {string} userInput - The instruction text
- * @returns {string} - The extracted command
- */
-export function extractLoadmillCommand(userInput) {
-    const trimmed = userInput.trim();
-    const lower = trimmed.toLowerCase();
-    // Handle "loadmill:" or "Loadmill:"
-    if (lower.startsWith("loadmill:")) {
-        return trimmed.substring("loadmill:".length).trim();
-    }
-    // Handle "loadmill " or "Loadmill "
-    if (lower.startsWith("loadmill ")) {
-        return trimmed.substring("loadmill".length).trim();
-    }
-    return trimmed;
-}
 /**
  * Execute a Loadmill instruction and handle the result
  * @param {string} command - The Loadmill command to execute
@@ -163,57 +135,48 @@ export function handleLoadmillSuccess(command, result, context, stepContext = nu
     const payload = result.runId
         ? { loadmillSuiteRunId: result.runId, loadmillCommand: command, loadmillBaseUrl: getLoadmillSiteBaseUrl(loadmillClient) }
         : { loadmillCommand: command, loadmillBaseUrl: getLoadmillSiteBaseUrl(loadmillClient) };
-    if (result.action === "search") {
-        addOutput({ type: 'success', text: `[Loadmill] Found ${result.result.flows.length} flow(s)`, eventType: 'system_message', payload, ...meta });
-        result.result.flows.forEach((flow, i) => {
-            const name = flow.description || flow.name || "Unknown";
-            addOutput({ type: 'info', text: `  ${i + 1}. ${name} (ID: ${flow.id})`, eventType: 'system_message', payload, ...meta });
+    addOutput({ type: 'success', text: `[Loadmill] Flow "${result.flowName}" passed`, eventType: 'system_message', payload, ...meta });
+    if (result.runId) {
+        addOutput({ type: 'info', text: `  Run ID: ${result.runId}`, eventType: 'system_message', payload, ...meta });
+    }
+    const note = result.runtimeParameterContext?.note;
+    if (result.runtimeParameterContext) {
+        emitDesktopDebug("loadmill.runtime_parameters", "execution", {
+            runId: context?.runId,
+            stepId: stepContext?.stepId,
+            instructionIndex: stepContext?.instructionIndex,
+        }, {
+            command,
+            flowName: result.flowName,
+            flowRunId: result.runtimeParameterContext.flowRunId,
+            parameterNames: result.runtimeParameterContext.parameterNames,
+            selectedParameterNames: result.runtimeParameterContext.selectedParameterNames,
+            futureInstructions: result.runtimeParameterContext.futureInstructions,
+            noteAdded: typeof note === "string" && note.trim().length > 0,
         });
     }
-    else {
-        addOutput({ type: 'success', text: `[Loadmill] Flow "${result.flowName}" passed`, eventType: 'system_message', payload, ...meta });
-        if (result.runId) {
-            addOutput({ type: 'info', text: `  Run ID: ${result.runId}`, eventType: 'system_message', payload, ...meta });
-        }
-        const note = result.runtimeParameterContext?.note;
-        if (result.runtimeParameterContext) {
-            emitDesktopDebug("loadmill.runtime_parameters", "execution", {
-                runId: context?.runId,
-                stepId: stepContext?.stepId,
-                instructionIndex: stepContext?.instructionIndex,
-            }, {
-                command,
-                flowName: result.flowName,
-                flowRunId: result.runtimeParameterContext.flowRunId,
-                parameterNames: result.runtimeParameterContext.parameterNames,
-                selectedParameterNames: result.runtimeParameterContext.selectedParameterNames,
-                futureInstructions: result.runtimeParameterContext.futureInstructions,
-                noteAdded: typeof note === "string" && note.trim().length > 0,
-            });
-        }
-        if (typeof note === "string" && note.trim()) {
-            const selectedNames = Array.isArray(result.runtimeParameterContext.selectedParameterNames)
-                ? result.runtimeParameterContext.selectedParameterNames.filter((name) => typeof name === "string" && name.trim())
-                : [];
-            const selectedNamesText = selectedNames.length > 0
-                ? ` (${selectedNames.join(", ")})`
-                : "";
-            context?.session?.addMessage?.("system", note);
-            context?.session?.addToTranscript?.(`[Loadmill Context] ${note}`);
-            addOutput({
-                type: 'info',
-                text: `[Loadmill] Added ${result.runtimeParameterContext.selectedCount} parameter(s)${selectedNamesText} to agent context`,
-                eventType: 'system_message',
-                payload: {
-                    ...payload,
-                    loadmillFlowRunId: result.runtimeParameterContext.flowRunId,
-                    loadmillRuntimeParameterCount: result.runtimeParameterContext.selectedCount,
-                    loadmillRuntimeParameterNames: result.runtimeParameterContext.parameterNames,
-                    loadmillSelectedRuntimeParameterNames: result.runtimeParameterContext.selectedParameterNames,
-                    loadmillParameterSelectionFutureInstructions: result.runtimeParameterContext.futureInstructions,
-                },
-                ...meta
-            });
-        }
+    if (typeof note === "string" && note.trim()) {
+        const selectedNames = Array.isArray(result.runtimeParameterContext.selectedParameterNames)
+            ? result.runtimeParameterContext.selectedParameterNames.filter((name) => typeof name === "string" && name.trim())
+            : [];
+        const selectedNamesText = selectedNames.length > 0
+            ? ` (${selectedNames.join(", ")})`
+            : "";
+        context?.session?.addMessage?.("system", note);
+        context?.session?.addToTranscript?.(`[Loadmill Context] ${note}`);
+        addOutput({
+            type: 'info',
+            text: `[Loadmill] Added ${result.runtimeParameterContext.selectedCount} parameter(s)${selectedNamesText} to agent context`,
+            eventType: 'system_message',
+            payload: {
+                ...payload,
+                loadmillFlowRunId: result.runtimeParameterContext.flowRunId,
+                loadmillRuntimeParameterCount: result.runtimeParameterContext.selectedCount,
+                loadmillRuntimeParameterNames: result.runtimeParameterContext.parameterNames,
+                loadmillSelectedRuntimeParameterNames: result.runtimeParameterContext.selectedParameterNames,
+                loadmillParameterSelectionFutureInstructions: result.runtimeParameterContext.futureInstructions,
+            },
+            ...meta
+        });
     }
 }