"""
Core agent infrastructure for the Kaizen Agentic framework.

This module provides the foundational classes for creating and managing
AI agents with continuous improvement capabilities.
"""

from typing import Dict, Any, Optional
from dataclasses import dataclass
from abc import ABC, abstractmethod


@dataclass
class AgentConfig:
    """Configuration for an AI agent."""

    name: str
    description: str
    model: str = "inherit"
    instructions: Optional[str] = None
    metadata: Optional[Dict[str, Any]] = None

    def __post_init__(self):
        if self.metadata is None:
            self.metadata = {}


class Agent(ABC):
    """Base class for AI agents in the Kaizen framework."""

    def __init__(self, config: AgentConfig):
        self.config = config
        self.performance_history = []
        self.optimization_data = {}

    @abstractmethod
    def execute(
        self, task: str, context: Optional[Dict[str, Any]] = None
    ) -> Dict[str, Any]:
        """Execute a task and return results with performance metrics."""
        pass

    def record_performance(self, metrics: Dict[str, Any]) -> None:
        """Record performance metrics for kaizen analysis."""
        self.performance_history.append(metrics)

    def get_optimization_data(self) -> Dict[str, Any]:
        """Get data for optimization analysis."""
        return {
            "performance_history": self.performance_history,
            "config": self.config,
            "optimization_data": self.optimization_data,
        }

    def update_configuration(self, updates: Dict[str, Any]) -> None:
        """Update agent configuration based on optimization insights."""
        for key, value in updates.items():
            if hasattr(self.config, key):
                setattr(self.config, key, value)
            else:
                self.config.metadata[key] = value