experiments/openhands/run_agent.py

#!/usr/bin/env python3
"""
Run OpenHands agent for a single branch coverage task.
"""
import os
import sys
import json
import shutil
import argparse
import traceback
import glob
from typing import Dict, Any, Optional

# Add exp directory to path
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))

from prompt import build_prompt_openhands

# Default configuration
DEFAULT_API_BASE = "http://localhost:60101/v1"
DEFAULT_MODEL = "qwen-3.5-27b"
RESULTS_DIR = "/experiments/openhands/results"

# Suppress OpenHands banner
os.environ['OPENHANDS_SUPPRESS_BANNER'] = '1'


def find_generator_code(result_dir: str) -> str:
    """
    Find generator code in the result directory.

    Look for:
    1. generator.py directly in result_dir
    2. Any *.libpng_read_fuzzer.*.py pattern (agent-created files)
    """
    # First check for generator.py
    generator_path = os.path.join(result_dir, 'generator.py')
    if os.path.exists(generator_path):
        with open(generator_path, 'r') as f:
            content = f.read()
            if content.strip():  # Non-empty
                return content

    # Look for agent-created files with pattern: *.prog.src_site_id.to_take.try_id.py
    patterns = [
        os.path.join(result_dir, '*.py'),
        os.path.join(result_dir, '**', '*.py'),
    ]

    for pattern in patterns:
        for py_file in glob.glob(pattern, recursive=True):
            if py_file.endswith('generator.py'):
                continue
            try:
                with open(py_file, 'r') as f:
                    content = f.read()
                    if 'def generate_buf' in content:
                        return content
            except:
                continue

    return ""


def run_agent_single(
    question: Dict[str, Any],
    try_id: int,
    llm_name: str = DEFAULT_MODEL,
    api_base: str = DEFAULT_API_BASE,
    model: str = DEFAULT_MODEL,
    enable_thinking: bool = False,
    timeout: int = 1800,  # 30 minutes default timeout
) -> Dict[str, Any]:
    """
    Run OpenHands agent for a single branch coverage task.

    Args:
        question: Dict with keys 'prog', 'src_site_id', 'to_take', 'format'
        try_id: Attempt number (0-indexed)
        llm_name: Name for result directory
        api_base: OpenAI-compatible API base URL
        model: Model name to use
        enable_thinking: Whether to enable thinking/reasoning mode
        timeout: Maximum time for agent to run (seconds)

    Returns:
        Dict with result information
    """
    from openhands.sdk import LLM
    from openhands.tools.preset.default import get_default_agent
    from openhands.sdk import Conversation

    prog = question['prog']
    src_site_id = question['src_site_id']
    to_take = question['to_take']
    file_format = question.get('format', 'unknown')

    # Build result directory path
    result_dir_name = f"{llm_name}---{prog}---{src_site_id}---{to_take}---{try_id}"
    result_dir = os.path.join(RESULTS_DIR, result_dir_name)

    # Clean and create result directory
    if os.path.exists(result_dir):
        shutil.rmtree(result_dir)
    os.makedirs(result_dir)
    os.makedirs(os.path.join(result_dir, 'logs'))

    # Copy source code to workspace
    # Try to find the source directory
    original_src_dir = None
    possible_dirs = [
        f'/src/{prog.split("_")[0]}',  # e.g., /src/libpng for libpng_read_fuzzer
        f'/src/{prog}',
        f'/src/{prog.replace("_", "-")}',
    ]

    for possible_dir in possible_dirs:
        if os.path.exists(possible_dir):
            original_src_dir = possible_dir
            break

    workspace_src_dir = original_src_dir

    # Build prompt
    sys_prompt, user_prompt, _ = build_prompt_openhands(
        prog, file_format, src_site_id, to_take, result_dir, workspace_src_dir
    )

    # Initialize LLM with extra_body for thinking mode support
    llm_kwargs = {
        'model': f'hosted_vllm/{model}',
        'api_key': 'dummy',
        'base_url': api_base,
        'extra_body': {
            "chat_template_kwargs": {"enable_thinking": enable_thinking},
            "include_reasoning": enable_thinking,
        },
        'timeout': 3600,
    }

    llm = LLM(**llm_kwargs)

    # Get agent with CLI mode
    agent = get_default_agent(llm=llm, cli_mode=True)

    # Create conversation
    conversation = Conversation(
        agent=agent,
        workspace=result_dir,
        persistence_dir=os.path.join(result_dir, 'logs'),
        max_iteration_per_run=50,
    )

    error_msg = None
    generator_code = ""

    try:
        # Send initial message and run agent
        conversation.send_message(sys_prompt + user_prompt)
        conversation.run()

        # Find generator code in result directory
        generator_code = find_generator_code(result_dir)

    except Exception as e:
        error_msg = f"Agent failed: {str(e)}\n{traceback.format_exc()}"

        # Save error log
        error_path = os.path.join(result_dir, 'err.md')
        with open(error_path, 'w') as f:
            f.write("# Error Log\n\n")
            f.write(error_msg)

    # Save generator.py if found, otherwise create empty file
    generator_path = os.path.join(result_dir, 'generator.py')
    if generator_code:
        with open(generator_path, 'w') as f:
            f.write(generator_code)
    else:
        pass

    return {
        'success': bool(generator_code),
        'generator_code': generator_code,
        'error': error_msg,
        'result_dir': result_dir,
    }


def main():
    parser = argparse.ArgumentParser(description="Run OpenHands agent for a single task")

    # Task specification
    parser.add_argument("--prog", type=str, required=True, help="Program name")
    parser.add_argument("--src-site-id", type=int, required=True, help="Source site ID")
    parser.add_argument("--to-take", type=int, required=True, help="Branch direction (0 or 1)")
    parser.add_argument("--format", type=str, default="unknown", help="Input file format")
    parser.add_argument("--try-id", type=int, default=0, help="Try ID")

    # Model configuration
    parser.add_argument("--api-base", type=str, default=DEFAULT_API_BASE, help="API base URL")
    parser.add_argument("--model", type=str, default=DEFAULT_MODEL, help="Model name")
    parser.add_argument("--llm-name", type=str, default=None, help="LLM name for results")
    parser.add_argument("--enable-thinking", action="store_true", help="Enable thinking mode")

    args = parser.parse_args()

    llm_name = args.llm_name if args.llm_name else args.model

    question = {
        'prog': args.prog,
        'src_site_id': args.src_site_id,
        'to_take': args.to_take,
        'format': args.format,
    }

    print(f"Running OpenHands agent for: {question}")
    print(f"Try ID: {args.try_id}")
    print(f"Model: {args.model}")

    result = run_agent_single(
        question=question,
        try_id=args.try_id,
        llm_name=llm_name,
        api_base=args.api_base,
        model=args.model,
        enable_thinking=args.enable_thinking,
    )

    print(f"\nResult: {'Success' if result['success'] else 'Failed'}")
    if result['error']:
        print(f"Error: {result['error']}")
    print(f"Result directory: {result['result_dir']}")


if __name__ == '__main__':
    main()