Coding Agents

class CodingAgentInterface(ABC):
    def initialize(self, workspace: str) -> None:
        """Initialize for a specific workspace."""

    def generate_code(self, prompt: str, debug_mode: bool = False) -> CodingResult:
        """Generate or modify code based on prompt."""

    def cleanup(self) -> None:
        """Clean up resources."""

    def get_cumulative_cost(self) -> float:
        """Return total cost accumulated."""

    def supports_native_git(self) -> bool:
        """Return True if agent handles its own commits."""

coding_agent:
  type: "aider"
  model: "gpt-4o-mini"
  debug_model: "gpt-4o-mini"

from kapso.execution.coding_agents.factory import CodingAgentFactory

config = CodingAgentFactory.build_config(
    agent_type="aider",
    model="gpt-4o-mini",
)

agent = CodingAgentFactory.create(config)
agent.initialize("/path/to/workspace")

result = agent.generate_code("Implement a sorting algorithm")
print(f"Files changed: {result.files_changed}")
print(f"Cost: ${result.cost:.4f}")

npm install -g @anthropic-ai/claude-code

coding_agent:
  type: "claude_code"
  model: "claude-sonnet-4-20250514"
  agent_specific:
    auth_mode: "auto"
    claude_md_path: "CLAUDE.md"

claude auth login
claude auth status

coding_agent:
  type: "claude_code"
  model: "claude-opus-4-6"
  agent_specific:
    auth_mode: "oauth"

export ANTHROPIC_API_KEY=...

coding_agent:
  type: "claude_code"
  model: "claude-opus-4-6"
  agent_specific:
    auth_mode: "api_key"

coding_agent:
  type: "claude_code"
  model: "us.anthropic.claude-opus-4-6-v1"
  agent_specific:
    auth_mode: "bedrock"
    aws_region: "us-east-1"

AWS_ACCESS_KEY_ID=...
AWS_SECRET_ACCESS_KEY=...
AWS_REGION=us-east-1

agent_specific:
  use_bedrock: true   # same as auth_mode: bedrock
  # use_bedrock: false  # same as auth_mode: api_key

coding_agent:
  type: "gemini"
  model: "gemini-2.0-flash"
  debug_model: "gemini-2.0-flash"

GOOGLE_API_KEY=your-google-api-key

# Create separate environment
conda create -n openhands_env python=3.12
conda activate openhands_env
pip install openhands-ai litellm

coding_agent:
  type: "openhands"
  model: "gpt-4o"
  agent_specific:
    sandbox_type: "docker"

@dataclass
class CodingResult:
    success: bool           # Whether generation succeeded
    output: str             # Agent's response text
    files_changed: List[str]  # Modified files
    error: Optional[str]    # Error message if failed
    cost: float             # Cost in dollars
    commit_message: Optional[str]  # Agent-generated message
    metadata: Dict[str, Any]  # Agent-specific data

{
    "code_changes_summary": "Brief description of changes made",
    "evaluation_script_path": "kapso_evaluation/evaluate.py",
    "evaluation_output": "Full output from running evaluation"
}

I've implemented the random forest classifier. Here's what I did:

1. Created main.py with the classifier implementation
2. Added data loading and preprocessing
3. Created kapso_evaluation/evaluate.py to test accuracy

Running evaluation...
Loading data...
Training model...
Accuracy: 0.92

```json
{
    "code_changes_summary": "Implemented random forest classifier with GridSearchCV for hyperparameter tuning. Added cross-validation and accuracy reporting.",
    "evaluation_script_path": "kapso_evaluation/evaluate.py",
    "evaluation_output": "Loading data...\nTraining model...\nAccuracy: 0.92"
}

## Feedback Generator Role

Coding agents also power the feedback generator. The default feedback generator uses `claude_code`, but any agent can be used:

```python
from kapso.execution.feedback_generator import FeedbackGenerator
from kapso.execution.coding_agents.factory import CodingAgentFactory

# Use gemini for feedback generation
config = CodingAgentFactory.build_config(
    agent_type="gemini",
    model="gemini-2.0-flash",
)

feedback_gen = FeedbackGenerator(coding_agent_config=config)

@dataclass
class CodingAgentConfig:
    agent_type: str         # "aider", "gemini", etc.
    model: str              # Primary model
    debug_model: str        # Model for debugging
    workspace: str = ""     # Working directory
    use_git: bool = True    # Git integration
    agent_specific: Dict[str, Any] = field(default_factory=dict)

from kapso.execution.coding_agents.base import CodingAgentInterface, CodingResult
from kapso.execution.coding_agents.factory import register_agent

@register_agent("my_custom_agent")
class MyCustomAgent(CodingAgentInterface):
    def initialize(self, workspace: str) -> None:
        self.workspace = workspace
        # Setup agent

    def generate_code(self, prompt: str, debug_mode: bool = False) -> CodingResult:
        # Generate code
        model = self.config.debug_model if debug_mode else self.config.model

        # Call your API
        response = my_api.generate(prompt, model=model)

        # Track cost
        self._cumulative_cost += response.cost

        return CodingResult(
            success=True,
            output=response.text,
            files_changed=response.files,
            cost=response.cost,
        )

    def cleanup(self) -> None:
        # Clean up resources
        pass

    def supports_native_git(self) -> bool:
        return False  # Let ExperimentSession handle commits

def supports_native_git(self) -> bool:
    return True  # Aider auto-commits

def supports_native_git(self) -> bool:
    return False  # Session will commit

def get_capabilities(self) -> Dict[str, bool]:
    return {
        "native_git": self.supports_native_git(),
        "sandbox": False,
        "planning_mode": False,
        "cost_tracking": True,
        "streaming": False,
    }

PYTHONPATH=. python -m src.cli --list-agents

Available Coding Agents:
==================================================
  aider: Git-centric pair programming with diff-based editing
  gemini: Google Gemini SDK for code generation
  claude_code: Anthropic Claude Code CLI for complex refactoring
  openhands: OpenHands agent with sandboxed execution (separate env required)