testchimp-runner-core 0.0.21 → 0.0.23

package/src/llm-facade.ts

@@ -1,20 +1,8 @@
-import axios from 'axios';
 import { PROMPTS } from './prompts';
 import { PageInfo } from './utils/page-info-utils';
 import { StepOperation } from './types';
-import { AuthConfig, createAuthConfigFromEnv, getAuthHeaders } from './auth-config';
-import { loadEnvConfig } from './env-loader';
-
-// LLM Request/Response interfaces for backend proxy
-interface CallLLMRequest {
-  model?: string;
-  system_prompt?: string;
-  user_prompt?: string;
-}
-
-interface CallLLMResponse {
-  answer?: string;
-}
+import { DEFAULT_MODEL, VISION_MODEL } from './model-constants';
+import { LLMProvider, LLMRequest, LLMResponse } from './llm-provider';
 
 // LLM Response interfaces
 export interface LLMScenarioBreakdownResponse {
@@ -49,6 +37,27 @@ export interface RepairConfidenceResponse {
   advice: string;
 }
 
+export interface GoalCompletionResponse {
+  isComplete: boolean;
+  reason: string;
+  nextSubGoal?: string;
+}
+
+export interface ScreenshotNeedResponse {
+  needsScreenshot: boolean;
+  reason: string;
+  alternativeApproach?: string;
+}
+
+export interface VisionDiagnosticResponse {
+  visualAnalysis: string; // What the supervisor sees in the screenshot
+  rootCause: string; // Why previous attempts failed
+  specificInstructions: string; // Exact instructions for the worker agent
+  recommendedApproach: string; // What strategy to use (selector-based, state-based, etc.)
+  elementsFound: string[]; // What elements are actually visible
+  elementsNotFound: string[]; // What elements were expected but not visible
+}
+
 export interface ScenarioStep {
   stepNumber: number;
   description: string;
@@ -66,101 +75,86 @@ export interface ScenarioStep {
 }
 
 export class LLMFacade {
-  private backendUrl: string;
-  private authConfig: AuthConfig | null;
-
-  constructor(authConfig?: AuthConfig, backendUrl?: string) {
-    // 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 = 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 || createAuthConfigFromEnv();
-    
-    if (!this.authConfig) {
-      console.warn('TestChimp authentication not configured. LLM calls may fail.');
-    }
-  }
+  public llmProvider: LLMProvider;  // Expose for orchestrator direct access
+  private logger?: (message: string, level?: 'log' | 'error' | 'warn') => void;
+  private tokenUsageCallback?: (inputTokens: number, outputTokens: number, includesImage: boolean) => void;
 
+  constructor(llmProvider: LLMProvider) {
+    this.llmProvider = llmProvider;
+    this.log('LLMFacade initialized with pluggable LLM provider');
+  }
+  
   /**
-   * Update authentication configuration
+   * Set token usage callback for tracking
    */
-  setAuthConfig(authConfig: AuthConfig): void {
-    this.authConfig = authConfig;
+  setTokenUsageCallback(callback: (inputTokens: number, outputTokens: number, includesImage: boolean) => void): void {
+    this.tokenUsageCallback = callback;
   }
 
   /**
-   * Get current authentication configuration
+   * Set a logger callback for capturing execution logs
    */
-  getAuthConfig(): AuthConfig | null {
-    return this.authConfig;
+  setLogger(logger: (message: string, level?: 'log' | 'error' | 'warn') => void): void {
+    this.logger = logger;
+    this.llmProvider.setLogger?.(logger);
   }
 
-  private async callLLM(request: CallLLMRequest): Promise<string> {
-    if (!this.authConfig) {
-      throw new Error('Authentication not configured. Please set authentication credentials.');
+  /**
+   * Log a message using the configured logger
+   */
+  private log(message: string, level: 'log' | 'error' | 'warn' = 'log'): void {
+    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);
     }
+  }
 
+  private async callLLM(request: LLMRequest): Promise<LLMResponse> {
     try {
-      const authHeaders = getAuthHeaders(this.authConfig);
-      const url = `${this.backendUrl}/localagent/call_llm`;
-      console.log(`repairing step`);
+      const response = await this.llmProvider.callLLM(request);
       
-      const response = await axios.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');
+      // 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: any) {
-      // 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: string, model: string = 'gpt-4.1-mini'): Promise<string> {
-    console.log('Generating test name with LLM...');
+  async generateTestName(scenario: string, model: string = DEFAULT_MODEL): Promise<string> {
+    this.log('Generating test name with LLM...');
     
-    const request: CallLLMRequest = {
+    const request: LLMRequest = {
       model,
-      system_prompt: PROMPTS.TEST_NAME_GENERATION.SYSTEM,
-      user_prompt: PROMPTS.TEST_NAME_GENERATION.USER(scenario)
+      systemPrompt: PROMPTS.TEST_NAME_GENERATION.SYSTEM,
+      userPrompt: PROMPTS.TEST_NAME_GENERATION.USER(scenario)
     };
 
     try {
       const response = await this.callLLM(request);
-      const testNameResponse = JSON.parse(response) as LLMTestNameResponse;
+      const testNameResponse = JSON.parse(response.answer) as LLMTestNameResponse;
       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)}...`;
     }
@@ -170,40 +164,337 @@ export class LLMFacade {
    * Generate hashtags for semantic grouping
    */
   async generateHashtags(scenario: string, model: string = 'gpt-4o-mini'): Promise<string[]> {
-    console.log('Generating hashtags with LLM...');
+    this.log('Generating hashtags with LLM...');
     
-    const request: CallLLMRequest = {
+    const request: LLMRequest = {
       model,
-      system_prompt: PROMPTS.HASHTAG_GENERATION.SYSTEM,
-      user_prompt: PROMPTS.HASHTAG_GENERATION.USER(scenario)
+      systemPrompt: PROMPTS.HASHTAG_GENERATION.SYSTEM,
+      userPrompt: PROMPTS.HASHTAG_GENERATION.USER(scenario)
     };
 
     try {
       const response = await this.callLLM(request);
-      const hashtagResponse = JSON.parse(response) as { hashtags: string[] };
+      const hashtagResponse = JSON.parse(response.answer) as { hashtags: string[] };
       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: string, 
+    completedActions: string[], 
+    pageInfo: any, 
+    model: string = DEFAULT_MODEL
+  ): Promise<GoalCompletionResponse> {
+    this.log('Checking goal completion with LLM...');
+    
+    const request: LLMRequest = {
+      model,
+      systemPrompt: PROMPTS.GOAL_COMPLETION_CHECK.SYSTEM,
+      userPrompt: PROMPTS.GOAL_COMPLETION_CHECK.USER(goalDescription, completedActions, pageInfo)
+    };
+
+    try {
+      const response = await this.callLLM(request);
+      return JSON.parse(response.answer) as GoalCompletionResponse;
+    } 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: string,
+    completedActions: string[],
+    pageInfo: any,
+    imageDataUrl: string,
+    model: string = VISION_MODEL
+  ): Promise<GoalCompletionResponse> {
+    this.log(`👔 Checking goal completion with vision (${model})...`);
+    
+    const request: LLMRequest = {
+      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) as GoalCompletionResponse;
+      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: string,
+    errorMessage: string,
+    attemptCount: number,
+    pageInfo: any,
+    model: string = DEFAULT_MODEL
+  ): Promise<ScreenshotNeedResponse> {
+    this.log('Assessing screenshot need with LLM...');
+    
+    const request: LLMRequest = {
+      model,
+      systemPrompt: PROMPTS.SCREENSHOT_NEED_ASSESSMENT.SYSTEM,
+      userPrompt: PROMPTS.SCREENSHOT_NEED_ASSESSMENT.USER(stepDescription, errorMessage, attemptCount, pageInfo)
+    };
+
+    try {
+      const response = await this.callLLM(request);
+      return JSON.parse(response.answer) as ScreenshotNeedResponse;
+    } 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: string,
+    pageInfo: any,
+    previousSteps: any[],
+    lastError: string | undefined,
+    imageDataUrl: string,
+    model: string = VISION_MODEL
+  ): Promise<VisionDiagnosticResponse> {
+    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: LLMRequest = {
+      model,
+      systemPrompt: PROMPTS.VISION_DIAGNOSTIC_ANALYSIS.SYSTEM,
+      userPrompt: 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) as VisionDiagnosticResponse;
+      
+      // 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: string,
+    supervisorDiagnostics: VisionDiagnosticResponse,
+    pageInfo: any,
+    model: string = DEFAULT_MODEL
+  ): Promise<string> {
+    this.log('🔨 WORKER: Generating command based on supervisor instructions...');
+    
+    const request: LLMRequest = {
+      model,
+      systemPrompt: PROMPTS.PLAYWRIGHT_COMMAND_WITH_SUPERVISOR.SYSTEM,
+      userPrompt: 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) as LLMPlaywrightCommandResponse;
+      
+      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: string,
+    pageInfo: any,
+    previousSteps: any[],
+    lastError: string | undefined,
+    imageDataUrl: string, // Full data URL: data:image/png;base64,...
+    model: string = VISION_MODEL
+  ): Promise<string> {
+    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: LLMRequest = {
+      model,
+      systemPrompt: PROMPTS.PLAYWRIGHT_COMMAND_WITH_VISION.SYSTEM,
+      userPrompt: 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) as LLMPlaywrightCommandResponse & { 
+        visualInsights?: string;
+        failureRootCause?: string;
+        recommendedAlternative?: string;
+      };
+      
+      // 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: string, model: string = 'gpt-4.1-mini'): Promise<ScenarioStep[]> {
-    console.log('Breaking down scenario with LLM...');
+  async breakdownScenario(scenario: string, model: string = DEFAULT_MODEL): Promise<ScenarioStep[]> {
+    this.log('Breaking down scenario with LLM...');
+    this.log(`📝 INPUT SCENARIO: ${scenario}`);
     
-    const request: CallLLMRequest = {
+    const request: LLMRequest = {
       model,
-      system_prompt: PROMPTS.SCENARIO_BREAKDOWN.SYSTEM,
-      user_prompt: PROMPTS.SCENARIO_BREAKDOWN.USER(scenario)
+      systemPrompt: PROMPTS.SCENARIO_BREAKDOWN.SYSTEM,
+      userPrompt: PROMPTS.SCENARIO_BREAKDOWN.USER(scenario)
     };
 
     try {
       const response = await this.callLLM(request);
-      const breakdownResponse = JSON.parse(response) as LLMScenarioBreakdownResponse;
+      this.log(`🤖 RAW LLM RESPONSE: ${response.answer}`);
+      
+      const breakdownResponse = JSON.parse(response.answer) as LLMScenarioBreakdownResponse;
+      this.log(`📋 PARSED BREAKDOWN: ${JSON.stringify(breakdownResponse, null, 2)}`);
       
       // Validate and clean up steps
       const cleanedSteps = breakdownResponse.steps
@@ -211,14 +502,17 @@ export class LLMFacade {
         .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,
@@ -235,9 +529,9 @@ export class LLMFacade {
     previousSteps: ScenarioStep[],
     lastError?: string,
     currentStep?: ScenarioStep,
-    model: string = 'gpt-4.1-mini'
+    model: string = DEFAULT_MODEL
   ): Promise<string | null> {
-    console.log('Generating Playwright command with LLM...');
+    this.log('Generating Playwright command with LLM...');
     
     const previousCommands = previousSteps
       .filter(s => s.playwrightCommand && s.success)
@@ -258,18 +552,18 @@ export class LLMFacade {
       errorContext
     );
 
-    const request: CallLLMRequest = {
+    const request: LLMRequest = {
       model,
-      system_prompt: PROMPTS.PLAYWRIGHT_COMMAND.SYSTEM,
-      user_prompt: prompt
+      systemPrompt: PROMPTS.PLAYWRIGHT_COMMAND.SYSTEM,
+      userPrompt: prompt
     };
 
     try {
       const response = await this.callLLM(request);
-      const commandResponse = JSON.parse(response) as LLMPlaywrightCommandResponse;
+      const commandResponse = JSON.parse(response.answer) as LLMPlaywrightCommandResponse;
       return commandResponse.command;
     } catch (error) {
-      console.error('Failed to generate Playwright command:', error);
+      this.log(`Failed to generate Playwright command: ${error}`, 'error');
       return null;
     }
   }
@@ -278,25 +572,31 @@ export class LLMFacade {
    * Parse script into steps for AI repair
    */
   async parseScriptIntoSteps(script: string, model: string = 'gpt-4o-mini'): Promise<Array<{ description: string; code: string; success?: boolean; error?: string }>> {
-    const request: CallLLMRequest = {
+    this.log('Parsing script into steps with LLM...');
+    
+    const request: LLMRequest = {
       model,
-      system_prompt: PROMPTS.SCRIPT_PARSING.SYSTEM,
-      user_prompt: PROMPTS.SCRIPT_PARSING.USER(script)
+      systemPrompt: PROMPTS.SCRIPT_PARSING.SYSTEM,
+      userPrompt: 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 [];
     }
   }
@@ -311,12 +611,12 @@ export class LLMFacade {
     pageInfo: PageInfo,
     failureHistory: string,
     recentRepairs: string,
-    model: string = 'gpt-4.1-mini'
+    model: string = DEFAULT_MODEL
   ): Promise<RepairSuggestionResponse> {
-    const request: CallLLMRequest = {
+    const request: LLMRequest = {
       model,
-      system_prompt: PROMPTS.REPAIR_SUGGESTION.SYSTEM,
-      user_prompt: PROMPTS.REPAIR_SUGGESTION.USER(
+      systemPrompt: PROMPTS.REPAIR_SUGGESTION.SYSTEM,
+      userPrompt: PROMPTS.REPAIR_SUGGESTION.USER(
         stepDescription,
         stepCode,
         errorMessage,
@@ -327,9 +627,9 @@ export class LLMFacade {
     };
 
     const response = await this.callLLM(request);
-    console.log(`🤖 LLM Repair Response:`, response);
-    const parsed = JSON.parse(response) as any;
-    console.log(`🤖 Parsed Repair Action:`, parsed);
+    this.log(`🤖 LLM Repair Response: ${response.answer}`);
+    const parsed = JSON.parse(response.answer) as any;
+    this.log(`🤖 Parsed Repair Action: ${JSON.stringify(parsed)}`);
     
     // Convert string operation to enum
     if (parsed.action && parsed.action.operation) {
@@ -357,16 +657,16 @@ export class LLMFacade {
   async assessRepairConfidence(
     originalScript: string,
     updatedScript: string,
-    model: string = 'gpt-4.1-mini'
+    model: string = DEFAULT_MODEL
   ): Promise<RepairConfidenceResponse> {
-    const request: CallLLMRequest = {
+    const request: LLMRequest = {
       model,
-      system_prompt: PROMPTS.REPAIR_CONFIDENCE.SYSTEM,
-      user_prompt: PROMPTS.REPAIR_CONFIDENCE.USER(originalScript, updatedScript)
+      systemPrompt: PROMPTS.REPAIR_CONFIDENCE.SYSTEM,
+      userPrompt: PROMPTS.REPAIR_CONFIDENCE.USER(originalScript, updatedScript)
     };
 
     const response = await this.callLLM(request);
-    return JSON.parse(response) as RepairConfidenceResponse;
+    return JSON.parse(response.answer) as RepairConfidenceResponse;
   }
 
   /**
@@ -378,18 +678,18 @@ export class LLMFacade {
     newRepairAdvice: string,
     model: string = 'gpt-4o-mini'
   ): Promise<string> {
-    const request: CallLLMRequest = {
+    const request: LLMRequest = {
       model,
-      system_prompt: PROMPTS.FINAL_SCRIPT.SYSTEM,
-      user_prompt: PROMPTS.FINAL_SCRIPT.USER(originalScript, updatedScript, newRepairAdvice)
+      systemPrompt: PROMPTS.FINAL_SCRIPT.SYSTEM,
+      userPrompt: 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;
     }
   }
@@ -435,13 +735,87 @@ LEARNING FROM FAILURES:
 
     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: string, model?: string): Promise<{ script: string; changes: string[]; skipped?: string }> {
+    try {
+      const response = await this.llmProvider.callLLM({
+        model: model || DEFAULT_MODEL,
+        systemPrompt: PROMPTS.SCRIPT_CLEANUP.SYSTEM,
+        userPrompt: 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: string, i: number) => {
+          console.log(`[LLMFacade]   ${i + 1}. ${change}`);
+        });
+      }
+
+      return {
+        script: parsed.script,
+        changes: parsed.changes || [],
+        skipped: parsed.skipped
+      };
+    } catch (error: any) {
+      console.error('[LLMFacade] Script cleanup failed:', error.message);
+      // Return original script on error
+      return { script, changes: [], skipped: `Error: ${error.message}` };
+    }
+  }
 }