testchimp-runner-core 0.0.21 → 0.0.23

package/src/providers/backend-proxy-llm-provider.ts

@@ -0,0 +1,91 @@
+/**
+ * Backend Proxy LLM Provider
+ * Calls backend proxy API with authentication
+ * Used by VS Extension and GitHub Runner
+ */
+
+import axios from 'axios';
+import { LLMProvider, LLMRequest, LLMResponse } from '../llm-provider';
+import { AuthConfig, getAuthHeaders } from '../auth-config';
+
+/**
+ * Default LLM provider that calls backend proxy
+ * Converts camelCase requests to snake_case for backend API
+ */
+export class BackendProxyLLMProvider implements LLMProvider {
+  private authConfig?: AuthConfig;
+  private backendUrl: string;
+  private logger?: (message: string, level?: 'log' | 'error' | 'warn') => void;
+
+  constructor(authConfig?: AuthConfig, backendUrl?: string) {
+    this.authConfig = authConfig;
+    this.backendUrl = backendUrl || 'https://featureservice.testchimp.io';
+  }
+
+  setLogger(logger: (message: string, level?: 'log' | 'error' | 'warn') => void): void {
+    this.logger = logger;
+  }
+
+  async callLLM(request: LLMRequest): Promise<LLMResponse> {
+    if (!this.authConfig) {
+      throw new Error('Authentication required for backend proxy LLM provider');
+    }
+
+    const headers = getAuthHeaders(this.authConfig);
+    
+    // Convert camelCase to snake_case for backend API (proto format)
+    const backendRequest = {
+      model: request.model,
+      system_prompt: request.systemPrompt,
+      user_prompt: request.userPrompt,
+      image_url: request.imageUrl
+    };
+    
+    const url = `${this.backendUrl}/localagent/call_llm`;
+    
+    try {
+      const response = await axios.post(
+        url,
+        backendRequest,
+        { headers, timeout: 300000 }
+      );
+      
+      // Calculate token usage (heuristic: 4 chars = 1 token)
+      const inputText = `${request.systemPrompt || ''}\n${request.userPrompt || ''}`;
+      const inputTokens = Math.ceil(inputText.length / 4);
+      
+      // Add image tokens if present (for vision models)
+      let imageTokens = 0;
+      if (request.imageUrl) {
+        imageTokens = this.estimateImageTokens(request.imageUrl);
+      }
+      
+      const outputTokens = Math.ceil((response.data.answer || '').length / 4);
+      
+      return { 
+        answer: response.data.answer,
+        usage: {
+          inputTokens: inputTokens + imageTokens,
+          outputTokens
+        }
+      };
+    } catch (error: any) {
+      this.logger?.(`LLM call failed: ${error}`, 'error');
+      throw error;
+    }
+  }
+  
+  /**
+   * Estimate image token cost based on dimensions
+   * For gpt-4.1-mini: patches × 1.62, capped at 1536
+   */
+  private estimateImageTokens(imageDataUrl: string): number {
+    // For simplicity, estimate common screenshot sizes
+    // Viewport (1920x1080): ~1452 tokens (after multiplier and cap)
+    // Full page (1920x3000+): ~1536 tokens (capped)
+    
+    // Conservative estimate: assume viewport screenshot
+    return 1500;  // ~1452-1536 tokens for typical screenshot
+  }
+}
+

package/src/providers/local-llm-provider.ts

@@ -0,0 +1,38 @@
+/**
+ * Local LLM Provider
+ * Calls LLM directly via callback (not via backend proxy)
+ * For future use by Script Service (Phase 2)
+ */
+
+import { LLMProvider, LLMRequest, LLMResponse } from '../llm-provider';
+
+/**
+ * Local LLM provider that calls LLM directly via callback
+ * Allows Script Service to use its own OpenAI integration
+ */
+export class LocalLLMProvider implements LLMProvider {
+  private llmCallback: (request: LLMRequest) => Promise<string>;
+  private logger?: (message: string, level?: 'log' | 'error' | 'warn') => void;
+
+  /**
+   * @param llmCallback Function that calls LLM (provided by environment)
+   */
+  constructor(llmCallback: (request: LLMRequest) => Promise<string>) {
+    this.llmCallback = llmCallback;
+  }
+
+  setLogger(logger: (message: string, level?: 'log' | 'error' | 'warn') => void): void {
+    this.logger = logger;
+  }
+
+  async callLLM(request: LLMRequest): Promise<LLMResponse> {
+    try {
+      const answer = await this.llmCallback(request);
+      return { answer };
+    } catch (error) {
+      this.logger?.(`Local LLM call failed: ${error}`, 'error');
+      throw error;
+    }
+  }
+}
+

package/src/scenario-service.ts

@@ -5,6 +5,9 @@ import { ScenarioWorker } from './scenario-worker-class';
 import { FileHandler, NoOpFileHandler } from './file-handler';
 import { AuthConfig } from './auth-config';
 import { CreditUsageService } from './credit-usage-service';
+import { LLMProvider } from './llm-provider';
+import { ProgressReporter } from './progress-reporter';
+import { AgentConfig } from './orchestrator';
 
 // Load environment variables
 dotenv.config();
@@ -21,14 +24,62 @@ export class ScenarioService extends EventEmitter {
   private authConfig: AuthConfig | null;
   private backendUrl?: string;
   private creditUsageService: CreditUsageService;
-
-  constructor(maxWorkers: number = 2, fileHandler?: FileHandler, authConfig?: AuthConfig, backendUrl?: string) {
+  private logger?: (message: string, level?: 'log' | 'error' | 'warn') => void;
+  private llmProvider?: LLMProvider;
+  private progressReporter?: ProgressReporter;
+  private useOrchestrator: boolean;
+  private orchestratorConfig?: Partial<AgentConfig>;
+  private debugMode: boolean;
+  private outputChannel?: any;  // VS Code OutputChannel type
+
+  constructor(
+    maxWorkers: number = 2,
+    fileHandler?: FileHandler,
+    llmProvider?: LLMProvider,
+    progressReporter?: ProgressReporter,
+    authConfig?: AuthConfig,
+    backendUrl?: string,
+    options?: {
+      useOrchestrator?: boolean;
+      orchestratorConfig?: Partial<AgentConfig>;
+      debugMode?: boolean;
+    }
+  ) {
     super();
     this.maxWorkers = maxWorkers;
     this.fileHandler = fileHandler || new NoOpFileHandler();
+    this.llmProvider = llmProvider;
+    this.progressReporter = progressReporter;
     this.authConfig = authConfig || null;
     this.backendUrl = backendUrl;
     this.creditUsageService = new CreditUsageService(authConfig, backendUrl);
+    this.useOrchestrator = options?.useOrchestrator || false;
+    this.orchestratorConfig = options?.orchestratorConfig;
+    this.debugMode = options?.debugMode || false;
+  }
+
+  /**
+   * Set a logger callback for capturing execution logs
+   */
+  setLogger(logger: (message: string, level?: 'log' | 'error' | 'warn') => void): void {
+    this.logger = logger;
+  }
+  
+  /**
+   * Set output channel for worker logs (VS Code OutputChannel)
+   */
+  setOutputChannel(outputChannel: any): void {
+    this.outputChannel = outputChannel;
+  }
+
+  /**
+   * Log a message using the configured logger
+   */
+  private log(message: string, level: 'log' | 'error' | 'warn' = 'log'): void {
+    if (this.logger) {
+      this.logger(message, level);
+    }
+    // No console fallback - logs are routed to consumer
   }
 
   private async initializeWorkers(): Promise<void> {
@@ -38,16 +89,35 @@ export class ScenarioService extends EventEmitter {
   }
 
   private async createWorker(): Promise<void> {
-    const worker = new ScenarioWorker(this.fileHandler, this.authConfig || undefined, undefined, this.backendUrl);
+    // Pass providers and orchestrator options to worker
+    const worker = new ScenarioWorker(
+      this.fileHandler,
+      this.llmProvider,
+      this.progressReporter,
+      this.authConfig || undefined,
+      this.backendUrl,
+      {
+        useOrchestrator: this.useOrchestrator,
+        orchestratorConfig: this.orchestratorConfig,
+        debugMode: this.debugMode
+      },
+      this.outputChannel  // Pass outputChannel for log routing
+    );
     await worker.initialize();
+    
+    // Forward log events from worker to service listeners
+    worker.on('log', (jobId: string, message: string) => {
+      this.emit('jobLog', jobId, message);
+    });
+    
     this.workers.push(worker);
-    console.log(`Scenario worker initialized with session: ${worker['sessionId']}`);
+    this.log(`Scenario worker initialized${this.useOrchestrator ? ' (Orchestrator Mode)' : ''} with session: ${worker['sessionId']}`);
   }
 
   async initialize(): Promise<void> {
     // Wait for workers to be initialized
     await this.initializeWorkers();
-    console.log('Scenario service initialized');
+    this.log('Scenario service initialized');
   }
 
   processScenario(scenario: string, testName?: string, config?: PlaywrightConfig, model?: string, scenarioFileName?: string): string {
@@ -74,12 +144,12 @@ export class ScenarioService extends EventEmitter {
       return;
     }
 
-    console.log(`[ScenarioService] Processing next job. Queue length: ${this.jobQueue.length}, Workers: ${this.workers.length}, Busy workers: ${this.busyWorkers.size}`);
+    this.log(`[ScenarioService] Processing next job. Queue length: ${this.jobQueue.length}, Workers: ${this.workers.length}, Busy workers: ${this.busyWorkers.size}`);
 
     // Find available worker (proper load balancing)
     const availableWorker = this.workers.find(worker => !this.busyWorkers.has(worker));
     if (!availableWorker) {
-      console.log('[ScenarioService] No available workers, waiting...');
+      this.log('[ScenarioService] No available workers, waiting...');
       return; // All workers busy, wait for one to become available
     }
 
@@ -88,7 +158,7 @@ export class ScenarioService extends EventEmitter {
       return;
     }
 
-    console.log(`[ScenarioService] Processing job ${job.id} with worker`);
+    this.log(`[ScenarioService] Processing job ${job.id} with worker`);
 
     // Mark worker as busy
     this.busyWorkers.add(availableWorker);
@@ -96,10 +166,10 @@ export class ScenarioService extends EventEmitter {
     try {
       // Process job directly with worker
       const result = await availableWorker.processScenarioJob(job);
-      console.log(`[ScenarioService] Job ${job.id} completed with result:`, result);
+      this.log(`[ScenarioService] Job ${job.id} completed with result: ${JSON.stringify(result)}`);
       this.handleJobResult(job.id, result);
     } catch (error) {
-      console.error('Error processing job with worker:', error);
+      this.log(`Error processing job with worker: ${error}`, 'error');
       this.emit('jobError', job.id, error);
       // Put job back in queue if it failed
       this.jobQueue.unshift(job);
@@ -115,7 +185,7 @@ export class ScenarioService extends EventEmitter {
     // Report credit usage for successful script generation
     if (result.success) {
       this.creditUsageService.reportScriptGenerationCredit(jobId).catch(error => {
-        console.warn(`Failed to report credit usage for script generation (job: ${jobId}):`, error);
+        this.log(`Failed to report credit usage for script generation (job: ${jobId}): ${error}`, 'warn');
       });
     }
     
@@ -137,7 +207,7 @@ export class ScenarioService extends EventEmitter {
   }
 
   async shutdown(): Promise<void> {
-    console.log('Shutting down scenario service...');
+    this.log('Shutting down scenario service...');
     
     // Cleanup all workers
     const cleanupPromises = this.workers.map(worker => worker.cleanup());
@@ -145,6 +215,6 @@ export class ScenarioService extends EventEmitter {
     
     this.workers = [];
     this.busyWorkers.clear();
-    console.log('Scenario service shutdown complete');
+    this.log('Scenario service shutdown complete');
   }
 }