@loadmill/droid-cua 2.22.0 → 2.23.0

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

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

@@ -4,15 +4,15 @@ import { connectToBrowser, getBrowserInfo, getCurrentPlatform as getBrowserCurre
 import { normalizeBrowserInfoForSession } from "../browser/normalize.js";
 import { sendCUARequest } from "../device/openai.js";
 import { buildExecutionRecoveryPrompt } from "../core/prompts.js";
-import { isAssertion } from "../device/assertions.js";
+import { extractAssertionPrompt, isAssertion } from "../device/assertions.js";
+import { handleAssertionToolCall } from "../core/tool-handlers/assert.js";
 import { logger } from "../utils/logger.js";
 import { emitDesktopDebug } from "../utils/desktop-debug.js";
 import { printCliOutput } from "../utils/console-output.js";
-// Mirrors the codes emitted by the Loadmill LLM gateway (see services/app/private/llm
-// in the server repo): a transient burst limit plus day/week/fixed-budget request and
-// token quotas. Free plans run on the fixed-budget quota.
+// Mirrors the quota codes emitted by the Loadmill LLM gateway (see
+// services/app/private/llm in the server repo). Free plans run on the
+// fixed-budget quota.
 const LLM_USAGE_LIMIT_ERROR_CODES = new Set([
-    "llm_rate_limit_exceeded",
     "llm_day_quota_exceeded",
     "llm_week_quota_exceeded",
     "llm_fixed_budget_quota_exceeded",
@@ -21,6 +21,8 @@ const LLM_USAGE_LIMIT_ERROR_CODES = new Set([
     "llm_fixed_budget_token_quota_exceeded",
 ]);
 const LOADMILL_UPGRADE_URL = "https://www.loadmill.com/book-a-demo";
+const LLM_REQUEST_RATE_LIMIT_ERROR_CODE = "llm_rate_limit_exceeded";
+const DEFAULT_ASSERTION_CONTEXT = "No additional prior context is needed; validate directly from the current screen.";
 function isLlmUsageLimitError(err) {
     if (!err || typeof err !== "object") {
         return false;
@@ -30,9 +32,15 @@ function isLlmUsageLimitError(err) {
     }
     return err.status === 429 && err.type === "rate_limit_error";
 }
+function isLlmRequestRateLimitError(err) {
+    return err && typeof err === "object" && err.code === LLM_REQUEST_RATE_LIMIT_ERROR_CODE;
+}
 function getLlmUsageLimitMessage() {
     return `Execution stopped: you've reached the AI usage limit for this account. Contact the Loadmill team to upgrade: ${LOADMILL_UPGRADE_URL}`;
 }
+function getLlmRequestRateLimitMessage() {
+    return "Execution stopped: too many AI requests are running for this account right now. Please retry shortly or reduce parallel test runs.";
+}
 /**
  * Execution Mode - Run test scripts line-by-line
  * Each instruction is executed in isolation (messages cleared after each turn)
@@ -105,10 +113,11 @@ export class ExecutionMode {
         lines.push(`  Retries:      ${this.stats.retryCount}`);
         return lines;
     }
-    buildStepContext(instructionIndex) {
+    buildStepContext(instructionIndex, instruction = null) {
         return {
             instructionIndex,
             stepId: `step-${String(instructionIndex + 1).padStart(4, "0")}`,
+            ...(typeof instruction === "string" ? { instruction } : {}),
         };
     }
     emit(addOutput, type, text, context = {}, stepContext = null, extra = {}) {
@@ -123,6 +132,45 @@ export class ExecutionMode {
             payload: extra.payload
         });
     }
+    resetInstructionConversationState() {
+        this.session.updateResponseId(null);
+        if (typeof this.session.clearTranscript === "function") {
+            this.session.clearTranscript();
+            return;
+        }
+        if (Array.isArray(this.session.transcript)) {
+            this.session.transcript = [];
+        }
+    }
+    async executeVerificationInstruction(instruction, context, stepContext = null) {
+        const toolResult = await handleAssertionToolCall({
+            engine: this.engine,
+            callId: stepContext?.stepId ? `${stepContext.stepId}-assert` : "instruction-assert",
+            argumentsText: JSON.stringify({
+                condition: extractAssertionPrompt(instruction),
+                context: DEFAULT_ASSERTION_CONTEXT,
+            }),
+            context,
+            stepContext,
+        });
+        const assertionStatus = toolResult.summaryUpdates?.assertionStatus;
+        if (assertionStatus === "passed") {
+            this.stats.assertionsPassed++;
+        }
+        else if (assertionStatus === "failed" || assertionStatus === "failed_skipped") {
+            this.stats.assertionsFailed++;
+        }
+        if (toolResult.kind === "retry_instruction") {
+            this.stats.retryCount++;
+            this.session.clearMessages();
+            return await this.executeInstruction(instruction, context, 0, stepContext);
+        }
+        if (toolResult.kind === "fail") {
+            return { success: false, error: toolResult.error || "Assertion failed." };
+        }
+        this.session.clearMessages();
+        return { success: true };
+    }
     /**
      * Execute all instructions in the test script
      * @param {Object} context - Additional context (Ink context with addOutput)
@@ -137,7 +185,8 @@ export class ExecutionMode {
         // Start timing
         this.stats.startTime = Date.now();
         for (let i = 0; i < this.instructions.length; i++) {
-            const stepContext = this.buildStepContext(i);
+            const instruction = this.instructions[i];
+            const stepContext = this.buildStepContext(i, instruction);
             // Check if execution should be stopped
             if (this.shouldStop) {
                 this.emit(addOutput, 'info', 'Test execution stopped by user.', runContext, stepContext, {
@@ -158,7 +207,6 @@ export class ExecutionMode {
                     return { success: false, error: 'Stopped by user' };
                 }
             }
-            const instruction = this.instructions[i];
             this.emit(addOutput, 'user', instruction, runContext, stepContext, {
                 eventType: 'instruction_started',
                 payload: {
@@ -236,10 +284,17 @@ export class ExecutionMode {
         const MAX_RETRIES = 10;
         const instructionContext = {
             ...context,
+            currentInstruction: instruction,
             futureInstructions: this.instructions.slice((stepContext?.instructionIndex ?? -1) + 1),
         };
+        if (retryCount === 0) {
+            this.resetInstructionConversationState();
+        }
         this.session.addToTranscript(`[User] ${instruction}`);
         this.session.addMessage("user", instruction);
+        if (isAssertion(instruction)) {
+            return await this.executeVerificationInstruction(instruction, instructionContext, stepContext);
+        }
         try {
             const screenshotBase64 = await this.getScreenshotAsBase64(this.session.deviceId, this.session.deviceInfo);
             const currentScreenshot = await this.engine.recordScreenshot?.(screenshotBase64, {
@@ -309,6 +364,26 @@ export class ExecutionMode {
                 stack: err.stack
             });
             const addOutput = context.addOutput || printCliOutput;
+            if (isLlmRequestRateLimitError(err)) {
+                const stopMessage = getLlmRequestRateLimitMessage();
+                logger.debug('Stopping execution because an LLM request rate limit was reached', {
+                    instruction,
+                    message: err.message,
+                    status: err.status,
+                    code: err.code,
+                    type: err.type,
+                });
+                this.emit(addOutput, 'error', stopMessage, context, stepContext, {
+                    eventType: 'error',
+                    payload: {
+                        message: stopMessage,
+                        status: err.status,
+                        code: err.code,
+                        type: err.type,
+                    }
+                });
+                return { success: false, error: stopMessage, usageLimitReached: true };
+            }
             if (isLlmUsageLimitError(err)) {
                 const stopMessage = getLlmUsageLimitMessage();
                 logger.debug('Stopping execution because an LLM usage limit was reached', {
@@ -449,6 +524,7 @@ export class ExecutionMode {
             });
             // Replace the system message with the enhanced one
             this.session.installRecoverySystemPrompt(recoverySystemPrompt);
+            this.session.updateResponseId(null);
             // Wait a bit before retrying
             await new Promise(resolve => setTimeout(resolve, 1000));
             // Retry the same instruction with incremented counter

package/build/src/prompts/design.js

@@ -139,7 +139,9 @@ Test design exploration is complete. Use the validated completion summary below
 Do not call tools.
 Do not continue exploring.
 Do not add explanation.
-Output only the final result in the required design-mode format.
+Output only the exact final result format below: one "Suggested test name:" line, then one fenced code block.
+Do not use TEST NAME, GOAL, STEPS, VERIFICATIONS, FINAL STATE, markdown headings, numbered lists, or bullets.
+The fenced code block must contain only executable test instructions, one per line, ending with exit.
 
 Completion summary:
 Suggested test name: ${suggestedTestName || "(choose a short kebab-case name)"}
@@ -151,3 +153,21 @@ Verification points:
 ${formatStringList(summary.verificationPoints)}
 ${notesForScript ? `Notes for script:\n${notesForScript}\n` : ""}`;
 }
+export function buildDesignScriptFormatRetryPrompt(previousOutput = "") {
+    const previousOutputText = typeof previousOutput === "string" ? previousOutput.trim() : "";
+    return `AUTHORING FORMAT CORRECTION:
+Your previous answer did not use the required design-mode format.
+
+Output only:
+Suggested test name: short-kebab-case-name
+
+\`\`\`
+one executable instruction per line
+exit
+\`\`\`
+
+Do not include TEST NAME, GOAL, STEPS, VERIFICATIONS, FINAL STATE, markdown headings, numbered lists, bullets, or explanation.${previousOutputText ? `
+
+Previous output to reformat:
+${previousOutputText}` : ""}`;
+}

package/build/src/utils/console-output.js

@@ -1,4 +1,5 @@
 import { classifyCaptureSource } from "../core/capture-sources.js";
+import { stepCompletionData } from "../core/report/run-log-model.js";
 function isHiddenExecutionOutput(item) {
     const captureSource = item?.payload?.captureSource;
     return classifyCaptureSource(captureSource).mediaKind === "hidden-debug";
@@ -24,6 +25,10 @@ export function formatCliOutput(item) {
         if (!text || text.trim().length === 0) {
             return null;
         }
+        const stepCompletion = stepCompletionData(text);
+        if (stepCompletion) {
+            return `assistant: Step complete — ${stepCompletion.instruction}`;
+        }
         return text
             .split("\n")
             .map((line) => `assistant: ${line}`)

package/build/src/utils/cua-debug-tracer.js

@@ -92,6 +92,54 @@ function summarizeRequestInput(input) {
         };
     });
 }
+function extractImageBase64Length(imageUrl) {
+    return typeof imageUrl === "string" ? imageUrl.replace("data:image/png;base64,", "").length : 0;
+}
+function summarizeRequestScreenshots(input, deviceInfo) {
+    const screenshots = [];
+    for (const item of input) {
+        if (item?.role && Array.isArray(item.content)) {
+            for (const entry of item.content) {
+                if (entry?.type !== "input_image" || typeof entry.image_url !== "string")
+                    continue;
+                screenshots.push({
+                    source: `message:${item.role}`,
+                    base64Length: extractImageBase64Length(entry.image_url),
+                });
+            }
+            continue;
+        }
+        if (item?.type === "computer_call_output" && typeof item.output?.image_url === "string") {
+            screenshots.push({
+                source: "computer_call_output",
+                callId: item.call_id,
+                base64Length: extractImageBase64Length(item.output.image_url),
+            });
+            continue;
+        }
+        if (item?.type === "function_call_output" && Array.isArray(item.output)) {
+            for (const entry of item.output) {
+                if (entry?.type !== "input_image" || typeof entry.image_url !== "string")
+                    continue;
+                screenshots.push({
+                    source: "function_call_output",
+                    callId: item.call_id,
+                    base64Length: extractImageBase64Length(entry.image_url),
+                });
+            }
+        }
+    }
+    if (screenshots.length === 0) {
+        return null;
+    }
+    return {
+        count: screenshots.length,
+        sources: screenshots.map((entry) => entry.source),
+        base64Lengths: screenshots.map((entry) => entry.base64Length),
+        width: deviceInfo?.scaled_width ?? null,
+        height: deviceInfo?.scaled_height ?? null,
+    };
+}
 function redactRequestForFileLog(requestParams) {
     return {
         ...requestParams,
@@ -223,6 +271,7 @@ export class CuaDebugTracer {
         const localRequestId = crypto.randomUUID();
         const requestLog = redactRequestForFileLog(requestParams);
         const messages = summarizeRequestInput(input);
+        const screenshot = summarizeRequestScreenshots(input, deviceInfo);
         const acknowledgedSafetyChecksSent = input
             .filter((item) => item?.type === "computer_call_output")
             .flatMap((item) => {
@@ -260,13 +309,7 @@ export class CuaDebugTracer {
             inputItemTypes,
             inputCallIds,
             messages,
-            screenshot: screenshotBase64
-                ? {
-                    width: deviceInfo?.scaled_width ?? null,
-                    height: deviceInfo?.scaled_height ?? null,
-                    base64Length: screenshotBase64.length
-                }
-                : null,
+            screenshot,
             safetyChecks: {
                 previousPending: previousPendingSafetyChecks,
                 previousPendingCount: previousPendingSafetyChecks.length,

package/package.json

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

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

@@ -1,11 +0,0 @@
-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;
-}