@loadmill/droid-cua 1.0.0 → 1.1.1

package/build/src/device/loadmill.js

@@ -0,0 +1,122 @@
+/**
+ * Loadmill instruction handling for script execution
+ */
+import { executeLoadmillCommand } from "../integrations/loadmill/index.js";
+/**
+ * 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
+ * @param {boolean} isHeadlessMode - Whether running in headless/CI mode
+ * @param {Object} context - Execution context
+ * @returns {Promise<{success: boolean, error?: string}>}
+ */
+export async function executeLoadmillInstruction(command, isHeadlessMode, context) {
+    const addOutput = context?.addOutput || ((item) => console.log(item.text || item));
+    addOutput({ type: 'info', text: `[Loadmill] Executing: ${command}` });
+    const result = await executeLoadmillCommand(command, {
+        onProgress: ({ message }) => {
+            addOutput({ type: 'info', text: `[Loadmill] ${message}` });
+        }
+    });
+    if (result.success) {
+        handleLoadmillSuccess(command, result, context);
+        return { success: true };
+    }
+    else {
+        return await handleLoadmillFailure(command, result.error, isHeadlessMode, context);
+    }
+}
+/**
+ * Handle a Loadmill execution failure
+ * @param {string} command - The failed command
+ * @param {string} error - Error message
+ * @param {boolean} isHeadlessMode - Whether running in headless/CI mode
+ * @param {Object} context - Execution context
+ * @returns {Promise<{success: boolean, error?: string}>}
+ */
+export async function handleLoadmillFailure(command, error, isHeadlessMode, context) {
+    const addOutput = context?.addOutput || ((item) => console.log(item.text || item));
+    addOutput({ type: 'error', text: '[Loadmill] FAILED' });
+    addOutput({ type: 'error', text: `Command: ${command}` });
+    addOutput({ type: 'error', text: `Error: ${error}` });
+    if (isHeadlessMode) {
+        // Headless mode: exit with error code
+        if (context?.exit) {
+            context.exit();
+        }
+        process.exit(1);
+    }
+    // Interactive mode: ask user what to do
+    addOutput({ type: 'system', text: 'What would you like to do? (retry/skip/stop)' });
+    const userChoice = await new Promise((resolve) => {
+        if (context?.waitForUserInput) {
+            context.waitForUserInput().then(resolve);
+        }
+        else {
+            // Fallback if waitForUserInput not available
+            resolve('stop');
+        }
+    });
+    const choice = userChoice.toLowerCase().trim();
+    if (choice === 'retry' || choice === 'r') {
+        // Retry by returning a signal to re-execute
+        return { success: false, retry: true };
+    }
+    else if (choice === 'skip' || choice === 's') {
+        addOutput({ type: 'info', text: 'Skipping failed Loadmill command and continuing...' });
+        return { success: true }; // Continue to next instruction
+    }
+    else {
+        // Stop execution
+        return { success: false, error: `Loadmill command failed: ${command}` };
+    }
+}
+/**
+ * Handle a successful Loadmill execution
+ * @param {string} command - The executed command
+ * @param {Object} result - The execution result
+ * @param {Object} context - Execution context
+ */
+export function handleLoadmillSuccess(command, result, context) {
+    const addOutput = context?.addOutput || ((item) => console.log(item.text || item));
+    if (result.action === "search") {
+        addOutput({ type: 'success', text: `[Loadmill] Found ${result.result.flows.length} flow(s)` });
+        result.result.flows.forEach((flow, i) => {
+            const name = flow.description || flow.name || "Unknown";
+            addOutput({ type: 'info', text: `  ${i + 1}. ${name} (ID: ${flow.id})` });
+        });
+    }
+    else {
+        addOutput({ type: 'success', text: `[Loadmill] Flow "${result.flowName}" passed` });
+        if (result.runId) {
+            addOutput({ type: 'info', text: `  Run ID: ${result.runId}` });
+        }
+    }
+}

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

@@ -0,0 +1,151 @@
+/**
+ * Loadmill API client for interacting with test flows
+ */
+import dotenv from "dotenv";
+dotenv.config();
+const DEFAULT_BASE_URL = "https://app.loadmill.com/api";
+/**
+ * Get Loadmill API token from environment
+ * @returns {string|null}
+ */
+export function getApiToken() {
+    return process.env.LOADMILL_API_TOKEN || null;
+}
+/**
+ * Get Loadmill base URL from environment
+ * @returns {string}
+ */
+export function getBaseUrl() {
+    return process.env.LOADMILL_BASE_URL || DEFAULT_BASE_URL;
+}
+/**
+ * Make an authenticated request to Loadmill API
+ * @param {string} endpoint - API endpoint (without base URL)
+ * @param {Object} options - Fetch options
+ * @returns {Promise<Object>}
+ */
+async function apiRequest(endpoint, options = {}) {
+    const token = getApiToken();
+    if (!token) {
+        throw new Error("LOADMILL_API_TOKEN environment variable is not set");
+    }
+    const baseUrl = getBaseUrl();
+    const url = `${baseUrl}${endpoint}`;
+    const response = await fetch(url, {
+        ...options,
+        headers: {
+            "Authorization": `Bearer ${token}`,
+            "Content-Type": "application/json",
+            ...options.headers,
+        },
+    });
+    if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Loadmill API error (${response.status}): ${errorText}`);
+    }
+    return response.json();
+}
+/**
+ * Search for test flows by query
+ * @param {string} searchQuery - Search query string
+ * @param {Object} options - Additional options
+ * @param {number} options.limit - Maximum number of results (default: 10)
+ * @returns {Promise<Array>} - Array of matching flows
+ */
+export async function searchFlows(searchQuery, options = {}) {
+    const { limit = 10 } = options;
+    const encodedQuery = encodeURIComponent(searchQuery);
+    const result = await apiRequest(`/test-flows?search=${encodedQuery}&limit=${limit}`);
+    // Handle different response formats
+    if (Array.isArray(result)) {
+        return result;
+    }
+    if (result && Array.isArray(result.flows)) {
+        return result.flows;
+    }
+    if (result && Array.isArray(result.data)) {
+        return result.data;
+    }
+    if (result && Array.isArray(result.items)) {
+        return result.items;
+    }
+    if (result && Array.isArray(result.testFlows)) {
+        return result.testFlows;
+    }
+    // Log unexpected response format for debugging
+    console.error("[Loadmill] Unexpected API response format:", JSON.stringify(result, null, 2));
+    return [];
+}
+/**
+ * Run a test suite with specified flows
+ * @param {string} suiteId - Test suite ID
+ * @param {Object} options - Run options
+ * @param {string[]} options.flowIds - Array of flow IDs to run
+ * @param {Object} options.parameters - Parameters to pass to the flows
+ * @returns {Promise<Object>} - Run result with runId
+ */
+export async function runTestSuite(suiteId, { flowIds = [], parameters = {} } = {}) {
+    const body = {};
+    if (flowIds.length > 0) {
+        body.flowIds = flowIds;
+    }
+    if (Object.keys(parameters).length > 0) {
+        body.parameters = parameters;
+    }
+    return apiRequest(`/test-suites/${suiteId}/run`, {
+        method: "POST",
+        body: JSON.stringify(body),
+    });
+}
+/**
+ * Run a single test flow
+ * @param {string} flowId - Flow ID to run
+ * @param {string} suiteId - Test suite ID containing the flow
+ * @param {Object} options - Run options
+ * @param {Object} options.parameters - Parameters to pass to the flow
+ * @returns {Promise<Object>} - Run result with testSuiteRunId
+ */
+export async function runTestFlow(flowId, suiteId, { parameters = {} } = {}) {
+    const body = {
+        flows: [flowId],
+        inlineParameterOverride: true,
+        sharedFlowVersionOverrides: [],
+    };
+    if (Object.keys(parameters).length > 0) {
+        body.overrideParameters = parameters;
+    }
+    return apiRequest(`/test-suites/${suiteId}/run?ui=true`, {
+        method: "POST",
+        body: JSON.stringify(body),
+    });
+}
+/**
+ * Get the status of a test run
+ * @param {string} testRunId - Test run ID
+ * @returns {Promise<Object>} - Test run status
+ */
+export async function getTestRunStatus(testRunId) {
+    return apiRequest(`/test-suites-runs/${testRunId}`);
+}
+/**
+ * Get the status of a flow run
+ * @param {string} flowRunId - Flow run ID
+ * @returns {Promise<Object>} - Flow run status
+ */
+export async function getFlowRunStatus(flowRunId) {
+    return apiRequest(`/test-flows-runs/${flowRunId}`);
+}
+/**
+ * Get AI-generated explanation for a failed test run
+ * @param {string} testRunId - The flow run ID (from testSuiteFlowRuns[].id)
+ * @returns {Promise<Object>} - Explanation with reason, suggestion, etc.
+ */
+export async function explainFailure(testRunId) {
+    return apiRequest(`/explain-failures`, {
+        method: "POST",
+        body: JSON.stringify({
+            testRunId,
+            testRunType: "flowRun"
+        }),
+    });
+}

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

@@ -0,0 +1,152 @@
+/**
+ * Orchestrates Loadmill flow execution
+ */
+import { searchFlows, runTestFlow, getTestRunStatus, getApiToken, explainFailure } from "./client.js";
+import { interpretLoadmillCommand, selectBestFlow } from "./interpreter.js";
+import { logger } from "../../utils/logger.js";
+const POLL_INTERVAL_MS = 5000; // 5 seconds
+const TIMEOUT_MS = 5 * 60 * 1000; // 5 minutes
+/**
+ * Wait for a specified number of milliseconds
+ * @param {number} ms
+ * @returns {Promise<void>}
+ */
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+/**
+ * Poll for test run completion
+ * @param {string} runId - The run ID to poll
+ * @param {Function} onStatusUpdate - Callback for status updates
+ * @returns {Promise<Object>} - Final run status
+ */
+async function pollForCompletion(runId, onStatusUpdate = () => { }) {
+    const startTime = Date.now();
+    while (Date.now() - startTime < TIMEOUT_MS) {
+        try {
+            const status = await getTestRunStatus(runId);
+            onStatusUpdate(status);
+            // Check if run is complete
+            if (status.status === "PASSED" || status.status === "passed") {
+                return { success: true, status: "passed", result: status };
+            }
+            if (status.status === "FAILED" || status.status === "failed") {
+                // Try to get failure explanation
+                let failureReason = "Test flow failed";
+                try {
+                    const failedFlowRun = status.testSuiteFlowRuns?.find(f => f.status === "FAILED");
+                    if (failedFlowRun) {
+                        const explanation = await explainFailure(failedFlowRun.id);
+                        if (explanation?.reason) {
+                            failureReason = explanation.reason;
+                        }
+                    }
+                }
+                catch (err) {
+                    logger.debug("Could not get failure explanation", { error: err.message });
+                }
+                return { success: false, status: "failed", result: status, error: failureReason };
+            }
+            if (status.status === "STOPPED" || status.status === "stopped") {
+                return { success: false, status: "stopped", result: status, error: "Test flow was stopped" };
+            }
+            // Still running, wait and poll again
+            await sleep(POLL_INTERVAL_MS);
+        }
+        catch (err) {
+            logger.error("Error polling Loadmill run status", { runId, error: err.message });
+            throw err;
+        }
+    }
+    // Timeout
+    return { success: false, status: "timeout", error: "Test run timed out after 5 minutes" };
+}
+/**
+ * Execute a Loadmill command from natural language input
+ * @param {string} userInput - Natural language command
+ * @param {Object} options - Execution options
+ * @param {Function} options.onProgress - Callback for progress updates
+ * @returns {Promise<{success: boolean, error?: string, result?: Object}>}
+ */
+export async function executeLoadmillCommand(userInput, options = {}) {
+    const { onProgress = () => { } } = options;
+    // Check for API token
+    if (!getApiToken()) {
+        return {
+            success: false,
+            error: "LOADMILL_API_TOKEN environment variable is not set. Please set it in your .env file."
+        };
+    }
+    try {
+        // Step 1: Interpret the command
+        onProgress({ step: "interpreting", message: "Interpreting command..." });
+        const interpreted = await interpretLoadmillCommand(userInput);
+        logger.debug("Loadmill command interpreted", interpreted);
+        // Step 2: Search for flows
+        onProgress({ step: "searching", message: `Searching for flows matching "${interpreted.searchQuery}"...` });
+        const flows = await searchFlows(interpreted.searchQuery);
+        // Ensure flows is an array
+        if (!Array.isArray(flows) || flows.length === 0) {
+            return {
+                success: false,
+                error: `No test flows found matching "${interpreted.searchQuery}"`
+            };
+        }
+        // Step 3: Select best match
+        onProgress({ step: "selecting", message: `Found ${flows.length} flow(s). Selecting best match...` });
+        const { selectedFlow, confidence } = await selectBestFlow(flows, interpreted.searchQuery);
+        if (!selectedFlow) {
+            return {
+                success: false,
+                error: "Could not select a matching flow"
+            };
+        }
+        // If action is "search", just return the results
+        if (interpreted.action === "search") {
+            return {
+                success: true,
+                action: "search",
+                result: {
+                    flows,
+                    selectedFlow,
+                    confidence
+                }
+            };
+        }
+        // Step 4: Run the flow
+        const flowName = selectedFlow.description || selectedFlow.name || "Unknown";
+        onProgress({
+            step: "running",
+            message: `Running flow "${flowName}" (confidence: ${(confidence * 100).toFixed(0)}%)...`
+        });
+        const runResult = await runTestFlow(selectedFlow.id, selectedFlow.testSuiteId, {
+            parameters: interpreted.parameters
+        });
+        const runId = runResult.testSuiteRunId || runResult.id || runResult.runId;
+        if (!runId) {
+            return {
+                success: false,
+                error: "Failed to start test flow - no run ID returned"
+            };
+        }
+        // Step 5: Poll for completion
+        onProgress({ step: "polling", message: `Test started (ID: ${runId}). Waiting for completion...` });
+        const finalResult = await pollForCompletion(runId, (status) => {
+            onProgress({ step: "polling", message: `Status: ${status.status}...` });
+        });
+        return {
+            ...finalResult,
+            flowName,
+            flowId: selectedFlow.id,
+            runId,
+            parameters: interpreted.parameters
+        };
+    }
+    catch (err) {
+        logger.error("Loadmill execution error", { error: err.message, stack: err.stack });
+        return {
+            success: false,
+            error: err.message
+        };
+    }
+}

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

@@ -0,0 +1,6 @@
+/**
+ * Loadmill integration public exports
+ */
+export { getApiToken, searchFlows, runTestFlow, getFlowRunStatus } from "./client.js";
+export { interpretLoadmillCommand, selectBestFlow } from "./interpreter.js";
+export { executeLoadmillCommand } from "./executor.js";

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

@@ -0,0 +1,116 @@
+/**
+ * AI-powered text interpretation for Loadmill commands
+ */
+import OpenAI from "openai";
+import dotenv from "dotenv";
+dotenv.config();
+const openai = new OpenAI({
+    apiKey: process.env.OPENAI_API_KEY,
+});
+/**
+ * Interpret a natural language Loadmill command into structured data
+ * @param {string} userInput - Natural language command
+ * @returns {Promise<{searchQuery: string, parameters: Object, action: 'run'|'search'}>}
+ */
+export async function interpretLoadmillCommand(userInput) {
+    const response = await openai.chat.completions.create({
+        model: "gpt-4o-mini",
+        messages: [
+            {
+                role: "system",
+                content: `You are a parser that extracts structured data from natural language Loadmill commands.
+
+Extract the following from the user's input:
+1. searchQuery: The flow name or description to search for (required). FIX any obvious typos or misspellings.
+2. parameters: Any key=value pairs mentioned (as an object)
+3. action: Either "run" (if user wants to execute) or "search" (if user just wants to find flows)
+
+Output JSON only, no markdown or explanation.
+
+Examples:
+Input: "run the checkout flow with user=test123"
+Output: {"searchQuery": "checkout flow", "parameters": {"user": "test123"}, "action": "run"}
+
+Input: "search for login test"
+Output: {"searchQuery": "login test", "parameters": {}, "action": "search"}
+
+Input: "run user authentication with email=test@example.com password=secret123"
+Output: {"searchQuery": "user authentication", "parameters": {"email": "test@example.com", "password": "secret123"}, "action": "run"}
+
+Input: "execute payment flow"
+Output: {"searchQuery": "payment flow", "parameters": {}, "action": "run"}
+
+Input: "create a transction with amount=200"
+Output: {"searchQuery": "transaction", "parameters": {"amount": "200"}, "action": "run"}`
+            },
+            {
+                role: "user",
+                content: userInput
+            }
+        ],
+        response_format: { type: "json_object" }
+    });
+    const content = response.choices[0].message.content;
+    const parsed = JSON.parse(content);
+    return {
+        searchQuery: parsed.searchQuery || userInput,
+        parameters: parsed.parameters || {},
+        action: parsed.action || "run"
+    };
+}
+/**
+ * Select the best matching flow from search results
+ * @param {Array} flows - Array of flow objects
+ * @param {string} originalQuery - Original user query
+ * @returns {Promise<{selectedFlow: Object|null, confidence: number}>}
+ */
+export async function selectBestFlow(flows, originalQuery) {
+    // Ensure flows is an array
+    if (!flows || !Array.isArray(flows) || flows.length === 0) {
+        return { selectedFlow: null, confidence: 0 };
+    }
+    if (flows.length === 1) {
+        return { selectedFlow: flows[0], confidence: 0.9 };
+    }
+    // Build a list of flows for the AI to choose from
+    const flowList = flows.map((f, i) => {
+        const name = f.description || f.name || "Unknown";
+        const suite = f.testSuiteDescription || "";
+        return `${i + 1}. ID: ${f.id}, Name: "${name}"${suite ? `, Suite: "${suite}"` : ""}`;
+    }).join("\n");
+    const response = await openai.chat.completions.create({
+        model: "gpt-4o-mini",
+        messages: [
+            {
+                role: "system",
+                content: `You are selecting the best matching test flow based on a user query.
+
+Given the user's query and a list of available flows, select the best match.
+
+Output JSON with:
+- index: 1-based index of the best matching flow
+- confidence: number between 0 and 1 indicating how confident you are
+
+If no flow seems to match well, set confidence to a low value (< 0.5).
+
+Output JSON only, no markdown.`
+            },
+            {
+                role: "user",
+                content: `Query: "${originalQuery}"
+
+Available flows:
+${flowList}`
+            }
+        ],
+        response_format: { type: "json_object" }
+    });
+    const content = response.choices[0].message.content;
+    const parsed = JSON.parse(content);
+    const index = (parsed.index || 1) - 1;
+    const selectedFlow = flows[index] || flows[0];
+    return {
+        selectedFlow,
+        confidence: parsed.confidence || 0.5
+    };
+}

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

@@ -1,6 +1,7 @@
-import { getScreenshotAsBase64 } from "../device/connection.js";
+import { getScreenshotAsBase64, connectToDevice, getDeviceInfo, getCurrentPlatform } from "../device/connection.js";
 import { sendCUARequest } from "../device/openai.js";
 import { isAssertion, extractAssertionPrompt, buildAssertionSystemPrompt, checkAssertionResult, handleAssertionFailure, handleAssertionSuccess, } from "../device/assertions.js";
+import { isLoadmillInstruction, extractLoadmillCommand, executeLoadmillInstruction, } from "../device/loadmill.js";
 import { logger } from "../utils/logger.js";
 /**
  * Execution Mode - Run test scripts line-by-line
@@ -66,10 +67,23 @@ export class ExecutionMode {
      * Execute a single instruction
      * @param {string} instruction - The instruction to execute
      * @param {Object} context - Additional context
+     * @param {number} retryCount - Current retry attempt (internal use)
      * @returns {Promise<{success: boolean, error?: string}>}
      */
-    async executeInstruction(instruction, context) {
+    async executeInstruction(instruction, context, retryCount = 0) {
+        const MAX_RETRIES = 3;
         const addOutput = context.addOutput || ((item) => console.log(item.text || item));
+        // ── Check for Loadmill instruction ──
+        if (isLoadmillInstruction(instruction)) {
+            const loadmillCommand = extractLoadmillCommand(instruction);
+            this.session.addToTranscript(`[Loadmill] ${loadmillCommand}`);
+            const result = await executeLoadmillInstruction(loadmillCommand, this.isHeadlessMode, context);
+            // Handle retry request from interactive mode
+            if (result.retry) {
+                return await this.executeInstruction(instruction, context);
+            }
+            return result;
+        }
         // ── Check for assertion ──
         const isAssertionStep = isAssertion(instruction);
         let assertionPrompt = null;
@@ -87,8 +101,19 @@ export class ExecutionMode {
         }
         try {
             const screenshotBase64 = await getScreenshotAsBase64(this.session.deviceId, this.session.deviceInfo);
+            // When continuing with previousResponseId, only send the new instruction
+            // The server already has full context from previous responses
+            let messagesToSend;
+            if (this.session.previousResponseId && !isAssertionStep) {
+                // Only send the new user instruction
+                messagesToSend = [{ role: "user", content: instruction }];
+            }
+            else {
+                // Fresh start or assertion - send full messages (system + user)
+                messagesToSend = this.session.messages;
+            }
             const response = await sendCUARequest({
-                messages: this.session.messages,
+                messages: messagesToSend,
                 screenshotBase64,
                 previousResponseId: this.session.previousResponseId,
                 deviceInfo: this.session.deviceInfo,
@@ -135,14 +160,17 @@ export class ExecutionMode {
                     handleAssertionSuccess(assertionPrompt, context);
                 }
             }
-            // Clear messages after each turn (isolated execution)
+            // Clear messages after each turn but KEEP the response chain for context
+            // When continuing with previousResponseId, only send new user message (not system)
             this.session.clearMessages();
+            // Note: we keep previousResponseId to maintain context across the test
             return { success: true };
         }
         catch (err) {
             // Log full error details to file
-            logger.error('Execution instruction error (will retry)', {
+            logger.error('Execution instruction error', {
                 instruction,
+                retryCount,
                 message: err.message,
                 status: err.status,
                 code: err.code,
@@ -151,15 +179,46 @@ export class ExecutionMode {
                 stack: err.stack
             });
             const addOutput = context.addOutput || ((item) => console.log(item.text || item));
-            addOutput({ type: 'info', text: 'Connection issue. Retrying...' });
-            const summary = `The last session failed. Let's try again based on the last user message.
-      Here's a transcript of everything that happened so far:
-      \n\n${this.session.getTranscriptText()}\n\n${this.initialSystemText}`;
+            // Check if we've exceeded max retries
+            if (retryCount >= MAX_RETRIES) {
+                addOutput({ type: 'error', text: `Failed after ${MAX_RETRIES} retries. Device may be disconnected.` });
+                // Attempt to reconnect to the device
+                addOutput({ type: 'info', text: 'Attempting to reconnect to device...' });
+                try {
+                    const platform = getCurrentPlatform();
+                    const deviceName = this.session.deviceName || undefined;
+                    const deviceId = await connectToDevice(deviceName, platform);
+                    const deviceInfo = await getDeviceInfo(deviceId);
+                    // Update session with new connection
+                    this.session.deviceId = deviceId;
+                    this.session.deviceInfo = deviceInfo;
+                    addOutput({ type: 'success', text: 'Reconnected to device. Resuming...' });
+                    // Reset retry count and try again
+                    return await this.executeInstruction(instruction, context, 0);
+                }
+                catch (reconnectErr) {
+                    logger.error('Failed to reconnect to device', { error: reconnectErr.message });
+                    addOutput({ type: 'error', text: `Could not reconnect to device: ${reconnectErr.message}` });
+                    return { success: false, error: 'Device disconnected and reconnection failed' };
+                }
+            }
+            addOutput({ type: 'info', text: `Connection issue. Retrying... (${retryCount + 1}/${MAX_RETRIES})` });
+            // Build context for retry - include transcript in system message to avoid conversational responses
+            const transcriptContext = this.session.getTranscriptText();
             this.session.clearMessages();
-            this.session.addMessage("system", summary);
+            // clearMessages() restores the base system prompt, but we need to add context
+            // Build enhanced system prompt with recovery context
+            let recoverySystemPrompt = this.initialSystemText;
+            if (transcriptContext) {
+                recoverySystemPrompt += `\n\n[SESSION RECOVERY - Connection was lost. Previous actions completed before the error:]\n${transcriptContext}\n\n[IMPORTANT: Resume execution silently. Do NOT narrate or explain. Just execute the next instruction.]`;
+            }
+            // Replace the system message with the enhanced one
+            this.session.messages = [{ role: "system", content: recoverySystemPrompt }];
             this.session.updateResponseId(undefined);
-            // Retry the same instruction
-            return await this.executeInstruction(instruction, context);
+            // Wait a bit before retrying
+            await new Promise(resolve => setTimeout(resolve, 1000));
+            // Retry the same instruction with incremented counter
+            return await this.executeInstruction(instruction, context, retryCount + 1);
         }
     }
 }