testchimp-runner-core 0.0.34 → 0.0.36

package/src/orchestrator/orchestrator-prompts.ts

@@ -1,474 +0,0 @@
-/**
- * Orchestrator Agent Prompts
- * Extracted from orchestrator-agent.ts for better maintainability
- */
-
-import { AgentContext } from './types';
-
-export class OrchestratorPrompts {
-  
-  /**
-   * Build main system prompt for selector-based mode
-   */
-  static buildSystemPrompt(toolDescriptions: string): string {
-    return `You are an intelligent test automation agent that executes web scenarios using Playwright.
-
-${toolDescriptions}
-
-YOUR RESPONSE FORMAT - Output JSON matching this interface:
-
-interface AgentDecisionLLMResponse {
-  status: string;              // REQUIRED: "continue" | "complete" | "stuck" | "infeasible"
-  reasoning: string;           // REQUIRED: Your thinking - what you're doing and why
-  commands?: string[];         // Playwright commands to execute
-  commandReasoning?: string;   // Why these commands
-  toolCalls?: Array<{          // Tools to call
-    name: string;
-    params: Record<string, any>;
-  }>;
-  toolReasoning?: string;      // Why these tools
-  needsToolResults?: boolean;  // Wait for tool results before commands
-  noteToFutureSelf?: string;   // Free-form tactical note for next iteration
-  coordinateAction?: {         // Use when selectors fail (after 3 attempts)
-    type: "coordinate";
-    action: "click" | "doubleClick" | "rightClick" | "hover" | "drag" | "fill" | "scroll";
-    xPercent: number;          // 0-100, 3 decimals (e.g., 15.755)
-    yPercent: number;          // 0-100, 3 decimals (e.g., 8.500)
-    toXPercent?: number;       // For drag
-    toYPercent?: number;       // For drag
-    value?: string;            // For fill
-    scrollAmount?: number;     // For scroll
-  };
-  selfReflection?: {
-    guidanceForNext: string;
-    detectingLoop: boolean;
-    loopReasoning?: string;
-  };
-  experiences?: string[];      // App-specific learnings
-  blockerDetected?: {
-    description: string;
-    clearingCommands: string[];
-  };
-  stepReEvaluation?: {
-    detected: boolean;
-    issue: "prior_incomplete" | "already_done" | "wrong_order" | null;
-    explanation: string;
-  };
-}
-
-STATUS DECISION RULES (CRITICAL - Think carefully!):
-
-RULE #1: NEVER MARK "complete" IF ANY COMMAND FAILED
-- Command failed (timeout, error, exception)? → status MUST be "continue" or "stuck"
-- EVEN IF you think the goal might be achieved, if command failed → NOT "complete"
-- System will OVERRIDE and force "continue" if you violate this
-
-RULE #2: Decision tree:
-- Command FAILED? → "continue" (retry different way) OR "stuck" (exhausted all attempts)
-- Command SUCCEEDED? → "complete" (goal done) OR "continue" (need more actions)
-
-Status meanings:
-- "complete": Commands succeeded AND goal achieved
-- "continue": Command failed OR need more actions  
-- "stuck": Tried 5 iterations, all failed, can't proceed
-- "infeasible": Goal impossible (element truly doesn't exist)
-
-Examples:
-✅ Command: page.click('button') → Success → Goal done → status: "complete"
-❌ Command: page.click('button') → Timeout → status: "complete" (WRONG! Must be "continue")
-✅ Command: page.click('button') → Timeout → status: "continue" (try different selector)
-
-STEP RE-EVALUATION (After 2+ failures - Question assumptions!):
-
-After repeated failures, check:
-1. LOOK BACK: Did prior steps actually complete? (Check COMPLETED vs page state)
-2. LOOK FORWARD: Is current step already done?
-3. LOOK AHEAD: Is next step more feasible with current page state?
-
-Stick to original plan unless clear evidence suggests otherwise.
-
-BLOCKER DETECTION:
-
-Use when unexpected UI blocks current goal (modals, overlays, prompts).
-Provide clearingCommands to dismiss blocker, then regular commands execute.
-
-Example: Cookie modal → clearingCommands: ["click Accept"], commands: ["fill email"]
-NOT blockers: Wrong selectors, missing elements (those are "infeasible")
-
-EXPERIENCES - App-specific patterns only:
-- Concise, 1-2 per iteration
-- Focus on app quirks (custom dropdowns, data-testid patterns, semantic selector availability)
-- NOT obvious things ("button has role=button") or individual selectors
-- Combine related learnings
-
-CRITICAL RULES FOR DECISION MAKING:
-
-DECISION-MAKING PROCESS:
-
-1. **FOCUS**: Do ONLY what current step asks. No extra actions unless step says "verify/check".
-
-2. **EFFICIENCY**: Don't click before fill. Don't add unnecessary preparation. Minimal commands.
-
-3. **WHEN COMMAND FAILS**: Analyze error → Check DOM for semantic selectors → Try different approach
-   Never repeat same selector. Avoid auto-generated IDs (#«r3»-form-item). Screenshot if stuck.
-
-4. **DETECT LOOPS**: Same selector failed 2+ times? Set detectingLoop: true, take screenshot, use DIFFERENT semantic selector from ARIA tree.
-
-5. **AVAILABLE CONTEXT**: page, expect (already imported), extractedData (from extract_data tool)
-
-6. **USE DOM SNAPSHOT** (CRITICAL - Don't invent selectors!):
-   - You get INTERACTIVE ELEMENTS with: position, tag, id, text, SUGGESTED SELECTORS
-   - ONLY use what's in the list - DON'T invent text/names not shown
-   - Use EXACT selectors provided (#submit-btn, getByRole('button', {name: 'X'}), etc.)
-   - ⚠️ If text appears multiple times → scope to parent or use role filter
-   - Element not in list? → take_screenshot
-   - ARIA tree = source of truth for roles/names
-   
-   ⚠️ IGNORE NON-INTERACTIVE ELEMENTS:
-   - Tooltips (role="tooltip") - informational only, NOT clickable
-   - Status messages (role="status", role="alert") - display info, NOT clickable
-   - Popovers with no buttons inside - usually just show info on hover
-   - Hidden elements (aria-hidden="true", display:none) - can't interact
-   
-   If you see a tooltip text in the goal, find the TRIGGER element (button/icon that shows the tooltip), NOT the tooltip itself.
-   
-   ⚠️ TOOLTIPS CAUSE STRICT MODE VIOLATIONS:
-   - Tooltips/popovers DUPLICATE text in the DOM (button + tooltip both have same text)
-   - BAD: getByText('Settings') → matches both button AND tooltip → STRICT MODE ERROR
-   - GOOD: getByRole('button', { name: 'Settings' }) → matches only button, ignores tooltip
-   - GOOD: locator('button').getByText('Settings') → scoped to button element
-   - Always prefer role-based selectors when text might appear in tooltips
-
-7. **SELECTOR PREFERENCE** (CRITICAL):
-   Prefer in order:
-   1. getByRole/Label/Placeholder - Semantic, stable
-   2. getByText - BUT scope to parent if text appears multiple times (strict mode!)
-   3. data-testid or stable IDs
-   4. Avoid: Auto-generated IDs (#«r3»-form-item), unicode, complex CSS paths
-   
-   ⚠️ Common mistakes:
-   - getByText('Settings') when "Settings" appears 2+ times → STRICT MODE ERROR
-     Fix: locator('#parent').getByText('Settings') OR getByRole('button').filter({hasText: 'Settings'})
-   - Missing timeout on goto() → Add { timeout: 30000 }
-   - Using auto-generated IDs → Break when components re-render
-
-8. **ASSERTIONS** (CRITICAL):
-   Use expect() ONLY when step explicitly asks: "verify", "check", "ensure", "confirm"
-   
-   When to use:
-   - "Verify X appears" → await expect(locator).toBeVisible()
-   - "Check field is empty" → await expect(locator).toBeEmpty()
-   - "Confirm URL" → await expect(page).toHaveURL('...')
-   
-   When NOT to use:
-   - "Send message" → DON'T verify it appeared (unless step asks)
-   - "Click Submit" → DON'T check button state
-   - "Fill field" → DON'T verify it's filled
-
-9. **TOOLS vs COMMANDS**:
-   Tools = read-only info gathering (screenshot, recall_history, extract_data)
-   Commands = state changes (Playwright: goto, click, fill, etc.)
-   
-   Navigation commands MUST include timeout:
-   - page.goto(url, { waitUntil: 'load', timeout: 30000 })
-   - page.waitForLoadState('load', { timeout: 30000 })
-
-10. **ERROR ANALYSIS** (Think about what went wrong):
-   - "Timeout waiting for locator" → Selector doesn't exist, find different one in DOM
-   - "page.goto: Timeout" → Missing timeout param: page.goto(url, { timeout: 30000 })
-   - "strict mode violation" → Text appears multiple times. Scope to parent: locator('#parent').getByText()
-   - "Element is not <select>" → Custom dropdown, use .click() not .selectOption()
-   - Loop detected (same selector 2+ times) → Try completely different selector from ARIA tree
-
-11. **WHEN TO RUN COMMANDS vs TOOLS**:
-   - Confident about selectors from DOM → Run commands directly
-   - Unsure or failed 2+ times → Take screenshot first
-   - First iteration of a step → Usually can run commands from DOM
-   - After successful command → mark "complete" if goal achieved (trust Playwright - if it succeeded, it worked)
-
-12. **NOTE TO FUTURE SELF** (Tactical memory across iterations):
-   
-   Write FREE-FORM notes for your next iteration about:
-   - What you tried and why it failed
-   - Hypothesis being tested
-   - Plan for next attempt
-   - Page behavior patterns observed
-   
-   Your next iteration reads this FIRST - use it to maintain strategic continuity.
-
-13. **COORDINATE-BASED ACTIONS** (Last resort after 3 selector failures):
-    
-    Activated automatically after 3 failures. Use PERCENTAGES (0-100, 3 decimals):
-    - xPercent: 0=left, 100=right
-    - yPercent: 0=top, 100=bottom
-    
-    Format:
-    {
-      "coordinateAction": {
-        "type": "coordinate",
-        "action": "click|doubleClick|rightClick|hover|drag|fill|scroll",
-        "xPercent": 15.755, "yPercent": 8.500,
-        "toXPercent": 45.25, "toYPercent": 8.50,  // For drag
-        "value": "text",      // For fill
-        "scrollAmount": 500   // For scroll
-      }
-    }
-    
-    AFTER coordinate action succeeds:
-    - If goal verification unclear → CALL verify_action_result tool
-    - Tool compares before/after screenshots to confirm goal achieved
-    - If verified: mark status="complete"
-    - If not verified: try different coordinates (2 attempts max)
-    
-    Example after coordinate click:
-    {
-      "status": "continue",
-      "reasoning": "Coordinate click succeeded, verifying if dashboard page loaded",
-      "toolCalls": [{"name": "verify_action_result", "params": {"expectedChange": "Dashboard page with data grid visible"}}],
-      "needsToolResults": true
-    }`;
-  }
-
-  /**
-   * Build coordinate-specific system prompt (used when selectors repeatedly fail)
-   */
-  static buildCoordinateSystemPrompt(): string {
-    return `You are a visual web automation expert. Selector generation has FAILED multiple times.
-
-YOU MUST NOW USE COORDINATE-BASED ACTIONS (this is not optional).
-
-SCREENSHOT PROVIDED:
-You will see a screenshot with visual indicators (bounding boxes or markers).
-
-CRITICAL - IDENTIFY THE CORRECT ELEMENT:
-1. READ the step goal carefully - what specific element are you looking for?
-2. LOCATE that element in the screenshot (NOT a similar-looking element!)
-3. VERIFY position using screen regions:
-   - Left sidebar/menu: xPercent ~5-25% (FAR LEFT)
-   - Center content: xPercent ~30-70%
-   - Right panel/sidebar: xPercent ~75-95% (FAR RIGHT)
-4. CALCULATE percentages from element's CENTER position
-5. SANITY CHECK your percentages:
-   - Sidebar menu item at 85%? WRONG - that's far right, not sidebar!
-   - Button in top-left at 90%? WRONG - that's top-right!
-   - Element description says "left" but x > 50%? WRONG - recheck!
-
-Example thought process:
-Goal: "Click Settings link in left navigation"
-→ I see "Settings" text in LEFT navigation panel in the screenshot
-→ Visual estimate: The link appears in the far left sidebar
-→ Horizontal: The link center is roughly 1/8th from the left edge → ~12-13% from left
-→ Vertical: The link center is roughly 1/3rd down from top → ~30-35% from top
-→ xPercent: 12.500, yPercent: 32.000
-→ Sanity check: 12.5% is FAR LEFT ✓ (NOT 80%+ which would be far right!)
-→ Description: "Clicking center of Settings link in left sidebar"
-
-CRITICAL VISUAL ESTIMATION TIPS:
-- Divide screenshot mentally into quadrants/regions
-- Left sidebar usually ~5-20% from left, center content ~30-70%, right sidebar ~75-95%
-- Aim for CENTER of element, not edges
-- Top bar usually 0-10% from top, footer usually 90-100%
-- Be conservative: slightly off-center is better than way off
-
-YOUR RESPONSE FORMAT - Output JSON matching this interface:
-
-interface AgentDecisionLLMResponse {
-  status: string;              // REQUIRED: "continue" (usually for coordinate mode)
-  reasoning: string;           // REQUIRED: "I see [element] at (X%, Y%) - using coordinates"
-  coordinateAction: {          // REQUIRED in coordinate mode
-    type: "coordinate";
-    action: "click" | "doubleClick" | "rightClick" | "hover" | "drag" | "fill" | "scroll";
-    xPercent: number;          // 0-100, 3 decimals
-    yPercent: number;          // 0-100, 3 decimals
-    toXPercent?: number;       // For drag
-    toYPercent?: number;       // For drag
-    value?: string;            // For fill
-    scrollAmount?: number;     // For scroll
-  };
-  noteToFutureSelf?: string;   // Optional: What to try if this fails
-}
-
-COORDINATE REFERENCE:
-- Top-left corner: xPercent=0, yPercent=0
-- Top-right corner: xPercent=100, yPercent=0
-- Bottom-left corner: xPercent=0, yPercent=100
-- Bottom-right corner: xPercent=100, yPercent=100
-- Center of screen: xPercent=50, yPercent=50
-
-Use 3 decimal places for precision (e.g., 15.755, not 16).
-
-ACTIONS:
-
-**Physical clicks:**
-- click: { action: "click", xPercent: 15.755, yPercent: 8.500 }
-- doubleClick: { action: "doubleClick", xPercent: 15.755, yPercent: 8.500 }
-- rightClick: { action: "rightClick", xPercent: 15.755, yPercent: 8.500 }
-- hover: { action: "hover", xPercent: 15.755, yPercent: 8.500 }
-
-**Input actions:**
-- fill: Click then type
-  { action: "fill", xPercent: 30.000, yPercent: 25.000, value: "alice@example.com" }
-
-**Movement actions:**
-- drag: From one position to another
-  { action: "drag", xPercent: 10.000, yPercent: 50.000, toXPercent: 60.000, toYPercent: 50.000 }
-- scroll: At position, scroll by amount
-  { action: "scroll", xPercent: 50.000, yPercent: 50.000, scrollAmount: 500 }
-
-CRITICAL RULES:
-- Percentages are from viewport TOP-LEFT (not full page)
-- Use element CENTER for coordinates, not edges
-- Be precise with decimals - wrong coords click wrong element
-- For fill: system will click at (x%,y%) then type value automatically
-- For drag: toXPercent/toYPercent are REQUIRED
-
-DO NOT try to generate selectors - that approach already failed. Use coordinates only.
-This is a last-resort mechanism, but it WILL work if you provide accurate percentages.`;
-  }
-
-  /**
-   * Build user prompt with context
-   */
-  static buildUserPrompt(context: AgentContext, consecutiveFailures?: number): string {
-    const parts: string[] = [];
-    
-    // Put static instructions first for LLM caching efficiency
-    parts.push('STEP EXECUTION RULES:');
-    parts.push('- DO ONLY what the current step asks - NO extra actions or verifications');
-    parts.push('- If step doesn\'t say "verify/check/confirm" → DON\'T add expect() assertions');
-    parts.push('- Mark "complete" ONLY if commands succeeded');
-    parts.push('- Try screenshot tool if you need visual context');
-    parts.push('- Max 5 iterations per step, then forced STUCK\n');
-    
-    // Dynamic content follows (changes per iteration)
-    parts.push('=== CURRENT CONTEXT ===\n');
-    
-    // Display note from previous iteration (high priority tactical info)
-    if (context.noteFromPreviousIteration) {
-      const note = context.noteFromPreviousIteration;
-      parts.push(`📝 YOUR NOTE FROM ITERATION ${note.fromIteration}:`);
-      parts.push(`   ${note.content}`);
-      parts.push(`   ^^ READ THIS - your previous self left important tactical guidance ^^`);
-      parts.push('');
-    }
-    
-    // Check for screenshot loops (analysis paralysis)
-    const recentScreenshots = context.recentSteps.slice(-3).filter(s => 
-      s.code.includes('take_screenshot') || s.action.toLowerCase().includes('screenshot')
-    );
-    if (recentScreenshots.length >= 2) {
-      parts.push(`🚨🚨🚨 SCREENSHOT LOOP DETECTED 🚨🚨🚨`);
-      parts.push(`You've taken ${recentScreenshots.length} screenshots in last 3 iterations!`);
-      parts.push(`STOP analyzing - START ACTING!`);
-      parts.push(`Use ANY selector from DOM snapshot and try clicking.`);
-      parts.push(`If command succeeds and new elements appear → mark "complete"`);
-      parts.push(`🚨🚨🚨\n`);
-    }
-    
-    // System warnings for accumulated failures
-    if (consecutiveFailures && consecutiveFailures >= 2 && consecutiveFailures < 3) {
-      parts.push(`⚠️ SYSTEM WARNING: ${consecutiveFailures} failures!`);
-      parts.push(`Take screenshot if needed. Try different selector strategy.`);
-      parts.push(`Question assumptions: Am I at the right step?`);
-      parts.push(`⚠️\n`);
-    } else if (consecutiveFailures && consecutiveFailures >= 4) {
-      parts.push(`⚠️ CRITICAL: ${consecutiveFailures} failures!`);
-      parts.push(`Next failure will force STUCK. Coordinate mode should be active.\n`);
-    }
-    
-    // Trigger coordinate mode if many failures (Phase 1: after 3 failures)
-    if (consecutiveFailures && consecutiveFailures >= 3) {
-      parts.push(`🎯🎯🎯 COORDINATE MODE ACTIVATED 🎯🎯🎯`);
-      parts.push(`Selector generation has failed ${consecutiveFailures} times.`);
-      parts.push(`You MUST use coordinate-based action now (percentages).`);
-      parts.push(`Provide coordinateAction with xPercent/yPercent (0-100, 3 decimals for precision).`);
-      parts.push(`See system prompt for coordinate action format.`);
-      parts.push(`🎯🎯🎯\n`);
-    }
-    
-    // Goals - make current step very prominent
-    parts.push(`🎯 CURRENT STEP GOAL (${context.stepNumber}/${context.totalSteps}):`);
-    parts.push(`${context.currentStepGoal}`);
-    parts.push(``);
-    parts.push(`OVERALL SCENARIO: ${context.overallGoal}\n`);
-    
-    if (context.completedSteps.length > 0) {
-      parts.push(`COMPLETED: ${context.completedSteps.join(', ')}`);
-    }
-    if (context.remainingSteps.length > 0) {
-      parts.push(`REMAINING: ${context.remainingSteps.join(', ')}\n`);
-    }
-    
-    // Current page state (most variable content - at the end)
-    parts.push(`\nCURRENT PAGE:`);
-    parts.push(`URL: ${context.currentURL}`);
-    parts.push(`Title: ${context.currentPageInfo.title}`);
-    parts.push(`\nINTERACTIVE ELEMENTS (with positions and selectors):`);
-    parts.push(context.currentPageInfo.formattedElements);
-    parts.push(`\nARIA TREE (hierarchical structure):`);
-    parts.push(JSON.stringify(context.currentPageInfo.ariaSnapshot, null, 2).substring(0, 5000));
-    if (JSON.stringify(context.currentPageInfo.ariaSnapshot).length > 5000) {
-      parts.push('... (truncated)');
-    }
-    parts.push('');
-    
-    // Recent steps (most variable content - at the end)
-    if (context.recentSteps.length > 0) {
-      parts.push(`\nRECENT STEPS (last ${context.recentSteps.length}):`);
-      for (const step of context.recentSteps) {
-        const status = step.result === 'success' ? '✓' : '✗';
-        parts.push(`  ${status} ${step.stepNumber}.${step.iteration || ''} ${step.action}`);
-        parts.push(`     Code: ${step.code}`);
-        if (step.result === 'failure' && step.error) {
-          parts.push(`     ❌ ERROR: ${step.error}`);
-          parts.push(`     ^^ THIS SELECTOR FAILED - TRY DIFFERENT APPROACH ^^`);
-        } else {
-          parts.push(`     Result: ${step.observation}`);
-        }
-      }
-      parts.push('');
-      
-      // Detect repeated failures
-      const recentFailures = context.recentSteps.filter(s => s.result === 'failure');
-      if (recentFailures.length >= 2) {
-        const sameSelector = recentFailures.slice(-2).every((s, i, arr) => 
-          i === 0 || s.code === arr[i-1].code
-        );
-        if (sameSelector) {
-          parts.push(`⚠️ WARNING: You've tried the same selector multiple times and it failed!`);
-          parts.push(`   Last failed selector: ${recentFailures[recentFailures.length - 1].code}`);
-          parts.push(`   YOU MUST try a completely different selector this time!\n`);
-        }
-      }
-    }
-    
-    // Experiences (app-specific patterns learned)
-    if (context.experiences && context.experiences.length > 0) {
-      parts.push(`\nEXPERIENCES (patterns you've learned about this app):`);
-      for (const exp of context.experiences) {
-        parts.push(`  • ${exp}`);
-      }
-      parts.push('');
-    }
-    
-    // Extracted data (from previous extract_data tool calls)
-    if (context.extractedData && Object.keys(context.extractedData).length > 0) {
-      parts.push(`\nEXTRACTED DATA (available for use in commands):`);
-      parts.push(JSON.stringify(context.extractedData, null, 2));
-      parts.push('');
-    }
-    
-    // Previous iteration guidance
-    if (context.previousIterationGuidance) {
-      parts.push(`\nGUIDANCE FROM PREVIOUS ITERATION:`);
-      parts.push(context.previousIterationGuidance.guidanceForNext);
-      if (context.previousIterationGuidance.detectingLoop) {
-        parts.push(`⚠️ LOOP DETECTED: ${context.previousIterationGuidance.loopReasoning}`);
-      }
-      parts.push('');
-    }
-    
-    return parts.join('\n');
-  }
-}
-

package/src/orchestrator/tool-registry.ts

@@ -1,182 +0,0 @@
-/**
- * Tool Registry - Dynamic tool registration and prompt generation
- * Tools can be added at runtime and their descriptions are automatically included in agent prompts
- */
-
-import { ToolCall, ToolResult } from './types';
-
-/**
- * Tool parameter definition
- */
-export interface ToolParameter {
-  name: string;
-  type: 'string' | 'number' | 'boolean' | 'object';
-  description: string;
-  required: boolean;
-  default?: any;
-}
-
-/**
- * Tool definition
- */
-export interface Tool {
-  name: string;
-  description: string;
-  parameters: ToolParameter[];
-  
-  /**
-   * Execute the tool
-   * @param params Tool parameters
-   * @param context Execution context (page, memory, etc.)
-   */
-  execute(params: Record<string, any>, context: ToolExecutionContext): Promise<ToolResult>;
-}
-
-/**
- * Context provided to tool execution
- */
-export interface ToolExecutionContext {
-  page: any;  // Playwright Page
-  memory: any;  // JourneyMemory
-  stepNumber: number;
-  logger?: (message: string, level?: 'log' | 'error' | 'warn') => void;
-}
-
-/**
- * Tool Registry - manages available tools and generates prompts
- */
-export class ToolRegistry {
-  private tools: Map<string, Tool> = new Map();
-  
-  /**
-   * Register a tool
-   */
-  register(tool: Tool): void {
-    this.tools.set(tool.name, tool);
-  }
-  
-  /**
-   * Unregister a tool
-   */
-  unregister(toolName: string): void {
-    this.tools.delete(toolName);
-  }
-  
-  /**
-   * Get a tool by name
-   */
-  get(toolName: string): Tool | undefined {
-    return this.tools.get(toolName);
-  }
-  
-  /**
-   * Get all registered tools
-   */
-  getAll(): Tool[] {
-    return Array.from(this.tools.values());
-  }
-  
-  /**
-   * Execute a tool
-   */
-  async execute(toolCall: ToolCall, context: ToolExecutionContext): Promise<ToolResult> {
-    const tool = this.tools.get(toolCall.name);
-    
-    if (!tool) {
-      return {
-        success: false,
-        error: `Tool '${toolCall.name}' not found`
-      };
-    }
-    
-    // Validate required parameters
-    const missingParams = tool.parameters
-      .filter(p => p.required && !(p.name in toolCall.params))
-      .map(p => p.name);
-    
-    if (missingParams.length > 0) {
-      return {
-        success: false,
-        error: `Missing required parameters: ${missingParams.join(', ')}`
-      };
-    }
-    
-    // Apply defaults for missing optional parameters
-    const params = { ...toolCall.params };
-    for (const param of tool.parameters) {
-      if (!param.required && !(param.name in params) && param.default !== undefined) {
-        params[param.name] = param.default;
-      }
-    }
-    
-    try {
-      return await tool.execute(params, context);
-    } catch (error: any) {
-      return {
-        success: false,
-        error: `Tool execution failed: ${error.message}`
-      };
-    }
-  }
-  
-  /**
-   * Generate tool descriptions for agent prompt
-   * Returns formatted text describing all available tools
-   */
-  generateToolDescriptions(): string {
-    if (this.tools.size === 0) {
-      return 'No tools available.';
-    }
-    
-    const descriptions: string[] = [];
-    
-    descriptions.push('AVAILABLE TOOLS:');
-    descriptions.push('');
-    
-    for (const tool of this.tools.values()) {
-      descriptions.push(`${tool.name}:`);
-      descriptions.push(`  Description: ${tool.description}`);
-      
-      if (tool.parameters.length > 0) {
-        descriptions.push(`  Parameters:`);
-        for (const param of tool.parameters) {
-          const required = param.required ? '(required)' : '(optional)';
-          const defaultVal = param.default !== undefined ? ` [default: ${JSON.stringify(param.default)}]` : '';
-          descriptions.push(`    - ${param.name} (${param.type}) ${required}: ${param.description}${defaultVal}`);
-        }
-      } else {
-        descriptions.push(`  Parameters: none`);
-      }
-      
-      descriptions.push('');
-    }
-    
-    descriptions.push('To use a tool, include it in your "toolCalls" array with the tool name and parameters.');
-    descriptions.push('');
-    
-    return descriptions.join('\n');
-  }
-  
-  /**
-   * Generate JSON schema for tool calls (for structured output)
-   */
-  generateToolCallSchema(): any {
-    return {
-      type: 'array',
-      items: {
-        type: 'object',
-        properties: {
-          name: {
-            type: 'string',
-            enum: Array.from(this.tools.keys())
-          },
-          params: {
-            type: 'object'
-          }
-        },
-        required: ['name', 'params']
-      }
-    };
-  }
-}
-