testchimp-runner-core 0.0.34 → 0.0.35

package/src/index.ts

@@ -45,6 +45,7 @@ export {
   SelfReflection,
   ToolCall,
   ToolResult,
+  ExplorationMode,
   DEFAULT_AGENT_CONFIG,
   // Tools (information-gathering only)
   TakeScreenshotTool,
@@ -58,6 +59,9 @@ export {
 export * from './types';
 export { PageInfo, InteractiveElement } from './utils/page-info-utils';
 
+// Model constants
+export { DEFAULT_MODEL, DEFAULT_SIMPLER_MODEL, VISION_MODEL } from './model-constants';
+
 // Authentication
 export * from './auth-config';
 
@@ -359,6 +363,12 @@ export class TestChimpService {
     return this.executeScript(repairRequest);
   }
 
+  // Exploration mode execution
+  async executeExploration(page: any, explorationConfig: any, jobId: string): Promise<any> {
+    // Delegate to scenario service's orchestrator
+    return this.scenarioService.executeExploration(page, explorationConfig, jobId);
+  }
+
   // Credit usage reporting methods
   async reportScriptGenerationCredit(jobId?: string): Promise<void> {
     return this.creditUsageService.reportScriptGenerationCredit(jobId);

package/src/orchestrator/decision-parser.ts

@@ -0,0 +1,139 @@
+/**
+ * Decision Parser Utility
+ * Parses and validates agent decisions from LLM responses
+ */
+
+import { AgentDecision } from './types';
+import { isSomVerification, isSomCommand } from './som-types';
+
+export class DecisionParser {
+  private logger?: (message: string, level?: 'log' | 'error' | 'warn') => void;
+
+  constructor(logger?: (message: string, level?: 'log' | 'error' | 'warn') => void) {
+    this.logger = logger;
+  }
+
+  /**
+   * Parse agent decision from LLM response
+   */
+  parse(response: string): AgentDecision {
+    try {
+      // Extract JSON from response
+      const jsonMatch = response.match(/\{[\s\S]*\}/);
+      if (!jsonMatch) {
+        this.logger?.(`[DecisionParser] ✗ No JSON found in LLM response`, 'error');
+        this.logger?.(`[DecisionParser] 📄 FULL LLM RESPONSE:\n${response}`, 'error');
+        throw new Error('No JSON found in response');
+      }
+      
+      const parsed = JSON.parse(jsonMatch[0]);
+      
+      // Validate required fields
+      // Accept either "reasoning" or "statusReasoning" (LLMs sometimes only provide one)
+      if (!parsed.status || (!parsed.reasoning && !parsed.statusReasoning)) {
+        this.logger?.(`[DecisionParser] ✗ Missing required fields in parsed JSON`, 'error');
+        this.logger?.(`[DecisionParser] 📄 FULL LLM RESPONSE:\n${response}`, 'error');
+        this.logger?.(`[DecisionParser] 📄 PARSED JSON:\n${JSON.stringify(parsed, null, 2)}`, 'error');
+        this.logger?.(`[DecisionParser] ❌ Has status: ${!!parsed.status}, Has reasoning: ${!!parsed.reasoning}, Has statusReasoning: ${!!parsed.statusReasoning}`, 'error');
+        throw new Error('Missing required fields: status and (reasoning or statusReasoning)');
+      }
+      
+      // Normalize: if reasoning is missing but statusReasoning exists, use statusReasoning as reasoning
+      if (!parsed.reasoning && parsed.statusReasoning) {
+        parsed.reasoning = parsed.statusReasoning;
+      }
+      
+      return parsed as AgentDecision;
+      
+    } catch (error: any) {
+      this.logger?.(`[DecisionParser] ✗ Failed to parse agent decision: ${error.message}`, 'error');
+      
+      // Only log full response if not already logged above
+      if (!error.message.includes('Missing required fields') && !error.message.includes('No JSON found')) {
+        this.logger?.(`[DecisionParser] 📄 FULL LLM RESPONSE:\n${response}`, 'error');
+      }
+      
+      // Return fallback
+      return {
+        status: 'stuck',
+        statusReasoning: 'Failed to parse agent response',
+        reasoning: `Parse error: ${error.message}`
+      };
+    }
+  }
+
+  /**
+   * Log agent decision for debugging
+   */
+  log(decision: AgentDecision, iteration: number): void {
+    this.logger?.(`[Orchestrator] 💭 REASONING: ${decision.reasoning}`);
+    
+    if (decision.selfReflection) {
+      this.logger?.(`[Orchestrator] 🧠 SELF-REFLECTION:`);
+      this.logger?.(`[Orchestrator]    Next: ${decision.selfReflection.guidanceForNext}`);
+      if (decision.selfReflection.detectingLoop) {
+        this.logger?.(`[Orchestrator]    🔄 LOOP DETECTED: ${decision.selfReflection.loopReasoning}`, 'warn');
+      }
+    }
+    
+    if (decision.toolCalls && decision.toolCalls.length > 0) {
+      this.logger?.(`[Orchestrator] 🔧 TOOLS: ${decision.toolCalls.map(t => t.name).join(', ')}`);
+      if (decision.toolReasoning) {
+        this.logger?.(`[Orchestrator] 📋 Why: ${decision.toolReasoning}`);
+      }
+    }
+    
+    if (decision.blockerDetected) {
+      this.logger?.(`[Orchestrator] 🚧 BLOCKER: ${decision.blockerDetected.description}`, 'warn');
+      this.logger?.(`[Orchestrator] 🧹 Clearing with ${decision.blockerDetected.clearingCommands.length} command(s)`);
+    }
+    
+    if (decision.stepReEvaluation?.detected) {
+      this.logger?.(`[Orchestrator] 🔍 STEP RE-EVALUATION: ${decision.stepReEvaluation.issue}`, 'warn');
+      this.logger?.(`[Orchestrator] 📝 Explanation: ${decision.stepReEvaluation.explanation}`);
+    }
+    
+    if (decision.commands && decision.commands.length > 0) {
+      this.logger?.(`[Orchestrator] 📝 COMMANDS (${decision.commands.length}):`);
+      decision.commands.slice(0, 3).forEach((cmd: any, i) => {
+        // Handle string commands (standard mode), SomCommand, and SomVerification objects
+        if (typeof cmd === 'string') {
+          this.logger?.(`[Orchestrator]    ${i + 1}. ${cmd.substring(0, 80)}...`);
+        } else if (isSomVerification(cmd)) {
+          const ref = cmd.elementRef || cmd.selector || 'unknown';
+          this.logger?.(`[Orchestrator]    ${i + 1}. [VERIFY] ${cmd.verificationType} on ${ref}: ${cmd.expected}`);
+        } else if (isSomCommand(cmd)) {
+          this.logger?.(`[Orchestrator]    ${i + 1}. [ACTION] ${cmd.action} on ${cmd.elementRef || 'coord'}`);
+        } else {
+          this.logger?.(`[Orchestrator]    ${i + 1}. ${JSON.stringify(cmd).substring(0, 80)}...`);
+        }
+      });
+      if (decision.commands.length > 3) {
+        this.logger?.(`[Orchestrator]    ... and ${decision.commands.length - 3} more`);
+      }
+      if (decision.commandReasoning) {
+        this.logger?.(`[Orchestrator] 💡 Why: ${decision.commandReasoning}`);
+      }
+    }
+    
+    // Log meta-learning suggestions with clear demarcations
+    if (decision.debugInfo?.suggestedPromptUpdates) {
+      this.logger?.(``, 'warn');
+      this.logger?.(`═══════════════════════════════════════════════════════════════`, 'warn');
+      this.logger?.(`[Orchestrator] 🧠 META-LEARNING SUGGESTION FROM AGENT`, 'warn');
+      this.logger?.(`═══════════════════════════════════════════════════════════════`, 'warn');
+      this.logger?.(``, 'warn');
+      this.logger?.(`SUGGESTED PROMPT UPDATE:`, 'warn');
+      this.logger?.(`  ${decision.debugInfo.suggestedPromptUpdates}`, 'warn');
+      this.logger?.(``, 'warn');
+      if (decision.debugInfo.reasoning) {
+        this.logger?.(`REASONING:`, 'warn');
+        this.logger?.(`  ${decision.debugInfo.reasoning}`, 'warn');
+        this.logger?.(``, 'warn');
+      }
+      this.logger?.(`═══════════════════════════════════════════════════════════════`, 'warn');
+      this.logger?.(``, 'warn');
+    }
+  }
+}
+

package/src/orchestrator/index.ts

@@ -5,12 +5,17 @@
 // Core orchestrator
 export { OrchestratorAgent } from './orchestrator-agent';
 
+// SoM (Set-of-Marks) handler
+export { PageSoMHandler } from './page-som-handler';
+
 // Tool system
 export { ToolRegistry, Tool, ToolParameter, ToolExecutionContext } from './tool-registry';
 
-// 6 information-gathering tools (state changes via Playwright commands)
+// 8 information-gathering tools (state changes via Playwright commands)
 export {
   TakeScreenshotTool,
+  ViewPreviousScreenshotTool,
+  RefreshSomMarkersTool,
   RecallHistoryTool,
   InspectPageTool,
   CheckPageReadyTool,
@@ -29,6 +34,25 @@ export {
   SelfReflection,
   ToolCall,
   ToolResult,
+  ExplorationMode,
   DEFAULT_AGENT_CONFIG
 } from './types';
 
+// SoM Types
+export {
+  SomCommand,
+  SomElement,
+  SemanticCommandResult,
+  CommandRunStatus,
+  CommandAttempt,
+  DomMutation,
+  InteractionAction,
+  Coordinate,
+  TypedSelector,
+  SomVerification,
+  VerificationType,
+  SomCommandOrVerification,
+  isSomVerification,
+  isSomCommand
+} from './som-types';
+