Upload 19 files

__init__.py

@@ -0,0 +1,11 @@
+"""PinkSky v7.0 — модульная архитектура"""
+
+from .main import main
+from .config import PORT, TOKEN, API_KEY, API_BASE, HF_TOKEN
+from .state import STATE
+from .process_manager import PROCESS_MANAGER
+from .internet_agent import INTERNET_AGENT
+from .notification_system import NOTIFICATIONS
+
+__version__ = "7.0.0"
+__all__ = ["main", "STATE", "PROCESS_MANAGER", "INTERNET_AGENT", "NOTIFICATIONS"]

build_mode_editor.py

@@ -0,0 +1,68 @@
+"""Build Mode Editor — управление режимами сборки"""
+
+import os
+import json
+from typing import Dict
+from .config import BUILD_MODES_FILE
+
+class BuildModeEditor:
+    def __init__(self, state):
+        self.state = state
+    
+    def list_modes(self) -> str:
+        modes = self._load_all_modes()
+        if not modes:
+            return "📋 Нет сохранённых режимов сборки"
+        lines = ["📋 Режимы сборки:"]
+        for name, config in modes.items():
+            lines.append(f"- {name}: {config.get('description', 'No description')}")
+        return "\n".join(lines)
+    
+    def show_mode(self, mode_name: str) -> str:
+        modes = self._load_all_modes()
+        mode = modes.get(mode_name)
+        if not mode:
+            return f"❌ Режим '{mode_name}' не найден"
+        return f"📋 {mode_name}:\n```json\n{json.dumps(mode, ensure_ascii=False, indent=2)}\n```"
+    
+    def save_mode(self, mode_name: str, config: Dict = None) -> str:
+        modes = self._load_all_modes()
+        if config is None:
+            config = dict(self.state.build_context)
+            config["description"] = f"Mode created {datetime.now().isoformat()}"
+        modes[mode_name] = config
+        try:
+            with open(BUILD_MODES_FILE, "w", encoding="utf-8") as f:
+                json.dump(modes, f, ensure_ascii=False, indent=2)
+            return f"✅ Режим '{mode_name}' сохранён"
+        except Exception as e:
+            return f"❌ Ошибка сохранения: {e}"
+    
+    def load_mode(self, mode_name: str) -> str:
+        modes = self._load_all_modes()
+        mode = modes.get(mode_name)
+        if not mode:
+            return f"❌ Режим '{mode_name}' не найден"
+        self.state.build_context.update(mode)
+        return f"✅ Режим '{mode_name}' загружен"
+    
+    def delete_mode(self, mode_name: str) -> str:
+        modes = self._load_all_modes()
+        if mode_name not in modes:
+            return f"❌ Режим '{mode_name}' не найден"
+        del modes[mode_name]
+        try:
+            with open(BUILD_MODES_FILE, "w", encoding="utf-8") as f:
+                json.dump(modes, f, ensure_ascii=False, indent=2)
+            return f"🗑️ Режим '{mode_name}' удалён"
+        except Exception as e:
+            return f"❌ Ошибка удаления: {e}"
+    
+    def _load_all_modes(self) -> Dict:
+        if not os.path.exists(BUILD_MODES_FILE):
+            return {}
+        try:
+            with open(BUILD_MODES_FILE, "r", encoding="utf-8") as f:
+                return json.load(f)
+        except:
+            return {}

conductor_engine.py

@@ -0,0 +1,163 @@
+"""Conductor Engine — оркестрация Build режима"""
+
+import threading
+import json
+import re
+from typing import Dict, List, Optional, Any
+from .models import Role, Conductor
+from .universal_agent import UniversalAgent
+from .state import STATE
+from .process_manager import PROCESS_MANAGER
+from .notification_system import NOTIFICATIONS
+
+class ConductorEngine:
+    def __init__(self, state):
+        self.state = state
+        self.use_interpreter = state.build_context.get("use_interpreter", True)
+        self.notifications = NOTIFICATIONS
+    
+    def orchestrate(self, user_request: str, chat_id: str = None, file_context: str = "", 
+                    build_params: Dict[str, Any] = None) -> str:
+        conductor = self.state.conductors.get(self.state.current_conductor, self.state.conductors["default"])
+        plan = self._get_plan(conductor, user_request, file_context, chat_id)
+        if not plan:
+            return "❌ Conductor не смог создать план."
+        results = self._execute_plan(plan, chat_id)
+        if len(results) == 1:
+            return results[0]
+        return self._synthesize(conductor, user_request, results, chat_id)
+    
+    def _get_plan(self, conductor: Conductor, user_request: str, file_context: str, chat_id: str = None) -> Optional[Dict]:
+        full_prompt = f"{user_request}\n\n{file_context}".strip()
+        rank_by = conductor.auto_rank_by
+        if conductor.cost_aware and rank_by == "coding":
+            rank_by = "balanced"
+        model_name = self.state.get_best_model(rank_by=rank_by, max_tier=2)
+        model = self.state.models.get(model_name, self.state.models["deepseek-v4-pro"])
+        conductor_role = Role(name="conductor", prompt=conductor.prompt, description="Internal conductor role")
+        agent = UniversalAgent(conductor_role, model)
+
+        roles_info = "\n".join([f"- {k}: {v.description} (complexity: {v.complexity}, preferred: {', '.join(v.preferred_models)})"
+                                 for k, v in self.state.roles.items()])
+        models_info = "\n".join([f"- {k}: coding_rank={v.coding_rank}, speed_rank={v.speed_rank}, reasoning_rank={v.reasoning_rank}, cost=${v.cost_per_1k_output}/1k"
+                                  for k, v in sorted(self.state.models.items(), key=lambda x: x[1].coding_rank) if k != "hf_fallback"])
+
+        plan_prompt = f"""User request: {full_prompt}
+
+AVAILABLE ROLES:
+{roles_info}
+
+AVAILABLE MODELS (sorted by coding rank):
+{models_info}
+
+Current selection criteria: {conductor.auto_rank_by}
+Cost-aware: {conductor.cost_aware}
+
+Create execution plan."""
+
+        try:
+            plan_text = agent.execute(plan_prompt)
+            json_match = re.search(r'\{.*\}', plan_text, re.DOTALL)
+            if json_match:
+                return json.loads(json_match.group())
+            else:
+                return {
+                    "strategy": "single",
+                    "tasks": [{"role": self.state.current_role, "model": self.state.get_model_for_role(self.state.current_role), "prompt": full_prompt}],
+                    "synthesis_prompt": ""
+                }
+        except Exception as e:
+            print(f"Planning error: {e}")
+            return {
+                "strategy": "single",
+                "tasks": [{"role": self.state.current_role, "model": self.state.get_model_for_role(self.state.current_role), "prompt": full_prompt}],
+                "synthesis_prompt": ""
+            }
+
+    def _execute_plan(self, plan: Dict, chat_id: str = None) -> List[str]:
+        tasks = plan.get("tasks", [])
+        strategy = plan.get("strategy", "single")
+        results = []
+
+        if strategy == "parallel" and len(tasks) > 1:
+            threads = []
+            result_container = {}
+
+            def run_task(idx, task):
+                if PROCESS_MANAGER.is_cancelled():
+                    result_container[idx] = "Cancelled"
+                    return
+                role_name = task.get("role", self.state.current_role)
+                model_name = task.get("model", self.state.current_model)
+                prompt = task.get("prompt", "")
+                if model_name not in self.state.models:
+                    model_name = self.state.get_model_for_role(role_name)
+                role = self.state.roles.get(role_name, self.state.roles["universal"])
+                model = self.state.models.get(model_name, self.state.models["deepseek-v4-pro"])
+                use_interp = self._should_use_interpreter(role_name, prompt)
+                agent = UniversalAgent(role, model, use_interpreter=use_interp)
+                try:
+                    result = agent.execute(prompt, chat_id=chat_id)
+                    result_container[idx] = result
+                except Exception as e:
+                    result_container[idx] = f"Task {idx} error: {e}"
+
+            for i, task in enumerate(tasks):
+                t = threading.Thread(target=run_task, args=(i, task))
+                threads.append(t)
+                PROCESS_MANAGER.register_thread(t)
+                t.start()
+            for t in threads:
+                t.join(timeout=120)
+            results = [result_container.get(i, "Timeout") for i in range(len(tasks))]
+        else:
+            for task in tasks:
+                if PROCESS_MANAGER.is_cancelled():
+                    results.append("Cancelled")
+                    continue
+                role_name = task.get("role", self.state.current_role)
+                model_name = task.get("model", self.state.current_model)
+                prompt = task.get("prompt", "")
+                if model_name not in self.state.models:
+                    model_name = self.state.get_model_for_role(role_name)
+                role = self.state.roles.get(role_name, self.state.roles["universal"])
+                model = self.state.models.get(model_name, self.state.models["deepseek-v4-pro"])
+                use_interp = self._should_use_interpreter(role_name, prompt)
+                agent = UniversalAgent(role, model, use_interpreter=use_interp)
+                try:
+                    result = agent.execute(prompt, chat_id=chat_id)
+                    results.append(result)
+                except Exception as e:
+                    results.append(f"Error: {e}")
+        return results
+
+    def _should_use_interpreter(self, role_name: str, task: str) -> bool:
+        code_roles = ["guru", "hacker", "sdet", "qa", "evangelist"]
+        if role_name in code_roles:
+            return True
+        code_keywords = ["код", "напиши", "создай", "файл", "исполни", "запусти", "отладить", "исправить", "проверить", "тест"]
+        if any(kw in task.lower() for kw in code_keywords):
+            return True
+        if "тест" in task.lower() or "проверк" in task.lower():
+            return True
+        return False
+    
+    def _synthesize(self, conductor: Conductor, original_request: str, results: List[str], chat_id: str = None) -> str:
+        synthesis_prompt = conductor.prompt + f"""
+
+Synthesize multiple agent results into a single answer.
+
+Original request: {original_request}
+
+Agent results:
+"""
+        for i, res in enumerate(results):
+            synthesis_prompt += f"\n--- Agent {i+1} result ---\n{res}\n"
+        synthesis_role = Role(name="synthesizer", prompt="You synthesize agent results.", description="Synthesizer")
+        synth_model_name = self.state.get_best_model(rank_by="reasoning", max_tier=2)
+        model = self.state.models.get(synth_model_name, self.state.models["deepseek-v4-pro"])
+        agent = UniversalAgent(synthesis_role, model)
+        try:
+            return agent.execute(synthesis_prompt, chat_id=chat_id)
+        except Exception as e:
+            return "\n\n---\n".join(results)

config.py

@@ -0,0 +1,65 @@
+"""Конфигурация приложения и DNS resolver"""
+
+import os
+import json
+import urllib.request
+import socket
+
+# === ENVIRONMENT CONFIG ===
+PORT = 7860
+TOKEN = os.environ.get("TELEGRAM_BOT_TOKEN", "").strip()
+ALLOWED_USER = os.environ.get("TELEGRAM_ALLOWED_USERS", "").strip()
+CF_URL = os.environ.get("CF_WORKER_URL", "").rstrip('/')
+
+# NVIDIA API
+API_KEY = os.environ.get("NVIDIA_API_KEY", os.environ.get("OPENAI_API_KEY", "")).strip()
+API_BASE = os.environ.get("NVIDIA_API_BASE", os.environ.get("OPENAI_API_BASE", "")).strip().rstrip('/')
+if API_BASE and not API_BASE.endswith("/v1"):
+    API_BASE += "/v1"
+
+HF_TOKEN = os.environ.get("HF_TOKEN", "").strip()
+HF_FALLBACK_MODEL = "Qwen/Qwen2.5-72B-Instruct"
+
+# === FILE PATHS ===
+ROLES_FILE = "prompts/roles.json"
+MODELS_FILE = "prompts/models.json"
+CONDUCTORS_FILE = "prompts/conductors.json"
+HISTORY_FILE = "prompts/history.json"
+BUILD_MODES_FILE = "prompts/build_modes.json"
+
+# === CUSTOM DNS RESOLVER ===
+HF_DOMAIN = "api-inference.huggingface.co"
+resolved_hf_ip = None
+
+def get_hf_ip_via_google():
+    global resolved_hf_ip
+    if resolved_hf_ip:
+        return resolved_hf_ip
+    try:
+        req = urllib.request.Request(f"https://dns.google/resolve?name={HF_DOMAIN}&type=A")
+        with urllib.request.urlopen(req, timeout=5) as response:
+            data = json.loads(response.read().decode('utf-8'))
+            for answer in data.get("Answer", []):
+                if answer.get("type") == 1:
+                    resolved_hf_ip = answer.get("data")
+                    print(f"[DNS] Got HF IP via Google: {resolved_hf_ip}")
+                    return resolved_hf_ip
+    except Exception as e:
+        print(f"[DNS] Google DoH failed: {e}")
+    return None
+
+original_getaddrinfo = socket.getaddrinfo
+
+def custom_getaddrinfo(host, port, family=0, type=0, proto=0, flags=0):
+    if host == HF_DOMAIN:
+        ip = get_hf_ip_via_google()
+        if ip:
+            return [(socket.AF_INET, socket.SOCK_STREAM, socket.IPPROTO_TCP, '', (ip, port))]
+    return original_getaddrinfo(host, port, family, type, proto, flags)
+
+socket.getaddrinfo = custom_getaddrinfo
+
+# === FOLDERS ===
+def ensure_folders():
+    for folder in ["skills", "projects", "downloads", "prompts", "build_modes"]:
+        os.makedirs(folder, exist_ok=True)

file_manager.py

@@ -0,0 +1,104 @@
+"""Работа с файлами"""
+
+import os
+import fnmatch
+from typing import Dict, List, Tuple, Any
+from datetime import datetime
+
+class FileManager:
+    SUPPORTED_EXTENSIONS = {
+        '.txt': 'text', '.py': 'python', '.js': 'javascript',
+        '.html': 'html', '.css': 'css', '.json': 'json',
+        '.yaml': 'yaml', '.yml': 'yaml', '.md': 'markdown',
+        '.csv': 'csv', '.xml': 'xml', '.log': 'log',
+        '.sql': 'sql', '.sh': 'bash', '.bat': 'batch',
+        '.ps1': 'powershell', '.ipynb': 'jupyter',
+    }
+
+    def __init__(self, base_dir: str = "."):
+        self.base_dir = base_dir
+
+    def read_file(self, file_path: str, max_size: int = 100000) -> Tuple[str, str]:
+        full_path = os.path.join(self.base_dir, file_path)
+        if not os.path.exists(full_path):
+            return ("", f"❌ Файл не найден: {file_path}")
+        try:
+            size = os.path.getsize(full_path)
+            if size > max_size:
+                return ("", f"⚠️ Файл слишком большой ({size} bytes > {max_size})")
+            with open(full_path, 'r', encoding='utf-8', errors='ignore') as f:
+                content = f.read()
+            ext = os.path.splitext(file_path)[1].lower()
+            lang = self.SUPPORTED_EXTENSIONS.get(ext, 'text')
+            return (content, f"✅ Прочитано {len(content)} chars ({lang})")
+        except Exception as e:
+            return ("", f"❌ Ошибка чтения: {e}")
+
+    def read_multiple_files(self, file_paths: List[str], max_total: int = 50000) -> Dict[str, Tuple[str, str]]:
+        results = {}
+        total = 0
+        for fp in file_paths:
+            content, status = self.read_file(fp)
+            if content:
+                total += len(content)
+                if total > max_total:
+                    results[fp] = ("", "⚠️ Превышен общий лимит")
+                    break
+            results[fp] = (content, status)
+        return results
+
+    def list_files(self, directory: str = ".", pattern: str = "*", recursive: bool = False) -> List[str]:
+        base = os.path.join(self.base_dir, directory)
+        if not os.path.exists(base):
+            return []
+        results = []
+        if recursive:
+            for root, dirs, files in os.walk(base):
+                for f in files:
+                    rel = os.path.relpath(os.path.join(root, f), self.base_dir)
+                    if self._match_pattern(f, pattern):
+                        results.append(rel)
+        else:
+            for f in os.listdir(base):
+                if os.path.isfile(os.path.join(base, f)) and self._match_pattern(f, pattern):
+                    results.append(os.path.join(directory, f))
+        return results
+
+    def save_file(self, file_path: str, content: str) -> str:
+        full_path = os.path.join(self.base_dir, file_path)
+        try:
+            os.makedirs(os.path.dirname(full_path), exist_ok=True)
+            with open(full_path, 'w', encoding='utf-8') as f:
+                f.write(content)
+            return f"✅ Сохранено: {file_path} ({len(content)} chars)"
+        except Exception as e:
+            return f"❌ Ошибка сохранения: {e}"
+
+    def analyze_file(self, file_path: str) -> Dict[str, Any]:
+        full_path = os.path.join(self.base_dir, file_path)
+        if not os.path.exists(full_path):
+            return {"error": "Файл не найден"}
+        try:
+            stat = os.stat(full_path)
+            ext = os.path.splitext(file_path)[1].lower()
+            lang = self.SUPPORTED_EXTENSIONS.get(ext, 'unknown')
+            with open(full_path, 'r', encoding='utf-8', errors='ignore') as f:
+                content = f.read()
+            lines = content.count('\n') + 1
+            return {
+                "path": file_path,
+                "size": stat.st_size,
+                "lines": lines,
+                "language": lang,
+                "modified": datetime.fromtimestamp(stat.st_mtime).isoformat(),
+                "chars": len(content)
+            }
+        except Exception as e:
+            return {"error": str(e)}
+
+    def _match_pattern(self, filename: str, pattern: str) -> bool:
+        if pattern == "*":
+            return True
+        return fnmatch.fnmatch(filename, pattern)
+
+FILE_MANAGER = FileManager()

helpers.py

@@ -0,0 +1,58 @@
+"""Вспомогательные функции"""
+
+import re
+from typing import Dict, List, Tuple, Any
+from .state import STATE
+
+def build_skill_prompt(new_request: str, file_context: str = "") -> str:
+    history = STATE.skill_history[-5:] if STATE.skill_history else []
+    context = ""
+    for entry in history:
+        context += f"\n{entry['role']}: {entry['content'][:500]}"
+    prompt = f"Previous context:{context}\n\nNew request: {new_request}"
+    if file_context:
+        prompt += f"\n\nFile context:\n{file_context}"
+    return prompt
+
+def parse_build_args(text: str) -> Tuple[Dict[str, Any], str]:
+    params = {}
+    # --agents=N
+    agents_match = re.search(r'--agents=(\d+)', text)
+    if agents_match:
+        params["agents"] = int(agents_match.group(1))
+        text = text.replace(agents_match.group(0), "")
+    # --tier=tier1|tier2|...
+    tier_match = re.search(r'--tier=(\w+)', text)
+    if tier_match:
+        params["tier"] = tier_match.group(1)
+        text = text.replace(tier_match.group(0), "")
+    # --interpreter=true|false
+    interp_match = re.search(r'--interpreter=(true|false)', text, re.IGNORECASE)
+    if interp_match:
+        params["use_interpreter"] = interp_match.group(1).lower() == "true"
+        text = text.replace(interp_match.group(0), "")
+    return params, text.strip()
+
+def parse_skill_args(text: str) -> Tuple[Dict[str, Any], str]:
+    params = {}
+    # --agents=role1,role2
+    agents_match = re.search(r'--agents=([\w,]+)', text)
+    if agents_match:
+        params["agents"] = agents_match.group(1).split(",")
+        text = text.replace(agents_match.group(0), "")
+    # --internet
+    if "--internet" in text:
+        params["internet"] = True
+        text = text.replace("--internet", "")
+    return params, text.strip()
+
+def parse_skill_agents(text: str) -> Tuple[List[str], str]:
+    params, clean = parse_skill_args(text)
+    return params.get("agents", []), clean
+
+def get_current_mode_info() -> str:
+    mode = STATE.current_mode
+    role = STATE.current_role
+    model = STATE.current_model
+    conductor = STATE.current_conductor
+    return f"🎛️ Режим: {mode} | Роль: {role} | Модель: {model} | Кондуктор: {conductor}"

internet_agent.py

@@ -0,0 +1,259 @@
+"""Бесплатный интернет-агент с минимум 3 способами поиска"""
+
+import re
+import requests
+import hashlib
+from datetime import datetime, timedelta
+from typing import Dict, List, Tuple, Any, Optional
+from collections import Counter
+
+class FreeInternetAgent:
+    """Интернет-агент с бесплатными поисковыми системами (минимум 3 способа)"""
+    
+    def __init__(self, cache_ttl: int = 3600):
+        self.session = requests.Session()
+        self.session.headers.update({
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
+        })
+        self.cache: Dict[str, Tuple[Any, datetime]] = {}
+        self.cache_ttl = cache_ttl
+        self._has_bs4 = False
+        try:
+            import bs4
+            self._has_bs4 = True
+        except ImportError:
+            pass
+        
+        # SearXNG инстансы
+        self.searxng_instances = [
+            "https://searx.be",
+            "https://search.bus-hit.me",
+            "https://searx.nixnet.xyz",
+            "https://searx.tuxcloud.net",
+            "https://searx.moe",
+        ]
+    
+    def _get_cache_key(self, *args, **kwargs) -> str:
+        key = f"{args}_{sorted(kwargs.items())}"
+        return hashlib.md5(key.encode()).hexdigest()
+    
+    def _get_from_cache(self, key: str) -> Optional[Any]:
+        if key in self.cache:
+            data, timestamp = self.cache[key]
+            if datetime.now() - timestamp < timedelta(seconds=self.cache_ttl):
+                return data
+            else:
+                del self.cache[key]
+        return None
+    
+    def _save_to_cache(self, key: str, data: Any) -> None:
+        self.cache[key] = (data, datetime.now())
+    
+    def search_web(self, query: str, num_results: int = 5) -> List[Dict[str, str]]:
+        """Умный поиск с несколькими источниками (минимум 3 способа)"""
+        cache_key = self._get_cache_key('search', query, num_results)
+        cached = self._get_from_cache(cache_key)
+        if cached is not None:
+            return cached
+        
+        results = []
+        
+        # Способ 1: SearXNG (мета-поиск)
+        results = self._search_searxng(query, num_results)
+        
+        # Способ 2: DuckDuckGo API
+        if not results:
+            results = self._search_duckduckgo(query, num_results)
+        
+        # Способ 3: Google (парсинг)
+        if not results:
+            results = self._search_google(query, num_results)
+        
+        # Способ 4: Яндекс (для русского) — опционально
+        if not results and any(ord(c) > 1024 for c in query):
+            results = self._search_yandex(query, num_results)
+        
+        self._save_to_cache(cache_key, results)
+        return results
+    
+    def _search_searxng(self, query: str, num_results: int) -> List[Dict[str, str]]:
+        results = []
+        for instance in self.searxng_instances:
+            try:
+                url = f"{instance}/search"
+                params = {
+                    "q": query,
+                    "format": "json",
+                    "categories": "general",
+                    "engines": "google,bing,duckduckgo,startpage",
+                    "language": "en",
+                    "pageno": 1
+                }
+                response = self.session.get(url, params=params, timeout=20)
+                response.raise_for_status()
+                data = response.json()
+                
+                if 'results' in data:
+                    for item in data['results'][:num_results]:
+                        results.append({
+                            'title': item.get('title', '')[:100],
+                            'url': item.get('url', ''),
+                            'snippet': item.get('content', '')[:200],
+                            'source': 'searxng',
+                            'engine': item.get('engine', '')
+                        })
+                    if results:
+                        print(f"🔍 SearXNG: {len(results)} результатов")
+                        break
+            except Exception as e:
+                continue
+        return results
+    
+    def _search_duckduckgo(self, query: str, num_results: int) -> List[Dict[str, str]]:
+        results = []
+        try:
+            url = f"https://api.duckduckgo.com/?q={query}&format=json&no_html=1&skip_disambig=1"
+            response = self.session.get(url, timeout=15)
+            data = response.json()
+            
+            if 'RelatedTopics' in data:
+                for item in data['RelatedTopics'][:num_results]:
+                    if 'Text' in item and 'FirstURL' in item:
+                        results.append({
+                            'title': item['Text'][:100],
+                            'url': item['FirstURL'],
+                            'snippet': item.get('Text', '')[:200],
+                            'source': 'duckduckgo'
+                        })
+            print(f"🦆 DuckDuckGo: {len(results)} результатов")
+        except Exception as e:
+            print(f"⚠️ DuckDuckGo ошибка: {e}")
+        return results
+    
+    def _search_google(self, query: str, num_results: int) -> List[Dict[str, str]]:
+        results = []
+        if not self._has_bs4:
+            return results
+        try:
+            from bs4 import BeautifulSoup
+            url = f"https://www.google.com/search?q={query}&num={num_results * 2}"
+            response = self.session.get(url, timeout=20)
+            soup = BeautifulSoup(response.text, 'html.parser')
+            
+            for g in soup.find_all('div', class_='g'):
+                title_elem = g.find('h3')
+                link_elem = g.find('a')
+                snippet_elem = g.find('div', class_='VwiC3b')
+                
+                if title_elem and link_elem:
+                    title = title_elem.get_text()
+                    link = link_elem.get('href', '')
+                    snippet = snippet_elem.get_text() if snippet_elem else ''
+                    if link.startswith('/url?q='):
+                        link = link.split('/url?q=')[1].split('&')[0]
+                    if link.startswith('http'):
+                        results.append({
+                            'title': title[:100],
+                            'url': link,
+                            'snippet': snippet[:200],
+                            'source': 'google'
+                        })
+                    if len(results) >= num_results:
+                        break
+            print(f"🔍 Google: {len(results)} результатов")
+        except Exception as e:
+            print(f"⚠️ Google ошибка: {e}")
+        return results
+    
+    def _search_yandex(self, query: str, num_results: int) -> List[Dict[str, str]]:
+        results = []
+        if not self._has_bs4:
+            return results
+        try:
+            from bs4 import BeautifulSoup
+            url = f"https://yandex.ru/search/?text={query}&numdoc={num_results}"
+            response = self.session.get(url, timeout=20)
+            soup = BeautifulSoup(response.text, 'html.parser')
+            
+            for item in soup.find_all('li', class_='serp-item'):
+                link_elem = item.find('a', class_='link')
+                snippet_elem = item.find('div', class_='text-container')
+                if link_elem:
+                    title = link_elem.get_text()
+                    link = link_elem.get('href', '')
+                    snippet = snippet_elem.get_text() if snippet_elem else ''
+                    if link.startswith('http'):
+                        results.append({
+                            'title': title[:100],
+                            'url': link,
+                            'snippet': snippet[:200],
+                            'source': 'yandex'
+                        })
+                    if len(results) >= num_results:
+                        break
+            print(f"🔍 Яндекс: {len(results)} результатов")
+        except Exception as e:
+            print(f"⚠️ Яндекс ошибка: {e}")
+        return results
+    
+    def fetch_page(self, url: str, max_size: int = 50000) -> Dict[str, Any]:
+        try:
+            response = self.session.get(url, timeout=30)
+            response.raise_for_status()
+            content = response.text[:max_size]
+            return {
+                "url": url,
+                "status": response.status_code,
+                "content": content,
+                "length": len(content),
+                "headers": dict(response.headers)
+            }
+        except Exception as e:
+            return {"url": url, "error": str(e)}
+    
+    def analyze_website(self, url: str) -> Dict[str, Any]:
+        page = self.fetch_page(url)
+        if "error" in page:
+            return page
+        content = page.get("content", "")
+        return {
+            "url": url,
+            "title": content.split("<title>")[1].split("</title>")[0] if "<title>" in content else "N/A",
+            "has_forms": "form" in content.lower(),
+            "has_scripts": "<script" in content.lower(),
+            "links_count": content.count("<a "),
+            "size": len(content)
+        }
+    
+    def fetch_multiple(self, urls: List[str], max_total: int = 50000) -> List[Dict[str, Any]]:
+        results = []
+        total = 0
+        for url in urls:
+            page = self.fetch_page(url, max_size=min(10000, max_total - total))
+            if "content" in page:
+                total += len(page["content"])
+            results.append(page)
+            if total >= max_total:
+                break
+        return results
+    
+    def clear_cache(self) -> str:
+        count = len(self.cache)
+        self.cache.clear()
+        return f"🗑️ Кэш очищен ({count} записей)"
+    
+    def get_cache_stats(self) -> str:
+        return f"📊 Кэш: {len(self.cache)} записей, TTL: {self.cache_ttl} секунд"
+    
+    def _extract_keywords(self, content: str) -> List[str]:
+        words = re.findall(r'\b[a-zA-Z]{4,}\b', content.lower())
+        return [w for w, _ in Counter(words).most_common(10)]
+    
+    def _detect_language(self, content: str) -> str:
+        ru_chars = len(re.findall(r'[а-яА-Я]', content))
+        en_chars = len(re.findall(r'[a-zA-Z]', content))
+        if ru_chars > en_chars * 0.5:
+            return "ru"
+        return "en"
+
+INTERNET_AGENT = FreeInternetAgent(cache_ttl=3600)

main.py

@@ -0,0 +1,45 @@
+"""Точка входа — запуск сервера"""
+
+import sys
+from http.server import HTTPServer
+from .config import PORT, TOKEN, API_KEY, ensure_folders
+from .state import STATE
+from .internet_agent import INTERNET_AGENT
+from .routes import WebhookHandler
+
+def main():
+    print("=" * 60)
+    print("🧠 PINKSKY v7.0 — МОДУЛЬНАЯ АРХИТЕКТУРА")
+    print("=" * 60)
+    
+    if not TOKEN:
+        print("❌ TELEGRAM_BOT_TOKEN не найден!")
+        sys.exit(1)
+    if not API_KEY:
+        print("⚠️ NVIDIA_API_KEY не найден")
+    
+    ensure_folders()
+    
+    print(f"📊 Загружено моделей: {len(STATE.models)}")
+    print(f"📊 Загружено ролей: {len(STATE.roles)}")
+    print(f"📊 Загружено кондукторов: {len(STATE.conductors)}")
+    print(f"🌐 Интернет: {'✅' if STATE.build_context.get('internet_access', True) else '❌'}")
+    print(f"🗑️ Кэш: {INTERNET_AGENT.get_cache_stats()}")
+    
+    STATE.current_mode = "chat"
+    server = HTTPServer(("0.0.0.0", PORT), WebhookHandler)
+    print(f"🚀 Сервер запущен на порту {PORT}")
+    print("=" * 60)
+    
+    try:
+        server.serve_forever()
+    except KeyboardInterrupt:
+        print("\n🛑 Остановка...")
+        from .process_manager import PROCESS_MANAGER
+        PROCESS_MANAGER.cancel_all()
+        STATE.save_history()
+        print("💾 История сохранена.")
+        server.shutdown()
+
+if __name__ == "__main__":
+    main()

mode_handlers.py

@@ -0,0 +1,101 @@
+"""Обработчики режимов: Chat, Skill, Build"""
+
+import threading
+from datetime import datetime
+from typing import Dict, Any
+from .state import STATE
+from .config import API_KEY, API_BASE
+from .universal_agent import UniversalAgent
+from .conductor_engine import ConductorEngine
+from .skill_orchestrator import SkillOrchestrator
+from .process_manager import PROCESS_MANAGER
+from .notification_system import NOTIFICATIONS
+from .helpers import parse_skill_args, build_skill_prompt, parse_build_args
+from .telegram_utils import send_tg, send_tg_file
+
+def configure_interpreter_for_model(model_name: str):
+    try:
+        from interpreter import interpreter
+        model = STATE.models.get(model_name, STATE.models["deepseek-v4-pro"])
+        interpreter.llm.model = f"openai/{model.endpoint}"
+        interpreter.llm.api_key = API_KEY
+        interpreter.llm.api_base = API_BASE
+        interpreter.llm.context_window = model.context_window
+        interpreter.llm.max_tokens = model.max_tokens
+    except ImportError:
+        pass
+
+def run_chat_mode(chat_id: str, text: str, file_context: str = "") -> str:
+    def chat_task():
+        STATE.cancel_flag = False
+        STATE.current_mode = "chat"
+        send_tg(chat_id, "🧠 Conductor анализирует запрос...")
+        try:
+            conductor_engine = ConductorEngine(STATE)
+            result = conductor_engine.orchestrate(text + file_context, chat_id=chat_id)
+            if not STATE.cancel_flag:
+                send_tg(chat_id, result)
+                STATE.add_to_history("chat", "assistant", result)
+        except Exception as e:
+            if not STATE.cancel_flag:
+                send_tg(chat_id, f"❌ Ошибка: {e}")
+    
+    t = threading.Thread(target=chat_task)
+    PROCESS_MANAGER.register_thread(t)
+    t.start()
+    return "Chat mode started"
+
+def run_skill_mode(chat_id: str, text: str, file_context: str = "") -> str:
+    params, clean_text = parse_skill_args(text)
+    agents = params.get("agents", [])
+    use_internet = params.get("internet", False)
+    
+    def skill_task():
+        STATE.cancel_flag = False
+        STATE.current_mode = "skill"
+        send_tg(chat_id, "🔧 Skill Mode: запуск агентов...")
+        
+        if use_internet:
+            search_results = INTERNET_AGENT.search_web(clean_text[:200])
+            if search_results:
+                web_context = "\n\nИнтернет-результаты:\n" + "\n".join(
+                    f"- {r['title']}: {r['snippet']}" for r in search_results[:3]
+                )
+                file_context += web_context
+        
+        try:
+            orchestrator = SkillOrchestrator(STATE)
+            result = orchestrator.execute_with_agents(chat_id, clean_text, file_context, agents)
+            if not STATE.cancel_flag:
+                send_tg(chat_id, result)
+                STATE.add_to_history("skill", "assistant", result)
+        except Exception as e:
+            if not STATE.cancel_flag:
+                send_tg(chat_id, f"❌ Skill error: {e}")
+    
+    t = threading.Thread(target=skill_task)
+    PROCESS_MANAGER.register_thread(t)
+    t.start()
+    return "Skill mode started"
+
+def run_build_mode(chat_id: str, text: str, file_context: str = "", params: Dict[str, Any] = None) -> str:
+    def build_task():
+        STATE.cancel_flag = False
+        STATE.current_mode = "build"
+        send_tg(chat_id, "🏗️ Build Mode: запуск оркестрации...")
+        try:
+            conductor_engine = ConductorEngine(STATE)
+            if params:
+                STATE.build_context.update(params)
+            result = conductor_engine.orchestrate(text + file_context, chat_id=chat_id, build_params=params)
+            if not STATE.cancel_flag:
+                send_tg(chat_id, result)
+                STATE.add_to_history("build", "assistant", result)
+        except Exception as e:
+            if not STATE.cancel_flag:
+                send_tg(chat_id, f"❌ Build error: {e}")
+    
+    t = threading.Thread(target=build_task)
+    PROCESS_MANAGER.register_thread(t)
+    t.start()
+    return "Build mode started"

model_ranking.py

@@ -0,0 +1,192 @@
+"""Все модели NVIDIA с ранжированием"""
+
+from .config import HF_FALLBACK_MODEL
+
+MODEL_RANKING = {
+    # TIER 1: ELITE CODING
+    "deepseek-v4-pro": {
+        "endpoint": "deepseek-ai/deepseek-v4-pro",
+        "context_window": 64000, "max_tokens": 8000,
+        "coding_rank": 1, "speed_rank": 15, "reasoning_rank": 1,
+        "cost_per_1k_input": 0.001, "cost_per_1k_output": 0.005,
+        "tags": ["elite", "coding", "reasoning", "math", "cheap"]
+    },
+    "kimi-k2.6": {
+        "endpoint": "moonshotai/kimi-k2.6",
+        "context_window": 32000, "max_tokens": 8000,
+        "coding_rank": 2, "speed_rank": 12, "reasoning_rank": 2,
+        "cost_per_1k_input": 0.003, "cost_per_1k_output": 0.015,
+        "tags": ["elite", "coding", "reasoning", "long_context"]
+    },
+    "qwen3.5-397b": {
+        "endpoint": "qwen/qwen3.5-397b-a17b",
+        "context_window": 128000, "max_tokens": 8000,
+        "coding_rank": 3, "speed_rank": 18, "reasoning_rank": 3,
+        "cost_per_1k_input": 0.002, "cost_per_1k_output": 0.008,
+        "tags": ["elite", "coding", "long_context", "chinese"]
+    },
+    "mistral-large-3": {
+        "endpoint": "mistralai/mistral-large-3-675b-instruct-2512",
+        "context_window": 128000, "max_tokens": 8000,
+        "coding_rank": 4, "speed_rank": 14, "reasoning_rank": 4,
+        "cost_per_1k_input": 0.002, "cost_per_1k_output": 0.010,
+        "tags": ["elite", "coding", "multilingual", "long_context"]
+    },
+    "gpt-oss-120b": {
+        "endpoint": "openai/gpt-oss-120b",
+        "context_window": 128000, "max_tokens": 8000,
+        "coding_rank": 5, "speed_rank": 20, "reasoning_rank": 5,
+        "cost_per_1k_input": 0.003, "cost_per_1k_output": 0.012,
+        "tags": ["elite", "coding", "reasoning", "openai"]
+    },
+
+    # TIER 2: STRONG CODING
+    "deepseek-v4-flash": {
+        "endpoint": "deepseek-ai/deepseek-v4-flash",
+        "context_window": 32000, "max_tokens": 8000,
+        "coding_rank": 6, "speed_rank": 8, "reasoning_rank": 8,
+        "cost_per_1k_input": 0.0005, "cost_per_1k_output": 0.002,
+        "tags": ["strong", "coding", "fast", "cheap"]
+    },
+    "llama-4-maverick": {
+        "endpoint": "meta/llama-4-maverick-17b-128e-instruct",
+        "context_window": 128000, "max_tokens": 8000,
+        "coding_rank": 7, "speed_rank": 10, "reasoning_rank": 7,
+        "cost_per_1k_input": 0.001, "cost_per_1k_output": 0.004,
+        "tags": ["strong", "coding", "meta", "long_context"]
+    },
+    "nemotron-3-super": {
+        "endpoint": "nvidia/nemotron-3-super-120b-a12b",
+        "context_window": 128000, "max_tokens": 8000,
+        "coding_rank": 8, "speed_rank": 16, "reasoning_rank": 6,
+        "cost_per_1k_input": 0.002, "cost_per_1k_output": 0.008,
+        "tags": ["strong", "coding", "nvidia", "reasoning"]
+    },
+    "mistral-medium-3.5": {
+        "endpoint": "mistralai/mistral-medium-3.5-128b",
+        "context_window": 64000, "max_tokens": 8000,
+        "coding_rank": 9, "speed_rank": 11, "reasoning_rank": 10,
+        "cost_per_1k_input": 0.001, "cost_per_1k_output": 0.005,
+        "tags": ["strong", "coding", "mistral", "balanced"]
+    },
+    "dracarys-llama-70b": {
+        "endpoint": "abacusai/dracarys-llama-3.1-70b-instruct",
+        "context_window": 32000, "max_tokens": 8000,
+        "coding_rank": 10, "speed_rank": 13, "reasoning_rank": 11,
+        "cost_per_1k_input": 0.001, "cost_per_1k_output": 0.004,
+        "tags": ["strong", "coding", "roleplay", "creative"]
+    },
+    "llama-3.3-70b": {
+        "endpoint": "meta/llama-3.3-70b-instruct",
+        "context_window": 32000, "max_tokens": 8000,
+        "coding_rank": 11, "speed_rank": 9, "reasoning_rank": 12,
+        "cost_per_1k_input": 0.0005, "cost_per_1k_output": 0.002,
+        "tags": ["strong", "coding", "meta", "fast", "cheap"]
+    },
+    "nemotron-super-49b": {
+        "endpoint": "nvidia/llama-3.3-nemotron-super-49b-v1.5",
+        "context_window": 32000, "max_tokens": 8000,
+        "coding_rank": 12, "speed_rank": 7, "reasoning_rank": 13,
+        "cost_per_1k_input": 0.0005, "cost_per_1k_output": 0.002,
+        "tags": ["strong", "coding", "nvidia", "fast", "cheap"]
+    },
+
+    # TIER 3: GOOD CODING
+    "step-3.7-flash": {
+        "endpoint": "stepfun-ai/step-3.7-flash",
+        "context_window": 32000, "max_tokens": 8000,
+        "coding_rank": 13, "speed_rank": 6, "reasoning_rank": 14,
+        "cost_per_1k_input": 0.0005, "cost_per_1k_output": 0.002,
+        "tags": ["good", "coding", "fast", "chinese", "cheap"]
+    },
+    "mistral-small-4": {
+        "endpoint": "mistralai/mistral-small-4-119b-2603",
+        "context_window": 32000, "max_tokens": 8000,
+        "coding_rank": 14, "speed_rank": 5, "reasoning_rank": 15,
+        "cost_per_1k_input": 0.0005, "cost_per_1k_output": 0.002,
+        "tags": ["good", "coding", "fast", "mistral", "cheap"]
+    },
+    "minimax-m2.7": {
+        "endpoint": "minimaxai/minimax-m2.7",
+        "context_window": 32000, "max_tokens": 8000,
+        "coding_rank": 15, "speed_rank": 4, "reasoning_rank": 16,
+        "cost_per_1k_input": 0.0005, "cost_per_1k_output": 0.002,
+        "tags": ["good", "coding", "fast", "chinese", "cheap"]
+    },
+    "nemotron-super-49b-v1": {
+        "endpoint": "nvidia/llama-3.3-nemotron-super-49b-v1",
+        "context_window": 32000, "max_tokens": 8000,
+        "coding_rank": 16, "speed_rank": 17, "reasoning_rank": 17,
+        "cost_per_1k_input": 0.0005, "cost_per_1k_output": 0.002,
+        "tags": ["good", "coding", "nvidia", "cheap"]
+    },
+    "llama-3.2-90b-vision": {
+        "endpoint": "meta/llama-3.2-90b-vision-instruct",
+        "context_window": 32000, "max_tokens": 8000,
+        "coding_rank": 17, "speed_rank": 19, "reasoning_rank": 18,
+        "cost_per_1k_input": 0.001, "cost_per_1k_output": 0.004,
+        "tags": ["good", "coding", "vision", "multimodal", "meta"]
+    },
+
+    # TIER 4: FAST / LIGHT
+    "nemotron-nano-12b": {
+        "endpoint": "nvidia/nemotron-nano-12b-v2-vl",
+        "context_window": 16000, "max_tokens": 4000,
+        "coding_rank": 18, "speed_rank": 2, "reasoning_rank": 22,
+        "cost_per_1k_input": 0.0001, "cost_per_1k_output": 0.0005,
+        "tags": ["light", "fast", "vision", "nvidia", "cheap"]
+    },
+    "nemotron-3-nano-30b": {
+        "endpoint": "nvidia/nemotron-3-nano-30b-a3b",
+        "context_window": 32000, "max_tokens": 8000,
+        "coding_rank": 19, "speed_rank": 3, "reasoning_rank": 19,
+        "cost_per_1k_input": 0.0002, "cost_per_1k_output": 0.001,
+        "tags": ["light", "fast", "nvidia", "cheap"]
+    },
+    "nemotron-nano-9b": {
+        "endpoint": "nvidia/nvidia-nemotron-nano-9b-v2",
+        "context_window": 16000, "max_tokens": 4000,
+        "coding_rank": 20, "speed_rank": 1, "reasoning_rank": 23,
+        "cost_per_1k_input": 0.0001, "cost_per_1k_output": 0.0005,
+        "tags": ["light", "fastest", "nvidia", "cheap"]
+    },
+    "nemotron-content-safety": {
+        "endpoint": "nvidia/nemotron-content-safety-reasoning-4b",
+        "context_window": 8000, "max_tokens": 2000,
+        "coding_rank": 21, "speed_rank": 1, "reasoning_rank": 24,
+        "cost_per_1k_input": 0.0001, "cost_per_1k_output": 0.0005,
+        "tags": ["light", "fastest", "safety", "nvidia", "cheap"]
+    },
+
+    # TIER 5: SPECIALIZED
+    "nemotron-3-nano-omni": {
+        "endpoint": "nvidia/nemotron-3-nano-omni-30b-a3b-reasoning",
+        "context_window": 32000, "max_tokens": 8000,
+        "coding_rank": 22, "speed_rank": 5, "reasoning_rank": 20,
+        "cost_per_1k_input": 0.0002, "cost_per_1k_output": 0.001,
+        "tags": ["specialized", "omni", "multimodal", "reasoning", "nvidia", "cheap"]
+    },
+    "diffusiongemma": {
+        "endpoint": "google/diffusiongemma-26b-a4b-it",
+        "context_window": 16000, "max_tokens": 4000,
+        "coding_rank": 23, "speed_rank": 10, "reasoning_rank": 25,
+        "cost_per_1k_input": 0.001, "cost_per_1k_output": 0.004,
+        "tags": ["specialized", "image", "diffusion", "google"]
+    },
+
+    # LEGACY
+    "glm": {
+        "endpoint": "z-ai/glm-5.1",
+        "context_window": 32000, "max_tokens": 8000,
+        "coding_rank": 9, "speed_rank": 8, "reasoning_rank": 9,
+        "cost_per_1k_input": 0.002, "cost_per_1k_output": 0.008,
+        "tags": ["legacy", "coding", "fast", "chinese"]
+    },
+    "hf_fallback": {
+        "endpoint": HF_FALLBACK_MODEL,
+        "context_window": 32000, "max_tokens": 8000,
+        "coding_rank": 50, "speed_rank": 50, "reasoning_rank": 50,
+        "cost_per_1k_input": 0, "cost_per_1k_output": 0,
+        "tags": ["fallback", "free", "hf"]
+    },
+}

models.py

@@ -0,0 +1,39 @@
+"""Датаклассы для моделей, ролей и кондукторов"""
+
+from dataclasses import dataclass, field
+from typing import List
+
+@dataclass
+class ModelConfig:
+    name: str
+    provider: str
+    endpoint: str
+    api_key_env: str
+    context_window: int = 32000
+    max_tokens: int = 8000
+    cost_per_1k_input: float = 0.0
+    cost_per_1k_output: float = 0.0
+    coding_rank: int = 50
+    speed_rank: int = 50
+    reasoning_rank: int = 50
+    tags: List[str] = field(default_factory=list)
+
+@dataclass
+class Role:
+    name: str
+    prompt: str
+    description: str
+    preferred_models: List[str] = field(default_factory=list)
+    complexity: str = "medium"
+    tags: List[str] = field(default_factory=list)
+    tools: List[str] = field(default_factory=list)
+
+@dataclass
+class Conductor:
+    name: str
+    prompt: str
+    description: str
+    strategy: str = "parallel"
+    max_agents: int = 3
+    cost_aware: bool = True
+    auto_rank_by: str = "coding"

notification_system.py

@@ -0,0 +1,85 @@
+"""Система уведомлений"""
+
+import re
+from datetime import datetime
+from typing import Dict, Any
+
+class NotificationSystem:
+    CRITICAL_ACTIONS = [
+        'delete', 'remove', 'kill', 'stop', 'shutdown',
+        'format', 'clear', 'reset', 'purge',
+        'upload', 'publish', 'deploy', 'push',
+        'change_password', 'add_user', 'remove_user',
+        'grant_access', 'revoke_access',
+        'install', 'uninstall', 'update',
+        'execute', 'run', 'start', 'stop',
+        'create_file', 'delete_file', 'modify_file',
+    ]
+    
+    HIGH_RISK_PATTERNS = [
+        r'rm\s+-rf', r'del\s+/f', r'format\s+', r'mkfs',
+        r'drop\s+database', r'truncate\s+', r'delete\s+from',
+        r'ALTER\s+TABLE', r'DROP\s+TABLE',
+        r'chmod\s+777', r'chown\s+root',
+        r'sudo\s+', r'admin\s+',
+    ]
+    
+    def __init__(self, chat_id: str = None):
+        self.chat_id = chat_id
+        self.notification_history = []
+        self.enabled = True
+    
+    def set_chat_id(self, chat_id: str):
+        self.chat_id = chat_id
+    
+    def set_enabled(self, enabled: bool):
+        self.enabled = enabled
+    
+    def check_action(self, action: str, context: Dict[str, Any] = None) -> bool:
+        action_lower = action.lower()
+        context = context or {}
+        for critical in self.CRITICAL_ACTIONS:
+            if critical in action_lower:
+                return True
+        for pattern in self.HIGH_RISK_PATTERNS:
+            if re.search(pattern, action_lower, re.IGNORECASE):
+                return True
+        if context.get('important', False):
+            return True
+        if context.get('files_changed', 0) > 3:
+            return True
+        return False
+    
+    def notify(self, action: str, details: str = "", severity: str = "info") -> str:
+        if not self.enabled:
+            return "🔇 Уведомления отключены"
+        if not self.chat_id:
+            return "⚠️ Chat ID не установлен"
+        
+        emoji_map = {'critical': '🚨', 'warning': '⚠️', 'info': 'ℹ️', 'success': '✅', 'error': '❌'}
+        emoji = emoji_map.get(severity, 'ℹ️')
+        
+        message = f"{emoji} *УВЕДОМЛЕНИЕ*\n\n🔹 *Действие:* `{action}`\n"
+        if details:
+            message += f"📝 *Детали:*\n```\n{details[:500]}\n```\n"
+        message += f"🕐 *Время:* {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}"
+        
+        self.notification_history.append({
+            'action': action, 'details': details,
+            'severity': severity, 'timestamp': datetime.now().isoformat()
+        })
+        
+        from .telegram_utils import send_tg
+        send_tg(self.chat_id, message)
+        return f"✅ Уведомление отправлено: {action}"
+    
+    def get_history(self, limit: int = 10) -> str:
+        if not self.notification_history:
+            return "📋 Нет уведомлений"
+        result = "📋 *История уведомлений:*\n\n"
+        for entry in self.notification_history[-limit:]:
+            emoji = {'critical': '🚨', 'warning': '⚠️', 'info': 'ℹ️'}.get(entry['severity'], 'ℹ️')
+            result += f"{emoji} `{entry['action']}` — {entry['timestamp']}\n"
+        return result
+
+NOTIFICATIONS = NotificationSystem()

process_manager.py

@@ -0,0 +1,67 @@
+"""Управление потоками и отмена генерации"""
+
+import threading
+from typing import List, Dict
+from concurrent.futures import ThreadPoolExecutor
+
+class ProcessManager:
+    def __init__(self):
+        self.active_threads: List[threading.Thread] = []
+        self.cancel_flags: Dict[int, bool] = {}
+        self.lock = threading.Lock()
+        self.executor = ThreadPoolExecutor(max_workers=10)
+        self.futures = []
+
+    def register_thread(self, thread: threading.Thread) -> None:
+        with self.lock:
+            self.active_threads.append(thread)
+            self.cancel_flags[thread.ident] = False
+
+    def register_future(self, future) -> None:
+        with self.lock:
+            self.futures.append(future)
+
+    def cancel_all(self) -> str:
+        with self.lock:
+            for future in self.futures:
+                if not future.done():
+                    future.cancel()
+            self.futures.clear()
+            for thread_id in self.cancel_flags:
+                self.cancel_flags[thread_id] = True
+            for thread in self.active_threads:
+                if thread.is_alive():
+                    try:
+                        thread.join(timeout=0.5)
+                    except Exception:
+                        pass
+            self.active_threads.clear()
+            self.cancel_flags.clear()
+
+        try:
+            from interpreter import interpreter
+            if hasattr(interpreter, 'cancel'):
+                interpreter.cancel()
+        except Exception:
+            pass
+
+        from .state import STATE
+        STATE.cancel_flag = True
+        STATE.current_mode = "paused"
+        return "✅ Все процессы генерации остановлены!"
+
+    def is_cancelled(self, thread_id: int = None) -> bool:
+        if thread_id is None:
+            thread_id = threading.current_thread().ident
+        with self.lock:
+            return self.cancel_flags.get(thread_id, False)
+
+    def clear(self) -> None:
+        with self.lock:
+            self.active_threads = [t for t in self.active_threads if t.is_alive()]
+
+    def get_active_count(self) -> int:
+        with self.lock:
+            return len([t for t in self.active_threads if t.is_alive()])
+
+PROCESS_MANAGER = ProcessManager()

routes.py

@@ -0,0 +1,24 @@
+"""HTTP маршруты"""
+
+from http.server import BaseHTTPRequestHandler
+import json
+from .telegram_handlers import BotHandler
+
+class WebhookHandler(BotHandler, BaseHTTPRequestHandler):
+    """Обработчик вебхуков Telegram"""
+    
+    def do_GET(self):
+        self.send_response(200)
+        self.end_headers()
+        self.wfile.write(b"PinkSky v7.0 is running!")
+    
+    def do_POST(self):
+        length = int(self.headers.get('Content-Length', 0))
+        data = json.loads(self.rfile.read(length))
+        self.send_response(200)
+        self.end_headers()
+        self.wfile.write(b"OK")
+        self.handle_message(data)
+    
+    def log_message(self, format, *args):
+        pass

skill_orchestrator.py

@@ -0,0 +1,87 @@
+"""Skill Orchestrator — многомодельный синтез в Skill Mode"""
+
+import threading
+from typing import Dict, List
+from .state import STATE
+from .universal_agent import UniversalAgent
+from .process_manager import PROCESS_MANAGER
+from .notification_system import NOTIFICATIONS
+
+class SkillOrchestrator:
+    def __init__(self, state):
+        self.state = state
+    
+    def execute_with_agents(self, chat_id: str, text: str, file_context: str = "", agents: List[str] = None) -> str:
+        if agents is None:
+            agents = self._auto_select_agents(text)
+        
+        main_result = self._execute_main(text, file_context, chat_id)
+        if len(agents) <= 1:
+            return main_result
+        
+        agent_results = self._run_agents_parallel(agents, text, main_result, chat_id)
+        return self._synthesize_results(text, main_result, agent_results, chat_id)
+    
+    def _auto_select_agents(self, text: str) -> List[str]:
+        text_lower = text.lower()
+        selected = ["universal"]
+        if any(k in text_lower for k in ["код", "code", "python", "файл", "script"]):
+            selected.extend(["guru", "hacker"])
+        if any(k in text_lower for k in ["тест", "test", "bug", "bug"]):
+            selected.extend(["qa", "sdet"])
+        if any(k in text_lower for k in ["архитектур", "architect", "design", "систем"]):
+            selected.append("architect")
+        if any(k in text_lower for k in ["review", "ревью", "audit", "аудит"]):
+            selected.extend(["techlead", "critic"])
+        return list(dict.fromkeys(selected))[:4]
+    
+    def _execute_main(self, text: str, file_context: str, chat_id: str) -> str:
+        role = self.state.roles.get(self.state.current_role, self.state.roles["universal"])
+        model_name = self.state.get_model_for_role(self.state.current_role)
+        model = self.state.models.get(model_name, self.state.models["deepseek-v4-pro"])
+        agent = UniversalAgent(role, model, use_interpreter=True)
+        full_task = f"{text}\n\n{file_context}".strip()
+        return agent.execute(full_task, chat_id=chat_id, mode="skill")
+    
+    def _run_agents_parallel(self, agents: List[str], text: str, main_result: str, chat_id: str) -> Dict[str, str]:
+        results = {}
+        threads = []
+        
+        def run_agent(agent_name):
+            if PROCESS_MANAGER.is_cancelled():
+                results[agent_name] = "Cancelled"
+                return
+            role = self.state.roles.get(agent_name, self.state.roles["universal"])
+            model_name = self.state.get_model_for_role(agent_name)
+            model = self.state.models.get(model_name, self.state.models["deepseek-v4-pro"])
+            agent = UniversalAgent(role, model)
+            prompt = f"Original task: {text}\n\nMain agent result: {main_result[:2000]}\n\nProvide your specialized perspective as {agent_name}."
+            try:
+                results[agent_name] = agent.execute(prompt, chat_id=chat_id, mode="skill")
+            except Exception as e:
+                results[agent_name] = f"Error: {e}"
+        
+        for name in agents[1:]:
+            t = threading.Thread(target=run_agent, args=(name,))
+            threads.append(t)
+            PROCESS_MANAGER.register_thread(t)
+            t.start()
+        
+        for t in threads:
+            t.join(timeout=90)
+        
+        return results
+    
+    def _synthesize_results(self, text: str, main_result: str, agent_results: Dict[str, str], chat_id: str) -> str:
+        synthesis = f"Synthesize results for: {text}\n\nMain result:\n{main_result[:1500]}\n\nAdditional perspectives:\n"
+        for name, result in agent_results.items():
+            synthesis += f"\n--- {name} ---\n{result[:1000]}\n"
+        
+        synth_role = self.state.roles.get("universal", list(self.state.roles.values())[0])
+        model_name = self.state.get_best_model(rank_by="reasoning", max_tier=2)
+        model = self.state.models.get(model_name, self.state.models["deepseek-v4-pro"])
+        agent = UniversalAgent(synth_role, model)
+        try:
+            return agent.execute(synthesis, chat_id=chat_id, mode="skill")
+        except Exception as e:
+            return main_result + "\n\n--- Additional ---\n" + "\n".join(f"{k}: {v[:500]}" for k, v in agent_results.items())

state.py

@@ -0,0 +1,466 @@
+"""Глобальное состояние PinkSky"""
+
+import os
+import json
+from datetime import datetime
+from typing import Dict, List, Any, Optional
+from .models import ModelConfig, Role, Conductor
+from .model_ranking import MODEL_RANKING
+from .config import ROLES_FILE, MODELS_FILE, CONDUCTORS_FILE, HISTORY_FILE
+
+class PinkSkyState:
+    def __init__(self):
+        self.models: Dict[str, ModelConfig] = {}
+        self.roles: Dict[str, Role] = {}
+        self.conductors: Dict[str, Conductor] = {}
+        self.current_mode: str = "chat"
+        self.current_conductor: str = "default"
+        self.current_role: str = "universal"
+        self.current_model: str = "deepseek-v4-pro"
+        self.chat_history: List[Dict[str, str]] = []
+        self.skill_history: List[Dict[str, str]] = []
+        self.build_history: List[Dict[str, str]] = []
+        self.build_context: Dict[str, Any] = {
+            "spec": "", "agents": 3, "models_tier": "tier1",
+            "skills_count": 2, "files_count": 3, "role": "universal",
+            "strategy": "parallel", "use_interpreter": True,
+            "notifications": True, "internet_access": True
+        }
+        self.cancel_flag: bool = False
+        self.load_all()
+
+    def load_all(self):
+        self._load_models()
+        self._load_roles()
+        self._load_conductors()
+        self._load_history()
+
+    def _build_model_config(self, name: str, data: dict) -> ModelConfig:
+        return ModelConfig(
+            name=name, provider="openai", endpoint=data["endpoint"],
+            api_key_env="NVIDIA_API_KEY",
+            context_window=data.get("context_window", 32000),
+            max_tokens=data.get("max_tokens", 8000),
+            cost_per_1k_input=data.get("cost_per_1k_input", 0.0),
+            cost_per_1k_output=data.get("cost_per_1k_output", 0.0),
+            coding_rank=data.get("coding_rank", 50),
+            speed_rank=data.get("speed_rank", 50),
+            reasoning_rank=data.get("reasoning_rank", 50),
+            tags=data.get("tags", [])
+        )
+
+    def _load_models(self):
+        defaults = {name: self._build_model_config(name, data) for name, data in MODEL_RANKING.items()}
+        if os.path.exists(MODELS_FILE):
+            try:
+                with open(MODELS_FILE, "r", encoding="utf-8") as f:
+                    custom = json.load(f)
+                    for k, v in custom.items():
+                        if k not in defaults:
+                            defaults[k] = ModelConfig(**v)
+            except Exception as e:
+                print(f"⚠️ Ошибка загрузки models.json: {e}")
+        self.models = defaults
+
+    def _load_roles(self):
+        defaults = {
+            "universal": Role(
+                name="universal",
+                prompt="You are PinkSky -- a universal AI assistant and autonomous developer. You help users with any tasks, scripts, theory, and project creation from scratch.",
+                description="Universal assistant for any tasks",
+                preferred_models=["deepseek-v4-pro", "kimi-k2.6", "qwen3.5-397b"],
+                complexity="medium",
+                tags=["general"]
+            ),
+            "guru": Role(
+                name="guru",
+                prompt="You are Guru Programmer PinkSky. 15+ years experience. Write elegant, production-ready code. Principles: KISS, explicit > implicit, composition > inheritance, PEP8, type hints, docstrings. Format: analysis -> code -> explanations -> edge cases.",
+                description="Guru programmer. Elegant code with deep explanations.",
+                preferred_models=["deepseek-v4-pro", "kimi-k2.6", "mistral-large-3", "gpt-oss-120b"],
+                complexity="high",
+                tags=["coding", "senior", "mentor", "python"]
+            ),
+            "hacker": Role(
+                name="hacker",
+                prompt="You are Hacker PinkSky. Code virtuoso. Find elegant and unconventional solutions. Use __slots__, descriptors, metaclasses. Optimize time complexity, memory layout. Love functional: itertools, functools, operator.",
+                description="Hacker-coder. Optimization and unconventional solutions.",
+                preferred_models=["deepseek-v4-pro", "deepseek-v4-flash", "llama-4-maverick", "nemotron-super-49b"],
+                complexity="high",
+                tags=["coding", "optimization", "hacks", "performance"]
+            ),
+            "architect": Role(
+                name="architect",
+                prompt="You are Software Architect PinkSky. Design systems that last years. Bounded contexts, aggregates, CQRS, Event Sourcing. API: REST, gRPC, GraphQL, WebSocket. Observability: logs, metrics, tracing from the start.",
+                description="Software Architect. High-level system design.",
+                preferred_models=["deepseek-v4-pro", "kimi-k2.6", "nemotron-3-super", "qwen3.5-397b"],
+                complexity="high",
+                tags=["architecture", "design", "system", "ddd"]
+            ),
+            "principal": Role(
+                name="principal",
+                prompt="You are Principal Engineer PinkSky. Solve problems no one else can. Refactor legacy without downtime. Platform-level: CI/CD, observability, service mesh. Engineering culture: code review, RFC process. ADR for all decisions.",
+                description="Principal engineer. Strategy, mentorship, hard problems.",
+                preferred_models=["deepseek-v4-pro", "kimi-k2.6", "mistral-large-3", "gpt-oss-120b"],
+                complexity="high",
+                tags=["leadership", "strategy", "mentoring", "legacy"]
+            ),
+            "evangelist": Role(
+                name="evangelist",
+                prompt="You are Quality Evangelist PinkSky. TDD, BDD, property-based testing, mutation testing. pytest, hypothesis, coverage, mypy, ruff, bandit. Test pyramid: unit -> integration -> e2e. CI/CD gates: coverage threshold, mutation score.",
+                description="Quality evangelist. Testing and quality culture.",
+                preferred_models=["kimi-k2.6", "deepseek-v4-pro", "mistral-medium-3.5"],
+                complexity="high",
+                tags=["quality", "testing", "tdd", "ci-cd"]
+            ),
+            "techlead": Role(
+                name="techlead",
+                prompt="You are Tech Lead PinkSky. Code review: correctness, readability, maintainability, security, performance. Find race conditions, memory leaks, injection points, N+1. must-fix vs should-fix vs nitpick. Code review = teaching, not tribunal.",
+                description="Tech Lead. Code review and team direction.",
+                preferred_models=["deepseek-v4-pro", "kimi-k2.6", "mistral-large-3", "gpt-oss-120b"],
+                complexity="high",
+                tags=["review", "leadership", "team", "mentoring"]
+            ),
+            "qa": Role(
+                name="qa",
+                prompt="You are QA Engineer PinkSky. Test cases: positive, negative, boundary, exploratory. Equivalence partitioning, boundary value analysis. Automation: Selenium, Playwright, Postman. Performance: k6, Locust. Security: OWASP Top 10.",
+                description="QA engineer. Bug hunting and test strategy.",
+                preferred_models=["mistral-small-4", "step-3.7-flash", "llama-3.3-70b", "deepseek-v4-flash"],
+                complexity="medium",
+                tags=["qa", "testing", "automation", "manual"]
+            ),
+            "sdet": Role(
+                name="sdet",
+                prompt="You are SDET PinkSky. Test frameworks: pytest plugins, custom matchers. CI/CD: parallel execution, test sharding. Test data: factories, fixtures, seeding, cleanup. Mocks/stubs/fakes: wiremock, mockserver. Test code = production code.",
+                description="SDET. Autotests and test infrastructure at dev level.",
+                preferred_models=["deepseek-v4-pro", "kimi-k2.6", "llama-4-maverick", "mistral-medium-3.5"],
+                complexity="high",
+                tags=["sdet", "automation", "framework", "infrastructure"]
+            ),
+            "qe": Role(
+                name="qe",
+                prompt="You are Quality Engineer (QE) PinkSky. Analyze SDLC: where quality is lost. Shift-left testing: quality gates at every stage. Metrics: DORA, SPACE, custom KPIs. Root cause analysis: 5 Whys, Fishbone, FMEA. Every production bug = learning opportunity.",
+                description="Quality engineer. Processes, metrics, and quality culture.",
+                preferred_models=["deepseek-v4-pro", "kimi-k2.6", "nemotron-3-super"],
+                complexity="high",
+                tags=["qe", "process", "metrics", "culture", "sdlc"]
+            ),
+            "researcher": Role(
+                name="researcher",
+                prompt="You are Researcher PinkSky. Deep topic analysis. Compare approaches: trade-offs, limitations. Structure: executive summary -> details -> sources. Identify trends. Evidence > opinions. Numbers > words.",
+                description="Researcher and analyst. Deep topic analysis.",
+                preferred_models=["deepseek-v4-pro", "qwen3.5-397b", "kimi-k2.6", "gpt-oss-120b"],
+                complexity="high",
+                tags=["research", "analysis", "comparison"]
+            ),
+            "critic": Role(
+                name="critic",
+                prompt="You are Critic and Auditor PinkSky. correctness, security, performance, maintainability. race conditions, injection points, memory leaks, N+1. code smells, technical debt, architecture risks. Every issue with severity. Suggest fixes.",
+                description="Critic and auditor. Bug and issue hunting.",
+                preferred_models=["deepseek-v4-pro", "kimi-k2.6", "mistral-large-3", "gpt-oss-120b"],
+                complexity="medium",
+                tags=["audit", "security", "review", "critic"]
+            ),
+        }
+        if os.path.exists(ROLES_FILE):
+            try:
+                with open(ROLES_FILE, "r", encoding="utf-8") as f:
+                    custom = json.load(f)
+                    for k, v in custom.items():
+                        if k not in defaults:
+                            defaults[k] = Role(**v)
+            except Exception as e:
+                print(f"⚠️ Ошибка загрузки roles.json: {e}")
+        self.roles = defaults
+
+    def _load_conductors(self):
+        defaults = {
+            "default": Conductor(
+                name="default",
+                prompt="""You are Conductor PinkSky (Default). Analyze request and choose optimal roles and models.
+
+RULES:
+1. Simple questions -- 1 role, 1 model.
+2. Complex tasks -- decompose, assign roles.
+3. Consider cost: cheap for simple, powerful for complex.
+4. If code -- add critic.
+5. If architecture -- add architect.
+
+AVAILABLE ROLES: guru, hacker, architect, principal, evangelist, techlead, qa, sdet, qe, researcher, critic, universal.
+
+AVAILABLE MODELS (by coding rank, best to worst):
+TIER 1 (Elite): deepseek-v4-pro, kimi-k2.6, qwen3.5-397b, mistral-large-3, gpt-oss-120b
+TIER 2 (Strong): deepseek-v4-flash, llama-4-maverick, nemotron-3-super, mistral-medium-3.5, dracarys-llama-70b, llama-3.3-70b, nemotron-super-49b
+TIER 3 (Good): step-3.7-flash, mistral-small-4, minimax-m2.7, nemotron-super-49b-v1, llama-3.2-90b-vision
+TIER 4 (Fast): nemotron-nano-12b, nemotron-3-nano-30b, nemotron-nano-9b, nemotron-content-safety
+TIER 5 (Specialized): nemotron-3-nano-omni, diffusiongemma
+
+FORMAT (STRICT JSON):
+{"strategy": "single|sequential|parallel", "tasks": [{"role": "role_name", "model": "model_name", "prompt": "subtask"}], "synthesis_prompt": "how to combine"}""",
+                description="Standard conductor -- balance of quality and speed",
+                strategy="selective",
+                max_agents=3,
+                cost_aware=True,
+                auto_rank_by="balanced"
+            ),
+            "strict": Conductor(
+                name="strict",
+                prompt="""You are Strict Conductor PinkSky. Minimum agents, maximum efficiency.
+
+RULES:
+1. ONLY one role and one model.
+2. Cheapest model capable of solving the task.
+3. Only sequential.
+
+FORMAT (STRICT JSON):
+{"strategy": "single", "tasks": [{"role": "name", "model": "name", "prompt": "task"}], "synthesis_prompt": ""}""",
+                description="Minimum agents, minimum cost",
+                strategy="single",
+                max_agents=1,
+                cost_aware=True,
+                auto_rank_by="coding"
+            ),
+            "creative": Conductor(
+                name="creative",
+                prompt="""You are Creative Conductor PinkSky. Maximum perspectives, brainstorm.
+
+RULES:
+1. Multiple roles from different angles.
+2. Parallel strategy.
+3. guru + hacker + researcher + critic.
+4. Do not save on models -- use the best.
+
+FORMAT (STRICT JSON):
+{"strategy": "parallel", "tasks": [...], "synthesis_prompt": "synthesize creative ideas"}""",
+                description="Maximum roles, creative brainstorm",
+                strategy="parallel",
+                max_agents=5,
+                cost_aware=False,
+                auto_rank_by="coding"
+            ),
+            "economy": Conductor(
+                name="economy",
+                prompt="""You are Economy Conductor PinkSky. Solve task for minimum cost.
+
+RULES:
+1. Start with TIER 4 (fast/cheap): nemotron-nano-9b, nemotron-nano-12b, nemotron-3-nano-30b.
+2. Only if it fails -- escalate to TIER 3/2.
+3. One role, one model.
+
+FORMAT (STRICT JSON):
+{"strategy": "single", "tasks": [{"role": "name", "model": "name", "prompt": "task"}], "synthesis_prompt": ""}""",
+                description="Cheap models, budget saving",
+                strategy="single",
+                max_agents=1,
+                cost_aware=True,
+                auto_rank_by="speed"
+            ),
+            "review": Conductor(
+                name="review",
+                prompt="""You are Code Review Conductor PinkSky. Maximum quality code review.
+
+RULES:
+1. techlead (architectural review) + critic (bugs/vulnerabilities) + guru (best practices).
+2. Parallel review.
+3. Synthesize into structured report.
+
+FORMAT (STRICT JSON):
+{"strategy": "parallel", "tasks": [{"role": "techlead", "model": "deepseek-v4-pro", "prompt": "architectural review"}, {"role": "critic", "model": "kimi-k2.6", "prompt": "bug hunting"}, {"role": "guru", "model": "mistral-large-3", "prompt": "best practices"}], "synthesis_prompt": "structured report with severity"}""",
+                description="Focus on code review. Multi-angle code check.",
+                strategy="parallel",
+                max_agents=4,
+                cost_aware=True,
+                auto_rank_by="coding"
+            ),
+            "build": Conductor(
+                name="build",
+                prompt="""You are Project Build Conductor PinkSky. Build full project from spec.
+
+RULES:
+1. Sequential: architect -> guru/hacker -> sdet -> critic.
+2. Each stage -- separate call.
+
+FORMAT (STRICT JSON):
+{"strategy": "sequential", "tasks": [{"role": "architect", "model": "deepseek-v4-pro", "prompt": "architecture"}, {"role": "guru", "model": "kimi-k2.6", "prompt": "code"}, {"role": "sdet", "model": "mistral-medium-3.5", "prompt": "tests"}, {"role": "critic", "model": "gpt-oss-120b", "prompt": "audit"}], "synthesis_prompt": "assemble into single project"}""",
+                description="Project build. Architecture -> code -> tests -> audit.",
+                strategy="sequential",
+                max_agents=5,
+                cost_aware=True,
+                auto_rank_by="coding"
+            ),
+        }
+        if os.path.exists(CONDUCTORS_FILE):
+            try:
+                with open(CONDUCTORS_FILE, "r", encoding="utf-8") as f:
+                    custom = json.load(f)
+                    for k, v in custom.items():
+                        if k not in defaults:
+                            defaults[k] = Conductor(**v)
+            except Exception as e:
+                print(f"⚠️ Ошибка загрузки conductors.json: {e}")
+        self.conductors = defaults
+
+    def _load_history(self):
+        if os.path.exists(HISTORY_FILE):
+            try:
+                with open(HISTORY_FILE, "r", encoding="utf-8") as f:
+                    data = json.load(f)
+                    self.chat_history = data.get("chat", [])
+                    self.skill_history = data.get("skill", [])
+                    self.build_history = data.get("build", [])
+            except Exception as e:
+                print(f"⚠️ Ошибка загрузки истории: {e}")
+
+    def save_roles(self):
+        data = {k: {"name": v.name, "prompt": v.prompt, "description": v.description,
+                    "preferred_models": v.preferred_models, "complexity": v.complexity, "tags": v.tags}
+                for k, v in self.roles.items()}
+        with open(ROLES_FILE, "w", encoding="utf-8") as f:
+            json.dump(data, f, ensure_ascii=False, indent=2)
+
+    def save_models(self):
+        data = {k: {"name": v.name, "provider": v.provider, "endpoint": v.endpoint,
+                    "api_key_env": v.api_key_env, "context_window": v.context_window,
+                    "max_tokens": v.max_tokens, "cost_per_1k_input": v.cost_per_1k_input,
+                    "cost_per_1k_output": v.cost_per_1k_output,
+                    "coding_rank": v.coding_rank, "speed_rank": v.speed_rank, "reasoning_rank": v.reasoning_rank,
+                    "tags": v.tags}
+                for k, v in self.models.items()}
+        with open(MODELS_FILE, "w", encoding="utf-8") as f:
+            json.dump(data, f, ensure_ascii=False, indent=2)
+
+    def save_conductors(self):
+        data = {k: {"name": v.name, "prompt": v.prompt, "description": v.description,
+                    "strategy": v.strategy, "max_agents": v.max_agents, "cost_aware": v.cost_aware,
+                    "auto_rank_by": v.auto_rank_by}
+                for k, v in self.conductors.items()}
+        with open(CONDUCTORS_FILE, "w", encoding="utf-8") as f:
+            json.dump(data, f, ensure_ascii=False, indent=2)
+
+    def save_history(self):
+        data = {"chat": self.chat_history, "skill": self.skill_history, "build": self.build_history}
+        with open(HISTORY_FILE, "w", encoding="utf-8") as f:
+            json.dump(data, f, ensure_ascii=False, indent=2)
+
+    def add_to_history(self, mode: str, role: str, content: str):
+        entry = {"role": role, "content": content, "timestamp": datetime.now().isoformat()}
+        if mode == "chat":
+            self.chat_history.append(entry)
+        elif mode == "skill":
+            self.skill_history.append(entry)
+        elif mode == "build":
+            self.build_history.append(entry)
+        self.save_history()
+
+    def get_best_model(self, rank_by: str = "coding", min_tier: int = 1, max_tier: int = 5, exclude: List[str] = None) -> str:
+        exclude = exclude or []
+        candidates = []
+        for name, model in self.models.items():
+            if name in exclude or name == "hf_fallback":
+                continue
+            tier = 5
+            if model.coding_rank <= 5: tier = 1
+            elif model.coding_rank <= 12: tier = 2
+            elif model.coding_rank <= 18: tier = 3
+            elif model.coding_rank <= 24: tier = 4
+            if min_tier <= tier <= max_tier:
+                candidates.append((name, model))
+        if not candidates:
+            return "deepseek-v4-pro"
+        if rank_by == "coding":
+            candidates.sort(key=lambda x: x[1].coding_rank)
+        elif rank_by == "speed":
+            candidates.sort(key=lambda x: x[1].speed_rank)
+        elif rank_by == "reasoning":
+            candidates.sort(key=lambda x: x[1].reasoning_rank)
+        elif rank_by == "balanced":
+            candidates.sort(key=lambda x: (x[1].coding_rank + x[1].speed_rank + x[1].reasoning_rank) / 3)
+        else:
+            candidates.sort(key=lambda x: x[1].coding_rank)
+        return candidates[0][0]
+
+    def get_model_for_role(self, role_name: str, preference: str = None, rank_by: str = None) -> str:
+        role = self.roles.get(role_name)
+        if not role:
+            return preference or self.current_model
+        conductor = self.conductors.get(self.current_conductor, self.conductors["default"])
+        rank_criteria = rank_by or conductor.auto_rank_by
+        max_tier = 5
+        if role.complexity == "high":
+            max_tier = 2
+        elif role.complexity == "medium":
+            max_tier = 3
+        if preference and preference in self.models:
+            return preference
+        available = [m for m in role.preferred_models if m in self.models and m != "hf_fallback"]
+        if available:
+            if conductor.cost_aware and rank_criteria != "coding":
+                available.sort(key=lambda m: self.models[m].cost_per_1k_output)
+            else:
+                if rank_criteria == "coding":
+                    available.sort(key=lambda m: self.models[m].coding_rank)
+                elif rank_criteria == "speed":
+                    available.sort(key=lambda m: self.models[m].speed_rank)
+                elif rank_criteria == "reasoning":
+                    available.sort(key=lambda m: self.models[m].reasoning_rank)
+                else:
+                    available.sort(key=lambda m: (self.models[m].coding_rank + self.models[m].speed_rank + self.models[m].reasoning_rank) / 3)
+            return available[0]
+        return self.get_best_model(rank_by=rank_criteria, max_tier=max_tier)
+
+    def get_models_by_tier(self, tier: int) -> List[str]:
+        result = []
+        for name, model in self.models.items():
+            if name == "hf_fallback":
+                continue
+            model_tier = 5
+            if model.coding_rank <= 5: model_tier = 1
+            elif model.coding_rank <= 12: model_tier = 2
+            elif model.coding_rank <= 18: model_tier = 3
+            elif model.coding_rank <= 24: model_tier = 4
+            if model_tier == tier:
+                result.append(name)
+        return result
+
+    def get_next_tier_model(self, current_model_name: str) -> Optional[str]:
+        if current_model_name not in self.models:
+            return None
+        current = self.models[current_model_name]
+        current_tier = 5
+        if current.coding_rank <= 5: current_tier = 1
+        elif current.coding_rank <= 12: current_tier = 2
+        elif current.coding_rank <= 18: current_tier = 3
+        elif current.coding_rank <= 24: current_tier = 4
+        next_tier = current_tier + 1
+        if next_tier > 5:
+            return None
+        models_in_tier = self.get_models_by_tier(next_tier)
+        if models_in_tier:
+            return models_in_tier[0]
+        return None
+
+    def export_history_json(self) -> str:
+        return json.dumps({"exported_at": datetime.now().isoformat(), "chat": self.chat_history, "skill": self.skill_history, "build": self.build_history}, ensure_ascii=False, indent=2)
+
+    def export_history_md(self) -> str:
+        lines = ["# PinkSky History Export", f"
+*Exported: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}*
+"]
+        for mode, history in [("Chat", self.chat_history), ("Skill", self.skill_history), ("Build", self.build_history)]:
+            lines.append(f"
+## {mode} Mode
+")
+            for entry in history:
+                ts = entry.get("timestamp", "unknown")
+                role = entry.get("role", "unknown")
+                content = entry.get("content", "")
+                lines.append(f"
+### {role} ({ts})
+")
+                lines.append(f"```
+{content[:500]}
+```
+")
+        return "
+".join(lines)
+
+STATE = PinkSkyState()

telegram_handlers.py

@@ -0,0 +1,316 @@
+"""Обработчики команд Telegram"""
+
+import json
+import threading
+from datetime import datetime
+from .config import ALLOWED_USER
+from .state import STATE
+from .process_manager import PROCESS_MANAGER
+from .internet_agent import INTERNET_AGENT
+from .file_manager import FILE_MANAGER
+from .notification_system import NOTIFICATIONS
+from .conductor_engine import ConductorEngine
+from .skill_orchestrator import SkillOrchestrator
+from .build_mode_editor import BuildModeEditor
+from .mode_handlers import run_chat_mode, run_skill_mode, run_build_mode
+from .telegram_utils import send_tg, download_tg_file, send_tg_file
+from .helpers import parse_skill_agents, parse_build_args, get_current_mode_info
+
+class BotHandler:
+    HELP_TEXT = """PinkSky v7.0 — МОДУЛЬНАЯ АРХИТЕКТУРА
+
+🎛️ Режимы:
+Chat — отправь сообщение
+/skill [задача] — Open Interpreter
+/build [спек] — сборка через кондуктор
+
+🎭 Роли:
+/role [guru|hacker|architect|principal|evangelist|techlead|qa|sdet|qe|researcher|critic|universal]
+/role list — список ролей
+
+🧠 Кондукторы:
+/conductor [default|strict|creative|economy|review|build]
+/conductor list — список
+
+🤖 Модели:
+/model [имя] — переключить модель
+/model list — список моделей
+
+📁 Файлы:
+/get [путь] — скачать файл
+/stop — остановить все процессы
+
+🌐 Интернет:
+/search [запрос] — поиск в интернете
+/cache — статистика кэша
+/cache clear — очистить кэш
+
+📊 Система:
+/status — текущий статус
+/history — история
+/export [json|md] — экспорт истории
+/mode — текущий режим"""
+
+    def __init__(self):
+        self.mode_editor = BuildModeEditor(STATE)
+        self.skill_orchestrator = SkillOrchestrator(STATE)
+    
+    def handle_message(self, data: dict):
+        if "message" not in data:
+            return
+        
+        message = data["message"]
+        chat_id = str(message.get("chat", {}).get("id", ""))
+        if ALLOWED_USER and chat_id != ALLOWED_USER:
+            return
+        
+        NOTIFICATIONS.set_chat_id(chat_id)
+        
+        text = message.get("text", message.get("caption", "")).strip()
+        
+        file_id, file_name = None, None
+        target_msg = message
+        if "reply_to_message" in message:
+            if "document" in message["reply_to_message"] or "photo" in message["reply_to_message"]:
+                target_msg = message["reply_to_message"]
+        if "document" in target_msg:
+            file_id = target_msg["document"]["file_id"]
+            file_name = target_msg["document"].get("file_name", "document.file")
+        elif "photo" in target_msg:
+            file_id = target_msg["photo"][-1]["file_id"]
+            file_name = "photo.jpg"
+        
+        file_context = ""
+        if file_id:
+            dl_path = download_tg_file(file_id, file_name)
+            if dl_path:
+                file_context = f"\n\n[SYSTEM: User attached file: ./{dl_path}]"
+                if not text:
+                    send_tg(chat_id, f"📁 Файл `{file_name}` сохранён. Ответь командой, например: `/build Что в этом файле?`")
+                    return
+        
+        if not text:
+            return
+        
+        parts = text.split(maxsplit=1)
+        command = parts[0].lower()
+        args = parts[1].strip() if len(parts) > 1 else ""
+        
+        # === HELP ===
+        if command in ["/help", "/start"]:
+            send_tg(chat_id, self.HELP_TEXT)
+            return
+        
+        # === STOP ===
+        if command == "/stop":
+            result = PROCESS_MANAGER.cancel_all()
+            send_tg(chat_id, f"{result}\n\n{self.HELP_TEXT}")
+            return
+        
+        # === STATUS ===
+        if command == "/status":
+            info = get_current_mode_info()
+            stats = f"""{info}
+
+📊 Моделей: {len(STATE.models)}
+📊 Ролей: {len(STATE.roles)}
+📊 Кондукторов: {len(STATE.conductors)}
+🌐 Интернет: {'✅' if STATE.build_context.get('internet_access', True) else '❌'}
+🗑️ Кэш: {INTERNET_AGENT.get_cache_stats()}
+🧵 Активных потоков: {PROCESS_MANAGER.get_active_count()}"""
+            send_tg(chat_id, stats)
+            return
+        
+        # === MODE ===
+        if command == "/mode":
+            send_tg(chat_id, get_current_mode_info())
+            return
+        
+        # === CONDUCTOR ===
+        if command == "/conductor":
+            if args == "list":
+                lines = ["🧠 Доступные кондукторы:"]
+                for name, cond in STATE.conductors.items():
+                    marker = " [ACTIVE]" if name == STATE.current_conductor else ""
+                    lines.append(f"- {name}{marker}: {cond.description} [rank_by={cond.auto_rank_by}]")
+                send_tg(chat_id, "\n".join(lines))
+                return
+            if args in STATE.conductors:
+                STATE.current_conductor = args
+                send_tg(chat_id, f"🧠 Кондуктор: {args.upper()}\n{STATE.conductors[args].description}")
+            else:
+                available = ", ".join(STATE.conductors.keys())
+                send_tg(chat_id, f"Текущий: {STATE.current_conductor}\nДоступные: {available}")
+            return
+        
+        # === ROLE ===
+        if command == "/role":
+            role_parts = args.split(maxsplit=1)
+            subcmd = role_parts[0].lower() if role_parts else ""
+            subargs = role_parts[1] if len(role_parts) > 1 else ""
+            
+            if subcmd == "list":
+                lines = ["🎭 Доступные роли:"]
+                for name, role in STATE.roles.items():
+                    marker = " [ACTIVE]" if name == STATE.current_role else ""
+                    lines.append(f"- {name}{marker}: {role.description} (complexity: {role.complexity})")
+                send_tg(chat_id, "\n".join(lines))
+                return
+            
+            if subcmd == "info" and subargs:
+                role = STATE.roles.get(subargs)
+                if role:
+                    send_tg(chat_id, f"🎭 Роль {subargs}:\n\n{role.description}\n\nComplexity: {role.complexity}\nPreferred: {', '.join(role.preferred_models)}\n\nPrompt:\n```\n{role.prompt[:500]}...\n```")
+                else:
+                    send_tg(chat_id, f"❌ Роль {subargs} не найдена")
+                return
+            
+            if subcmd == "add" and subargs:
+                add_parts = subargs.split(maxsplit=1)
+                if len(add_parts) < 2:
+                    send_tg(chat_id, "Формат: /role add <name> <prompt>")
+                    return
+                new_name, new_prompt = add_parts[0], add_parts[1]
+                from .models import Role
+                STATE.roles[new_name] = Role(
+                    name=new_name, prompt=new_prompt,
+                    description=f"Custom role (added {datetime.now().strftime('%Y-%m-%d')})",
+                    complexity="medium"
+                )
+                STATE.save_roles()
+                send_tg(chat_id, f"✅ Роль {new_name} добавлена!")
+                return
+            
+            if subcmd in STATE.roles:
+                STATE.current_role = subcmd
+                send_tg(chat_id, f"🎭 Роль: {subcmd.upper()}\n{STATE.roles[subcmd].description}")
+            else:
+                available = ", ".join(STATE.roles.keys())
+                send_tg(chat_id, f"Текущая: {STATE.current_role}\nДоступные: {available}")
+            return
+        
+        # === MODEL ===
+        if command == "/model":
+            model_parts = args.split(maxsplit=1)
+            subcmd = model_parts[0].lower() if model_parts else ""
+            subargs = model_parts[1] if len(model_parts) > 1 else ""
+            
+            if subcmd == "list":
+                lines = ["🤖 Модели (по coding rank):"]
+                for name, model in sorted(STATE.models.items(), key=lambda x: x[1].coding_rank):
+                    if name == "hf_fallback":
+                        continue
+                    marker = " [ACTIVE]" if name == STATE.current_model else ""
+                    tier = 1
+                    if model.coding_rank > 5: tier = 2
+                    if model.coding_rank > 12: tier = 3
+                    if model.coding_rank > 18: tier = 4
+                    if model.coding_rank > 24: tier = 5
+                    cost = f"${model.cost_per_1k_output}/1k" if model.cost_per_1k_output > 0 else "free"
+                    lines.append(f"- {name}{marker} -- TIER {tier} | coding={model.coding_rank} speed={model.speed_rank} reasoning={model.reasoning_rank} | {cost}")
+                send_tg(chat_id, "\n".join(lines))
+                return
+            
+            if subcmd == "add" and subargs:
+                add_parts = subargs.split()
+                if len(add_parts) < 2:
+                    send_tg(chat_id, "Формат: /model add <name> <endpoint>")
+                    return
+                new_name, new_endpoint = add_parts[0], add_parts[1]
+                from .models import ModelConfig
+                STATE.models[new_name] = ModelConfig(
+                    name=new_name, provider="openai", endpoint=new_endpoint,
+                    api_key_env="NVIDIA_API_KEY"
+                )
+                STATE.save_models()
+                send_tg(chat_id, f"✅ Модель {new_name} добавлена!")
+                return
+            
+            if subcmd in STATE.models:
+                STATE.current_model = subcmd
+                send_tg(chat_id, f"🤖 Модель: {subcmd.upper()}\n{STATE.models[subcmd].endpoint}")
+            else:
+                available = ", ".join([k for k in STATE.models.keys() if k != "hf_fallback"])
+                send_tg(chat_id, f"Текущая: {STATE.current_model}\nДоступные: {available}")
+            return
+        
+        # === GET FILE ===
+        if command == "/get":
+            if not args:
+                send_tg(chat_id, "Использование: /get ./projects/test.py")
+            else:
+                send_tg_file(chat_id, args)
+            return
+        
+        # === SEARCH ===
+        if command == "/search":
+            if not args:
+                send_tg(chat_id, "Использование: /search запрос")
+                return
+            results = INTERNET_AGENT.search_web(args)
+            if results:
+                lines = [f"🔍 Результаты поиска: {args}\n"]
+                for i, r in enumerate(results[:5], 1):
+                    lines.append(f"{i}. [{r['title']}]({r['url']})\n{r['snippet'][:150]}...\n")
+                send_tg(chat_id, "\n".join(lines))
+            else:
+                send_tg(chat_id, "❌ Ничего не найдено")
+            return
+        
+        # === CACHE ===
+        if command == "/cache":
+            if args == "clear":
+                result = INTERNET_AGENT.clear_cache()
+                send_tg(chat_id, result)
+            else:
+                send_tg(chat_id, INTERNET_AGENT.get_cache_stats())
+            return
+        
+        # === HISTORY ===
+        if command == "/history":
+            mode = args if args in ("chat", "skill", "build") else "chat"
+            history = getattr(STATE, f"{mode}_history", [])
+            if not history:
+                send_tg(chat_id, f"📋 История {mode} пуста")
+                return
+            lines = [f"📋 История {mode} (последние 5):"]
+            for entry in history[-5:]:
+                ts = entry.get("timestamp", "unknown")
+                role = entry.get("role", "unknown")
+                content = entry.get("content", "")[:200]
+                lines.append(f"\n[{ts}] {role}:\n{content}...")
+            send_tg(chat_id, "\n".join(lines))
+            return
+        
+        # === EXPORT ===
+        if command == "/export":
+            fmt = args if args in ("json", "md") else "json"
+            if fmt == "json":
+                data = STATE.export_history_json()
+                FILE_MANAGER.save_file("exports/history.json", data)
+                send_tg_file(chat_id, "exports/history.json")
+            else:
+                data = STATE.export_history_md()
+                FILE_MANAGER.save_file("exports/history.md", data)
+                send_tg_file(chat_id, "exports/history.md")
+            return
+        
+        # === BUILD MODE ===
+        if command == "/build":
+            if not args:
+                send_tg(chat_id, "Укажите спецификацию проекта.")
+                return
+            params, clean_args = parse_build_args(args)
+            run_build_mode(chat_id, clean_args, file_context, params)
+            return
+        
+        # === SKILL MODE ===
+        if command == "/skill":
+            if not args:
+                send_tg(chat_id, "Укажите задачу.")
+                return
+            run_skill_mode(chat_id, args, file_context)
+            return
+        
+        # === DEFAULT: CHAT MODE ===
+        run_chat_mode(chat_id, text, file_context)

telegram_utils.py

@@ -0,0 +1,69 @@
+"""Telegram утилиты: отправка сообщений и файлов"""
+
+import os
+import json
+import urllib.request
+import time
+import requests
+from .config import CF_URL, TOKEN
+
+def send_tg(chat_id, text):
+    if not CF_URL or not TOKEN:
+        return
+    safe_text = str(text)[-4000:]
+    url = f"{CF_URL}/bot{TOKEN}/sendMessage"
+    data = json.dumps({"chat_id": chat_id, "text": safe_text, "parse_mode": "Markdown"}).encode('utf-8')
+    headers = {"Content-Type": "application/json", "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64)"}
+    req = urllib.request.Request(url, data=data, headers=headers)
+    try:
+        urllib.request.urlopen(req, timeout=15)
+    except Exception as e:
+        print(f"TG send error: {e}")
+
+def download_tg_file(file_id, file_name, retries=3):
+    if not TOKEN:
+        return None
+    import urllib3
+    urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
+    base_api = CF_URL if CF_URL else "https://api.telegram.org"
+    get_file_url = f"{base_api}/bot{TOKEN}/getFile?file_id={file_id}"
+    for attempt in range(retries):
+        try:
+            res = requests.get(get_file_url, timeout=15, verify=False).json()
+            if not res.get("ok"):
+                return None
+            file_path = res["result"]["file_path"]
+            dl_url = f"{base_api}/file/bot{TOKEN}/{file_path}"
+            os.makedirs("downloads", exist_ok=True)
+            safe_name = os.path.basename(file_name)
+            local_path = os.path.join("downloads", safe_name)
+            response = requests.get(dl_url, stream=True, timeout=60, verify=False)
+            if response.status_code != 200:
+                direct_url = f"https://api.telegram.org/file/bot{TOKEN}/{file_path}"
+                response = requests.get(direct_url, stream=True, timeout=60, verify=False)
+            response.raise_for_status()
+            with open(local_path, "wb") as f:
+                for chunk in response.iter_content(chunk_size=8192):
+                    if chunk:
+                        f.write(chunk)
+            return local_path
+        except Exception as e:
+            time.sleep(2)
+    return None
+
+def send_tg_file(chat_id, file_path):
+    if not os.path.exists(file_path):
+        send_tg(chat_id, f"File not found: {file_path}")
+        return
+    base_api = CF_URL if CF_URL else "https://api.telegram.org"
+    url = f"{base_api}/bot{TOKEN}/sendDocument"
+    send_tg(chat_id, f"Sending file: {os.path.basename(file_path)}...")
+    try:
+        with open(file_path, 'rb') as f:
+            res = requests.post(url, data={'chat_id': chat_id}, files={'document': f}, verify=False, timeout=60)
+        if res.status_code == 200:
+            print(f"File {file_path} sent to TG!")
+        else:
+            send_tg(chat_id, "Failed to send file.")
+    except Exception as e:
+        send_tg(chat_id, f"Send error: {e}")

universal_agent.py

@@ -0,0 +1,145 @@
+"""Универсальный агент с поддержкой Open Interpreter"""
+
+import json
+import urllib.request
+import re
+from typing import Dict, List, Optional, Any
+from .models import Role, ModelConfig
+from .config import API_KEY, API_BASE, HF_TOKEN
+from .file_manager import FILE_MANAGER
+from .internet_agent import INTERNET_AGENT
+from .notification_system import NOTIFICATIONS
+from .process_manager import PROCESS_MANAGER
+from .state import STATE
+
+class UniversalAgent:
+    def __init__(self, role: Role, model: ModelConfig, use_interpreter: bool = False):
+        self.role = role
+        self.model = model
+        self.use_interpreter = use_interpreter
+        self.conversation_history: List[Dict[str, str]] = []
+        self.file_manager = FILE_MANAGER
+        self.internet = INTERNET_AGENT
+        self.notifications = NOTIFICATIONS
+        self.tools = {
+            "search_web": self.internet.search_web,
+            "fetch_page": self.internet.fetch_page,
+            "analyze_website": self.internet.analyze_website,
+            "read_file": self.file_manager.read_file,
+            "save_file": self.file_manager.save_file,
+            "list_files": self.file_manager.list_files,
+            "analyze_file": self.file_manager.analyze_file,
+        }
+    
+    def _add_tools_to_task(self, task: str) -> str:
+        tools_desc = "\n\nAVAILABLE TOOLS:\n"
+        for name, func in self.tools.items():
+            tools_desc += f"- {name}: {func.__doc__ or 'No description'}\n"
+        tools_desc += "\nUse tools when needed. Return results in natural language."
+        return task + tools_desc
+    
+    def execute(self, task: str, sys_prompt_override: str = None, chat_id: str = None, 
+                history: List[Dict[str, str]] = None, mode: str = "chat") -> str:
+        if self.use_interpreter and mode in ("skill", "build"):
+            return self._execute_with_interpreter(task, chat_id, mode)
+        return self._execute_with_api(task, sys_prompt_override, chat_id, history, mode)
+    
+    def _execute_with_interpreter(self, task: str, chat_id: str = None, mode: str = "chat") -> str:
+        try:
+            from interpreter import interpreter
+            configure_interpreter_for_model(self.model.name)
+            base_instructions = interpreter.custom_instructions or ""
+            interpreter.custom_instructions = base_instructions + f"\n\nCURRENT ROLE: {self.role.name}\n{self.role.prompt}"
+            messages = interpreter.chat(task, display=False)
+            interpreter.custom_instructions = base_instructions
+            if messages and len(messages) > 0:
+                return messages[-1].get("content", "Done")
+            return "No response from interpreter"
+        except Exception as e:
+            return f"Interpreter error: {e}. Falling back to API..."
+    
+    def _execute_with_api(self, task: str, sys_prompt_override: str = None, chat_id: str = None,
+                          history: List[Dict[str, str]] = None, mode: str = "chat") -> str:
+        system_prompt = sys_prompt_override or self.role.prompt
+        messages = [{"role": "system", "content": system_prompt}]
+        if history:
+            for h in history[-10:]:
+                messages.append({"role": h.get("role", "user"), "content": h.get("content", "")})
+        messages.append({"role": "user", "content": task})
+        
+        if self.model.provider == "hf":
+            return self._call_hf(messages, chat_id)
+        return self._call_openai_compatible(messages, chat_id)
+    
+    def _call_openai_compatible(self, messages: List[Dict], chat_id: str = None) -> str:
+        url = f"{API_BASE}/chat/completions"
+        data = json.dumps({
+            "model": self.model.endpoint,
+            "messages": messages,
+            "temperature": 0.7,
+            "max_tokens": self.model.max_tokens
+        }).encode('utf-8')
+        req = urllib.request.Request(url, data=data, headers={
+            "Authorization": f"Bearer {API_KEY}",
+            "Content-Type": "application/json"
+        })
+        try:
+            with urllib.request.urlopen(req, timeout=45) as response:
+                res = json.loads(response.read().decode('utf-8'))
+                return res['choices'][0]['message']['content']
+        except Exception as primary_error:
+            return self._tiered_fallback(messages, primary_error, chat_id)
+    
+    def _call_hf(self, messages: List[Dict], chat_id: str = None) -> str:
+        url = "https://api-inference.huggingface.co/v1/chat/completions"
+        data = json.dumps({
+            "model": self.model.endpoint,
+            "messages": messages,
+            "temperature": 0.7,
+            "max_tokens": self.model.max_tokens
+        }).encode('utf-8')
+        req = urllib.request.Request(url, data=data, headers={
+            "Authorization": f"Bearer {HF_TOKEN}",
+            "Content-Type": "application/json"
+        })
+        try:
+            with urllib.request.urlopen(req, timeout=60) as response:
+                res = json.loads(response.read().decode('utf-8'))
+                return res['choices'][0]['message']['content']
+        except Exception as e:
+            return f"HF API Error: {e}"
+    
+    def _tiered_fallback(self, messages: List[Dict], primary_error, chat_id: str = None) -> str:
+        if chat_id:
+            from .telegram_utils import send_tg
+            send_tg(chat_id, f"⚠️ {self.model.name} failed: {primary_error}. Trying fallback...")
+        tried = [self.model.name]
+        current = self.model.name
+        while True:
+            next_model = STATE.get_next_tier_model(current)
+            if not next_model or next_model in tried:
+                break
+            tried.append(next_model)
+            model_cfg = STATE.models.get(next_model)
+            if not model_cfg:
+                break
+            try:
+                agent = UniversalAgent(self.role, model_cfg)
+                result = agent._call_hf(messages, chat_id) if model_cfg.provider == "hf" else agent._call_openai_compatible(messages, chat_id)
+                return result + f"\n\n_(Fallback via {next_model})_"
+            except Exception as e:
+                current = next_model
+                continue
+        return self._fallback_hf(messages, primary_error, chat_id, tried)
+    
+    def _fallback_hf(self, messages: List[Dict], primary_error, chat_id: str = None, tried_models: List[str] = None) -> str:
+        if not HF_TOKEN:
+            return f"API Error: {primary_error}. No HF_TOKEN for backup."
+        fallback = STATE.models.get("hf_fallback")
+        if not fallback:
+            return f"API Error: {primary_error}. HF fallback not configured."
+        try:
+            result = self._call_hf(messages, chat_id)
+            return result + "\n\n_(Context saved via HF Serverless)_"
+        except Exception as hf_error:
+            return f"Both systems failed.\n1. API: {primary_error}\n2. HF Fallback: {hf_error}"