agent.py

"""
agent.py — Главный оркестратор агента.
Объединяет все компоненты: память, инструменты, безопасность, планировщик.
Реализует основной цикл: Plan → Safety → Execute → Verify → Remember.
"""

import os
import json
import time
import traceback
from pathlib import Path
from typing import Dict, List, Optional, Any, Tuple, Callable, Union
from dataclasses import dataclass, field
from enum import Enum

from agent_config import AgentConfig, config as default_config
from logger import AgentLogger, logger as default_logger
from exceptions import (
    AgentException, StepLimitExceededError, RetryLimitExceededError,
    ModelNotLoadedError, SafetyError, ToolExecutionError
)
from utils import get_timestamp, hash_text, truncate_text

from memory.memory_manager import MemoryManager
from tools.tool_registry import ToolRegistry
from tools.base_tool import ToolResult
from safety.safety_checker import SafetyChecker, SafetyCheck, ThreatSeverity
from llm.planner import LLMPlanner, PlannerMode, PlannerResult
from core.llm_engine import LLMEngine
from core.generator import Generator


class AgentState(Enum):
    """Состояния агента."""
    IDLE = "idle"
    PLANNING = "planning"
    EXECUTING = "executing"
    VERIFYING = "verifying"
    REFLECTING = "reflecting"
    WAITING_CONFIRMATION = "waiting_confirmation"
    COMPLETED = "completed"
    FAILED = "failed"
    STOPPED = "stopped"


@dataclass
class AgentStep:
    """Запись о шаге агента."""
    step_number: int
    state: AgentState
    action: Optional[Dict[str, Any]] = None
    result: Optional[ToolResult] = None
    safety_check: Optional[SafetyCheck] = None
    verified: bool = False
    error: Optional[str] = None
    timestamp: str = field(default_factory=get_timestamp)
    execution_time: float = 0.0
    
    def to_dict(self) -> Dict[str, Any]:
        return {
            'step': self.step_number,
            'state': self.state.value,
            'action': self.action,
            'result': self.result.to_dict() if self.result else None,
            'safety_check': self.safety_check.to_dict() if self.safety_check else None,
            'verified': self.verified,
            'error': self.error,
            'timestamp': self.timestamp,
            'execution_time': self.execution_time
        }


@dataclass
class AgentResponse:
    """Ответ агента пользователю."""
    success: bool
    message: str
    data: Any = None
    steps: List[AgentStep] = field(default_factory=list)
    total_steps: int = 0
    total_time: float = 0.0
    memory_used: bool = False
    error: Optional[str] = None
    
    def to_dict(self) -> Dict[str, Any]:
        return {
            'success': self.success,
            'message': self.message,
            'data': self.data,
            'total_steps': self.total_steps,
            'total_time': round(self.total_time, 3),
            'memory_used': self.memory_used,
            'error': self.error,
            'steps': [s.to_dict() for s in self.steps]
        }


class LocalAgent:
    """
    Главный оркестратор локального агента.
    
    Архитектура:
    1. Получает задачу от пользователя
    2. Проверяет память (Memory) — есть ли готовое решение
    3. Если нет — планирует действие (Planner/LLM)
    4. Проверяет безопасность (Safety)
    5. Выполняет инструмент (Executor/ToolRegistry)
    6. Проверяет результат (Verifier)
    7. Сохраняет в память (Memory)
    8. Повторяет или возвращает ответ
    """
    
    def __init__(
        self,
        config: AgentConfig = None,
        logger: AgentLogger = None,
        memory_manager: MemoryManager = None,
        tool_registry: ToolRegistry = None,
        safety_checker: SafetyChecker = None,
        planner: LLMPlanner = None
    ):
        """
        Инициализация агента.
        
        Args:
            config: Конфигурация агента
            logger: Логгер
            memory_manager: Менеджер памяти
            tool_registry: Реестр инструментов
            safety_checker: Проверка безопасности
            planner: Планировщик
        """
        # Конфигурация
        self.config = config or default_config
        
        # Логгер
        self.logger = logger or default_logger
        
        # Инициализируем компоненты (если не переданы)
        self.memory_manager = memory_manager or MemoryManager(
            sqlite_path=self.config.memory.sqlite_path,
            chroma_path=self.config.memory.chroma_path,
            graph_path=self.config.memory.graph_path,
            embedding_model=self.config.memory.embedding_model,
            similarity_threshold=self.config.memory.similarity_threshold,
            enable_vector=self.config.memory.memory_type in ('chromadb', 'both'),
            enable_graph=self.config.memory.graph_enabled
        )
        
        # Реестр инструментов
        tool_config = {
            'bash': {
                'allowed_directories': self.config.allowed_directories,
                'command_log_path': self.config.safety.command_log_path
            },
            'file_read': {
                'allowed_directories': self.config.allowed_directories
            },
            'file_write': {
                'allowed_directories': self.config.allowed_directories
            },
            'file_search': {
                'allowed_directories': self.config.allowed_directories
            },
            'file_ops': {
                'allowed_directories': self.config.allowed_directories
            }
        }
        self.tool_registry = tool_registry or ToolRegistry(config=tool_config)
        
        # Система безопасности
        safety_config = {
            'safety_level': 'normal',
            'auto_confirm': self.config.safety.auto_confirm,
            'allowed_directories': self.config.allowed_directories,
            'blocked_commands': [],
            'safety_log_path': self.config.safety.command_log_path
        }
        self.safety_checker = safety_checker or SafetyChecker(config=safety_config)
        
        # Устанавливаем callback для подтверждения опасных действий
        self.safety_checker.set_confirm_callback(self._confirm_action)
        
        # Планировщик
        planner_config = {
            'model_path': self.config.model.model_path,
            'model_config': {
                'n_ctx': self.config.model.n_ctx,
                'n_threads': self.config.model.n_threads,
                'n_batch': self.config.model.n_batch,
                'temperature': self.config.model.temperature,
                'top_p': self.config.model.top_p,
                'top_k': self.config.model.top_k,
                'max_tokens': self.config.model.max_tokens,
                'repeat_penalty': self.config.model.repeat_penalty,
                'use_mlock': self.config.model.use_mlock,
                'verbose': self.config.model.verbose
            }
        }
        self.planner = planner or LLMPlanner(config=planner_config)
        
        # LLM Engine и Generator
        self.engine = LLMEngine(llm=self.planner.llm if self.planner.is_model_loaded() else None)
        self.generator = Generator(engine=self.engine)
        
        # Передаем generator в CodeGeneratorTool
        code_tool = self.tool_registry.get_tool('generate_code')
        if code_tool:
            code_tool.generator = self.generator
        
        # Состояние агента
        self.state = AgentState.IDLE
        self.current_task = ""
        self.steps: List[AgentStep] = []
        self.start_time = 0.0
        
        # Статистика сессии
        self.session_stats = {
            'tasks_completed': 0,
            'tasks_failed': 0,
            'total_steps': 0,
            'memory_hits': 0,
            'total_time': 0.0,
            'started_at': get_timestamp()
        }
        
        # История диалогов
        self.conversation_history: List[Dict] = []
        
        # Хуки (callbacks)
        self.hooks: Dict[str, List[Callable]] = {
            'on_step_start': [],
            'on_step_complete': [],
            'on_task_start': [],
            'on_task_complete': [],
            'on_error': []
        }
        
        self.logger.separator()
        self.logger.info("🤖 Локальный агент инициализирован")
        self.logger.info(f"   Память: {'активна' if self.memory_manager else 'отключена'}")
        self.logger.info(f"   Инструменты: {len(self.tool_registry.get_tool_names())} доступно")
        self.logger.info(f"   Модель: {'загружена' if self.planner.is_model_loaded() else 'не загружена (fallback)'}")
        self.logger.info(f"   Безопасность: {self.safety_checker.safety_level.value}")
        self.logger.separator()
    
    def run(self, task: str, auto_confirm: bool = None) -> AgentResponse:
        """
        Запускает агента для решения задачи.
        
        Args:
            task: Задача от пользователя
            auto_confirm: Автоматически подтверждать опасные действия
            
        Returns:
            AgentResponse с результатом
        """
        self.state = AgentState.IDLE
        self.current_task = task
        self.steps = []
        self.start_time = time.time()
        
        # Устанавливаем авто-подтверждение
        if auto_confirm is not None:
            old_auto_confirm = self.safety_checker.auto_confirm
            self.safety_checker.auto_confirm = auto_confirm
        
        self.logger.separator("=")
        self.logger.info(f"📋 Задача: {task}")
        self.logger.separator("=")
        
        # Вызываем хук
        self._run_hooks('on_task_start', task=task)
        
        try:
            # Шаг 1: Проверяем память
            self.logger.info("🔍 Проверяю память...")
            memory_result = self.memory_manager.find_solution(task)
            
            if memory_result and memory_result.confidence >= 0.9:
                self.logger.success(f"✅ Найдено решение в памяти (уверенность: {memory_result.confidence:.2f})")
                self.session_stats['memory_hits'] += 1
                
                # Выполняем решение из памяти
                if self._is_executable_solution(memory_result.solution):
                    result = self._execute_cached_solution(memory_result)
                    
                    self.session_stats['tasks_completed'] += 1
                    self.state = AgentState.COMPLETED
                    
                    response = AgentResponse(
                        success=True,
                        message="Задача решена (из памяти)",
                        data=result.data if result else None,
                        steps=self.steps,
                        total_steps=len(self.steps),
                        total_time=time.time() - self.start_time,
                        memory_used=True
                    )
                    
                    self._run_hooks('on_task_complete', task=task, response=response)
                    self._add_to_history(task, response)
                    return response
                else:
                    self.logger.info("Решение из памяти — информационное, возвращаю как ответ")
                    self.session_stats['tasks_completed'] += 1
                    self.state = AgentState.COMPLETED
                    
                    response = AgentResponse(
                        success=True,
                        message=str(memory_result.solution.get('answer', memory_result.solution)),
                        data=memory_result.solution,
                        steps=self.steps,
                        total_steps=0,
                        total_time=time.time() - self.start_time,
                        memory_used=True
                    )
                    
                    self._add_to_history(task, response)
                    return response
            
            # Шаг 2: Цикл планирования и выполнения
            max_steps = self.config.max_steps
            context = ""
            
            for step_number in range(1, max_steps + 1):
                self.logger.info(f"\n--- Шаг {step_number}/{max_steps} ---")
                
                # Планирование
                self.state = AgentState.PLANNING
                self.logger.info("🧠 Планирую действие...")
                
                plan_result = self._plan_action(task, context)
                
                if plan_result is None:
                    self.logger.error("Не удалось спланировать действие")
                    break
                
                action = plan_result
                self.logger.info(f"   Действие: {action.get('action', 'unknown')}")
                self.logger.info(f"   Параметры: {json.dumps(action.get('input', {}), ensure_ascii=False)[:200]}")
                
                # Проверяем, не финальный ли ответ
                if action.get('action') == 'final_answer':
                    self.logger.success("✅ Получен финальный ответ")
                    self.state = AgentState.COMPLETED
                    self.session_stats['tasks_completed'] += 1
                    
                    final_answer = action.get('input', {}).get('answer', str(action))
                    
                    response = AgentResponse(
                        success=True,
                        message=final_answer,
                        data=action.get('input', {}),
                        steps=self.steps,
                        total_steps=len(self.steps),
                        total_time=time.time() - self.start_time,
                        memory_used=False
                    )
                    
                    self._run_hooks('on_task_complete', task=task, response=response)
                    self._add_to_history(task, response)
                    return response
                
                # Проверка безопасности
                self.state = AgentState.WAITING_CONFIRMATION
                safety_check = self._check_safety(action)
                
                step = AgentStep(
                    step_number=step_number,
                    state=self.state,
                    action=action,
                    safety_check=safety_check
                )
                
                if not safety_check.passed:
                    if safety_check.severity == ThreatSeverity.CRITICAL:
                        self.logger.error(f"⛔ Действие заблокировано: {safety_check.reason}")
                        step.error = safety_check.reason
                        step.state = AgentState.FAILED
                        self.steps.append(step)
                        
                        # Пробуем другой подход
                        context += f"\nПредыдущее действие заблокировано: {safety_check.reason}. Попробуй другой подход."
                        continue
                    
                    elif safety_check.severity == ThreatSeverity.DANGER:
                        # Запрашиваем подтверждение
                        confirmed = self.safety_checker.request_confirmation(
                            f"Выполнить: {action.get('action')}",
                            json.dumps(action.get('input', {}), ensure_ascii=False)[:500]
                        )
                        if not confirmed:
                            self.logger.info("❌ Действие отклонено пользователем")
                            step.error = "Отклонено пользователем"
                            step.state = AgentState.FAILED
                            self.steps.append(step)
                            context += "\nПредыдущее действие отклонено. Попробуй другой подход."
                            continue
                
                # Выполнение
                self.state = AgentState.EXECUTING
                step_start = time.time()
                
                self._run_hooks('on_step_start', step=step)
                
                self.logger.info(f"⚡ Выполняю: {action.get('action')}")
                result = self._execute_action(action)
                
                step.execution_time = time.time() - step_start
                step.result = result
                step.state = AgentState.EXECUTING
                
                self.logger.info(f"   Результат: {'✅ Успешно' if result.success else '❌ Ошибка'}")
                if result.error:
                    self.logger.info(f"   Ошибка: {result.error[:200]}")
                
                # Верификация
                self.state = AgentState.VERIFYING
                verified, verification_message = self._verify_result(task, result)
                step.verified = verified
                
                if verified:
                    self.logger.success(f"✅ {verification_message}")
                    step.state = AgentState.COMPLETED
                    self.steps.append(step)
                    
                    # Сохраняем успешное решение в память
                    self._save_successful_solution(task, action, result)
                    
                    self._run_hooks('on_step_complete', step=step)
                    
                    self.session_stats['tasks_completed'] += 1
                    self.state = AgentState.COMPLETED
                    self.session_stats['total_steps'] += len(self.steps)
                    
                    response = AgentResponse(
                        success=True,
                        message=self._format_result_message(result),
                        data=result.data,
                        steps=self.steps,
                        total_steps=len(self.steps),
                        total_time=time.time() - self.start_time,
                        memory_used=False
                    )
                    
                    self._run_hooks('on_task_complete', task=task, response=response)
                    self._add_to_history(task, response)
                    return response
                else:
                    self.logger.warning(f"⚠️ {verification_message}")
                    step.state = AgentState.FAILED
                    step.error = verification_message
                    self.steps.append(step)
                    
                    # Добавляем в контекст для следующего планирования
                    context += f"\nШаг {step_number}: {action.get('action')} — {'успешно' if result.success else 'ошибка'}: {verification_message}"
                    
                    # Анализируем ошибку
                    if self.planner.is_model_loaded():
                        self.state = AgentState.REFLECTING
                        reflection = self.planner.reflect_on_error(
                            task=task,
                            attempts=context,
                            error=verification_message
                        )
                        context += f"\nАнализ: {reflection}"
                    
                    self._run_hooks('on_step_complete', step=step)
            
            # Превышен лимит шагов
            self.logger.error(f"❌ Превышен лимит шагов ({max_steps})")
            self.state = AgentState.FAILED
            self.session_stats['tasks_failed'] += 1
            
            response = AgentResponse(
                success=False,
                message=f"Не удалось решить задачу за {max_steps} шагов",
                steps=self.steps,
                total_steps=len(self.steps),
                total_time=time.time() - self.start_time,
                error="Step limit exceeded"
            )
            
            self._run_hooks('on_task_complete', task=task, response=response)
            self._add_to_history(task, response)
            return response
            
        except Exception as e:
            self.logger.error(f"💥 Критическая ошибка: {str(e)}")
            self.logger.error(traceback.format_exc())
            
            self.state = AgentState.FAILED
            self.session_stats['tasks_failed'] += 1
            
            response = AgentResponse(
                success=False,
                message=f"Произошла ошибка: {str(e)}",
                steps=self.steps,
                total_steps=len(self.steps),
                total_time=time.time() - self.start_time,
                error=str(e)
            )
            
            self._run_hooks('on_error', error=e)
            self._add_to_history(task, response)
            return response
            
        finally:
            # Восстанавливаем auto_confirm
            if auto_confirm is not None:
                self.safety_checker.auto_confirm = old_auto_confirm
            
            self.session_stats['total_time'] += time.time() - self.start_time
    
    def _plan_action(self, task: str, context: str) -> Optional[Dict[str, Any]]:
        """
        Планирует следующее действие.
        
        1. Пробует deterministic parse_task у каждого инструмента
        2. Если не получилось — спрашивает LLM (только имя инструмента)
        """
        # 1. Deterministic: каждый инструмент пробует сам извлечь параметры
        for tool in self.tool_registry.get_all_tools():
            if hasattr(tool, 'parse_task'):
                try:
                    params = tool.parse_task(task)
                    if params:
                        self.logger.info(f"   Deterministic: {tool.name}")
                        return {
                            'action': tool.name,
                            'input': params,
                            'reasoning': f'Parsed by {tool.name}'
                        }
                except Exception:
                    pass
        
        # 2. LLM: выбор инструмента с описаниями
        tools_list = []
        for t in self.tool_registry.get_all_tools():
            desc = t.description[:60] if hasattr(t, 'description') else t.name
            tools_list.append(f"{t.name} - {desc}")
        tools_description = "\n".join(tools_list)
        
        result = self.planner.plan(
            task=task if not context else f"{task}\n\nКонтекст:\n{context}",
            mode=PlannerMode.TOOL_CALL,
            history=[],
            tools_description=tools_description
        )
        
        if result.content and isinstance(result.content, dict):
            tool_name = result.content.get('tool', '')
            if tool_name and self.tool_registry.has_tool(tool_name):
                self.logger.info(f"   LLM selected: {tool_name}")
                # Извлекаем все поля кроме 'tool' как параметры
                params = result.content.get("input", {})
                
                if params is None:
                    params = {k: v for k, v in result.content.items() if k != "tool"}
    
                return {
                    'action': tool_name,
                    'input': params,
                    'reasoning': f'LLM selected: {tool_name}'
                }
        
        self.logger.info(f"   RAW: {result.raw_response[:200]}")
        return None
    
    def _check_safety(self, action: Dict[str, Any]) -> SafetyCheck:
        """
        Проверяет безопасность действия.
        
        Args:
            action: Словарь с действием
            
        Returns:
            SafetyCheck
        """
        action_name = action.get('action', '')
        action_input = action.get('input', {})
        
        if action_name == 'bash':
            command = action_input.get('command', '')
            return self.safety_checker.check_command(command)
        
        elif action_name in ('read_file', 'write_file', 'file_operations'):
            path = action_input.get('path', '')
            operation = 'read' if action_name == 'read_file' else 'write'
            if action_name == 'file_operations':
                operation = action_input.get('operation', 'read')
            return self.safety_checker.check_file_operation(path, operation)
        
        elif action_name in ('web_search', 'web_fetch', 'web_api', 'web_download', 'generate_code'):
            url = action_input.get('url', action_input.get('query', ''))
            return self.safety_checker.check_network_request(url)
        
        # По умолчанию — разрешено
        return SafetyCheck(passed=True, reason="OK")
    
    def _execute_action(self, action: Dict[str, Any]) -> ToolResult:
        """
        Выполняет действие через реестр инструментов.
        Автоматически следует next_action если есть.
        
        Args:
            action: Словарь с действием
            
        Returns:
            ToolResult
        """
        action_name = action.get('action', '')
        action_input = action.get('input', {})
        
        # Автозаполнение для generate_code
        if action_name == 'generate_code':
            if not action_input.get('description'):
                action_input['description'] = self.current_task
            if not action_input.get('language'):
                # Определяем язык
                task_lower = self.current_task.lower()
                for lang, keywords in [('python', ['python', 'питон']), 
                                       ('html', ['html', 'веб', 'калькулятор']),
                                       ('bash', ['bash', 'sh', 'скрипт'])]:
                    if any(k in task_lower for k in keywords):
                        action_input['language'] = lang
                        break
                else:
                    action_input['language'] = 'html'
        
        # Проверяем существование инструмента
        if not self.tool_registry.has_tool(action_name):
            return ToolResult(
                success=False,
                error=f"Инструмент не найден: {action_name}. "
                      f"Доступные: {', '.join(self.tool_registry.get_tool_names())}"
            )
        
        # Вызываем инструмент
        result = self.tool_registry.call_tool(action_name, action_input)
        
        # Автоматически выполняем next_action если есть
        if result.success and result.next_action:
            self.logger.info(f"   ↳ chain: {result.next_action.get('action', '')}")
            return self._execute_action(result.next_action)
    
        return result
    
    def _verify_result(self, task: str, result: ToolResult) -> Tuple[bool, str]:
        """
        Проверяет, достигнут ли ожидаемый результат.
        
        Args:
            task: Исходная задача
            result: Результат выполнения
            
        Returns:
            (успешно, сообщение)
        """
        if not result.success:
            return False, f"Инструмент вернул ошибку: {result.error}"
        
        return True, "Инструмент выполнен успешно"
    
    def _execute_cached_solution(self, memory_result) -> Optional[ToolResult]:
        """
        Выполняет решение из памяти.
        
        Args:
            memory_result: Результат поиска в памяти
            
        Returns:
            ToolResult или None
        """
        solution = memory_result.solution
        
        if 'action' in solution and 'input' in solution:
            action = {
                'action': solution['action'],
                'input': solution['input']
            }
            
            # Проверяем безопасность
            safety_check = self._check_safety(action)
            if not safety_check.passed:
                self.logger.warning(f"Кешированное решение заблокировано: {safety_check.reason}")
                return None
            
            # Выполняем
            return self._execute_action(action)
        
        return None
    
    def _is_executable_solution(self, solution: Dict) -> bool:
        """Проверяет, является ли решение исполняемым действием."""
        return 'action' in solution and 'input' in solution
    
    def _save_successful_solution(self, task: str, action: Dict, result: ToolResult):
        """
        Сохраняет успешное решение в память.
        
        Args:
            task: Задача
            action: Выполненное действие
            result: Результат
        """
        try:
            action_name = action.get('action', '')
            
            # Определяем теги на основе действия
            tags = [action_name]
            if action_name == 'bash':
                tags.append('command')
            elif action_name in ('web_search', 'web_fetch'):
                tags.append('web')
            elif action_name in ('read_file', 'write_file', 'file_operations'):
                tags.append('file')
            elif action_name == 'generate_code':
                tags.append('generation')
            
            # Сохраняем
            self.memory_manager.save_solution(
                task=task,
                solution={
                    'action': action_name,
                    'input': action.get('input', {}),
                    'result_summary': str(result.data)[:500] if result.data else ''
                },
                solution_type='action',
                tags=tags,
                tools_used=[action_name]
            )
            
            self.logger.info("💾 Решение сохранено в память")
            
        except Exception as e:
            self.logger.warning(f"Не удалось сохранить в память: {e}")
    
    def _format_result_message(self, result: ToolResult) -> str:
        """
        Форматирует результат для пользователя.
        
        Args:
            result: Результат выполнения
            
        Returns:
            Отформатированное сообщение
        """
        if not result.data:
            return "Выполнено"
        
        # Для разных инструментов — разное форматирование
        if 'stdout' in result.data:
            return result.data['stdout'][:1000]
        
        if 'content' in result.data:
            return result.data['content'][:1000]
        
        if 'code' in result.data:
            return f"Код сгенерирован ({len(result.data['code'])} символов) и сохранен в {result.data.get('filename', 'файл')}"
        
        if 'results' in result.data:
            return f"Найдено результатов: {len(result.data['results'])}"
        
        if 'items' in result.data:
            items = result.data['items'][:10]
            return '\n'.join([
                f"  {'📁' if item.get('type') == 'directory' else '📄'} {item['name']}"
                for item in items
            ])
        
        return str(result.data)[:1000]
    
    def _confirm_action(self, action: str, details: str) -> bool:
        """
        Callback для подтверждения опасных действий.
        
        Args:
            action: Описание действия
            details: Детали
            
        Returns:
            True если подтверждено
        """
        print(f"\n{'='*50}")
        print(f"⚠️  ТРЕБУЕТСЯ ПОДТВЕРЖДЕНИЕ")
        print(f"Действие: {action}")
        if details:
            print(f"Детали: {details[:500]}")
        print(f"{'='*50}")
        
        while True:
            response = input("Разрешить? [y/N]: ").strip().lower()
            if response in ('y', 'yes', 'да'):
                return True
            elif response in ('', 'n', 'no', 'нет'):
                return False
    
    def _add_to_history(self, task: str, response: AgentResponse):
        """Добавляет диалог в историю."""
        self.conversation_history.append({
            'task': task,
            'response': response.to_dict(),
            'timestamp': get_timestamp()
        })
        
        # Сохраняем в файл
        if self.config.save_history:
            try:
                history_path = self.config.history_path
                Path(os.path.dirname(history_path)).mkdir(parents=True, exist_ok=True)
                
                with open(history_path, 'a', encoding='utf-8') as f:
                    json.dump({
                        'task': task,
                        'response': response.to_dict(),
                        'timestamp': get_timestamp()
                    }, f, ensure_ascii=False)
                    f.write('\n')
            except Exception:
                pass
    
    def add_hook(self, event: str, callback: Callable):
        """
        Добавляет хук на событие.
        
        Args:
            event: Событие (on_step_start, on_step_complete, on_task_start, on_task_complete, on_error)
            callback: Функция-обработчик
        """
        if event in self.hooks:
            self.hooks[event].append(callback)
    
    def _run_hooks(self, event: str, **kwargs):
        """Запускает хуки для события."""
        for callback in self.hooks.get(event, []):
            try:
                callback(**kwargs)
            except Exception as e:
                self.logger.warning(f"Ошибка в хуке {event}: {e}")
    
    def get_statistics(self) -> Dict[str, Any]:
        """Возвращает полную статистику агента."""
        return {
            'session': self.session_stats,
            'state': self.state.value,
            'memory': self.memory_manager.get_statistics() if self.memory_manager else {},
            'tools': self.tool_registry.get_statistics() if self.tool_registry else {},
            'safety': self.safety_checker.get_statistics() if self.safety_checker else {},
            'planner': self.planner.get_statistics() if self.planner else {},
            'conversation_count': len(self.conversation_history)
        }
    
    def get_last_steps(self, n: int = 5) -> List[Dict]:
        """Возвращает последние n шагов."""
        return [s.to_dict() for s in self.steps[-n:]]
    
    def reset_session(self):
        """Сбрасывает состояние сессии."""
        self.state = AgentState.IDLE
        self.current_task = ""
        self.steps = []
        self.start_time = 0.0
    
    def stop(self):
        """Останавливает агента."""
        self.state = AgentState.STOPPED
        self.logger.info("🛑 Агент остановлен")
    
    def health_check(self) -> Dict[str, Any]:
        """Проверяет состояние всех компонентов."""
        return {
            'state': self.state.value,
            'planner_loaded': self.planner.is_model_loaded(),
            'memory_healthy': self.memory_manager.health_check() if self.memory_manager else False,
            'tools_count': len(self.tool_registry.get_tool_names()) if self.tool_registry else 0,
            'safety_level': self.safety_checker.safety_level.value if self.safety_checker else 'unknown'
        }