agent.py

"""
TenderScope AI Agent — Интеллектуальный агент для работы с тендерами.

Обрабатывает запросы на естественном языке и вызывает MCP-инструменты.
Идеально для демонстрации на хакатоне.
"""

import asyncio
import json
import logging
from typing import Any, Dict, List, Optional
from dataclasses import dataclass

from dotenv import load_dotenv
load_dotenv()  # Загружаем .env перед импортом клиентов

from src.common.llm_client import LLMClient, LLMMessage
from src.common.utils import get_env_var

logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s - %(levelname)s - %(message)s",
)
logger = logging.getLogger(__name__)


# Описание доступных инструментов для LLM
TOOLS_DESCRIPTION = """
Доступные инструменты MCP-сервера TenderScope:

1. search_tenders(keywords, min_budget?, max_budget?, region?, deadline_days?)
   - Поиск тендеров по ключевым словам
   - keywords: строка для поиска (обязательно)
   - min_budget: минимальный бюджет в рублях (число)
   - max_budget: максимальный бюджет в рублях (число)
   - region: регион (например: "Москва")
   - deadline_days: дней до дедлайна (по умолчанию 30)

2. get_tender_details(tender_id)
   - Получение детальной информации о тендере
   - tender_id: ID тендера (строка)

3. get_tender_documents(tender_id, doc_type?)
   - Получение документов тендера
   - tender_id: ID тендера (строка)
   - doc_type: тип документа (tz/contract/requirements/other)

4. score_tender(tender_id, title, requirements, budget?, customer_type?)
   - Скоринг тендера на основе базы знаний компании
   - tender_id: ID тендера
   - title: название тендера
   - requirements: список требований (массив строк)
   - budget: бюджет в рублях
   - customer_type: "госзаказ" или "коммерция"

5. compare_tenders(tenders)
   - Сравнение нескольких тендеров
   - tenders: массив объектов {tender_id, title, budget, score?, requirements?}

6. get_company_history(include_projects?, technology_filter?, customer_type?)
   - История участия компании в тендерах
   - include_projects: включить список проектов (bool)
   - technology_filter: фильтр по технологии
   - customer_type: "госзаказ" или "коммерция"
"""

SYSTEM_PROMPT = f"""Ты — TenderScope AI, интеллектуальный ассистент тендерного отдела IT-компании.

Твоя задача — помогать менеджерам находить и анализировать государственные закупки.

{TOOLS_DESCRIPTION}

ПРАВИЛА:
1. Анализируй запрос пользователя и определяй какие инструменты нужно вызвать
2. Возвращай JSON с планом действий в формате:
{{
    "thinking": "твои размышления о запросе",
    "actions": [
        {{"tool": "имя_инструмента", "params": {{параметры}}}}
    ],
    "response_plan": "как ты представишь результаты пользователю"
}}
3. Если нужно несколько инструментов — добавь их все в actions
4. Для поиска тендеров ВСЕГДА используй search_tenders первым
5. После поиска можно вызвать get_tender_details и score_tender для лучших результатов
6. Отвечай на русском языке
7. Будь конкретным в параметрах — если пользователь сказал "от 5 млн", то min_budget=5000000

ПРИМЕРЫ:

Запрос: "Найди тендеры на разработку ПО от 3 млн рублей"
Ответ:
{{
    "thinking": "Пользователь ищет тендеры на разработку ПО с минимальным бюджетом 3 млн",
    "actions": [
        {{"tool": "search_tenders", "params": {{"keywords": "разработка программного обеспечения", "min_budget": 3000000}}}}
    ],
    "response_plan": "Покажу список найденных тендеров с бюджетами и дедлайнами"
}}

Запрос: "Оцени тендер 0123456789 на разработку CRM"
Ответ:
{{
    "thinking": "Нужно получить детали тендера и оценить его релевантность",
    "actions": [
        {{"tool": "get_tender_details", "params": {{"tender_id": "0123456789"}}}},
        {{"tool": "score_tender", "params": {{"tender_id": "0123456789", "title": "Разработка CRM", "requirements": ["CRM", "веб-разработка"], "customer_type": "госзаказ"}}}}
    ],
    "response_plan": "Покажу детали тендера и оценку релевантности с рекомендацией"
}}

Запрос: "Сравни тендеры: CRM за 8 млн в Москве и мобильное приложение за 12 млн в Питере"
Ответ:
{{
    "thinking": "Нужно сравнить два тендера по бюджету, региону и другим параметрам",
    "actions": [
        {{"tool": "compare_tenders", "params": {{"tenders": [
            {{"tender_id": "tender1", "title": "Разработка CRM", "budget": 8000000, "region": "Москва"}},
            {{"tender_id": "tender2", "title": "Мобильное приложение", "budget": 12000000, "region": "Санкт-Петербург"}}
        ]}}}}
    ],
    "response_plan": "Покажу сравнительную таблицу и рекомендацию какой тендер лучше"
}}
"""


@dataclass
class AgentAction:
    """Действие агента."""
    tool: str
    params: Dict[str, Any]
    result: Optional[Any] = None
    error: Optional[str] = None


class TenderScopeAgent:
    """
    AI-агент TenderScope.
    
    Обрабатывает запросы на естественном языке,
    планирует действия и вызывает MCP-инструменты.
    """

    def __init__(self):
        self.llm = LLMClient()
        self.conversation_history: List[Dict[str, str]] = []

    async def process_query(self, user_query: str) -> str:
        """
        Обработка запроса пользователя.
        
        Args:
            user_query: Запрос на естественном языке
            
        Returns:
            Ответ агента
        """
        logger.info(f"📝 Получен запрос: {user_query}")
        
        # Шаг 1: Планирование действий через LLM
        plan = await self._plan_actions(user_query)
        if not plan:
            return "❌ Не удалось спланировать действия. Попробуйте переформулировать запрос."
        
        logger.info(f"🧠 План: {plan.get('thinking', '')}")
        
        # Шаг 2: Выполнение действий
        actions = plan.get("actions", [])
        results = []
        
        for action_data in actions:
            tool_name = action_data.get("tool")
            params = action_data.get("params", {})
            
            logger.info(f"🔧 Вызов инструмента: {tool_name}")
            
            result = await self._execute_tool(tool_name, params)
            results.append({
                "tool": tool_name,
                "params": params,
                "result": result,
            })
        
        # Шаг 3: Формирование ответа через LLM
        response = await self._generate_response(user_query, plan, results)
        
        return response

    async def _plan_actions(self, query: str) -> Optional[Dict]:
        """Планирование действий через LLM."""
        try:
            messages = [
                LLMMessage(role="system", content=SYSTEM_PROMPT),
                LLMMessage(role="user", content=query),
            ]
            
            response = self.llm.chat(messages, max_tokens=1000, temperature=0.3)
            content = response.content.strip()
            
            # Извлекаем JSON из ответа
            if "```json" in content:
                content = content.split("```json")[1].split("```")[0]
            elif "```" in content:
                content = content.split("```")[1].split("```")[0]
            
            # Убираем возможный thinking блок Qwen
            if content.startswith("<think>"):
                content = content.split("</think>")[-1].strip()
            
            return json.loads(content)
            
        except Exception as e:
            logger.error(f"❌ Ошибка планирования: {e}")
            # Fallback: простой поиск
            return {
                "thinking": "Fallback: простой поиск по запросу",
                "actions": [{"tool": "search_tenders", "params": {"keywords": query}}],
                "response_plan": "Покажу результаты поиска",
            }

    async def _execute_tool(self, tool_name: str, params: Dict) -> Any:
        """Выполнение MCP-инструмента через прямые вызовы."""
        try:
            # Используем прямые вызовы без MCP-обёртки
            from src.tools_direct import (
                search_tenders_direct,
                get_tender_details_direct,
                get_tender_documents_direct,
                score_tender_direct,
                compare_tenders_direct,
                get_company_history_direct,
            )
            
            if tool_name == "search_tenders":
                result = await search_tenders_direct(**params)
                return result.structured_content
                
            elif tool_name == "get_tender_details":
                result = await get_tender_details_direct(**params)
                return result.structured_content
                
            elif tool_name == "get_tender_documents":
                result = await get_tender_documents_direct(**params)
                return result.structured_content
                
            elif tool_name == "score_tender":
                result = await score_tender_direct(**params)
                return result.structured_content
                
            elif tool_name == "compare_tenders":
                result = await compare_tenders_direct(**params)
                return result.structured_content
                
            elif tool_name == "get_company_history":
                result = await get_company_history_direct(**params)
                return result.structured_content
                
            else:
                return {"error": f"Неизвестный инструмент: {tool_name}"}
                
        except Exception as e:
            logger.error(f"❌ Ошибка выполнения {tool_name}: {e}")
            import traceback
            traceback.print_exc()
            return {"error": str(e)}

    async def _generate_response(
        self,
        query: str,
        plan: Dict,
        results: List[Dict],
    ) -> str:
        """Генерация финального ответа через LLM."""
        
        # Формируем контекст для LLM
        results_text = json.dumps(results, ensure_ascii=False, indent=2, default=str)
        
        prompt = f"""Пользователь спросил: "{query}"

План действий: {plan.get('response_plan', '')}

Результаты выполнения инструментов:
{results_text}

Сформируй понятный и полезный ответ для пользователя на русском языке.
Используй эмодзи для наглядности.
Если найдены тендеры — покажи топ-3 с бюджетами.
Если есть скоринг — объясни рекомендацию.
Будь конкретным и полезным.
"""
        
        try:
            messages = [
                LLMMessage(role="system", content="Ты помощник тендерного отдела. Отвечай кратко и по делу на русском."),
                LLMMessage(role="user", content=prompt),
            ]
            
            response = self.llm.chat(messages, max_tokens=1500, temperature=0.5)
            content = response.content.strip()
            
            # Убираем thinking блок если есть
            if "<think>" in content:
                content = content.split("</think>")[-1].strip()
            
            return content
            
        except Exception as e:
            logger.error(f"❌ Ошибка генерации ответа: {e}")
            # Fallback: простой вывод результатов
            return self._format_results_simple(results)

    def _format_results_simple(self, results: List[Dict]) -> str:
        """Простое форматирование результатов (fallback)."""
        lines = ["📊 Результаты:\n"]
        
        for r in results:
            tool = r.get("tool", "unknown")
            result = r.get("result", {})
            
            if tool == "search_tenders":
                tenders = result.get("tenders", [])
                lines.append(f"🔍 Найдено тендеров: {len(tenders)}")
                for i, t in enumerate(tenders[:5], 1):
                    budget = t.get("budget", 0) / 1_000_000
                    lines.append(f"  {i}. {t.get('title', 'N/A')[:50]}... — {budget:.1f} млн руб")
                    
            elif tool == "score_tender":
                score = result.get("score", 0)
                rec = result.get("recommendation", "")
                lines.append(f"📊 Скоринг: {score}% — {rec}")
                
            elif tool == "get_company_history":
                stats = result.get("stats", {})
                lines.append(f"📈 Проектов: {stats.get('total_projects', 0)}, успех: {stats.get('success_rate', 0)}%")
        
        return "\n".join(lines)


async def demo_agent():
    """Демонстрация работы агента."""
    agent = TenderScopeAgent()
    
    print("=" * 60)
    print("🤖 TenderScope AI Agent — Демонстрация")
    print("=" * 60)
    print()
    
    # Демо-запросы
    demo_queries = [
        "Найди тендеры на разработку программного обеспечения с бюджетом от 3 миллионов рублей",
        "Покажи историю нашей компании по тендерам",
    ]
    
    for query in demo_queries:
        print(f"👤 Пользователь: {query}")
        print("-" * 40)
        
        response = await agent.process_query(query)
        
        print(f"🤖 TenderScope AI:\n{response}")
        print()
        print("=" * 60)
        print()


async def interactive_mode():
    """Интерактивный режим для демо."""
    agent = TenderScopeAgent()
    
    print("=" * 60)
    print("🤖 TenderScope AI Agent")
    print("   Интеллектуальный ассистент тендерного отдела")
    print("=" * 60)
    print()
    print("Примеры запросов:")
    print("  • Найди тендеры на разработку ПО от 5 млн")
    print("  • Покажи историю компании по тендерам")
    print("  • Найди тендеры на CRM-системы в Москве")
    print()
    print("Введите 'выход' для завершения")
    print("=" * 60)
    print()
    
    while True:
        try:
            query = input("👤 Вы: ").strip()
            
            if not query:
                continue
                
            if query.lower() in ["выход", "exit", "quit", "q"]:
                print("👋 До свидания!")
                break
            
            print()
            response = await agent.process_query(query)
            print(f"🤖 TenderScope AI:\n{response}")
            print()
            print("-" * 40)
            print()
            
        except KeyboardInterrupt:
            print("\n👋 До свидания!")
            break
        except Exception as e:
            print(f"❌ Ошибка: {e}")


if __name__ == "__main__":
    import sys
    
    if len(sys.argv) > 1 and sys.argv[1] == "--demo":
        asyncio.run(demo_agent())
    else:
        asyncio.run(interactive_mode())