testchimp-runner-core 0.0.21 → 0.0.23

package/dist/llm-facade.js

@@ -1,104 +1,77 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LLMFacade = void 0;
-const axios_1 = __importDefault(require("axios"));
 const prompts_1 = require("./prompts");
 const types_1 = require("./types");
-const auth_config_1 = require("./auth-config");
-const env_loader_1 = require("./env-loader");
+const model_constants_1 = require("./model-constants");
 class LLMFacade {
-    constructor(authConfig, backendUrl) {
-        // Use provided backend URL or fall back to environment configuration
-        if (backendUrl) {
-            this.backendUrl = backendUrl;
-            console.log(`LLMFacade initialized with provided backend URL: ${this.backendUrl}`);
-        }
-        else {
-            // Fall back to environment configuration for backward compatibility
-            const envConfig = (0, env_loader_1.loadEnvConfig)();
-            this.backendUrl = envConfig.TESTCHIMP_BACKEND_URL;
-            console.log(`LLMFacade initialized with environment backend URL: ${this.backendUrl}`);
-        }
-        // Use provided auth config or try to create from environment
-        this.authConfig = authConfig || (0, auth_config_1.createAuthConfigFromEnv)();
-        if (!this.authConfig) {
-            console.warn('TestChimp authentication not configured. LLM calls may fail.');
-        }
+    constructor(llmProvider) {
+        this.llmProvider = llmProvider;
+        this.log('LLMFacade initialized with pluggable LLM provider');
     }
     /**
-     * Update authentication configuration
+     * Set token usage callback for tracking
      */
-    setAuthConfig(authConfig) {
-        this.authConfig = authConfig;
+    setTokenUsageCallback(callback) {
+        this.tokenUsageCallback = callback;
     }
     /**
-     * Get current authentication configuration
+     * Set a logger callback for capturing execution logs
      */
-    getAuthConfig() {
-        return this.authConfig;
+    setLogger(logger) {
+        this.logger = logger;
+        this.llmProvider.setLogger?.(logger);
     }
-    async callLLM(request) {
-        if (!this.authConfig) {
-            throw new Error('Authentication not configured. Please set authentication credentials.');
+    /**
+     * Log a message using the configured logger
+     */
+    log(message, level = 'log') {
+        if (this.logger) {
+            this.logger(message, level);
+        }
+        // Console fallback for debug visibility
+        if (level === 'error') {
+            console.error(message);
         }
+        else if (level === 'warn') {
+            console.warn(message);
+        }
+        else {
+            console.log(message);
+        }
+    }
+    async callLLM(request) {
         try {
-            const authHeaders = (0, auth_config_1.getAuthHeaders)(this.authConfig);
-            const url = `${this.backendUrl}/localagent/call_llm`;
-            console.log(`repairing step`);
-            const response = await axios_1.default.post(url, request, {
-                headers: {
-                    ...authHeaders,
-                    'Content-Type': 'application/json'
-                },
-                timeout: 30000 // 30 second timeout for LLM calls
-            });
-            if (response.data && response.data.answer) {
-                return response.data.answer;
-            }
-            else {
-                throw new Error('Invalid response from LLM backend');
+            const response = await this.llmProvider.callLLM(request);
+            // Report token usage if callback is set
+            if (response.usage && this.tokenUsageCallback) {
+                this.tokenUsageCallback(response.usage.inputTokens, response.usage.outputTokens, !!request.imageUrl);
             }
+            return response;
         }
         catch (error) {
-            // Handle specific error cases with user-friendly messages
-            if (error.response?.status === 412) {
-                throw new Error('Insufficient credits. Please upgrade your TestChimp plan or add more credits to continue using AI features.');
-            }
-            else if (error.response?.status === 401) {
-                throw new Error('Authentication failed. Please check your API credentials.');
-            }
-            else if (error.response?.status === 403) {
-                throw new Error('Access denied. Please check your API permissions.');
-            }
-            else if (error.response?.status === 429) {
-                throw new Error('Rate limit exceeded. Please try again later.');
-            }
-            else {
-                console.error('LLM call failed:', error);
-                throw new Error(`LLM call failed: ${error.message}`);
-            }
+            // Let provider handle its own error messages, just re-throw
+            this.log(`LLM call failed: ${error}`, 'error');
+            throw error;
         }
     }
     /**
      * Generate a test name from scenario description
      */
-    async generateTestName(scenario, model = 'gpt-4.1-mini') {
-        console.log('Generating test name with LLM...');
+    async generateTestName(scenario, model = model_constants_1.DEFAULT_MODEL) {
+        this.log('Generating test name with LLM...');
         const request = {
             model,
-            system_prompt: prompts_1.PROMPTS.TEST_NAME_GENERATION.SYSTEM,
-            user_prompt: prompts_1.PROMPTS.TEST_NAME_GENERATION.USER(scenario)
+            systemPrompt: prompts_1.PROMPTS.TEST_NAME_GENERATION.SYSTEM,
+            userPrompt: prompts_1.PROMPTS.TEST_NAME_GENERATION.USER(scenario)
         };
         try {
             const response = await this.callLLM(request);
-            const testNameResponse = JSON.parse(response);
+            const testNameResponse = JSON.parse(response.answer);
             return testNameResponse.testName;
         }
         catch (error) {
-            console.error('Failed to generate test name:', error);
+            this.log(`Failed to generate test name: ${error}`, 'error');
             // Fallback to a simple generated name
             return `Test: ${scenario.substring(0, 50)}...`;
         }
@@ -107,50 +80,263 @@ class LLMFacade {
      * Generate hashtags for semantic grouping
      */
     async generateHashtags(scenario, model = 'gpt-4o-mini') {
-        console.log('Generating hashtags with LLM...');
+        this.log('Generating hashtags with LLM...');
         const request = {
             model,
-            system_prompt: prompts_1.PROMPTS.HASHTAG_GENERATION.SYSTEM,
-            user_prompt: prompts_1.PROMPTS.HASHTAG_GENERATION.USER(scenario)
+            systemPrompt: prompts_1.PROMPTS.HASHTAG_GENERATION.SYSTEM,
+            userPrompt: prompts_1.PROMPTS.HASHTAG_GENERATION.USER(scenario)
         };
         try {
             const response = await this.callLLM(request);
-            const hashtagResponse = JSON.parse(response);
+            const hashtagResponse = JSON.parse(response.answer);
             return hashtagResponse.hashtags || [];
         }
         catch (error) {
-            console.error('Failed to generate hashtags:', error);
+            this.log(`Failed to generate hashtags: ${error}`, 'error');
             // Fallback to empty array
             return [];
         }
     }
+    /**
+     * Check if a goal has been completed based on actions taken and current page state
+     */
+    async checkGoalCompletion(goalDescription, completedActions, pageInfo, model = model_constants_1.DEFAULT_MODEL) {
+        this.log('Checking goal completion with LLM...');
+        const request = {
+            model,
+            systemPrompt: prompts_1.PROMPTS.GOAL_COMPLETION_CHECK.SYSTEM,
+            userPrompt: prompts_1.PROMPTS.GOAL_COMPLETION_CHECK.USER(goalDescription, completedActions, pageInfo)
+        };
+        try {
+            const response = await this.callLLM(request);
+            return JSON.parse(response.answer);
+        }
+        catch (error) {
+            this.log(`Failed to check goal completion: ${error}`, 'error');
+            // Conservative fallback - assume not complete if we can't determine
+            return {
+                isComplete: false,
+                reason: 'Error checking completion status'
+            };
+        }
+    }
+    /**
+     * Check goal completion with visual verification (uses vision model)
+     */
+    async checkGoalCompletionWithVision(goalDescription, completedActions, pageInfo, imageDataUrl, model = model_constants_1.VISION_MODEL) {
+        this.log(`👔 Checking goal completion with vision (${model})...`);
+        const request = {
+            model,
+            systemPrompt: `You are checking if a test automation goal has been completed by analyzing both DOM state and visual appearance.
+
+CRITICAL: For action goals (login, submit, click, navigate), check if the PRIMARY ACTION and its SIDE EFFECTS are complete:
+- "Login" = Fill fields AND click button AND verify navigation/page change
+- "Submit form" = Fill fields AND click submit AND verify submission (success message/page change)
+- "Click X" = Click X AND verify expected page change or UI update
+
+For verification goals (verify, check, confirm), verify the VISUAL PRESENCE of expected elements.`,
+            userPrompt: `GOAL: ${goalDescription}
+
+ACTIONS COMPLETED:
+${completedActions.map((action, i) => `${i + 1}. ${action}`).join('\n')}
+
+CURRENT PAGE STATE:
+URL: ${pageInfo.url}
+Title: ${pageInfo.title}
+Interactive Elements:
+${pageInfo.formattedElements}
+
+Based on the screenshot AND page state, is this goal COMPLETE?
+
+Respond ONLY with valid JSON:
+{
+  "isComplete": true/false,
+  "reason": "Brief explanation based on what you SEE in the screenshot and DOM",
+  "nextSubGoal": "If incomplete, what specific next action is needed?"
+}`,
+            imageUrl: imageDataUrl
+        };
+        try {
+            const response = await this.callLLM(request);
+            const parsed = JSON.parse(response.answer);
+            this.log(`👔 Vision goal check result: ${parsed.isComplete ? 'COMPLETE ✅' : 'INCOMPLETE ❌'}`);
+            return parsed;
+        }
+        catch (error) {
+            this.log(`Failed to check goal completion with vision: ${error}`, 'error');
+            // Conservative fallback - assume not complete if we can't determine
+            return {
+                isComplete: false,
+                reason: 'Error checking completion status with vision'
+            };
+        }
+    }
+    /**
+     * Ask LLM if a screenshot would help debug the current failure
+     */
+    async assessScreenshotNeed(stepDescription, errorMessage, attemptCount, pageInfo, model = model_constants_1.DEFAULT_MODEL) {
+        this.log('Assessing screenshot need with LLM...');
+        const request = {
+            model,
+            systemPrompt: prompts_1.PROMPTS.SCREENSHOT_NEED_ASSESSMENT.SYSTEM,
+            userPrompt: prompts_1.PROMPTS.SCREENSHOT_NEED_ASSESSMENT.USER(stepDescription, errorMessage, attemptCount, pageInfo)
+        };
+        try {
+            const response = await this.callLLM(request);
+            return JSON.parse(response.answer);
+        }
+        catch (error) {
+            this.log(`Failed to assess screenshot need: ${error}`, 'error');
+            // Conservative fallback - don't use expensive screenshot unless we're sure
+            return {
+                needsScreenshot: false,
+                reason: 'Error assessing need, defaulting to no screenshot'
+            };
+        }
+    }
+    /**
+     * Get diagnostic analysis from screenshot (supervisor role)
+     */
+    async getVisionDiagnostics(stepDescription, pageInfo, previousSteps, lastError, imageDataUrl, model = model_constants_1.VISION_MODEL) {
+        this.log('👔 SUPERVISOR: Analyzing screenshot for diagnostic insights...');
+        const previousCommands = previousSteps
+            .map(s => s.playwrightCommand)
+            .filter(Boolean)
+            .join('\n');
+        const attemptHistory = previousSteps.length > 0
+            ? `Previous attempts context: ${previousSteps.length} commands executed`
+            : '';
+        const errorContext = lastError
+            ? `Last Error: ${lastError}`
+            : '';
+        const request = {
+            model,
+            systemPrompt: prompts_1.PROMPTS.VISION_DIAGNOSTIC_ANALYSIS.SYSTEM,
+            userPrompt: prompts_1.PROMPTS.VISION_DIAGNOSTIC_ANALYSIS.USER(stepDescription, pageInfo, previousCommands, attemptHistory, errorContext),
+            imageUrl: imageDataUrl
+        };
+        try {
+            const response = await this.callLLM(request);
+            const diagnostics = JSON.parse(response.answer);
+            // Log supervisor's findings
+            this.log(`👔 SUPERVISOR ANALYSIS:`);
+            this.log(`   📸 Visual: ${diagnostics.visualAnalysis}`);
+            this.log(`   🔍 Root cause: ${diagnostics.rootCause}`);
+            this.log(`   📋 Instructions: ${diagnostics.specificInstructions}`);
+            this.log(`   💡 Approach: ${diagnostics.recommendedApproach}`);
+            if (diagnostics.elementsFound?.length > 0) {
+                this.log(`   ✅ Elements found: ${diagnostics.elementsFound.join(', ')}`);
+            }
+            if (diagnostics.elementsNotFound?.length > 0) {
+                this.log(`   ❌ Elements NOT found: ${diagnostics.elementsNotFound.join(', ')}`);
+            }
+            return diagnostics;
+        }
+        catch (error) {
+            this.log(`Failed to get vision diagnostics: ${error}`, 'error');
+            throw new Error(`Vision diagnostic analysis failed: ${error}`);
+        }
+    }
+    /**
+     * Generate command based on supervisor's instructions
+     */
+    async generateCommandFromSupervisorInstructions(stepDescription, supervisorDiagnostics, pageInfo, model = model_constants_1.DEFAULT_MODEL) {
+        this.log('🔨 WORKER: Generating command based on supervisor instructions...');
+        const request = {
+            model,
+            systemPrompt: prompts_1.PROMPTS.PLAYWRIGHT_COMMAND_WITH_SUPERVISOR.SYSTEM,
+            userPrompt: prompts_1.PROMPTS.PLAYWRIGHT_COMMAND_WITH_SUPERVISOR.USER(stepDescription, supervisorDiagnostics.specificInstructions, supervisorDiagnostics.visualAnalysis, supervisorDiagnostics.elementsFound || [], supervisorDiagnostics.elementsNotFound || [], pageInfo)
+        };
+        try {
+            const response = await this.callLLM(request);
+            const commandResponse = JSON.parse(response.answer);
+            if (commandResponse.reasoning) {
+                this.log(`🔨 WORKER reasoning: ${commandResponse.reasoning}`);
+            }
+            return commandResponse.command;
+        }
+        catch (error) {
+            this.log(`Failed to generate command from supervisor instructions: ${error}`, 'error');
+            throw new Error(`Command generation from supervisor instructions failed: ${error}`);
+        }
+    }
+    /**
+     * Generate Playwright command with vision (uses vision model)
+     */
+    async generatePlaywrightCommandWithVision(stepDescription, pageInfo, previousSteps, lastError, imageDataUrl, // Full data URL: data:image/png;base64,...
+    model = model_constants_1.VISION_MODEL) {
+        this.log(`⚠️ USING VISION MODE (${model})...`);
+        const previousCommands = previousSteps
+            .map(s => s.playwrightCommand)
+            .filter(Boolean)
+            .join('\n');
+        const attemptHistory = previousSteps.length > 0
+            ? `Previous attempts context: ${previousSteps.length} commands executed`
+            : '';
+        const errorContext = lastError
+            ? `Last Error: ${lastError}`
+            : '';
+        const request = {
+            model,
+            systemPrompt: prompts_1.PROMPTS.PLAYWRIGHT_COMMAND_WITH_VISION.SYSTEM,
+            userPrompt: prompts_1.PROMPTS.PLAYWRIGHT_COMMAND_WITH_VISION.USER(stepDescription, pageInfo, previousCommands, attemptHistory, errorContext),
+            imageUrl: imageDataUrl // Full data URL constructed by client
+        };
+        try {
+            const response = await this.callLLM(request);
+            const commandResponse = JSON.parse(response.answer);
+            // Log diagnostic insights from vision analysis
+            if (commandResponse.visualInsights) {
+                this.log(`📸 Visual insights: ${commandResponse.visualInsights}`);
+            }
+            if (commandResponse.failureRootCause) {
+                this.log(`🔍 Root cause analysis: ${commandResponse.failureRootCause}`);
+            }
+            if (commandResponse.recommendedAlternative) {
+                this.log(`💡 Recommended alternative: ${commandResponse.recommendedAlternative}`);
+            }
+            if (commandResponse.reasoning) {
+                this.log(`🧠 Vision-based reasoning: ${commandResponse.reasoning}`);
+            }
+            return commandResponse.command;
+        }
+        catch (error) {
+            this.log(`Failed to generate command with vision: ${error}`, 'error');
+            throw new Error(`Vision-enhanced command generation failed: ${error}`);
+        }
+    }
     /**
      * Break down scenario into steps
      */
-    async breakdownScenario(scenario, model = 'gpt-4.1-mini') {
-        console.log('Breaking down scenario with LLM...');
+    async breakdownScenario(scenario, model = model_constants_1.DEFAULT_MODEL) {
+        this.log('Breaking down scenario with LLM...');
+        this.log(`📝 INPUT SCENARIO: ${scenario}`);
         const request = {
             model,
-            system_prompt: prompts_1.PROMPTS.SCENARIO_BREAKDOWN.SYSTEM,
-            user_prompt: prompts_1.PROMPTS.SCENARIO_BREAKDOWN.USER(scenario)
+            systemPrompt: prompts_1.PROMPTS.SCENARIO_BREAKDOWN.SYSTEM,
+            userPrompt: prompts_1.PROMPTS.SCENARIO_BREAKDOWN.USER(scenario)
         };
         try {
             const response = await this.callLLM(request);
-            const breakdownResponse = JSON.parse(response);
+            this.log(`🤖 RAW LLM RESPONSE: ${response.answer}`);
+            const breakdownResponse = JSON.parse(response.answer);
+            this.log(`📋 PARSED BREAKDOWN: ${JSON.stringify(breakdownResponse, null, 2)}`);
             // Validate and clean up steps
             const cleanedSteps = breakdownResponse.steps
                 .map(step => step.trim())
                 .filter(step => step.length > 0)
                 .slice(0, 10); // Limit to 10 steps max
+            this.log(`✅ CLEANED STEPS: ${JSON.stringify(cleanedSteps, null, 2)}`);
             return cleanedSteps.map((desc, index) => ({
                 stepNumber: index + 1,
                 description: desc,
             }));
         }
         catch (error) {
-            console.error('Failed to breakdown scenario:', error);
-            // Fallback to simple breakdown
-            const stepDescriptions = scenario.split('.').map(s => s.trim()).filter(s => s.length > 0);
+            this.log(`❌ Failed to breakdown scenario: ${error}`, 'error');
+            // Fallback to simple breakdown by newlines (preserves URLs)
+            const stepDescriptions = scenario.split('\n').map(s => s.trim()).filter(s => s.length > 0);
+            this.log(`🔄 FALLBACK STEPS: ${JSON.stringify(stepDescriptions, null, 2)}`);
             return stepDescriptions.map((desc, index) => ({
                 stepNumber: index + 1,
                 description: desc,
@@ -160,8 +346,8 @@ class LLMFacade {
     /**
      * Generate Playwright command for a step
      */
-    async generatePlaywrightCommand(stepDescription, pageInfo, previousSteps, lastError, currentStep, model = 'gpt-4.1-mini') {
-        console.log('Generating Playwright command with LLM...');
+    async generatePlaywrightCommand(stepDescription, pageInfo, previousSteps, lastError, currentStep, model = model_constants_1.DEFAULT_MODEL) {
+        this.log('Generating Playwright command with LLM...');
         const previousCommands = previousSteps
             .filter(s => s.playwrightCommand && s.success)
             .map(s => `// Step ${s.stepNumber}: ${s.description}\n${s.playwrightCommand}`)
@@ -173,16 +359,16 @@ class LLMFacade {
         const prompt = prompts_1.PROMPTS.PLAYWRIGHT_COMMAND.USER(stepDescription, pageInfo, previousCommands, attemptHistory, errorContext);
         const request = {
             model,
-            system_prompt: prompts_1.PROMPTS.PLAYWRIGHT_COMMAND.SYSTEM,
-            user_prompt: prompt
+            systemPrompt: prompts_1.PROMPTS.PLAYWRIGHT_COMMAND.SYSTEM,
+            userPrompt: prompt
         };
         try {
             const response = await this.callLLM(request);
-            const commandResponse = JSON.parse(response);
+            const commandResponse = JSON.parse(response.answer);
             return commandResponse.command;
         }
         catch (error) {
-            console.error('Failed to generate Playwright command:', error);
+            this.log(`Failed to generate Playwright command: ${error}`, 'error');
             return null;
         }
     }
@@ -190,41 +376,45 @@ class LLMFacade {
      * Parse script into steps for AI repair
      */
     async parseScriptIntoSteps(script, model = 'gpt-4o-mini') {
+        this.log('Parsing script into steps with LLM...');
         const request = {
             model,
-            system_prompt: prompts_1.PROMPTS.SCRIPT_PARSING.SYSTEM,
-            user_prompt: prompts_1.PROMPTS.SCRIPT_PARSING.USER(script)
+            systemPrompt: prompts_1.PROMPTS.SCRIPT_PARSING.SYSTEM,
+            userPrompt: prompts_1.PROMPTS.SCRIPT_PARSING.USER(script)
         };
         try {
             const response = await this.callLLM(request);
-            const parsed = JSON.parse(response);
+            this.log(`Raw LLM parsing response (first 500 chars): ${response.answer.substring(0, 500)}`);
+            const parsed = JSON.parse(response.answer);
+            this.log(`Parsed JSON structure: ${JSON.stringify(parsed, null, 2).substring(0, 1000)}`);
             // Expect JSON object with steps array
             if (parsed.steps && Array.isArray(parsed.steps)) {
+                this.log(`LLM parsing successful, got ${parsed.steps.length} steps`);
                 return parsed.steps;
             }
             else {
-                console.error('Unexpected LLM response format - expected {steps: [...]}:', parsed);
+                this.log(`Unexpected LLM response format - expected {steps: [...]}: ${JSON.stringify(parsed)}`, 'error');
                 return [];
             }
         }
         catch (error) {
-            console.error('Failed to parse LLM response as JSON:', error);
+            this.log(`Failed to parse LLM response as JSON: ${error}`, 'error');
             return [];
         }
     }
     /**
      * Get repair suggestion for a failing step
      */
-    async getRepairSuggestion(stepDescription, stepCode, errorMessage, pageInfo, failureHistory, recentRepairs, model = 'gpt-4.1-mini') {
+    async getRepairSuggestion(stepDescription, stepCode, errorMessage, pageInfo, failureHistory, recentRepairs, model = model_constants_1.DEFAULT_MODEL) {
         const request = {
             model,
-            system_prompt: prompts_1.PROMPTS.REPAIR_SUGGESTION.SYSTEM,
-            user_prompt: prompts_1.PROMPTS.REPAIR_SUGGESTION.USER(stepDescription, stepCode, errorMessage, pageInfo, failureHistory, recentRepairs)
+            systemPrompt: prompts_1.PROMPTS.REPAIR_SUGGESTION.SYSTEM,
+            userPrompt: prompts_1.PROMPTS.REPAIR_SUGGESTION.USER(stepDescription, stepCode, errorMessage, pageInfo, failureHistory, recentRepairs)
         };
         const response = await this.callLLM(request);
-        console.log(`🤖 LLM Repair Response:`, response);
-        const parsed = JSON.parse(response);
-        console.log(`🤖 Parsed Repair Action:`, parsed);
+        this.log(`🤖 LLM Repair Response: ${response.answer}`);
+        const parsed = JSON.parse(response.answer);
+        this.log(`🤖 Parsed Repair Action: ${JSON.stringify(parsed)}`);
         // Convert string operation to enum
         if (parsed.action && parsed.action.operation) {
             switch (parsed.action.operation) {
@@ -246,14 +436,14 @@ class LLMFacade {
     /**
      * Assess repair confidence and generate advice
      */
-    async assessRepairConfidence(originalScript, updatedScript, model = 'gpt-4.1-mini') {
+    async assessRepairConfidence(originalScript, updatedScript, model = model_constants_1.DEFAULT_MODEL) {
         const request = {
             model,
-            system_prompt: prompts_1.PROMPTS.REPAIR_CONFIDENCE.SYSTEM,
-            user_prompt: prompts_1.PROMPTS.REPAIR_CONFIDENCE.USER(originalScript, updatedScript)
+            systemPrompt: prompts_1.PROMPTS.REPAIR_CONFIDENCE.SYSTEM,
+            userPrompt: prompts_1.PROMPTS.REPAIR_CONFIDENCE.USER(originalScript, updatedScript)
         };
         const response = await this.callLLM(request);
-        return JSON.parse(response);
+        return JSON.parse(response.answer);
     }
     /**
      * Generate final script with repair advice
@@ -261,16 +451,16 @@ class LLMFacade {
     async generateFinalScript(originalScript, updatedScript, newRepairAdvice, model = 'gpt-4o-mini') {
         const request = {
             model,
-            system_prompt: prompts_1.PROMPTS.FINAL_SCRIPT.SYSTEM,
-            user_prompt: prompts_1.PROMPTS.FINAL_SCRIPT.USER(originalScript, updatedScript, newRepairAdvice)
+            systemPrompt: prompts_1.PROMPTS.FINAL_SCRIPT.SYSTEM,
+            userPrompt: prompts_1.PROMPTS.FINAL_SCRIPT.USER(originalScript, updatedScript, newRepairAdvice)
         };
         const response = await this.callLLM(request);
         try {
-            const parsed = JSON.parse(response);
+            const parsed = JSON.parse(response.answer);
             return parsed.script || updatedScript;
         }
         catch (error) {
-            console.error('Failed to parse final script response:', error);
+            this.log(`Failed to parse final script response: ${error}`, 'error');
             return updatedScript;
         }
     }
@@ -311,15 +501,77 @@ LEARNING FROM FAILURES:
         if (currentStep?.error)
             errors.push(currentStep.error);
         const errorText = errors.join(' | ');
+        // Detect if we're repeatedly looking for elements that don't exist
+        const attemptedCommands = currentStep?.attempts
+            ?.map(a => a.command)
+            .filter(Boolean) || [];
+        const lookingForNonExistent = attemptedCommands.some(cmd => cmd?.includes('getByText') ||
+            cmd?.includes('toBeVisible') ||
+            cmd?.includes('waitFor')) && errors.some(err => err.includes('not found') ||
+            err.includes('Timeout') ||
+            err.includes('Expected: visible'));
+        let hallucinationWarning = '';
+        if (lookingForNonExistent && attemptedCommands.length >= 2) {
+            hallucinationWarning = `
+⚠️ HALLUCINATION ALERT:
+You've made ${attemptedCommands.length} attempts trying to find/verify elements that don't exist.
+STOP looking for these elements. They are NOT in the DOM.
+Instead:
+- Check if the goal is ALREADY COMPLETE (action succeeded = goal done)
+- Use alternative verification (state changes, network, page load)
+- Move on if the primary action succeeded
+`;
+        }
         return `ERROR CONTEXT:
 Last Error: ${errorText}
-
+${hallucinationWarning}
 ANALYZE THE ERROR AND ADAPT:
 - Study the error message to understand what went wrong
+- If element "not found" after 2+ attempts, it probably doesn't exist - stop looking for it
 - Try a completely different approach than what failed
 - Consider alternative selectors, timing, or interaction methods
 - Never repeat the exact same command that failed`;
     }
+    /**
+     * Cleanup generated script - remove redundancies and make minor adjustments
+     */
+    async cleanupScript(script, model) {
+        try {
+            const response = await this.llmProvider.callLLM({
+                model: model || model_constants_1.DEFAULT_MODEL,
+                systemPrompt: prompts_1.PROMPTS.SCRIPT_CLEANUP.SYSTEM,
+                userPrompt: prompts_1.PROMPTS.SCRIPT_CLEANUP.USER(script)
+            });
+            // Parse JSON response
+            const jsonMatch = response.answer.match(/\{[\s\S]*\}/);
+            if (!jsonMatch) {
+                console.log('[LLMFacade] Cleanup response not in JSON format, returning original script');
+                return { script, changes: [], skipped: 'Response not in JSON format' };
+            }
+            const parsed = JSON.parse(jsonMatch[0]);
+            // Validate response
+            if (!parsed.script) {
+                console.log('[LLMFacade] Cleanup response missing script field, returning original');
+                return { script, changes: [], skipped: 'Invalid response format' };
+            }
+            console.log(`[LLMFacade] Script cleanup completed. Changes: ${parsed.changes?.length || 0}`);
+            if (parsed.changes && parsed.changes.length > 0) {
+                parsed.changes.forEach((change, i) => {
+                    console.log(`[LLMFacade]   ${i + 1}. ${change}`);
+                });
+            }
+            return {
+                script: parsed.script,
+                changes: parsed.changes || [],
+                skipped: parsed.skipped
+            };
+        }
+        catch (error) {
+            console.error('[LLMFacade] Script cleanup failed:', error.message);
+            // Return original script on error
+            return { script, changes: [], skipped: `Error: ${error.message}` };
+        }
+    }
 }
 exports.LLMFacade = LLMFacade;
 //# sourceMappingURL=llm-facade.js.map